From 52d02724597b9dfa04e8f2e1b644a07d1f7432a4 Mon Sep 17 00:00:00 2001 From: Adam Sawicki Date: Mon, 18 Nov 2019 15:03:59 +0100 Subject: [PATCH] Regenerate documentation, rebuild binaries Switched binaries from vs2017 to vs2019. --- bin/VmaReplay_Release_vs2017.exe | Bin 247808 -> 0 bytes bin/VmaReplay_Release_vs2019.exe | Bin 0 -> 238080 bytes bin/VulkanSample_Release_vs2017.exe | Bin 301568 -> 0 bytes bin/VulkanSample_Release_vs2019.exe | Bin 0 -> 290304 bytes docs/html/allocation_annotation.html | 38 +- docs/html/annotated.html | 6 +- docs/html/choosing_memory_type.html | 32 +- docs/html/custom_memory_pools.html | 42 +- docs/html/debugging_memory_usage.html | 2 +- docs/html/defragmentation.html | 54 +- docs/html/deprecated.html | 6 +- docs/html/general_considerations.html | 4 +- docs/html/globals.html | 108 +- docs/html/globals_defs.html | 6 - docs/html/globals_func.html | 96 +- docs/html/lost_allocations.html | 38 +- docs/html/memory_mapping.html | 52 +- docs/html/quick_start.html | 26 +- docs/html/search/all_11.js | 182 +- docs/html/search/defines_0.js | 2 +- docs/html/search/defines_1.js | 4 +- docs/html/search/enums_0.js | 12 +- docs/html/search/enumvalues_0.js | 72 +- docs/html/search/functions_0.js | 92 +- 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 | 34 +- docs/html/statistics.html | 10 +- docs/html/staying_within_budget.html | 6 +- docs/html/struct_vma_allocation.html | 2 +- .../struct_vma_allocation_create_info.html | 4 +- docs/html/struct_vma_allocation_info.html | 18 +- docs/html/struct_vma_allocator.html | 2 +- .../struct_vma_allocator_create_info.html | 2 +- docs/html/struct_vma_budget.html | 3 +- .../struct_vma_defragmentation_context.html | 2 +- .../html/struct_vma_defragmentation_info.html | 6 +- .../struct_vma_defragmentation_info2.html | 6 +- .../struct_vma_defragmentation_stats.html | 4 +- docs/html/struct_vma_pool.html | 2 +- docs/html/vk__mem__alloc_8h.html | 770 +- docs/html/vk__mem__alloc_8h_source.html | 28593 ++++++++-------- docs/html/vk_khr_dedicated_allocation.html | 6 +- 56 files changed, 15351 insertions(+), 15169 deletions(-) delete mode 100644 bin/VmaReplay_Release_vs2017.exe create mode 100644 bin/VmaReplay_Release_vs2019.exe delete mode 100644 bin/VulkanSample_Release_vs2017.exe create mode 100644 bin/VulkanSample_Release_vs2019.exe diff --git a/bin/VmaReplay_Release_vs2017.exe b/bin/VmaReplay_Release_vs2017.exe deleted file mode 100644 index 538031ff1f7216277afb71e037aeba387415c897..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 247808 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 z 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�n8{oKSUAhsKLW})^$W9||Dv*db9uvD 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 z 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 diff --git a/bin/VmaReplay_Release_vs2019.exe b/bin/VmaReplay_Release_vs2019.exe new file mode 100644 index 0000000000000000000000000000000000000000..e144ae1ae1463de0aa807d990215a2072be0f6f4 GIT binary patch literal 238080 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
K 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 WzTExgkuRsdT=8_n)6~id|Nal5yUC&e literal 0 HcmV?d00001 diff --git a/bin/VulkanSample_Release_vs2017.exe b/bin/VulkanSample_Release_vs2017.exe deleted file mode 100644 index fb3b1410c33c563074b30cb69b5f11a4c89826ad..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 301568 zcmd?Sdwf*Yx$r+>5{Y7%K^cvTGHP0*@sb*=!C;*sGq6WyBnlC{ps^r^14@KMV-*Qb zre@ylu4${4o@(Ws)=E!bE4?XFFA0}S0OjTlv`W0PF(^?hiK5K=eb(ADNdViP&*#^_ ze)(i(uf6uO*Y#P?eXWUI)#`G)T&`R`>9otWf~))m)b~IB>f`b7(JP0${(Sh0C$Gqf zzIgJK+Sv>Ib@S)lIRE;a{4=h<`Q~}`{_o%5pWkq^fA-D((4@)!o94~D;p~EfBZ{1& zhxPqv?4+M}&C7hozrA4I)!gsiX`@6V&zno2%6I?VBfZJtM8J+fr}e9OZt} z&)=RGUeYzM;?rF>U&4LGr=#axs;=+cEZ56t GCisayIeDWIMlWOl&7xAY=_zQqGXKOH5i*&Ar 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ώNZk-_!Jy{Y+=KOg2732eS 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%0DHyhS>TJ+pgC-kv z5KvHwUcq)RO2HnRXSEI1+Mw44y9g+#M6ci$FG|5ZHqVd^3NQsnV$cR50tzb8D_G`5 z$x~(Xgl!%1rhciB99Y%pYl zf+K8?2`H#UuV67Lic&CS^HkX&Y=b%*G!RfwiC)2aFG|5Co2SDDJvLZvgS7+{RH9dK zjTfb0ug$Z|277EUWP^gKrl1nNg2P^vfUO~r;Qli1;X|h3w z4SH;_nt*~z^a|eLMJc$}=IOP;E*tEz!4LrjmFN{rd(nvd?Cc+E7hV1dbKfkL5Dqw& zHBaC2YqD>s`8Q>d{@hIkEQlEHB&GFh4l)(FgUru@9Ax6|ePt%kE3)S{y~lBH3G!_! zoidO$Mm16KSD`kkx8F#zbd~RUG=IcGIH4lcugiW|re7{M57;yvcPFE@coyvGAOhpc4vjV7NW%_Gt9yB1k@edq(T+?%;mdDn*a&Yq~($JM=6oq}fjNE6;N1?yJ zvVxwvD`jGBRA$*$b4F#>!3JQ~&i-eECSQ)H7U54I@)kt{Y9t*i#Kpa{?{!&7*Xs$q zy+wxk^=Q8rILpJHP+k|vq+!LlB6n|6tvH@<{!c8N*UrAh=ssNF+|Vzyxd>M$xrUrV z+3fQgLLZ~doj;--PM9OxArI~F-ngH3RB^m!OY_eUX`)J|3(AZV(Fi9Moi8_{cb0Hp z;C%|H#cBKv3F-p1?wlfHwtam1&KH4QY8i*tXJpoEE(cxX-1qQ^F6;{)&;`**2enGc zls?T&BFS{SCD3)J##0ZKk)GuAyskizMY0)_L|c9l=f*37)zKgiIQuZ`3^}M#9btJ;haBn`d9eoshxdEIM9tukY@AW;qd$zixndt;Cwmz z0EZjTTSHWb9*TVM1-gG_%8&65XM~=}NF|Zirb^{N?{IjAgOs~AiNmYLBE7bWRySgc z?PC3vp_r6?g~PXfg@c)K?*)!yU*LS1)$!$Oes{dG^(x1A1L##p*ce@PF>mzZswII7yYs3@+G3N;ol2dI^-tBs1Fqw7G{=)rvb)gx3D7}6SEy}+s4}EH%LlL|Ae|5e$uJu@XAz=eC!pZc%&S${= zMdggUfUTu-W1~?~w}N!t^hg+n#A_FC0Ow4P$j$fE2=d23*ISgp2v!m4_-_kzy`&m` zs5QcxE1S7B@*C}B(VD*2Q)+8Aw4Q~R#G%05Uny(jAq_(-;F&m9h1{p2-Oun2C{Rnh zH&WBr_EE(l3_KPOb{Izj5l zR)`(w7H)@i0wI6e@R2LE4mKi3{}2bfNRdax`>eO&A0&UeSPE(8ZAa4!*-6TdIjx=CR`1o>j;JDJwXi+Un8TU#%5`-Y-{ zyPdMONe`H*FLLo5)BRY)?ZaHLyM-r-ZBL%si^ZsHX%#c?20o;yFy>Ed$K|dhxsS}3 zBugo0jd%T+)!8yGO9leL@qv=?+CXrDp0D?EV?8ItJ#~23MS+&5iuDL-htuDy>48&< z2Wp4nvk~wwKg=iq4ZO`jYTZlAE9SU24;bzTbwBra+pV^qE*y=v-fKo%@Ao=g#ZxQF z9@OxSg(73Qiw&rx*4>dh_j+6%;gK6ZM_COpw4)k$m5I(Cba95RzCqsZ0wg?6&1NoE zh8&}}XS5WDJ71i_ZWg!=HmB0Tg;lM2LwHS@@<0x_(n_{K0b8p0=CgY9+|$RcT6hM} z2(f_6t|(2uuS}G@xql|cV^+vr6Zf)uNO(;>e~93(X-rQ)4ciRDSqF_kJdrSBEriqBl}9lA1y99M8pS{_RkRht{gY4CH8dh&N-aDBRg zH1c=zBLC4Z3U&wZChK+^p7-Dz$l6!c&y;>u^G*_zTUib^MkjOXVW@_UVX&OL#d4K^ zIB!d@?iB7|j*7`PvU1*sK5k}Nd;m9ogTFEtns-bB@?Oenf1!C{R^NW4o-~tksZ<}Z zV!}&7aXaoiklkAM<~|`KrewCxd?nWTpphj9x>AC6>V|sIkHf*S{^0;^6aQV{?-(5D zXcXaAYc|l-48~^Pqzalp7w5jS<9h6jYX?VZLN)_+2_6Pe#*g-qY>dI!$+sx`;Dq0s z6_>5MC$H{W)jfC|hH1*e)fWe|6~=P4z0w9c&3D9}1+?RHZ)hA)?#%4cE{FkQT^%$? zA-<6vYouH9k6^zv=Dr^D9@O#JCIS$8TMtJc1Eh+$ScukOxg)<&o#V9S4b@?&to42N zq%&)$;{msIfsgSwv&(X)s@;*9%+z>|Y{dtQzi#DTf=Rpl63DI57YCnR~gDMt7~?L6swZ0&!V5tS}EFIHh?i5$CZf$GH3c=Q?17 z771PPv2wfhLhaUp?p`_ve|7wt>+Rd>$Y*+2%{e~My+)nxpHoEu zWY0F>cifxm0l$Yrs*t5|p_AFe8~>24q;NA>(WT=!)Z!#aex{ZXSTAglOW^lh~0qo?kzUDZ~HYlNu# za&7Wk_3jNiDCx93%$;0M#C;nvm$cN`_xoe+pQ6<#+3jrES{c$)kF7$}13Z~PeW`1o zxwlV7S38|pk_dF&Of}IiZla}oyg6Ejs>jZBX#nBPNC#X;vb@*?jRP*<>(4J7ab!Ew z^Nu(u`=38IGP}w5;M9Zi{WdS(HP|xRvN^hoym+;e@01iO>pwe4_bJrsO@^SB z-W(lb;_{%@GDf>;+wKtU8h%@gdCG3y&-!knb{yQ&ad|DR;C)0HZlcVz9H|B}8)7vV z1_L)PWk@5VrMn+t9~MLrAcAreoagY)gOJG&I+^+fiSAN7fh8j#tyETURB* zQ5Rty{to!{ zqjrIO`Y^#~MDFz?a~mxCw}UJFms~b~qRDz8%VUXM9{(L(BbLYc`O713qP0BdA6#v1 zu3EpZ@6_79UNu>(12!*^J_S|DQQba#WI_6Zf@Mm;N)O%2t;cP+Da?H&!cJvKP*K{4@1!s?k~%r_{NFix0ol5_dEmb z5$@8?G0lvmULkM5tIQ}zWdHQ2?55g+gR9;D8MSDu%}!4oZx86z!uKpUC@Ir^FNt~@ ze^*A;a}~$y=%`uxF>oJ6bN?-`dNWN}BGO@Ofje!Fdv?2~2;tf2QjMcZadx{^rI;$N z4qiw*w;)E$Y)sVrrFo^DmnTfqXF@={HMBGRDN~7cS;dwg_SevH48-s^c8y-JPxWR^ zu63|N@+4*(&{s0%ne<{TbyxYGA@t!wL2%^{+bM?uySz=Wj&yk{ZZP5R${Q8B6Tbde z&~oNRC)us50jawsmqKSg`<=HqC8l&X+AK?59MX}ea!8N%V1W7#{#Nt12L8H70>O~7 zW%D2)6yuIU6VDj+U$}M^wq_lKm!b5r1|5vEfeQf#%M6s7cCtDna1=7n*P>=l0S;c6 zWwR?WUS5&Th*p}VC~>6Ss!)_PR2LH*+N@Gbdu0;*w5ORh)7pPd()^8T?LR8At$h+h z{0=L<^y&z3FhzDx7^6r_UJ-9Fx9M)p7WoU?7Y<3HvwyE^g}_Y>#UgpN{?8|l)rn8! z)#!I(f7tKD5;|eD>jbiiMPu~ng_A}O!t2Td24P1H_}*OJYxI!54m^^}f_i{H0>pQU zw0{VQ)uVI9YGqNbl`L4FIn5u@4Py;r`lur8A8%nCinpjS_s&g5x@G3%B{L^@=TPIf z7y7fieXOb4a^gt9Xm;;9)9=Q+Dm)q?ZW~p^gXQI8Rey0VFKh{KEDT>#TiysFkAP*J zNclmq)Z-L6OKmjhI`2Y;8rfUB3D0L2T3mW(EI7UO>4V3#=S%*WP8@4YeWQxVeV&1( zGuEiSpUVyJfOT8LhiKI$MXR|n}X z$C!lRs3PDd9vn2`H?gl7`>B!H_li9a+;o@zKOxM0@PYZWf3jav5{_s5ZwuTz7C_dP z9}L59p5epr#c|%YtOjr6Ui=^=X&P1DYb!QZTeZ2oX2CUi3$A_if~(X%a1fHn=DU!j z-5`m2^yjf4_S~lq9+B*JSs(-%(Lsaw&rwCZyj^2ee|;{m81N2*=+RZ9@w`#Ad(;r3 z9hMhf#Q^5IckY*F{N4>&94|G^AvWRc%N~HW3-<7!X>J~Sz@#k7ykFywW{#PXQAM8p zqyUgBLL1}#b#%8G{-^?XjVd78ur}Mqa~au68CB$}QAKE@$ZsPtRvXT!0&3%eY#UdP z)kf*4BD7KLw=po*z+d{r$bqYk;%pm7kJZNAql(Z*&~KxAEPU@U1s#`>g~onkym`t@HrR{i&%kOj@C&i)*di^vQzFZG3y zPAIFai2yF@Fv*C0fY(gcWvjWq!HFTtJX&}XW*=oW8lw1u$Ha@Vu5h@yc*~R?K_NZM zLP~;c9qIPcJFvl%p7%$%kD?Q}h4>P@FYNBfC)CO$&t%xdOWctuO}}bdP8rn|44u`Z zYaky?Vsx$Svn3pJuW`IL^EqRPNWjc}vV?m1v7mg|Eb}qTaRtA zx+zgNTx4#X%k_Vt>u&|XUN_J|bC>yvNawckyaJsvc#LA5zgag9ccpC;%`;I7K0FT7 zjs4IAWY>Ru&;&a$H!*JZ_szxrwf6l;ZFhg`*WC4P*9K95}KDFN6^60<~ zFD&I>B{!6xp2@$yf$=xIph)2sw~uREOmf($RI`qII|zQFxk zYId|tjwDNfWR3fJW_`4Fk zarw;r*58%9$4ObefJ|u@365*O4r!dhdrg>Up5eQLIYHx6;*aS3Q18x@AwJ}zJR2e6 z5CH{@z64lHq}rWVL{Mez&y8V}Zvb@}W7A>XhW#UKI;?xeJEGZ(fluVM|3`+=<8Bgm z3Rb?MHodTK^3jtwgE^_Rd5^RoOv(qeHSXX^E3NGhLD_&9v9vSWSa=9@_0mMG`x{+> z$9)SAhYw^SyNaJPrJo@|kkwbL@~jbNFEH9?jdx;{Bj`RK8Ew7uXolmEw z^=3HF*26}&p0^R<7z-UYuiu}ESX&SJ&Xl?@j{w$N)Z*8;hIr4xx3$m;d-knMtLNSY zY`3Hk=*;O2RCS*IlD&T~G({EHf^G$4Vu*ZpHeTc|A`55T794@q8=d z{PiTj=$rX4H#PYtKJ%ohLN?X-tp;-+|SZ1#OyfKj09 zA!a)2{)f;a=KexynbNoZDzr#z!FBL+rt~N?0Q==sVh?SkHIyjF6xno51i3w1rgv(2 zD=tG>e-i&p9JJt;u9mB?JhYGv$IWI5C5qE+y)2=qHH*UaMrj)mF;Wh@gr3W*@SlkH zMBV$;eHl=|?=$XLs(Hj|yI|ozi}7%~H~Wf)p=$A3i)trJ0HXAPh{#E zuqawMl-cBNcWM?jG(V+l^1@j13%Ln><}bN9s`l^NN6eFyl-R*G=HD*d@bVs@2}v{t zRb?}Wg}M%@%9KAsJS0`I4gk><#G_!`#r50oi~~N${p{pF>&aRi(!?Q>b3gXEph^m* zbXXI7ZoJye$|-TM-X zgI(oa>MIyv2}21Z_6dVCiZG0@>N}b$6aagF`d^|F9_5c^zqR|*V!m!JUrnp&+E1wI zF7x5pZ~Y!Bhl0;K^@j|s+tB)q?G=#g6TM51oW!~4ARb|eihOV=~qNa)ps_URS zN@vkhmKZD)O22-R$UEj~p87qwnP-CcDIuT`!{X)~M(B@LaO@H8Ow&beAc3E8qusVW zUHg+wAVBSd&3_gh$%kak>S;m7^#OM66E zQ6K<$Uc_{E+fjOoewUd-Zd~gO^$?CU>0T1*+&=Re|1m5mV=Ohu#x}o%ee}|5t;!*n z3|Mr~sq|2vaBJAZt=3Pvx7jtA5<+o7smf4+0jW75rT^*Qb-MIC`2muuC>{bU#TcHL z_g)|PJQvs9-S+e+c2fY?2A%y?PR(=8f00G&_K4eWj11Ghq$f=KsIiTJ4*Z-9)MGk; z-1GyjYKY|+29ZFW#*j6LbjFXLXQHzV$!}@N{iPk4v0arZ-Ti`SBg8H)OV{u6<+wx- zxh7ykMp?T4`-?d|*+HCDA)E&LDm14#L({U2WY&g|?}FcsM7|5awmjt9lvn9h#IgTM zrG~kd)bx}M7zRfLpw3eP$k~pe(RfJ&Wl$#WoH z7HUUOL&SZ^ZYdtve!M5kX>2jf+*_|FKd_(I z_%g@+sZV%GN0amrT}0n%|3UVDWskcA{=_Wymw&S#B(&ywNk7A{^be%x6M;YcdBi-N zk=MW1_lO8+t>b-iXZnA$YWz7c8^?%EW5nhTE*rERF%1o4Gt_Cgy|{bYOMhZ(&%|aw zXvzI1#u#-U)I20yv)yM(k9|Hn50=_jli<_RSmiu_Yaf!KvpkM(UY6tAouhW;49=g3 zV&ZJ=mx@@7&Gt?Fl*jhnhL++8w(kc*)?Bsw>5^aV-NgCnl~(cQ@`@IAYA!EsJ=1rC za2To_FRN8Ebc&s?its&XM#L8oq(#? zC$$%)O8<^M12tBczN?J3QrtIT9UHwZ@>0(lPmXx2bTvD=Atpb%cO=pH zk;QDEb12U1&+iyhkKI;a4gUGZ8sVMgy}&}OK?h-;VVOJ!=^nn?85qOpA1+zEeU9Vz z8TX+hp?zT{q;!Hss)$wp!D;+3cp4i)ROHW ze^HMOse#v?^j38aWS+meC9s?DUY1$Mx4h$i{5wzZ2rs#0O(MCZm%lCi{fWPq_HMws!2)-vwcIy$_Pg>9Qp6X9 z9M|<&)%3I<@yvmZ!~TjxtTtQ*p^mdH{V{S6j@S0>yEwNE*zSNoW34q#7TI(6ZY%0C zoYiAgmNU5d8@_7YyDfA1Gj%0Xdd-tr1VY9BU-=ROVSw}yM{YKT(MRr^cjqvuiTDSu zvu)_AAvP^ekG~rX$~$t8*J8@8vrFg+6S_g_mNWFQvmCpbW2^)zt-^6F52DQA6;99@i#u#^+(f7^vikjc00r$_!nJE`5}zA zAvIaLC3E{ann0^$ST&Kn|atp z4_9YOk3pQCjCLWdL0bMrJ|s7HDi`{kpKs!Jt|!!4h+_^!@vEvo<_lHqQTL=La!7VK z@kcmHBP|CQ5U)?}#Wf30<9gWv|92@fnMzcoFDs!jJn<@%cF+mGLpDIC!cJBk5nZj( zwNsTj&o@P^83zoso!eDd0xR`3$=e$#JWVXpKk}{xAtD+-L_u zc8{rbHT=>q9V_IIu997$^tfNZ>hrNTY~@Z4a;N>Qzr00o5wP;<^2dmSip$W!eyRO} z$lho{M_WnUofs1W?M!cY+{}u8{B#0)W^;Ll7&)E#*9bURbL;goesQZ2qo2VEA$v}{ z>0Z+C$$mUq{)3bCvf;O&fSxzJ2PS(cnz{WBa7M}xNuG=(9LW$a`=MnJ%nG_;qZU?9 zc5pr}pP*N9>>=jMq%4<^eT5`}RE*QDxH4XsJk~ZD5o(~TgsNnTXttqK0pme%v@H1{ z$eSmnzk}|w|B;|wLSKiJCG(8@AYt;>$8*5`IdS@aPx)$U`k>QAsLVTEeBrK9r;Gmv za^_9rkMe3>LY$voX+73|L;{iE?7;S@7bF6)WE7=wPZ*V*qZjoQ9iB{^jXA;@@k*YV zKeK7d9;qdF&^be^+zFvRkFHr+U+2}+C9;terV1b%8)82(f<1Y`bU$9Q6JuIk=RgFE zM}e*dCRR>b*u*M`{WlYvK@3k_vObu+tDFbzT$pjudkGH-@gKdZdM@;0VKG?LoB94~ z1||Y16G`s;SY2->TS?D5jm>Qc~72HuIEb$SH*k;(WiC-eE}fn-EYd z;}gjwp`iduYPk*(PblimMjq(*aB!O1SVMi8@2{c`OHoBJQ$H}to`7pxR)(s}2~^I^ zp%prz^bo}h(ntO>$3MW)wT3JM5p$>V&|GTcAtR?U97K8(Z_AKp1y=n}isonm`~#~z z{nK4WP)3IKPly&EWQG=C#IkiNKPOnh@ENCWGIU^Ojt*=~Uw1cY*z5dKxcVCA?r0}a z`=x9`Z(39X(?>3t-q z)B5^{>BNtB=IBH>@eidFWz#%55m+;dPE3Vf<A;bDcC;C@@<)<219%Z&YPS=<)=h?QY_ zB5)Izjs?b%jHo9%l0`9xXOc2qyxs}S!92wkLTy-T|%5?W!jlTyyHCYZmydJMjlZcs3w6&cWepAx=e*(6 zyvl{++r}y7PXuiMJ(sb^Q`6q&lkcsqpYQ=rg?Q~;@D9#XWA0;e9Vt3)JW@WKDSc+U zWbHNukCaf4SWOy$ZxTGQy0E19EG{WcrEn$tf9(ODd7urdwoWOr-3eA1NGGo;9z4c4 zqg+kZ*(6>aT~#d0x6DKxGvQ4D)8Q<@p0H*@oJP*`j|KS$;-lW@e?)u)S#tPT1K#9= z>Ek|_80!cy2?c{O7Z9y`M1vj+AxFVyd-~a5dGPr##OzX?{{@IC`1}L-q=~dp`#^ls z4kUbvaIoh78a2!p@Q4jR?mIa>)h| z6;Bmm`({s}c-&v!?Lq6KVAI*ES`ZV08EnFTwne9fXp8cJ<<1d!h4ZTZH%Ol!3Y5hA zIYX7y_J>9x+6Us-D_KZ=D82hdK7Lg@IJ0x*nhPOdzH6?7p_U#zB2#+)!-BzB$i)gV z)DCD(NO!IEK=omWRjK;^3lPhrcpnI#;g1dt^RX%noW^T&`0_75BB%;f=YJijvh;n- z{qz4jJ{5f=d^&tf7Eq&h&pdo8O3wmmKhh5R3|r8DA&@@keXzs(V8{J(NCKnzj{Ba| z_qQVBk2|x?NnJl=)T(ebjj(K8_d7Td~`1)oQG;9HTlmnrtf;Z6p?`xo-c%qRu3c|u^N9<6Y@klqoOJs)8 zTp{6q6{;i>YwpYh>BK?mI!Feku0xOUE7xuto?8!VUZ)P`^E121DSn2m@G}W7YfxPL zp|gI{WF13Qh(`@-8wQD2=I^s3cw^RJ%;szco?ZXvln0GbD&t99-Z2CR1Zk;O*(i7? z{qWZjd+5FnE9a4Q$Y&76d1oLa0YwV3ldg348dER<2Xj~e)_1dD;Cmux$d6#yz_6o0 z`B$)=|s!|8khe!mZ6D!Q27k^UOe*Elu`IFmA>9qGm9dp|Z;R0mx$ow-&10f>zc z+eSEXCtG7duXTU&r@DK{|O+Pas$rcb}29n)Pz4QpF$_SYzkF3HN>j zeFUoby8n#1`(l-QoxTGw2M5&W?#y)v%wBW){!$bxeAVj1B2Y!~; zh(~3U(hq)IoqLUe85nf-1`QmLjsbubzaHRhjp*iVlw2k|x$_UeKd>f;e?trs9>~c54#vN| zfm^sh%HkgD56B3X!AId=jOnL->QI-|nLPY+5Otxz5$HOTh#q;y+~?voZwI>Yvsn;% zsF+^HD*?q!qe;$;<3hN`DGqdUQ$_x{u(?krFzLwT4E_gICBHC`<`;vF{~C9njaNP& z>w6DSKOTGZ-2@xSEt0~SfV})BBw`eElCzd4M7`!n_e}z<$o3zJ_iAR9o!(A=pTF7yxrD2v(KQQon)8#hs1Eo)w zy%AZK(G$wlg&h2+XwTf8IXi>{7!O!HI<@Vm-e;OJc!$xQ4W;_aQ zL>>U>c@7@vUI8tSyP6(!mBQ#M@pp;it0^tZ*97Qx4I6Ph5!`rypFb&IO%a2l{ei9n z>McvKF7kUz<6qTRIAGpSbGVdAPL8PiDMG%Vcsjyt@{U_qFHIfhzX*PuIhqK)S#Q+E zP6ZPX#tWO=w3(xHpcDO^fF%O=rl^5!hd_OVU~b(5u{yHn%aiN-jTldSZaf3+2wTZheV@gSP(I*5Y7b> zy;sTCo@$nXR~1((0;6bxJ2CDr2BBDTlBqfUHPvZX!(hK-Z6j9)`hY2OnYw&+VUq;8Ef%gOdWm zhcOhnyZ9m}a9yu487WVPECHuXNn4!RPFbK69S;zktyC=k_Vi2t>hY*BzXN#n^f3G~ zgW<0_mGI*G;m+R{N7udgx-;YMffxt-w6H^@9OnKb1iuh-dnL6$fh!Q}`F?SkyWoBKyLU2Mc$3$5G9sk5 zm$keR!HZX6qi8S`O>fw$DBSk(h>NCcg}LC-1N_4AZgFzK6jn-@@PkK^wAa4UM4A_K5AzI9A8usNnbM08$;aI5LV5-^ zbFa2_x<5>hD(KJ*z0Xen`ejkYd1X$a<*js9L5^DloneXNc)k@n-QSbh3?r5bSJk}T z{FddsQd2GiAut)R-LhkaTO<8NJHbGzI|~whE{|FD9)bQkg&g4L3~7Mxdjk|~5F=lz zr<;10%{}di$59~^)?=x57R?(@<-4)I0~5G!kM;c(dhlYr@C~Og1AcR>mZ`YzT+UGEvaOa?~^SEt+Zzz35yr%a`EDL*ybP~=x*DN?> znw^Y^_8@IFuSvKFHt?UEfXD2-mihJ0PcipPm@1s^KCCV?+-Ef03oGba;J&$xc2~qU zyHzbLq}ivgthPsGFD0*68tRrSKbgRLSSK56r8AqF-B``bft#+U z6YHJIMu zz^_DOIyceMrnZ@ClC8lsIT2kmd`CnjC!km`GDICiejOxE9uR#Zp%`h3a?waHMurmw z1IrBILOnz0A=m-mSYSMf?ipuS@0QPavb66-?EO`%7TvYwWm2yQ8K;n})L!kem9U=@ zC@`&f%WPRq~(`%ET<)I891vqPrY(VEcIm`Gi@VR z^9%8s%`NautjW4!vtPvA0%vwzar5C)yEIhcw=Qd8#JoJL6_VPL+9 zU1uNc^k!a2QGdKMS$1*#bqNAF>DQH#S~hH{ zDM%q|%GZvx!!M9MkB#~wUqaNz!GOgt!(5e!I$oZLQb1O$gZA2u&EihCoAf8nDSpTc3C`~Sd=-(|)Uh_5=0Ce;aDbW$)l zW^~uC{OEPZ%?TzjVr11Hz4#GwX{#>X*k-od=M(N%~qK`^bR+lV{rKB{Nk+%zkeTI{FCvT_p}ah6vC04W6t5~ zuvU(Gd1C{ehO`E5l1xH}hsKx=HY4~s6eWRit_PFp`s9HQ3VhTtoM%9=v|z*_mVER< zRKyTpA*O5vkhpkor=pyPi)m=^%M9fe;Qz93zmXAW7)=Zc5?}Ld>oo=dXkpl5M(j{1 z715*vbfX)<^ zJ4uO^i(|}?V{bCj##2fmCT8d1`d>0?wpbp;@LEzo%#xWKW@zi-iHH78nuig)64 zn>$QMy*V5^uA~M=9XAij!#WAuGUQbe6+LvBDbT86TBQfgH^UjUw2x|ExRP!E^R|6N z7zZ!1{^m1AwQq|ay8X#;5-g&Zn{So;B6*j2Qju_9>xtF8AL#rcAQ{yk0|z|H=7S?{ zz~Ku~hKvwpsCj|k9g}wy1jjB??$o@d<$+L5(gpO%S?qL>D-JsOe&ELC+UyV+tfFJ) z*=$_OR_io#sc!-7;k^Ccp9?VB&R^Ue3BQpY-rT&<@31#UErt&(!=io-^m$(^jOE1w zO+ukqWGrYc?3jpZlX~r<+pcFO>N>raB%_09TSNovx`n7Wc+n|UgLXV)444VB^@`>R zAPQ_n153?n-^6NvzwH#;7a%AyDH&`$pjK0qE0BWR3r2Q8zknT!~Qq| z@<)-gbL0M)Q}g7COLF}F!qoI5*((x-TNk;t+d`a;?JX}yRdX^9S1fYl+vwNm+gkj3 zB#wK`DSRx}xqf`S5WgDhWw|jBEW(>mNfF8am(U0@2Kbds8GPY7Iy#NFxWZx$UMn?1L?0OG7mD}=vn;cJ4M88oxXQK$!P&;W;j?z!+ zua`D4o;=L7_^_^PD|b?p8LrE}oa8iTuJ>M#r5uo+=NNI^&>zu_%s(=ZNW9;+Bg>1ZXQ-fl&2-$YlP7aq;6z4 zjJZpZeP6=m_kNu?*j`^1=k1+5)SGy=8y|e~X!#<$_^Y;oXX7>duU%s|#-dm40a$w) zuc*)85KB&bZgi5_Lg`vo_+fGycGuho+w=0MQ?gY4JLtc}9)|$@yBwkg_^;>lSE(77 zarMQnFTS&gW3srW+Sl^9$T9h*mO>}9T?H5?1ad$8+_k^VL0keSAK3i@HhH+g`=)^X zw-p!I{m}3}sVfBTkjzC}T9cc>^UWq`6}WoI3ioCm(59sU^#a&jAx@jACjaPbC~13ToL=Dx)e`8@_3@HzfxI|x&8 zb$0)?(uk4TG>GdEIZbttHYJI03O(9ZwLn#EHC1hGyUJEYZQ8@B@!+a1;dJ5eGyoy)C=A}8XZQzN(9ks_x47Gx?$bZF#; z8pA>mcrhIqC0=pdFCL`ew0m^xC>H5#;Rr?Q{LR^a$A!HQ9xkte8+kJj{8|zJU0fWf z*!X57@a1qYP_bPRCq(kGk-*6<=|IKfN(qwiU5NF`*X({XP``_>tAf$M$#b^^DmI&< zRc}T)?@b|X;X3|XvWEZ8zk~n2v8pz3@}=b={s&?C|MYTdcvRV)=@bn*<%%~J>Hmf@ zQ#-M`V*M7LrquQd{a-&r|2LifW}t*!zv7Q?2EP0_e;fJRZb~WtEWS3Yesb*ee<7}1 z{FR(t#K&WNP?TY)NOfM3ZMI18V$%<@_Stg5uT4{7_OuGdZVMBqCAAj(?sPSo2fX@S zS&*vSlt9Ikf)Y>^?3DF+eLw3LDbInC9DZ5atOwjBXEQHP`Z;E)AS0-MN|9l&hCzKW z;QHNOVKbpGkU)DSUzz5W-m7dHasB&r`)hV40`>d(xVXaa43nShgSvb`L!63@^|nGm4-pebyH8ks%KpYUJP{+445~|J9JPAoE58O4-4lU7?|Y2zFT2iPUlG z;9dZO&X55B@XX@59i6c1YK9oRs%rGWY6BIZ?>{&^TT9;XhNFRsxm&2kOxt60fP^J$ z)SW?M=ik9k{@m@PNmdCzZRDqKtWxX+Vhh*#yIjB7@+-gc?LU0Ft(# z$z5_bP%60^u~Ee}yHPgG+cF>qQaf|pBW^_NKT~=EcWd3f?H7|Uu17{bCVYoMga8JDAB-ZXesLnH#jquq0nmRKyxDl0sSmyXBksOc4g8BuIEy#z zYIuW_Djj~74xkhiN?+&jb|qE%{8!Yn5*B|;@4r)}pTY_2`*2g&cRn!s|Vw4&A#9d=PWK z4i`J&xM7jb>$`hN-Q3M9Ky|G2ZWOPaR7#)ei?2DL_f0s`Ul*L=I}K6IlE7PNI1w26j% zsBTsbOW6)rG#ZfB38Z!D72*9ES=Pm^u@6I;y9l=hoWd=URNZ*&-Xp^woWkeK$1Ax8%-oa(4Zg*BtU9N(qx0EsG%Xsy6!Ev zSHG9`YD=x&($=fM0?393B_b+{RaDdsp&Ah(3bNn#nVHXKHw3l!e(xW@*DuPR zc{p>ys=yJ~T?A;wFTawy%<(oVp{dYH@2HvL(2DQiICCeX zDRxs?2DZ>nTH#fB{(XWNkb=~bi0cuO^L1BO#8oS z9&s(?z!66;nj-yt-)o8_`%YD-`Z@=!9{`(9`}#8g5!bZ)1gn@+KtabZAw}7S&&c>X zVu)O*iL5_WA*X>X^z6`UU`v+l?w9mI$LVawM_hkb#8^|NDzJ=ZjV|?l70ENa!N<8u zSJ_uO5!l*~-Da6nWtIYt(^rU%rxTHzYFOkFkgT#nrz_-HrTZ!m+gP(w>HY5ZtQJ=(uEMpd z4^tf!$ScBG-25X~=R6@RQ31~ia`__S2B)9G_l&{DMj@KQxA%VK8kp1QOvzu#8}2JP zi?x~;+*jj=rgts=7W^&v+wr&K--~}Q{x1Ao93o0+_#<868TU%&?Qe( zMpnvwN@XEhvIps7$%zjZbAgSyvDU zj~3iHMr-bnXOq!dddSmawB{A5GDT}`;wllX?e3+uenuKDKe9Pf?9;iMicV$)St*j- z>1@F(IK%B6nBYut=vIIoPm~uCf9;(O_eO#L)BG=NnLl-P=Pm8$fX*`myNTuVr z+_Mr_5U}5|%E5$&&$|T*DDqVA< za0_~Bt)w_+GZt!tbvSTXz5t<+tTg>d6CTT*ZxUK6p(4S7<%FI`D27Y57z|fwp=9-; z)YT&TvQ5&mX3O{~%xzf8z=p59N{yd>b)6_fh71E|>G4yA+&id3&ekYPqbQ%;q)~Q8 zQM$!82VFCxDBBFm)ZG@9*EGsyQIs_XW&5iZ%3n0f_o67x3Wa*1?Sor({TP3#%4~nT z0g>fyz~+ULyMUv!N%BC^#n^`wQ@gukYd1zB}O{;=kf|N4ZwKAfxE zp^Ja)zbOCnsV&-{Eq>;>%Tw1%KpsP=SvrI(u1tvI_d4W()RiX0wM2)ozhFX!F4iHB zrq-H}wB>~8gHP40`qsQO-&xxtBD^!-xrcSLnvdr@7r)8B_vYt1_w13MeJqXTA$G2_ zdP{CFmnHYwE$CvJn~>v@whqBf;!|>=&R0tJOinv|1FfgPOVC*4Xd`J!0&%i~v)P+# zDB1Q<^8s9q{0lXAMO|`xjbMZnFYP)O4HJ3N_~#8Z3zkItA9e!>5YDHlfW7>}VQ`kCpi7ZF7fx$7jQs3YX@D#1i6aT*bA zL^VM^u@GcDM{70DjW6PwK|zF9cg2``CJBzS;1s_4PpYnmnj68C2_Myzi5wL^)Vvyq zph(i(CLmzH0x|Ik0(ej*r;qY0)scWT8mt3A|Id7=PpfHzjZA7n%@VHY1s`k_l#rUX zN=QgC5Ld)C1hP_VPz+RpQj#)G{%o>%A4=_#%EY@B0M*@W*@>UNq%^!EOLY{P*GP#< zz#~i?Wx77u^a7>f$2E#0igLF>`OQlf6~9K=f3-zrmO)t=r7~ZmgrX?p1V#S5%;(i{ zkl>nCU#SkIh}K9(#d4Y{J?s6oDNF`AZ&2z+r?oY3QhiMhWmgci*T`Hy;0mKYv{-hh ztW#`Tu9Y(KdvZ_aK6%`xgcc;r9dzBU=QZwFg*)XQjhhB8lLg|ltBBwOse*vxMqK$B z?0SBg=$-Ipy@QWg-}L(J*AUz}b#Wo`cojygI(ji-_u_$amcIB(X)KPRf;HTm@uqJm zJ2ii&fVg7;y5TFCN^|`BU2wi!3M+s1R{%@8bG3B;PEf@4yJjuj?>QAI*_dUrF^g<` z0e!Mutq|8XX~ahbk-^BU0`f_WoU8~qelISSkA4LcTI(Ix1e2DLkN+UJbMoRm^07)` zNIt-5S<%(2uv{bv9 ze??qBFj8HLREYXL@MLNna3zQ!39r%?=@%n?06A@~DieGIm#FSto zZ2@~F1pKO#4K?pF@p=BBkPkJ#Z33tcw~6-r&3g$6IL@geQ6Z_%7KbNkLaXomQ1kN! zTiYdCtXN)2BqDd7n&*E^Fbez?$pyi}WU*<+kOdqYnW05ocP`Ua_Hr@b0oN(Q5-p_& zYQXU;h4b^DNZbspfa{~%Q7TO!%QOKQY2U7p9&gly20}>cein6qB{910-z6^HhON5a zN^Pkj*wpZ$uLl8>0We|M2ox1l3RMcqG70CgX6T$2zHsrD_A>hvtE**v7}+?1@l8G7 zZ#X_8vO~V#pfNFAZEnENWgOnX*Q6m#+tG$sd3{@+x4Nn@;|SkU_PaVb z=&#^FD-^eKTo|~!JD-o7V^)suxPu;;__2Y?y%#q_d4myZmh^(lfZn+Le-+YHhb|L<{YVkJ&ZwRc zH^_vv<5X2&uA4!e5&)HbA%H<7zd}@B%pSBC!dlHS7*?H+8&#@XYJv|+*216g29{K( zJSL=}=1hWO+g6tN2R3^(DA8ac0Cr0R1ne)#wAZgtLd`{l>D*tYa$GDpp=L>eSmLZT z7$KEj2^w^K2@PG~&Qj==4g(KG>Sd~h(e+58R}t+~ zWgcu+nPw8QB%~kU)>AdliadYCN;I2jX|`Avj~tKJiP{$5u2t(gO(ZE#&Czy^nGAz- z{|<^&tp$C$FA~9cBCqu9s!W^H@lk2B05XE&6oH&4;QW|hhxs4QAxemHa}YxnUGszn z+(#ri1^$nz9JsZ5CS*RiU*tr5S!u!Tx2Nks9w4inE3 z(LT|FH(=GXs^P^;g<^s zgn$<(phSa(8Z6OZg$Antq2^+Kg;q%6Dyq~E6A15eg|(W9bHGv+U=1EptN`5s`m(cMy z3sVS4_VIOTUyJsMBze!6zc|11c{ADlvmG1FDPbWG#gO)fPs0a)GKOX1&at!H{`l+;GerxQWyoV^bga zu}Zxy93VAQhg9TXS;8eC<6Ud&kjj0XGI!wn!*|I+4Rf=I>j^Rl>V7xct9Z&ZV6P(F zn_-_VK!l#aaXggwNBkX=WQ8=~`nhoL8F`(iC=IHY8klyc#06Y`ibwhQN5bqgDgY>= zC+t6R)7cr*k%f=G|0<$%?v4*BgYFHNxufiyC2=MpzyGxnVMNvoN7% zJgO1w7Qzxkp~^yN(g^#;n5uMxq41oAFjpgNv=A;61btpZop)Du-gp59WwC{Fr$#wfp$z?$VA}Xz0U5h3lb0F$y&fic zcQ-~S)+j*E9;fjd0@ z7g!Ph*xyKaz%@p&jMOdjO~!tzr5>Uwd}b&}-XFG54lPnlUei>nV^D6lP~Oy3rYV%6 zdk7{I+XeLGo#oVMesisaD|CK;EvPELe!K9^Ssr0+D&YEY3^Rw7CP_1!p_s{riaN2~ z6nm7UXMMle+{_tVlYT_4@vp@cGBOKe;Cip|BlF4|5Jau-uTG}>-ou8?7+JL`NF5V# zy;`M>W92|b0x*@Ak{GBlIb(Z2aI_$JN2HLOrtiqFJgkNe%Z|(BsP1Ae3%rQST=Sii zc_Z%<*s~^fhBvt6B5%{jd%gZCyx+mRi@`ikR3DayPhJl15;S>y;azAKaUsIx1^zor zg*smsZq^;*VwTTXsqy;nEXfarWEdi!4$Lm%ZKN@_#hkq17@?B;Y$Nwhq-o6Fa(#j= zp`p&3an!r6)p@K%{`Vf?I=8Rvvf$kszRH`}?ydYvWg+pXcfz~A40XSbBIvmGNfs|& znkt$g6U#O#vgg-vz>&RyN40uZagSPVIx$(mV{)R?x z(B2`ohTb(xEn#X!*M`4W%A>DA``gjTKt-d>C6^RT_yC@Mbs2?hqb=z?+pK-6tk#C# zoO7JB5C+?n4s+`UZ)5h(8ItV+wroZ$k%1YeB`f?p@Zoe{l+(8{SQ5)1&;QpEF5&=Q`l)orn4!)3zve|MZ{D+EVbCC)cTnX1xF70Zhf=VzHSKtJ!(qIjM zQHXGcjReYMyVkTc|HEq~gyFJ^@Z@l?CQAd5~K*TkrQtDn| zF@@l4{ulB^J(<2vAv~%OehC6*?$3CLD$!AX71bnBLDwuD)}X>_H2Q8lA+JaOz@YHZ;#%e?wrAXxQEBXD}Ap?6ZLo#DF)-4<<3S+}U zt&wA3@I{E%)TkA5PovaY7_8zZH5r{RVMpz2ShL+3QLX+WZ*VHDeurxH_KS&-LFt*y z$-Ti6TK)%nz5Yqvoi0ht>B$}8_l6V2Ro>ia!?X9DwEHgpaiVMt7fJbqS;Hz$L`vJ= z7QQ_TWPig-?t=;}T2bI%)WtYicKJp4>2pQnb|ZW#!siEg6x2U-L#Y&a?z*f*ks`P^ zi3XY}l!6b6TbC93+&$chUCgyk1ssPkCWzoW6ZQ>`!%0Vyot{_y zt`36LenqD9CsXMp1f@SHzN9A;I{S^!_>S0M4^?(PTs{>MT5td z;w+6Qq%FjSxN~0+I?MO?ve}Lumph@|H%4B&3l3-uEq^J>=7E=l4VsX=As+HlxUqYjWpn*IYY33Qug&`s@3_Ex?t3q)4Mzm(g`rQ&-- zEz+5Los-+b+tY~G^}iOQ@zGumGW`Sk%F{2d+sygtMp3+-Inn4K=m zxW1&O!qxrALl?{dl2t&8NDwG&k=IVnQ{Qe<*9Na|r`qa6s&d&Y-+l7NOo}=g{;Whr zTtA*88IZoTE&STW($m@(3quoB_d~t6RVgwD9iQu*1zgh#zzH}eff{lBtxQE;W<_S} z$YCmSHIa?k4%{|5zT!y7MfV(VovpEK3hQ>TSP2K|qG-vv@dfPRYh-t41a21T_$AjO z$?r57`a4O4DC=g5C_+a@0&krHzGq>&CMFipQ%eCg;zy-bBu2YSr~(oaYF^H-CTwq% zxFFwl1RNELIs z1ye)XRpO32Duz$&fIdkkL_^JM_*EIPc%7 zYJ_YDP+K7PIKM)UWR73!WWind$?Y$qxfMat(3ectn3t7mUH{6CQGfl_NF@9Omju&9 zyTM|r$FG+3K-AS0bsfT$!aqj5Ah~godC4WdQ1dQ+`5&DrGURPHUPQSnDvBgSlxii) z>QXJrSVReV(orfvsv$r|?0_)}s8zZ13DDfKs7EmM0_YI=<$suZ(&1R70`vHll<=NF z$>~DRBoN*QnO;R)gGx;;mWmRv%PB`v?OLHs52e(=PhzDfOYwco7n6M$k zl9KQxgiv!X6LP@^g%BJY700=l0ckgbB{0;SLPGK_G#fR|WJ2)0uYE!|)ZEDLgj!=NW(t{m6q#UQQFs>l^9F*elL4&w zI*5=JUs+J;`4;Mq9Qhu~TnwjHd|!JGd|AhP`wX=bn0>xfB>ZbLM1?_D>azynIgN0R zh451lWG(SkwVqJ8BK!-DaMZ0RtO!>dgfpK~6jp?9(+F=_2!#gWJqw{kBRp#%j4(2| ze{U#Ut`SyQ2&Wr_Pb~_AHNveH!v2f3kRv(mqN>3c4wcR8H9|^wi$Mr#gzoSzjWAXt zbcfd%gts-q>hO~qVUR{x9lqBf-0`$g)Xy}+=jRzs&Ids>x!ywfu}0WwA$SZzhlNn2 z5uUIRQVl}-Gls z0oT6>ra_r&q5Mvx)M+YzFetJo^}m;o?SxHCAJZ zyuwGYcB&x9(IT)$YOEa^tJYx2Lhdf2Rh~L&(6Cc{0i&GH$>0w(%0`7U zbRWU8_j$E5WfF%)wmDO-;R_MY)9{3BsyqA-z8q065%kNXWM3zN>QLvGJ1?fHCidye{cGDm+K)uQ@odrJ-?srBr& zXfa?f6#_xmvc1P5T)54#2e(W$o8C)Mv#3am9`*a}S&Gr}twl9S)CZ=B-oWy$$+bz$ z3130vW!FN6;G&3YGAfWUfSfWRW&tsZ)_PrP=b7j+Dw-`iMxV75eaKUbMNuaOJWCi9 z;FbjR-zxwS*QsP!$eu?!PFb!L4KvYWdCN6R7sS_vS_Xzl52>%J)M~v~TD_agMESV2 zlY+}0G^%2gbGd^tk&ycw=uEf&tFj;ul1Uq-?PV7mzId2WG3w|f50n=R9}5ZN{G|*x z@GSxOAAVeW7!HZFr2+!>ZiHbFvl1VN@%W|NP-`kXu$OYCWwpW^&<5@mN_ldul`N?w zEXgWP$dY3uforWI*2u4JG{>fkD(s6$E=vvIMqF8_iTo^si)g);b84cN;Dae7bEZ4i z5y48I43{}xq`(baAz^PPoPf0w&Tw~laJ9J79jn$ME+=l<1NNUQ{mx4Dq0prgCTK07 z$-w;B(*keib`E=*%Hhphox?qic;_oGEvy!D;~?i8UbvFD)#2xPH5Bf9^N+@i^U#voBtU?5pU;pd}{IefYV%rg$ zTDO>qXI^j;<47&DTo^E19c5Q{1`H4G6%D53xC!l2PH!f~+m2J^3FS!*mnN4(Sj07! z;-og5iykt8k|SI zf|OHJ1+pg0H^cn)%y7Kq6Q8sYDlAKzkfh=}I+>L7<()e?JpmG>5!d^OB(3sKAbR<( zig?V!UQpdQwP@``{754Fp54%ChjBOVZrpN)G#PiYvJ7~_cv3>1y&atJG-pXe9??3f zXAj|AEBur}kk{WF&*#f%;PoP`(3bG0?=fxMzfFo-TN7^}xR#VM(!EdyzRNa=Nu9ls zmDsdSp3HRx|3WC$sU)13q((aBgGGD^c-^hXLerusdlMB(ZWQH7gL2jr7L~tglyjpf zD-B9{6y+Bh<*3VIw8)_RYZT>Hjj}t6aDl`!tbQZ8)>t==j%ZP)Oc?j4;P-Q^+er zjrDx!GsMSWL%(Lt9c`@Uvw8+`d5BbPu*^V<_|Frmn!;y0m%mO1aB=0vpOmYc9kObq zgva^!!XvNaSR{Pj(yt@o@z3(};4*$PxA1dKCqIk3_&NU`e$M$VKhHeO&->>ckAxi; zu@@S&AG}B8cYUe=S0F@O#f8!=`I-U--PJJoAbgCC>wP{acxSP>o*&>m4@V|EqyLdB zZ_qW}j}CHQkOiCEz>A*dfB0OY-P4=86B-8Q(JgkK?in5FJVh`3v$|^T)8@U#`hwAi zn~o>e=Zua7HcO(@B++TXC5fGO^(yP=Jxxaw>W6xo5A#t}OCA?7yD@O`AmsM&HGibc zHg>)f+1&YDEc08Gd3eKO=79=eLz#ORkSKt6cXtxz3EZ zZU&kB-MdtZfoc~XDu+Up>o><$<2-h!71b{q)y*pi3W@bfDhV3f4CU|>A0LaX~vS9YND zp5^3m*;k{e4GsOnw;hwp*?CIDbvNkp&|~RI4pZeax5mU{{+6buFz~BN{T*M#OIx4` zZ@tVkVb2t)-t|*pBtx!euyxdM`@zXF=Na9yKJjj126~>8F4%Jv*B-xzs{%cpAv=SKTA7cTf&v_8&Ce z={(cNTakraWwe1X?P?R(xa@zOgiU)P{EI`Ju~;W(9t)?4**a~26w*VfqISxOTLAAE z!t#f?$F?H_PSM%u_U#@2(aV22$ztMjrpw(i+Kz(}s)kGw8;}*?r!vXY=4ixP{V`Q7%_;PomCn%V5(c_e~ok zt_T@4GW6y@Tl4?J@73SMUWSO}k6&0X2|C8lE?wHC>wGCsg zruv5bpLVkRPmbnamI~ZANl-t(H!i$}!bDH%u?}Qh< z&WY*)&>W8WU|ggsy^$Yk6$VgVtnLKuZ)uog1y{34xRu@UE#W`)hbIH5<=aRVcdTHL z%#GO^-x|J8a5z@bZ}gtrKoS*v%#(6UB$uX7N#+XC!UQgRg%lMXU(BnF7!|=;qhM{i}W;*9Cb{uNBMH~>V$UZy=)*M zo?}LiY@(oH#{^vZ$V6c5<>Jm5n=U|}tY!Mj$7vLXyeuQTx28BkR&j(V4!$X&n`aZ% z6vyk|tvJq0Mi42Ez{!i_=&2&CDh_q-V8D|F8Jy?JZ{6E3{McYoy?yyr$Qs~SpsNm- zlt~FwWpX%AA}E9jL@iKAT+0<#6z8aW+2npUPW;3i2>*VbsPj3+TaJpx?wH!$`g@yaLc8C;FZL8Rk}`LBfYGg@NRzoYZC{KPhn%b&dpt99Tk&)h@m$uMGTWAYEa*9#@uX-sTWu1uxooCC^%plpZyj4&Gu4CEA z6ka`ngZ#z+Q!KWWW_`& zkc*Wdx2i(41Sg@;vv^lA^fJbKzggAh~g;U-B+UC*L0ZV-3I zSg!yn6V)CPziWGVQJ2VfY!6PmDUxq!51q^$PbdV{9umV3eowWBN3TFu)gFF^OVsbZ zNU6U`B8>X)RY>1e{rz)A{eMurd(=Mx8nNoXP|?)tzewC#{f{1sYY$du&|Ck1pJ3^K zBQ8t-FNiy1>{bZIe}KrU^#2vJIMIJwn$mx#%vaP5nP2?u@Zv z0sq_jcgmFSTl#}eWjtg012IBY{byE;-N_SKmHtQJQuRMo>Hk8BF#5kpA$?c<_rFrr zf5p2;|9i6H^}i9np78qZA#t1f|C!OhHC}xdIc;Hf?a;EEip0+HVwWp#6iIl@#9zXQ z(|(!wAi$tA?X(H7XZLi2^as*Yb?4MgbgobPVt9hhUZ3TCCG35cH3Ip&+k0Vaeqzg} zjbGbR&gK$4_offNww-qNrq;XemKQVKFCM@9OfD2?c<06LTOmld0yTHt4T=Vr=)}a|CMe2>t@5_^&1rs*-T>0`wXTN;EAdrjG z2yA#iZk3|veIV}y$8}`jV8fZ-*4C8yM;O5!Z0L7zqqlWSO2;jX4H(Kq$GDxW4Qva) zaE6+Eut~5j{48!!-N#x>9Px*WI5rUO~LekAV%1rBb`X@kaB`OZIgdlSFp zrW^9RQ9eqb4`$=I#rJ)l%#&GGDQ8sWWK+OZki+uj&dxVB=P{XrPZrl--pm7Fl7!Os z$$QHM^3?M6>h;$m#jA@~Wq4ymu4QC#lC2`&_wzHDA1;->3?UqG9l|K^WmMN@?&q19B(!*03&Z3d?E4+cEG?{7g zghR3%dvEg%8r{<6bw1%J{UM8BpNygsZc5*{Hlg!Kw7i^8+pi(AdCPOO6C0;ESJ)@u z4?jXD6#m=k>e0!hQ7xT=!fUmsKPzRA;q2UhpH-Sx**9j}NNNkb=~TNVOl_ea8@o=GZa@KW&a7ymrv_gw=oCep574ok2-ONrW8H`{v^^TwvO zi1*bt@8}IQ+Fz3Z@Q4P#(cn=H9@F4I0h{f${3fiG+CT$;mVTepl~Uu;8`FcUMbFo8dbc6OZ1B&Q4#xr{PrZy{=zgV%aH;)0q8lgxKzT)0f0M z2Lr-q(g^R{7Cs$dx>$pdc&wt7dq=8>@Jy{o*h@`yM`a{0J%Tlh25N!ynd z#7V@5-y&f2mgW{OM}p;ShiSJ`-+n7i`N;0GTaN6GP%hLcV?UmiDimHv%J41JNrtqq zi~H<_$0LE=;X}9;hJQ$SJF81PX<&lu9|p!qB7yb#GW3$0!HBkemJ)tzEHs-VHZ%Qg@IQC$>DPjM5H)#(IASRk+b}8 zgFXC==x`^;7jA}cU}NX^!8lK2OlV~B)CSHTa4_OBxfV0#MY)-CHmbYw!oR}Ytklj2 za8e_G3ie81P@pQ8TcD>3q)r*z4bqOIwp}LSDO@;b_gtWL#HyNoEN;=Z^O3wj>*xq~ zN9Hc;s`gb>mmRFEuHY4@RL|*Kp`4T#cvHFz zUL+gPP~>fLbTOESq;*{tab~xiA}0f~OHb)%^PQhvE8qwAwJZ$K&EJ~prFNKtcK)Wd zeh|myhhEG%gQm6wPRXB%v-4EK`r}w9^>ISi(qY_X_z0{6M}@P+*17(J{`IGmt{>^% zq8ra8WKex=$UYNUq%MT)({Z616?Jy~48b_3{#wW-@b=yNZtv;s@}`Z68A?hJ&OPA)$1usPzaYtN1+r4+=x+s*Fvyy2*d`{B zA%+aOau~gkr5wy_#C4TqGVo+KR7b08*x8~g^N^zIqSl*Bezh#elIQH z#DiR<#s_q28(2K)vV^R5O5gb*`V4V#_0lI`n4?BCR(~slEY@6uj)BOewk27+o6feQ zH<@>o!aHb4EO@K0WLROf24CK$vJ?qVB9Yh6^LTvkcDXpoX)76umaC@ySK>~jU9V~H zRtZm}-LAqFZAl-c4X+C0=c3h)i=d+Is#-%Mc8bJuLAgJHmr+3pCxODNOFoAhM#=|C z_p>{uhyPe4>Xr<^(7#ud=MJAMB@=X=M+xYF_o&@5@i*%DInnr5iSL*#l5F3;PAUxa zMz@T!k2#mU-UnMYHl@9Z+2vUW3Pj)Yn{yN%%MP^AJOXd(ntUPYDcq#MwwH!KEA1)# zB8+6eys#^GT|2Sin+X;#_y3KQOg z!sk0dxm`n56`?5(x3t4Q3xPm$n?$0IBClUxJ&PbJFjrn!z=}#+QiHT`h!$X_V45V? z_!P0eB)b>Iq7C-5pvm@_v_j}fV+(q^oDZN74!#J}i-jrNa1zitYDo@y6T>fH zs@2vtx{|$WfNVo_oXWS9rvDWR3xxvt9{;Q!ktH`|@*>0)+?{X6VCVOY!3H-yyBxXB zSnOzemQs|D2pC1_5fnoa4jek@t{AeX{cMC3Ds>~BH;$HN&8uIux8at#ze?h`tC_R8-qyWt?`Yhk zJt^MNtzNT+38f41jP7B@C`@kW^Pi0fSYogD2sYhbCtg~>?2YSeIjY{0_iW4{dA}L1 z+qbVxVEz-dk0VTvZSLO2$hIjtDg2SLV9EVRkJ40qhZ=jG)GhmMRCs}v3QD~~uiqnG7kU(AXAiA4RZy1Tf*UXR9U8;VsSHEHPyI=htP`{t3-*j4HB<-MbA5y=E z)vwgYNZMEG_n7+KtbSLh-y79$l1h7zaxaMqpQYS`)o&MN9Z5S=VZN>09}TzaWMP1N z;d!<$@JiT0eO0DMmxkD2Pk`9(|5Y_X<*adu7bq2g3++qa#P1=pE66;b5zdn*u>%?$ZURcdO_E4?x66Aau6m^>9oJu4i& zr+_YVNI^z>p>yJ^6}*<4mV$N)C%k&F{;c`A%igzj6$byq#u7^I=0p|T@M%GS)HDkw zTANZ1Vglm+nzAn)!cfT>d=j(JQ4O*A>d$$em=SeuOzr`9r9MJO_d{19pw2bl`6;(M zrEKNdA;&cmF{rikX`ZQa&UBrFSI(LxN${+##B6kKZnZf}?4tkUZ zBPH^6#VI-E0KoA0bUe4aC9=mEm>oU_RK-<>IG=Pp*hSDiCIBz2MY z?c&8UDD+e0XUS7#Z}G1UHg9od{HL!wH#k1z^1D-bXv|sE>MU`sx)okCUlnP?B7KQ# zvJSy@44NdA#Cgt=SB1bEtX4L^Kz2OLpsSoIIWgs)SCh=r5r4M_<*AS02Ll*gVdGGje<@=pCq{>CCd21iEtr2c5rpr|#^? z#-^i5OAo05vQ&0AZ@SIM>9~OwlOHU2n3dz=hjYTuoPp8XmHQmq{&%CrA!s8{j`!tI z9Gmi-8#dYIdz{ssxzDk*D9+js<+A-fd%1tUZWs05S#yl?IFcYY*DF^)qHEuf-@A57 zQqfcGkwp1@H$g(XgjvoM65Q1-{x{{=VJ6<{F$3kdU|^D@n>8?*V-Afr2^u8it7j#s zi1LJFwh&Ocv#5Rk6lZl(f}mf~UxYg-BF+s#c2C!Q=iGx5Q`MhAXI`qC+x9oipX972 zy%0_ZscJKH=YEK*I?UQ;iw(kwip1NbtdUICel7Vu-i5PnSBel0eV*sMyF9f>Fg}ui zBjO6n&+A~-zb3c-*Y9*oz;T>42TfXJEl5b>PI#_0BM8BGS;{f2jP)dHP$T$5 zpSl|ILg287^c5(tx%I^o{NA6sQevHlB!@K{NP6f?d@qXcWl*~$H;05j8b!kGxT-!7 zZyQW`cwo=RLiO$W&dxSMYc}yy|0;qX+C=JIDz%^=>O|t5DUz^-gl`df$SvYMp4zAc zP>DJ>39$o0ND|c_k-Qw*kF)a#Bo!f1@}al**@Jbg|6KIEhth)_GDvN!`BD^cK=UIK zLF>N|LVF_o9N!Q7*98L=*S*5xHj0GC@vq6t8-gI2JuanO!(ywrUlF&ZsJhn$`_M5k zRiPh}0y#e!aElwm z5<>&0m3&3on%8pIMX*g$o5u*%7Ww%~qPuLl&+Tz;$r1Ms8^3$Lkfgh5lkW-jS0$|O zwKIi>(ED@?uG)Pn^xzr7Z#zGoqK!`8&!{_Wr>sAFR(e~4sylg8U`x)r+i!jF8AQNR zDSI~7S@MR*IqMbYtj~D&;h+e^=f5x|#ZjTZN4k$ATBcm*tWUuDP$IiL&XV^DIDna_ zx2fJQ$S>N~%NiKiHQl++5>a^VYc~1qz!Vi9pj-GFZXbGhW-!k=^K~F^3eJ2RS}*dC zmprOP1XVV*pOB=4XMEH5LT`^`tM(%_Sa&c9v%A+>^0CLc;cf0N*zjII=Pb-BrW6ql z_LEp#cYT)YEdC(RdHp^lfgk3QZ>T^F+(F0Y8um1osnpG-(E^TD)cEsKX`~s}12<(ur>SeP0 zCE2CJ{n%OZr6ehazF6)4Jclw@x?6c+H2r1%ZKg~9^CC{NIZJk+ww_7brObPUO0zJ%BQ1ZOBH1fFV?=$Q;yN{-4r~_{R$tKlM1Tf30Isx7too z<0!^Yj4R|gy&5~o5D0sI{Z#2e8TF*#*JG*2Q(LGx1U{-x)2Sg;Cb2jkNNv|q_p3v3 zaNkPk^3=VA$`C3?7(lEGzYI!bNL9e$#Tqc}oj)=IsPwU=HKNX98QFY>hI#hX5hRGB zYIUX${R!$KLmQmwY0uzvmVD;iU_U_WQ=I9?X&%m^7H9e;ZxclwJaV3M<~xjQW`5+H zNt2lMDzp+P4xE%OikbBqB>!BkLS#rqQ?T zjUU{WC~dqrAz9V%feI|8nG>i-P2(>p?w>4N#$Vt|Fpi}OYUnin0-C5ALnRHA1Q-Ml zXe0V-n3TY`PL9SB>IMUm*G1;9#PzNS{)Y4;HAks6Z=|Tvni`pbQx(=@8e;z;h_9uX zagVc_u3w%#s{O!>w&-sT=>eIu_B~}^>7}I8B9n*YM~%fc)4xbhyJr{FvvM|y94|vT zD`$r|_o`6oUia*a3ML(U9vIT29N(dwJ0y}}2u$CTbTU-P%GrbSxQu1Q&M-{kXDbnV zj!8IXRSgrea-`2XPG+-mj#?CX6bgcjBCzageD=1)s2*Q2KmIPM)ri3)-zdrdF05tn zO9rJ=)|y17&xM1^g^Z)>j?h8ZeWo#uH?z^$fkLHASqbeAMo zJ$1FHsv-Awm%hg zCQ;5ook$>js~8}pzXs2@wVK9XFeU-al1sWO#7;3PA>U*AgZ(~DU&WGJDU<4@Oq)vH zRG~|;7<2+lNdt$f!@PeDw|6LzL##ri5sdQ#LSgi^bQ3@<;7lG~E_n;FAjyEGWDh}` z=|O~g@jyjg3=LLGbWp`ut%RPm>n{Fp%Bu zezK92)_Awg*1CU4)BAU`4$?ncyba@46sKOeOm_O1;WnI2g#Af+sC9G#td`7d<2cJe zS)WPYh_C1-niu!`QB75*zON_N}Bd2 zut4c*swm;gpu!yQvevc86LDppCF_;4a_SA-mqU1T;#q+G~Q9trEp7y)-gUKv2X=~Vqflu1C;x5(UDu0h2i^`+?hkE=nwCdQ` z;~ygaT|Iso4Rs8Pkttcby%K)l>7KGN@+tabNRJ#!*4=#CBysXbn38i7VV0chw7W!P zzC!1#P262yDH?8Zm+O4xh`S_4C(-)Pcp{Un{oHjapsbf4wvARJV))Lt*p<=MKX~6d zA@JLC)P9VSN0*PLuVfzrUnQ)TccmmrGWkU2cJUwjtIiYtTJfjyEtt4PC%cKmt@O5C zyJgte(W2c&;(kiI6|FVe-6eD$!fo+3@@2-*PnNVxG``YNm3FTYoKo!$i@R96SBTq- z+oFkFUI{y7@@UCFhHs^Cua&rD+%fn?ik?xKY_9XEleRep0S}u^4>p1jPNd-#1k^)! z1PR}8BW-N-PEJr=^D!5_Xo@FIzmbCPl|IKxe|k)M(}s3g@)#SksmHJC(NjHsmEV0a ze$n9rJ^oT;?U3~3f1$XSm^h<>zqgPuhI{a zFI`Pr_3l$VvIPGM?N)it)NVy**A|7Z>e3J$-Yt1~obWjMR(oIrXg|HKm(ABm5j#`u z>`vaWm{#zkKl7O)+l$je$_!}6I~#Q#+pP!dlE%0UE`e`FdAGCC|pAO ztMvxt!n4BCa6b;6a&$<#`JPdM*Uvb>UkD!$|JVlOPNRS)OK%VR2Jq21nUW3K&Qroq ze9#AhD6?AK*k_c$tSJ28YjL=e^@Pz|mdV>DExfB2XpIvhz+sD5I84qi_LQy4OZD|V^3zq}#)uShL_EJNGx6-sK$H(F$d z-(O?+J^N4bo38kM!3Ae>P9$W%HHP1ulk%G#!>{b0;`f15^4A>YcU}y?Q%}n8vD13= z`8#ocXMNTyey%9L1*Eq0IaMh2sn5a~e%HnFi+-SXvX5{Q6~D)JTKaUx@H^5!%1@uu z>CBZ~_`o$(Wc!a2C0o?29F84i^OXt*0cC@Jpf`}haq;yccEpuRgdPoWy6!5tcmqQ- zB_*eGpOn^e(?*rO|G)k$Da4xc_lSYd8@SWJ_YM5Z%^Gi&fj=>@+Q4ZBUTNUP1`aT= zOU@ke_qKr>4E&RU`wgGN1}0sr@rM{V(m=0)a}B)9!2e_5pA2j>@ErpW8u&9qUkSs{ z^YW+;e~S$qZ(x#vYp3h@Sq64Z)BeW|ESRDFml^;5>$Ly(2HtGo1qSXa((!*W@IC`e z3`{jJ*}zYxYWyU_=N<#w4IFX3j{k{)e==~pf%^kVu-(BhLN&m{5JX6n^W z1Cveoxd#5Hfh!GMVqlSha}BIE(4y~~sp&5_&9Wji&RCfqyaZegkU_EH>~;1J5+@tE+YTj||*t;C~wUfPuFgILpAx zjNQB1_$M2Gmyv6X2|w4s!}*%ejRr5-z%~>97X$A%@OA^s4V-4+cmppm@H7Kk@-+RI zy&67k;2Hz(F>tAYp&dIKLd@Mi`#8dz=MjRszAV3vWY2A*l) z;mL-+fm;oH$K=Ot^z*)vXPt?E)WG`;tTV9Kz#IdI8JJ>Vmq+t^-N5G!Tw~zB7`V{D zA_FfoaF~H-8rW_0z1Kji9jwVt%#o4O+L;Yd9X)^-Xwnb!E4?t1E7GS5;Im@GTUXXH?%(U2|)-yJE?_ids!VWku-DE35a3 zC$0W8Tbixj#%$bnt8K1|ulLneRxfb-YHHk7HPs7ji!0{&YU-{izOpAs;jR4C zJsK#&t>s_3k?;9*o$mUws>*V7N#5qw@Ucm?&s{U$oz~!9B0s*0CBBBbijgBniZ0}@ z*fYJ@JvleOz>_!Ly?9aCq`HbSU&X|R`SUC4(ihBGn5)aCrf!6LSbg0*A~Z&R_57M> zkV5JsJRU*&6t1Km?#|A3Uw_S<=`$ux@=Twu#rdb?DX;hSmPZGjD31xREC+4|N`gs-g^Xe*VsgTnv zdVj ztFM??SzS(5Ev~5djht7rsCHz1EvqfDe|_p_`ogmEin_v@@`kF4IK|Y*MD#6NEJkn1 z7L`@X0o}O2KKV~V)COOLrKb8=8KPx=DRsiqMBlPlvAyMp6`)W4J@uogrlu;E`!FeY z3GADr6?<}yz4)2tU(v&ndKZ^p#gV{hyOw69>t|nFdeJvxE-G74aeZaQt#MhYv_kvN zOEkJKHc=JE@v9S)lipBS?aP|u8@|LnY?ymNT+nS2G*^Ny9WBl>agG`rrPiyxq%SrN zCSOF26MoU0zNKC?N8t`1?!GeHo!N_Cy=oMN6^o`-{CHAL1Gf8$YZr2j1iBdLYV$fq{lUT)UgnQ8(lZ>voek9#US^Dr1x_cJ$XhNd0 zi(qm3MIX~D>MMMcE2`&dF)WiMjbQ;`m{whKdGdCbYp29mkmt z6+gl)^ygwsbe!&-{#*QRD68~MuBrQOIZ%8vm*^AyJ--c=myNM9H{DiiE3?%x`lzr? zv{l-wZRP5BfvuR3dYjKSk{7G%Z8gNmU-&cK->>m#SUOzy>+23`f6fH$FU`>~#f0}B zZ|(Yt#@}t=UIPyp`1lh#ew~3W2DTZv+rY4aYYc38UZ+d`n})RpW*YdsiElGd@-(@o z#x{BCv>S4#<=H0YPP#@p2%naFZQj&E&branl-1d66C29QZ<7T4VoROwRA|r_JkCA8B9H(f(qiakuSi{8Me$+T4^vgKZII;2a9Ag zdxiIyCE_fjCuyu^7O$UlFMy)`_!M#n#$40o+79(tXW)9u1ZbJy@vgC84sUkEaJy50UZ?q<>Y_}1!2#wbAUj^EBqu1IP{bm!A zhL!Bmt+6$fAsI9=}(YH26cVvKTe?U zUjJ^jEkt9w*E?s#2^kSCMxCKe|u@~g`$mdrk}s+_30SoA)$7*)r~`DM-?8IurY z#1za;m&Qi+5c?+iq1Ts+dr|F;^6m0PTSG5OJx%31%XhLWbYkXDf(fTQ+Qv6op$mJp zk+||UcEjpZMesuE$zs#q%BV3__~*sgwR+R)MgZs1Mt$JwFv0CIQe4ejru3)#nI`5xh@a2oM*9C zFfLus_}?>a+SF-tuFoyV&&w^&pL*>ay~H}lQ&JpNlaORcaqWzPf;nEMLIoZu{`crH zuso64H#0K1`0w#kYcKyTj&b}JRV*s1tEsKOgkM?^)XOFA}v7*j* z+vKXU1@-P>qPap(;nZm}=M+twTI88lJadkBDpSMj^QY%eEbz>ksOOCT>-;87^?Igx zt}QkUgZs;yF_%&&l&#pFhcC z)M?cV?3S!fxanJD)uIAxR);UX&l20MdyF_fl_GMcd+E{`dr&ifJ}W~Q+1k2_#Z#5% zg#2p@Zsj3VmluP7HxceeXvMBJCSX*AOt78#0t&{3tQ zCN6p{jy#bhI*&>peuDfxPx&@sUxG} z<(ER7uKIpe38KY8XBDrPzVKK=Wy0|7c;pzoLTY$5a_f37b0j?i`>rh^j!#c}Gn-s$ z{?V{#(QOk|cZ^Owi)wwc=5;NrI2FciRIPxUzuc+?HFcG~g^RM&>fQXG8{IFJ02!oA ztz$m~&-j>`Kd1}b^&{N#iC0e5P}Ay1nEx9r$AS@Q3#?%uYm_oSoX6Zo=7x2)TTGi@ zpvGyHXhULp#)*?^$}2_`S1zg;5tVX;$`gKTSJzFy%%bmt+eV12?ivv`HrhvWcY6Ks z5qZ?ZXd)}L5Bt*7&f@GO1C4L)PkYkU>J^}#k(Sl7$CY1Cz3Y)HTKOt{6^rWCii=o+ zlcdwOXqqgGL=&p%>$l^JVJa+JBBpfWjLCDR=ihk3_@GC=Setipd_AR-wH;;Fbd!oz zVXsw$-t9{)LNptCq!^cvxcENi_dV@FkB|E5f8s_hX8kUvL0I-j`lJQa&BdyoPE);A zrR{cLE|#YEtZF19@R7>$#L3H&)?_vf3ZsJ$H6dsDUpG%N^}QCshGD8=H&0I7P8nu8 zcSTAKS>u+Cdh`Ehm#55NAi8PZn_jMNK(gP%fU39j$i~(ZYpAL|pO}&Qn<{6Ih+8#{ z6P|MD&2L&oJ@wRZW!tD1N5!Z9rc9`ga$oE&^i0W}IJ4OEEqYO@q8+Vdc@#V8q`x$C z)EEOyo%rv`Ga7j={h!El>Hm9q#$GBKx+cG1YF`?P%jb#uiBBBcUV5GH`0nNPKhsZ) za+NgSB7bb`w(Qr||$h+x&XII~kUb!tKUpcl?@a$+C8o4%wz{lDR7TGF?*-*Wa* z=h3H@EBv^I93S<~t@)qMZ*StUA{aOEd(8V zsFv3Iiq->$D7kq3_mx1ikM_Dsx*l$jixIAOdCEMCoaiCJ6>jn7$Bc^H8E!o;i48Ov zjmswsKl3XWj4WQrM5J6(v$#%D+lj6R?L^v;IcmO-rS2gz=cUNMys zf}~i8Usg8Dh!vOoE>fde8Qohe_p}B-YsW?VPcklv9YV-9=8XJni`k)tL40}kjHhDf7pxv;X2$G(svN}W z`{d~^mC7aCcbTRNeYbR%_GV|a)~o)XuSX@*Di+8Alc|d<>Z;0W)n;vGChK+eG%B{C z8Dd5Iezpq{hSME=Mal&H+vQW0UJ;BP^!F@VMn(N6^fXG;)F)w!TAW;cVp^K+V;n7c z?xoQ`Hgbxoc11%$Jg)JH2`UevS(4I_6Ew;h+L1!Eu9JM znNMnKP(MPO%6fMhE7fYFBm0M=1oc>~-ncFkV zRDoht`;5q4yrAz0nV6{*aZ}cKVkbsL$(i^=466b?zfjQS!TC%*$)BVw^@#s3DO47=EJb2=+^T;W z(K}SnK*8j;^=FbZ*(4#4eJhDhe?>t*WYlH5@ib z6bFe@B&E-chOjH7dR8ld1Ki-LZne0kuW&{NR83LW7u zo#Ruzv6YWYFEau48JTHwIIFuzPV0l$6FxRJA}0LO%$Nwy87aEG$k=+q$C0sF zX2Ftggc`HdN5eBL|MW#zF`I2fL0R1bmX1d#e}?hdZ0_sJ>TY9)Y)-w{6#Ue1mXWJ{ zCcv^46?23?=}ncWn1h@dJtinBM^AiQbWgf*W8)%B!Vwc`W0Nb*s1ZIl)YQcWjF?;* z=V#&X!nB6dV)U;GMfGUtx{dj?swi()C33G2YUmN9TNT zdaw7Dj~_pu6}CB*^V3x!jGW8ZuR40Fcw|L&xp;1x{eRhe_xQStI{$x8ZcUT4P13YY zdOa!W4SG2Zp%f_eq-}bEwuCe-1q->S3FLA}PD%>6L_n;_O01|A!HwK3h#HVf#uwrGwjas!L%J2D}na??MPEJepxBLBLANzS^@|t z{ogSdIA}2RV~h6~%>Jpt;2}%5IDD-Mr~lFBYmW&BK5tOnVZ&B`&|>HdhTdm!z+&i5 zLm#jhxXXlxzhwFEHW;$`>ajR@pP>itH`r^j`>4s6vU-PXe!czN|F6-r*8wkIA2#_t z*?ctp!Ia1Us!2C!ap*M@?y=?U^~yVB=zTVv{kjSFT2yb?c#FNiFk#QW{We{nr4M*= zEqdiCx8(`uCz*CxU@&0Imp#pdgEm}lvCpRKpKju-Ej?s0FvHM$Y`E9rtS){>$W)Ck zpk{@*kNMfxUQt#iVYxPMykO&n7jIO&s##rD!RM+sl&&eO@~B>T{kn~1rNnyS3(G5E zTu<2B4NJZr?u(+qkJ8%?g5Cg=gnJg_Nsq1^$n zA#&R>h0=NUjDTbv*3({W(AA-ALCLNmM#eLn@A8fY_BnM>nCNzatNF?2madj7Yufxq zoj0#%U-wFK)yZw9j<=GsQEKsg^J^bHg+84prmp#{0-FU^YlHR<2GiJhejXL>Xy55D z#KxQSGUpe8@<&s0{}Bl32|{c-E7v5{46*T6pNRZ2shZuQ7Sz@+%ciT~j`SXhB47fQNa@j!UN+KQ^k8?maI$Spi7p8IcINBjIO z8%o*5w_@{}s?zlrmtL}oz^ZjCODoG(*%zFV6eIc9t=YJN{fpLK@$nlYUPC$6`Ps-T!?7hf8yn?;WcxT8x{Xz4&Q)cmTx1S%y?-UFRKh)%^eN0#?V?*_;k-XAsfGgbYJv(vnMlO^dpOrP<|&VgQuRlc^*CgB3`80z|U*grdAue2`)WU^}_#N&dwT0gVtXCJX z8)qXs;WzL!x`AI_R;Wt|l@ha_&`Nxjnp(xPYAGD$(9M*Z*1x{=lCp}b^_w?R0adal zS6|anUuA#8$jGbnah!Rb-yG54FJ5^1!oUI^of}%(LsADik@Ihh-lKRWt2FZVZ$r$x z!PuQdve(tGe@`mE8#TZCDdsu(bX-6!&~G*5mmRYAD5T#q$}iU9ubAh1elM+WFq|jQ zO7TpyksUOZYz1uZU}Z8UhJ8Ecm!dk6+)lk;t3|cM%co(+$T+_Ak+MW;ygdDTYbNvD zH$)V}eyFLruG9G$cBhWiH+z2|A~c~K`LXr7dUJ+DjHF01OB|ExiUn`*+cf#4utf!H` z+J>f@9nI|>{^mw9iji9NgOr$~OKerU6LJGT@{-d@ki>fNlk6S!Zp#rBarNRo>O`BO zof7DS1a{P#YMs5KR+H`YQ|5J?e-f@?7Pg%^52wtS^oglD=?S7@8uou*{%Eand5fdi ze0jea_D*Psm`Z#8uKYB6_G&)9z4Uw`-dqkb&RX#?F~%Z?|9$zxI*u~xE0%B^YyDmN zZIhw&wp~RDT707R1#`6R5QwvnM~SzKSBuBVpYF|ZdlzTx&T4a}{UbAlO)AZqN?L-k zl1n*`nY`@8*Oz;q$cO_`?CDKflSG=V+4ee8wXj46QtzaaRSmUW+bbI6jDVFjEiJV* zbyxD6B+lEs(uvv7&?!qu5+QWGw&6s(31jWKy()BKMPg!e%U-8nv+0wQ>TE{b>W(Ru zr!Z2Qi1|j?kJ(r3lzUTGM`KN0!^)aaO>J{abGW&olUbPLBbINz9Oh)1wJj4Q{Qse! zO~tMJc=2RZH)>Y%+!5J}>y1XS_SSc{*mBrx|D*c0SH%j5Kl9~e^|KDw$#jb|noiE% z{G`R>KTgR_o&UenzrD&WL%bcl78su&(}p))T@&JWjLmJfzU`_3H%THmC84=3zV9|| zY`8j-%4uiu@@d}@Ha!q{P0CXtt=Q8p1EuHJ%qKLhF4F&qJ{na_HoPMwoN}Jno{=F> z`mI;exUwZ45n~k#kL+=eDvm3!H~-NJLXQ} zSfBTB<<(7R%+ZDHy_EB_yyNKN%k9*uTjCSdr+!OQs~??WdMrg~Wdb6PR3o)GiDLU` zq;Pl=mv2)8>+enN9kFMyb$Zm1x=c4N-NAOQn%b6zNcs^4{O{6dS}VUcYVK^}$EjY< zK2Tp7hXBYnN6re7C6GEflaZccehkfAX723f_=pn@^6};Q$K{XEn{ZUu+4awy)j3li zR24m*%2ujfgVs4ABuTn z5nnl;-M#y=XRvsCMcRkC>qeHRofatLLyWG-Z%$-Tu|L~CUZMYo^;z|Fl(-3;E&uk0 zaFtm(p;0*twO%_+wEFIuN@INfP5Uy&O7xK7wE=z1Zh~>iq>MJZIQicEL{A`UI3RYe z`6-`xjWlV)k=UplFVk`I?EJzm5z69m%y?aA7AA$BAg@lUh@yD;HY>bFah5n^@A6g& zPwtW1!uF~S%#mZ$L{xZ1If4E4@r^MhX_O-=N0woPnzHVOI*xX&UoB&8g4>~CFPd^hljnKWX6-nwJ~nNP^7RmmI`CEebAF*<1c`*aTao&Bz+J(gg zyI>Ma-*M&N_x>U_D=`L)7D?Ml|FZP#=nA_zh}JJ>(#kTw9MTz``>+Z>GxgI2Nu*5q zYqCx+|59=Jg#8lW^5KL}aPYk-pZE?D_D%-&_#nqzLf;CX-%>?>MBZPb@+2RJ2yeA~ zo;>;DLI1l^zBIyvg#8X*Rp{e^Z#`CYHXmMH{?l*#d^uREio)yo&@Ufmm8<7l2HpQX z@I^0^E*h5nNFLmauTn*>g@3MJzVOe7&$EPJ9O_`^i!VH5=}LG>qx0d)6~E_PokEka zlsrAoWfOK?K4I6rPuO)a0V3XybFti#(!In^J(N?N5c>j+k!T}2absI z+S%~mqV=eK@5k1o$G6Mj8-<`fgnL1`#4cX@neXsPyIM-P+N$vQB#nCsJv2Urx25Lt z+M~-Oe&O2+pI-u8C*lhx;FG$$b!>{3vus?7l6Kq#dV0P530A`AU6L+40iP@HPWUCo z0q|txRVU!{^m!=x7#=gSyrMS@-Mi%FT`ytzAgo+&IkFr+>8JUG<%5cHd3-_-XGP^n z{q7~)1Ip#`34MQNly9^|!Y3b=l*{82yw2g1{O%%rK$y5(zM?q30O4JREy5@12Qs31 zr8x}}PQt8#o?23bQ6{jUdkol^|zEbzHGwP3Ha_zi|Q45dkN2#jB~m2 zmd5b~37033cQ`dFPs%k+_?VU!l_wl8q(u3|F2jTaae5_v(BTuiR1+QoN-#)^mw1e^KJ`rPm)@j$Vh) zE3cFzo^NXcKAYVLNc!xBBlSiYtVj6z7mVZ+z5R2e`4is&;iXPG@4ofklvutHeEyT* z3mk{<$egG=vHLN?@$!UztHUSlYA@mVb|vMDuaEKs@}#`VktaFGPQWMfo}L|>zXOE* z(B+bNZ`^2d_(Xo_IDCOPzNN?E>zfs;cQ4`i`iL*D+)w7h=h?-(pU3m*epD3Y^U5Lg zJE41*lw%)Zza@Bl@$!VPDFL6*{f<1597w>INZ!6vQdAIrxsIn-^4ksHAF1KJ+TnA{kr&73CmdhDlD=d{v_8bQmhfJy z*Ohl{dX!JnDfs+xe8N%U@JV~wO1LMEPxrTJQF+3*mvD6gzPS#c*da*RpMdY_sZn_{ z-X9_ylmc+M<>+zvq#V11Pnft|zW9E=7Cyh`iq2yty*pk>xw0KTPoCs#uQRR*-vPp2 zKl1nlUA-cI&*YJM6Y;Ih|6o2zmpySLpX6ujgsA<*&LP6_`GXvDiM%}t=I!zM6Zz%y zN6JgY*FW#%_(Jei+uVp8Z=7`PC*{b7Z{G*-N&a?m--<79eEy_9(odos!dHIU2g?(^ z2Tqc2>8T^%m4DY@5IL|kLKauWu9{s*qP)#iJYBSd$b-?OG$ z91;INl%ElL;s~zV{yN6mx04m$+Kl6h28DkqJl?g|@e564co%KveenlzBGmKeXp1mN+ma{R~3 zgYbw<$+KK;K15HVORP5Fl*i3qej{_W|6)BXLE7Gi6y-^D^>oMaHo@n~boqvno9L2z z(bnHa<9h1N`jhaw>C>G&OWZJga>+BcToMZ6b~&;LDk+n9x$>l(?&T-n-sSQQ4af5B zqr6+8rK4wUT%Nr2fAly}9Lb%O77ZKej#Dwuzd^CHXw&l*_AE=~u44_<9Xss}tGGt20rwhd$W% zyJY$Hp9EtrmoEt4+TSNDzWEo!BLRu?c-?#nf1*q3E8xUQ9=yvPbT9IJFOZ0a;@%hKmpY7yP1i5-7 z&yqjR&KRM?_BYRWkoydG zivx?#To|gaHCh$|;^dl#TeGrqy}Y2U#=lU0FjG|Dj8|1d3$9DHwAMDE^<84#ff~Nn zwjvHa9e_5#;BIK$s;4$t-ALt|@XmTkryt;iN4~UPQ)CVd>1JFeYGEKy*SMYgDq*=t zEL>SpS+sR!sU*vfqY2R;OVhu}oeOPlH0@?dTOP}IsnE8@(AH@k)p0Z-HpS6aLJP&x zw7l*ZTDg|j6HC*4yJBdSny(j{F262srRM8{wv}HcFYM4qi|Xf@gS=cb;UfL3N_n=t zjwWMi*IaW=eJ$owYuRU@?bi{mD_U2ob(F`@E;TlAX_bbr8k)|Fq^&f3A!yw^`7Z1> zc{y@cih9WBg^TnO?Cs~6cPX}Bi^+z1XjzJW&b74Dg*E_9GG}QenzkxM&7K^gEfE?o zw^YBB&8XDRWFeC3Fva&bG0uvd+D@#*)sv#;PbD0(3HlhXXYveQ!AGRT0)uAlYGFrb zM_o}se@CJkT91^&&~%=)tdsobV?A+7#iY>0>Inf~T9QgDP73&Vmzq(MrZS4tLcSEA zN?D;)&dfA5li#>cD;cfERb+;G%aYZuL&Rn{pjcZ3{l^Pzcf)kYb2riwyDutwR!@hB8YFvG~ z8dow(jVsO!`Et`$Ze@nbCBM1FV~4Urnbp3s3{_S?N(C#^R5tRmOVU+#an_J;Yr5JR z9;LGDp;a21)`<;<^7*Z90q@PVPI4SaD_Af}%?M9aQ%WYNalTxYQqH_+HG3hj%?;#H z%H+omADu#gtCIQ^nkiG73QSX~4tE{xvrsG&j-?f_E<6U=V}6$wsz5YE1Fyfl<|I<%O%$ z)ar1$8hbQDr5+xwdf`H4~Lm?rLkF^GbB_)fQI!g#Jyt>i514f8uNtU$87w zomO&%n&PWgS;HAa>4RwluIz4P|BmVw86hkCI`Fn-hW4>@jht!hND}+Ym@2&A0403T zhW}#2Iny)L^pZT4yL;?#)=L;{{u>+USex^c_xM5#Ls>)cAHf&lKZF^<9TDd<{ox`}0 zb2vq%9?VjGtCe~kw_c~G4xuaPY=EJ&X2iuaXK?t<7^T}wsBmGLT1Xq1C;6&md|9W| z>9~iqTx3f7ATE|p-*xzWyknVIksHdX&JGk@J4s!!cf7A=Po8h!4viihHIN!gsZI_gmCKkm{2F5#f`o4fS%P;{k8*{W zrAYVzJzG)gSx|KT-qQ8>9Ok}KpG>_ashq+LRp6U3LXWhI1LzT1!#4k-;~p8DxNiQC zk$dlDCj6z#jo#?^Z^kv#m(yeV@^F<>W2>24um{78bE9;45wuF7AyVSqu$#tLG={B> zvsF?3ELBueq>6mgRsQhAp}fJ|fo$wwaMl=gTDVZnsrRc>N@mb^^P_#t>${ZgN%Tnh z)Q6JQta<`mw=@{qrHv+RWSxerQ;{_fSu;n->PA+Qt&ePE$u-sD*R~rwJM)!Cj2E(@^Bawx^MDmHMxGanp`qVP4@YfzGISS-_+4+YIug4T0dP)Ety8!n5?9% zdMw+W6euVfrE=>ha-W@`a=HIyhRhh&gUp;$GZ@42)wJJD9L^ic9n2mW8yZucW%|CY zbE{gl!FBT&*F z1u2Sp7nG}D#Td0X{E%8u{}nZ_u%R#)kU8* z`hEdQOJ4kWqc`Uc6JPuVldtDMi9Z6$HSSIm_DNd{PgN6r)07?)2h6zT%T8rKUB2?} zafSO+)c%s`D*f;b73|~P7Op(i^!?Z{xg5bGg7v-e7AlzJGHc4K7DK;{}`u101VGFKrp7$dV9 znQz#7AHt?zeZZvu11Q((hfMfMP_FlEc*a*v*wp7E)aS$0XFv7%;E4KMijEbw-wfM& ztNEId+w*lJ=b`}55@PG*yKc|Dr^qUj6;cWCgV#}hoNi8e&#qa z{vIgT`0ttU#h_dTb# z1qV&I4U~F$#D)vb8><#{7pZwov(z--1~qPY%uwbabIwp&b!s3*-!BKyQ*7(oZ}rRv zrC%+z;mV&Fxu5%~(KGpHrXM`_bJPC+{Z$jb<2A!Kd&uyu14WLhzvrpH=cvB{>hH-B z^|yz7eAm`rxz)SP;ze&5dD*`<@)o~k!p(0ReJ_D>&3(s&cYt!u`!B)ylQtDQGcY0ZjiAJD zNjBjRgQ6>EQHGks7&2wJU})0dgn{v)-0GY_w!UYrB~QZBXY=zAcwd@N=jpFwC1*;# zHqL~7)3VgG@B}rD=d@{+<9Tk*RnuN97@jmVVW8mjF>2QS)77kSG57z)YF0@=&GOAx zI@a22E8+@v%uo$SPE(g1ny)q=SfDoSTd2zRF5q=}K3inu&Yo@M2FIvH;Wg^C`qgSqNf~xN zZ-kwDkn@I>6SQ*HgCc1wDDABt6zhaQ?k4IwkglnAfpYz2jNx$Swlh2)?(9L*zF709&?cyBrTQVZQTgmTko8LaG{~=KF zyAPE7?gu4jgP`bt1(d69smW)>Stg%noo({D=^T^KLn}?bMwglJ#5LBAdj51a`8tby zEhS&YBk~m>U$@wN4O@Mq)|&Lc0_8fi-h|g|FySUp+Qox5Y|4K*dM-oHHuP*6p(kDH z-S!K0xhYqcMXiK?3oo>K%8i~oK=Ji#GU1d;6P~@YPbi1| zeEF<@WOStIHJE+qko@>x|q(poH&DkUx>_%Su&QEA&dtU=rg|;f8dzp)ymg65BJU zOl9q>r{1UjgxiDOLRlb&uAnRU6nwGqv>}IIuUi$59vU^6I*=SnsxDlSrdE)ym~^Q} zS*K|9sbAraY1#B}XrA2IIMyf}USDRa%3LvOICUtQ6*lsHLAtu&U<%JwnQFrREY>PA zRItgXZorji+k6wRh*R*$8c1xsiV6G1rm3;@nbQ7-WNoK#X_{JElCCBkCEu*21+MU^ zow$B2Tk@TO%+c5*JuZ&+yz6%Nr-h-|AC!xI}VdA8`f?t7&^< zkJ7IyGk8blQyX!^y3Evr6L#0R^XaD**O-3n(uZG4R*$*#4zt#L0Q#tF4Zn{E*4$dN zK9Na3amVSwH+f$0_;N<6oN%hjsZUWkC5&6c^eI`-J)ETaKI~HmaDD7;E@aSg!vzKM zPGyXY%hh^5OuSix%2J{0ed=4dLpGfoj!!4!tCudj$ET`r*?C5v8+OJky*5}lIbBT- zXQ>G#v?cm?Dt)$}w7iHX&mcZV^wa4 zd7mWpDD~mX&rtdGSt`FW6W#bL^pj7>H$6*D507Ck3lcY-xak#>hx3Of4*DiAMq-}{ z*kS@UnoyiGRDdn=O48-MjlOsHknh*_n0%S}0d>cH-RMIPw$6t?zu4;2@9kLgtbpg# zOxE6t)TzFyYWnchp~-{!0~13Ns`JXp@8k?MnS4zqUz5q#Wb!q+W8#o6FJ0wf!#r%5 zhYj;~XNOGN=KgcHPyGyc9c$FOZ98G#)GXEqv(;4WGZp(x?TD<3n)in{ptC4T6@_zH zI~~W`=~z|NF>QFtP{H7&feGb4sXOv8GdDJ;zL}$V7D!fEH`q09`eosq6g4NDtx}Js ztMZ2#yKq^PymmEChcj42@Ow1MBH<$3QlU{_@nMk>Nh7mf7E^u&bqd$m!j|1qEXAx^*V(|sXLhmSxzWb-HS(XiwvE*-L6Iq~gg zEA8f$$4$GL^n@MX@@bpgAM-0|FD0X*>((LaMz@<$G9NSbUC%qnr+lg!7iKZjqs@dG)b?CNplz7LI6A3B<%)*nt)s}5$Vv$&U* z@IE@df|Wh)zk0mtVBRF}n-20WazE?RjCW&b->I}MzAvS2#w}$W)@>SD5`GXD^k~SI z@K15|Lc`AS;g~eUyK;5e=vVR{v;e&Y=q>1&Fr@WihtMIP`UTFs6T+tPGV4DLOfH#h8~jfD4)RikV58yhS_Uy-q!a*m~3sn}%rCCc?OHsH5Gx=x96 zX$ATn?&z2?C_r11>(W`}=MgOcU zH47bn^yj00Jasabc9B{+M)7?om3x@Jr1L^wal*dQDQa|a>M--*fVp3cRztt?so&#L z*soAXKbb^3PCcBVX3oyYdDm+92~^sB0(mm#;Rxpumsgw}%9)eJ z7&DIh$yn|uW9TngGVaR#WI&#c(y@uyV8Gr_P&?wj@{@OrohJRp*zJ6f8do{9(^<>S zP=$=$Q%iVutH{t}{m?Is%t7ZKC2|jvPIUd*%E|jL`y8q7cdRkd&g7oMm>;>{?L*dW z@JYJDVWWQ?DB+wrqt*1g%{?e@K)-7&A4gs3XFi*UA@VTmw=-cR$+tTE$d>%Ma|S8TioY5;9|h%l02JRdmVW);4E-@se1o9K(Q~9n zcpj@x2^8{7lzli?rE_0Y@B7py+z`K0EEIuGSk~O~edC#HjvE>?m^m;ylwLimJWW5R z4<9!93s@U0b8O+|Tg3eYD@eG{C)Qw(LUNMM*Gr&KMyDj{b)IpcT=}5*3TUr+z5;i> zPwy4!Bd(D7cy9e9l~S3{@A{KeE3TK{ZA$*#aE{#j>vO12<_IO@V%8g^J`dP3l#}V(%2n;u6D0LR_P+@I-?ELo#jBOG=1$Vp9&>J5X8Id%^ zyK)PbWHJ}>tMRnKm=ze>pu8{YrhIpkM)Di7^|~_8l;>sk?Fc<*7T+`~$yRw4v8`C_ zT5j#yW7FOWeq*As!?b*B-%~QwDPiWOj7bHINp}7@Bj=rlF{@N_k9 zzn}dcg({_frplh2#62rXy=`TZR8W#5{%n=Sc#%?4z;9G311^QlKvE7j?8}xtZj_^hJtypOGxt$w^OMy1xV1VBWnf+x zOGA#sSskoGf_!CGf}-;q=_7}JVfx6a z>?x7{(0qoemuo=@7ZmeeswsyttjLTZ1NseJc}l?av3}AgQD5gRG5pC-*t_3(Jh&Mdup54}%m(y#VU`=fyr#E=7i1Q_eH-H-mEJ zoSMa2`8YL;=OsV$@7#*$TRACXw$C&&b@(41m2zl6HW!NvjRt zg`ixYvEkp?@WeGHz7dpbj}7}C%v28^%~y9Ho}})moXGnn_H2gC+EdPgOtpYLE``uy zcdVE>!5;KV-i9diq76p=c^i%VpMesmpX=ERGvN{L)`RBRM(@|;K0k0_lA2JSqy}c0 zdXEhwCypm)VHSIZ$EkVLNfC2U_J$2-4~-qn8ZdLlkj>99`8l}BY5y^m-rA^RcCu^)Pb}A5S01r4Jx?cT}#_iQmf1My6cP zHXFH5U18*2bfwLgp11ORSIK%w3GXSKdFwHLD=aqjBSTQ`H!E69x)xBbFM`tUp0xCw z6WqTBkyqMk(%%ir^^6V2&Pm3On3L?ac?mdqkvwT3{JW;j$bA8n>nJGsn$m8-Hv2Qi zusBlo{R$ye!3Cfp24Sg&1$Q`iHZtTN~W zvcEQGc9xpm#2OOw)9EFXRPOJhcMxf_Ytb|AW|RKUpj>$$GvS>1S?p2ZEGgQ15$!#H zw_an@JJ@u4C#_sZEdSZNO!{AglAj#8|4aJ%@u~@czdQfB7vY z{e7UMFF2Du0!?G+!$oQWYk1MoSa#2vd)HFZKd*D4RQo4Px+FZ&wbvG-MtPx7y4%x#D@@_M7nnAffY{NN$ zESol$w2bk)_4VraxlqXX~d8{{x_01w6+V@}rAs>`TmHoHuVx zqc*KZZwGv*+-}n4e#WF*0BXH+vzQO0#6HiMu~7HzY@6@TSpGGiHR)@?lSw~d^Bwq{ z;r|FIm+yfz^*}gReV+Si){E%@J${jo-mqYih6xMCISMHA9mt@8&^;d4||BNph{@XygzGlM( zr!WWPxz5>vuAeIh;L-QX%9&~y-tGUAq>ixfUek_F*5P}hrEu;_A-odrhGWtw-eZzR z#mUlh9c(w7b~kxHH##^}Se{iV3^&_aXnjdyRZo=J0(-%J(Lz z4xF2xSQ_v7TplNF=mDNtaBkXI8tb7hkCV3V!6fxO&P^LjV-3*ZNwgLj#2)z%8G9@R z<*K&f5}j<^Hzlt42=F{0x56k;y)5-aqi{I*n&mo?rFzZxdjkO8}HV;@$IS){e$)2f`hDm@6S`!Pb8_5eMu@iVC2PyY5(x45qzR2HmzL` z87h?Z`J=3ZhFKrw*)D_iMOi=3euigFT({K|8%76df{Df<@OIA39w zDy-*T$DFW`IbmUOFON z->{YYW{g%dR>bVyV|9V?Q`VG8D=UfS_apLdnctp&KS}MxZC#B0QkggKZdby$;Od1& z9mR*;H2S>-=G19RsMjAPsn>D+l9u(blrX<9A^a9@pOqIMcGKwRM)SNl=&kd4ZKwK& zNvad4ifvsxVe?*PoGK`eeXru>%YQIQt;V_elJHhsxs?|mcGH;OZ!ov2H*+iBjT6<4 z$CUaf*511hF{T_yR;~N^J>%X~RktTiUASwMD(y~Ji<whb2RJU zE4gp1U|zFK>8Cn7pBd(!@gki}`d6sh^xNw|>36$qSWw~xY2E5}Q1-v|+4$VoP5+z; z%5^0u=|gW&7hn%4{Lg~4Ms?JNdw*f#n+}`w1+!CmFIz$$ieC zO;Z0?ja642n4_xp%~c!r&Qs^?IhB2fr}3NL`6|6>feO5pq<)9%<6Ngg^txfahj;%E z)q?P#npgh=*7Ls4`pd*DfD_Q27>|5fCJn`B3>LX8g zv*kwWW60*=ZJVcKpvX(9Nmf#m*`U~eDk%1!3(9pg-RRpo+Jy5nOnzEGNxyN7Nxy5X zN&jrNNq<95vaY}Da!vRn`8K}5$a^0YJ+mj9@ETCACQ#)52Pl-cLE#%S#mHL-O4zJt zj^lTdW7W7v_?_fT_ImiXD*2t2w1s|z=s8KrrK)@e&k}y-4QEK*5;20tJ=NhU7|(mG z8;qO)x(ehy+5YjWkony-=640$JH|X>-g(G;q#HYnjbS}5N}OEM9>i61Zkd!*oRm{& zVQ5sBKJ#ZS7^DsaJsL$*U6$50+vxPqF?Ji6Yr@|HMP}|i6Rw0`WPcnKPQ9Swq_d&OeoSdVdd?Ov5o;mS0%k}-asto?GY z2rOhChbuYL_Bl6Pnx;zOoojjf7bUBo<2>G&aGc!WV#Ye0#~Txl;~iiV`#U&~Hzpj% z8)QFGE6(F}!(!u{eBPth@=GfH3qj`6v<;zu?#yKMZQO&@fn1~WdB@LwjC}5o_PI6W z@g9Y5%F<-@6LGzu+~vTb;1!bG)BrzreU$e#1T5$NOyB zZhG`L!oCSIE)K za!Iay-TA8f;CvNo8prtx%%ygXRh#x?tMm7cQKkFFtEC5W)uKaLq~qE2*aXroGU-I` z3hhc4x8*I(+{Itq0mZCx1tv z9V6`_hn9XB@7c(6pF=wp+7Nt493AVS%|%|o(a{1e1kLZzZiQA2Ez#ADedM~^;?ovi zwD^X_M=m#fdo12yvCU$I#q%tlYB9^=FnN&c6^qYX{F=qLte!twOxbAo^DQp4xYlB= z#ecH+S&Lt@c);ST7Jp}Px0SCm!@s91jh-DA&$gIiv44|^-)3>R!h|2PxPG$t|Y>PpQ>n&DW3|YL%;vS2|79X_u zq{Tsto}Q)jKe-OrcJ-pgbW5LZ@qUZF7P~E$TdcL%X3>)$zQoAC$)ZO;aH*j`XtA4q zE7w+wPh0vO7QJ*UY`hol`H)HHg%8>A@2tKyn?A#)%dU+-vb>i;Wg5EH1O?x0r45tu;o@OBSEBc(29X7JDqVS-jNZ`4*R2EV7tu z@sF#me2d?;_^K_B-`eL5o1c9){$7i>SnRM^X)$PVw#96V!(~R_Pb@xdaj(TsT5Pgd zZgGjl*%osx9<%lyvgq}LTa^ALz5YtJIoYkk`K~6tSH26V9wA15OHOne0je&_?R{w3d_Y@$i@jjX+Cdww{{Ow5oqs3R}Lp4^6Q^fgt+K!SdFG`&o;ZCGtmPz4puc+zhXl~#Y z*s=tvbkS8KF-X!jH6M!Py>pai>uq%;y&;?v3G-FL5Z~DJG-8Eh;u3!;krSRG>FjqV zRSguY-;<#Rpv8O(kyBQ7T+3sI3RKUwp6))w8LQjT`gP*hwe6^BkrNIZ5~$+r z@AK74eHj{diq*ZzeE)fMdq-q8Iej5zpLfOiQGZtOb!6)RK>pHz5rBhu+T;%)L zUcTbKzs?E2aE)jsHh;Ew+~iFDzGiqMb+5-Fo%3mukJkEC9W__4lUChO&w8z^KeoS+ z^A=)_Q6tsD>a&(Y!*hzyni%D;(_gpV$cd<0saUI8OVH!ES31=OEmCG9KEXG?mD(hl zbW6NgKGkl^D^fEhhIZ7zx7giWToKjga92d+M2wCo7SeT z+ScZ~}`p_YaVYp-ailRp2Z7qf{^zIt@-{l-pZJ80+^EA@%g zO)U)#Ayp(AHIZEwYGq4%XM?DRbReX%3B%W~ zqlG-4V$a33Y-Qbb+#8yAkWFQ4d_>GeDOjpwXL&ZF`dR#vgGZ2jrQre5|XmA7|>FY0OzZ)oW3tl8e6ihW{M>1c zd&k9UlMbz`Yj3+)eLcCdqo%F1MQ&j>vHC_*c|*gMHi-78l{blu(het8(0Dt;4IL|6 z7+}k~;p?)sNNcZezgkF7=$u7UvDdKvimuME;gGDAbt`qhTGh~KNHU@!Y4fJC3a@nc zspZQTS4jmohl8Er`e5*)veMGv)=Rm6EMFcN8M8KcsZu}oEw91`+gsXeYg$^`>uOpW zf)=!lm8IonrCTI%b89HLxLD+UCwX~ueQuhRn{2;4{?zN?2`)Gw>rB#ce31XCQr!42Q+`2X+*=cUa2q!X% zG_|d3t2UB8%eCnTCiJX%J~dz7*4*}YTT=u`&auMe7|o_SKRDYoztSxyUxkZq2k1C%d^Knr!1FSY@{3~m00={En^D45!jbsy4#A*tdN7 z3hpa*T#VeosxFZB@Tt@)J=LfRG1sVSjLb5+7&n;1v|nAdG8BrtXUHuj9F0#9`;pYD z4dL!8X4J9(QPtd5)!7{86wi+uI$60=-DLdD49^jUjj2^D+v=<8+pB6jm@w4UbcU;H z!c}2CnW}2&X45a*KU3*s>69V;^<+!4~xs6>9Mo(9p)_Q-^@;bg! z&=IZczheki8#ZlOS-!X=VCFqzRaMo>?ruHFHB+UI(|Icb6(f_|x`t4=xxLLZ12g~l zm^zly*vD+?CqN+kX@G)y>Q7aTia6H@8>S@eoW_cXVDIVjdW7 ztYWUrsrFShbsbbsdu>%?S6iLBS~WJx!UkuHsj90RW#R#2ST)wk)L5xeBjhz&d7J_| zBCa!{s#`TOCe^XVq%Gv+r_u1JB2{H-u&S|HX803TmDHyV-J%+=?r6qvYRm`;RtsxC zqJwVAH=r@g4kje(F4e`V42sn*)d*2yZ&dVxntJ9iRgfC4Y+h2L&Qdf{z0^__s*%ML zs*0}H+}79*bTsgEPD_IeVRpV#h5SaiLU6&|DJ9TdFx=eQu%txno2RO3|V@$D+wEa))D@1UycY-o~-6(jSM zO%H$qCj(J-$jCxJ z)SgPCud$VRIB#Lm7OJ8rbZn=cq((znX9Br4Y0h;@YKJRb+fo2qMs4`o8iqby3) zRdY6o4WyjZO_f$n?TKdHH6`^9&^w&3%p$^AL@ z()-`|r{$y?6#t+I)0dowA$vF3|IQBDQTWms^)gtud;fjT%i#^uIDFYEN9A%4fB*eF zMxu#o5;} z^yG^U>kLOU?9n~+((ACKx6Y-<$Vd<`X*Iu>-V1|~IP3Syr};fvJbo)Sosn+yCcJU+ zBXn4Ko(>Pabh@nYMCh8oYmcFL|Mzw$2i-onkVh+-NH8C0Y!3!iqWIdHdZtd?PJ;S@ zNsBrzUq?sHPJP=pOKeV(D#VRu?{g#LZe1iP1U_roROQd&8Yt0H;IjimA8u_AG)rzkA z`khARN%5~~Xlv+bu9FnU;b(EZqh`B2EY!%vzqDn0JI`uOtyQa~9{+)Kj!Iqfzf*6- zV8=-pYmfEKZL(ZIHjh`n82*TGowNV@_rK8sAvXAb8zK4^jx0HalQDf!EfV)XAqn_-uMIHZPwol-j&CBDDd=w!#I&6c;*Dd?|xTLzPC4d zBI^m9cPTgrHy3{ZOr6AcEbwQ8f5NTB&x0gqLn*Zl{}AYXJ5O-!WY$8U3vR&OiN72y zoW^ei@Vno_lW*dE7L;qb)0;UP4MSyX-oJ8596-GFZdSjPW;1Q(mG=|_giZ6?X|~n``{5Adp_+Fzu*Mx z7o3878@eC-3{LFd2mTWG9&~j9>w!3-2f!&6vckgeX22C&Xeao~!5{Hv_YnRea6%RB zR(L@9e%MkU=WK#wtFbSB!9_Uv=9u6WxF-C9Vcd221z*G6ihl_FSRLiX-wVFl$hv{h z!Pl-NKS}t(w^})8AOA4;ZaaC#uR@dsw^!)ks~z+;;Rh$PYW@O#KN!A|ex016dO-CF zrTXv-s@?33NWl-@#J86E@b`kt`Y2awiVA`+;N%-hf@j}NJHapbAzU|p!Dn&1@C&ZE zhqB-=2fx2pR^3z7AXxWR%96(KO+eqb$vXaQu>JekR_I{OkNLgMDE#0RLzGMWV9hXn zJ{>=J%`xg7e-Ah##iw4u?+4dr`&7?p^n!J{oIQ=d7kqeM}~ZR;Nf*I#0I%E9ki{~&k~hj!>b4!&&tL*Td% zp%-25HzefS64&EW#-?bz3x7WTK5)f0pB^X6!E15S{(HbzFY~Fn@C<=7FE{i6_yb%J z`XHE7LpkyL!E15Sk9xq_wVV$RJpf)+?^FJ9*c0@=nIL#uBWLDA7yK;l0Di$caYyjG z-!_o%A)Ll{3(~VWZv!mG72y|LiVNa*zg-~TIGD*d2CAV8&cpTK7hHtv!|#5BK)ze> z6yFXQfG+qv?iKuk2XM#myWbX&?-8W&ErI-;6pdr>m*5v1k1NOTenUXMJFumV{6H7H z40j!V!8+U?{O-2_l@1v7E`@eAhQhVZ**^~)Ll zx9{}v(XJGYci{Kq9{|s|#^g+Bn^itEPT3qFh6g`a^_ zorcrxAMCQF{AXMdbiw;@OYyts>HiX1@CIxPU2r|F8^3#gzMQN7J6tbx!9U|3!tb7i@1Bz{ z=jVSBHw2I1Uffaqf{)@-CSY68J2PMKPFx;z!G7Fa{DLoX&izvSL*Sbqr>^l2gJ*vV zS@?tChTDDW1^ngUr#@roec)d{XZ&i9Pkjz|1fD*y==1b_`~mQfxcrHfrRpbNI*?#15&e(yf= zgMSd5d%sT&;tznktiKn$9Zj4k-xGvMXi`1f(QLl?a7G3pn;;8$=5@Vn=_yXU~mdGJdgryas0SdZh7 zUX7o@pN(Je3%DZuec;L`7=Q3rgTqhK_VBysy36_Q|BUN_F8Ej6?f3=jo;H5L=d6Da z{L=vK3?B6yGXItSj$iQW-=Q7i?+4HLE@LD9Aei?(qt_1x4wB~r@&MNUnD&6*JwN?s zXx@43?z!u79{aYR&|lye+=06lzu=#7cj6Zu{Zs6TKN~#z5Z{}?@1D6XXRn|2GsaBl zf^vTP5&Z5s>T|bzuN!#~}=-KFUM*6pZNxy?G7A80Xgmx5GW>$oxb^rozJ;yvmxI5?h42r9 zb?=yd9RfRkgI?%8V1RSRhwuy54r8mS*c|-kZ;^|C0KE6luKlp@TPdUrtGMU;$ytE!;PT-S^nIDS z#xIzSTZLcng1siKd%mBX1-SYF@&S+FrMMRSg3Y)d{O*~4a{k{{57Hi>3w{*07r)@` zxTo>E=lIE)f1mvdVn&yRzk`Z|2j z1$!PwFMh#?A5GG8RQD`BIb-j~xI^#=Ui&!XGk(FPPaqS&;6*s0yXWS~d3xW&6$Mf> ze(IalHGaX>Pg2+T1vldA@e6(kCp^_)@-rrH?iqJ-c3u;%2Oh!earfdE%zBpm;}@*P z9TGX<3(qkQ;~xY+_pj9DVr&b({O`19{6paP|ATuK{z0(m`}7y)+wS>v?%8#6rrneu zFc!ftSdQz(FZfMdAAa{NI`^D9Ilu19gX9Sw!T-b!;TM#1>4x#U=hMkKb>m;;eo>sF z@w@ov;vWRZbLQMq{OO!}tY1{!_*l{Jr2khv;wk`@tK3 zX8gV2LoXRy^@9(-Y}$N3`1oto3;YA%gG1O^(traj~D0k7xmw4>q&H*v0+tTR`G7f+`W;urj+rT2n)oX>R_x*rU37S~byf-j#+Us*zbKaF)*oZPc| z!A#D}5`Q*$i}m+9XK2Z}Ta!5->uu5s7UI&+Fi+ z^6<;KQA0T4k+Yqa;lv*TAHm7<#iQUsoIFPh9<~1b6?~6*WwP=krv-c#CwUkI(^nb4 z;G?(zJcq#FTY7d`vRaQ5`GUKwU(VM12u|eO1ipq_MOrxnv1$#x_(R}xxF-DNYe{<% z`NiK0`YuUUd+}$3J-8wK{oo_GApQaHH#qrz+rT!?X2Xd;aCx%20(WFA^1%mjyT;MR zYB<{rH$cA-lrz@EFDPfINm@aDMjC!WIS)|h2;Oh~d%@%eTVLw`uK#To@b>?C_`j`u|5u*>v%vp03$Usgxp+#6T&WQs z-yC)PY_*77b0a>bE^_>LJN`09!6zIAlN<$nCM|MRISQV26kO*h__L$n_l|-$9R)8q z3idb(0*-=eN5ONBf*TzLX^w(1j)EzUf+dcER!70hj)Er~1#MP=nC2A}Na4ja-$a4< z#WWo#5Wkq_Fbc#kruhyE#4o1#Gz!EorkR5R@r!9TqCos&nmbV-elg8iC=kDxrUM1y z7tG0mq?Abv5;OcaP;OtT6F;uq8GLV@_jG}$N+znI340`ZG!N>Lzw zG0hDq5Wkov6$RoK(`2AP{9>93C=kEc{!|o*Uu<8A0`ZIOA3%Zl#r72_5Wm>|J`{*w zY=1rq#4onL9R=bS+s{LRXZuYk@NEBO6nM735Cxv?{{;n}?U$p#v;Flb@NEA#6nM6O z4+Wm>kD#1$D_cr{Tvi{w%>>X&-Qnrz_b0? zDDZ6Gg#yp^Z=t}m{f|-L+5Rgi@N9oE3Ow6?9R;54t5D$C{#g`ww*N2+JlnsE0?+nG zQQ+DB2nsyg{}2Vz?#1@^pg`Ka*nSNPq}_|{Z$p8!d$Iit6iB-l+n9L52HZZ zz1aR;6iB-l+y4Ot((c9fZ=pciz1aRB3Z&hO?H@paw0p7rCKO1!7u(;D0%`YR`wb|N zb}zQS0|nCV#r7pAkajP&Z$^Q%d$IkGP$2DIY=1urq}_|{H=sb;z1aQ>D3Eq9wm%aE z((c9fZ77g-FSh?V3Z&hO?Vmz{w0p7r)hLj5FSh>;3Z&hO?O#EGw0p7rJ`_m17u$zW zAnjgkKZF8l_hS126nM7(2nsygC!@f#eHscp+mAtkXZtBA@NB;X1)l9&QQ+DBWfXX} ze;fs#?ORdc+5Tk|c(#8W1)l9&P~h4A5DGloKa2v;_O&SRZ2xT(c(%U<1)lBmP~h2q z9tu3$SD?VN{e39#Y=1rqJllT;1)l9sLxE@eEhzA8{}2j1+h2kL&-ULyfoJ2{SmLkx&RtI}dFH^m zf7sonDUf!EW77KsolB=G+JA2Xp*WS6uMseJ6 z{KBJ{27(EsvM5O}PU_`*B^UZ-p_-7zUp0CeAS$O{|#wh8Z?lHp8SUyzY>-9FWuqX z_*H+_&srj{_q%iV@jV};vDuGtY3J>lz|Ty-i(Q=Z=*{~%p3BEaMzBdI-;~$;XnP@V zug+lC_8*h|9cf$0PgdW{h7A0f^j|BF@RwGNVQpjYmp0p1#lJf(#Aa>pFZ;X8-oYQe z{4F*u`-rr+PW~xxdoGJjnV69Fs1JY6uMK#B{qW)(dH&_E%rs|4rn5nTXW_rK z!eCdLUe5OI@4Y?RtmvA-HeDAuKEO)$4L19~`w&|{uSMF=|MRkO_sK$*|BaWVedCkY zjefs=ob^;}llJ@>dko|8d2GO(AzA+Ud-pCkvd=DHqb}7-f8(NI#{7bXtbN(m!@hsY zuvOtvyO*$ziDRX|;P*Xk1Nl>I{`Egfd&Rs<$+|a+*|_&F%HtQWnC&fUT){q08zt}e z#*@3ft~IOJ&Z$Z1?@E8oYZ&}AD;;}T+D)^1y{ER9vQwGYWPgV?4deT|*0R4&-6j2V zuC*9xgMYx@>6G(t?ppIB8*WH@=ghE?nYV@g za5(%*?pF5R;*XFY0W;q6&9<+P*v9%_xGMdbcfOM>JGzY(7QXL4uQ{&Z zfpFREYPKVz)9=riIbvyYSW7iqw&WcAQDesGvu(4kRI{OP?(oOoK*Ni^tA+oPJbgA# z^Lscytex+n|D@KxhwF#6>vP;+o_2p6_n*}6pX2#F?fE#K-_V|)V|>Ee_;8G0o;H3Q z)aF-U{ta#Z1>(cd;zJ;Q3@v^H;>*zDOCbKj zTKoybXPy?H0`Z&F;#VNPJuSWk;@{KaUm!m`Ek6YE$J6phAiq2T{O@9RR$<*{oK)*~)zr>K^ zxu&LX0{Ula`X``|rlyYq`e|zVDWI>Wrmq6}YiRl_pwEV;&jR{wX!zvz6kKg(D)<3Cqv_t0KdW-zXbRe*7zpCzp%zX0X~K`J__(N ztnpKTuX!3@1^An%@mGM)c^aPu_?@fqTY&G=HNK0R`A>gF$)5!Op$}0y-vj@pt@`)C ze_v1N`X2Z%{p$Wa@L&4X{d4fY#Xnv>9|!-Xt)8EQ|MGk_J{m^{FnWy@#WyZ z^sDjb;6L;*O7p|Pe_#J-{y6wAZ8g6f{FkEIieCZ#%j>E57T~|MRs0L^|K|PN%nt$n%j>E95#Yb8}9) zCt@K}j|FS>D2Lb*|zv71g|KX1kUj+CsZN(n}{^R&4 z@kxOH(y#a>z<=pid=ucm^eg@e@L$@Bj{^M1@d4te0RNF60phCw|D|8?SAhTi^K!*! z0si~_5x)ia4}a8Cd>7!qKmHyXUjBEmZ@yH0Kz^zp=zK%f7u3I@>JPd;)hBd+RKL*u zo2tH{=cD?Ep5IjU5seSkPc(j1U(xtd{YB$X^%>2Nsp>bHKU39rG`~#Me>DG0)rS-x zOx2GRKTOq^6kkl$pA>&g)u$AnRKHUEGF9JFd{g~P@y}F!O!>i7{Y?48RDDhPMfEr3 zAJylSpH#n7{xVhHQ+_j5|5N@mwLTzyU~2t9`oYxtg7k%{^#|z>Q|lAbC#Kdfq+bmD z_t!V1Z%nO!NdK5xACW#XwSFS~WNLjy`pVS$i}aVN^%?0iQ|mXH9Fr0-0v|49Ft zS|1W0X#Gh1p!Fs3g{k!?@rSAPDe;M^^(*mp~5Q)+=|HT37UTT|nBo=RI7Hpy%IO)Bkg6E-!Z z(&`bvskD_pP79~fZXB8OYAUVo+@xu#H2nO=Or-?^`H!X6{JO{2pD$iti~znPg+V}z zetInK2>3sH^%toB`Tk&hJh}jH7IhBrzxMcl88llZ4l_6#h{c;#Pp_i0>zjSjD9jvW1LfDovw{m%; zq^!7dV%h5D>&h$3SFWFk4Fz+HE6XNr%nk*yo$%_F*rpY~PU7EJLs!9Ic>Ox;lwOD} zl2mVF{!edH$H?<=W@X9p4cOvkv$FAy+*cM`5U!ZJZuLfNd4ykua?7c^AF9Hs{w^`! zDcM+38Z7nyG(yFd_(dn>Yf9FIf*V%PSnhA5XM|Q3msXa9f|GCc6Q2CPuM(d8se1}f zzV&c8Jv^Dl4aR3?0~)MPQFv%6gd&cavZ1GX?5D24yV)U za=M)!ClF7Ir^jpKb#W{1#GB)-@%DH}yffYv?~eDxd*glaKx0~CdSgaouraGKrxATe z@i|Zb8g`nUZfDp*JJZgxbL@P(z@BR_w2SPBU13+*QM<;jwd-ulcI;-m)o!;tY-|i5 z@2@sdm#`8}qB+r;Xisz`Iul)q?nFo8boCOgGETar4~*cdon8Epj7n zg46}4)tTC2{oEXQiLTCH}g!|JrUtZu8v>b3f;KrAhm9?OUYW0|q6 zSWYZIRuG#TTNo>fMPe1Ps#r8u6RVBkI^FnOH2x}RDr$-};U7fw?QYn{f0Y~}ssqb(8>f!OA;ZF^6J$B&gBNya^Rv$TG z%G8C&HRHy6ufFz*D^DmWIH<%a`l~Z9 zy>;QmCmxsn%rE)FaSwC7;KWmoe^eb$I{u&Pc=GXoR>$(=pXd16>E*{i%kjul%8!4F z2b`i)sTd*A+kQ?>h9s4U^LM zx?SIO4d^#$h${p|zL%qJH=WA4N1giA9Xapkavk8jls>u=P*8}-pW9VGJN=ULE_Zby z>4U&IcjVMH^uSz~s$g!eYqL~To9prnQ;+o5{9M-p?$>s>T@6{c_dZSVJYON|JgIlP ziu3n|>b*W8a%EG5%jg)Vozixv9cd`9%T<5Ej4LjST;_6ZU&UR@bgki7%Q5TE2iu&W z!CcMKxN-_Qh~p7`3j{84LW2fWZKSQPBY-R22hMltc{TnCewQo%yF72;c?ri+`@)?t zW9E#@d8B9u4W*A&=}~UiD*m{> zFv#`0z1Iun`o-Ss!_MJ)N$>SfmeU_*~awIhQ{(7Ana%V-rd| zp;%2xafnOr`13C?qua|(>vJ<6DVexXx+Yb0(gaGhHrh|6QmH`2ax)ew@rJCVX}w@t z`KcmnJddMG$}hd-qD%T{{>%4`2UV|Wy<%F6Xz$|}xLw8t2{S&P zMh!6IX1-C_FI6=8Tq%1o_<8$aNBgaF^UZkPYTh$jH<(6XQ8xBMpNmWKg&ba>E)XcF z63ek(HKQH0I*)>PF3yP*JXH*lOlz$@V3@#MTmt!$Qs1R}l^4$|lu}|jQh=E{dNG4m z^@RSSmJ8*1(yyeE8S@KzM>wxo9eqm!zvy<;jMHiMBIstui!R#9+v>(=BPe+<`rLE= ze(5s`B&g;|o|-XtHl_A@zi$8UAE4hKx9|Iu`g^(Cw>_8q=j~bfX}Uc}@25RW>-O88 z>&L0~?Ai}L(e0(C70fqVmq&(~R!*wcW40zD2Zt=zQ^Mz_)k&|F22)-+EY8p`$Bh4K zzC4dx^+M>&YjbJZ6RLui!)xW16;%hG)WmO-)0$Yz;USLpX#>@ZQ#el*9UcZZYo+2v z`u`9vv-&@a-UkYfr<>Mzk6E_foV{E0(~RPf@uwi=So8tgr_Z>PA~VsiL#Mr6mzL#7tICp{))dD<&3< zV>eCFoGo`ieLlL$!8f|FS-~RMDGY(wg|mfCchc zqX)))2BmNO`LJ|p#m+Dt0fwy`8V?M&CTilNawF~E zj@?}16;!RK1!`IK%{jidnb$E+LDg(cMaG608nq(3e4%(vi797{p9v*CIjdy=r;6Sh zD;-oLx2lWzP@saWuH?ce7Zgw}pNXcGcM(dG(})b3n5xyZ1c}(pDYUE1gGRH-NBVCOpfVK&!bzeJ&U@RZzu||V?K8MT1 zM;Dh=nij;7PPufkItBftTXk3l65gV<3RuBqxGU4X=_SSIU*MOngnItUQ2e?EzqOT? zn$~W*H8irk(c_PPp3``c8U4u=SEJiZtw}dOa)Z5WfNJ(NX6w$zyy#asks%Hb)mTeS z>))xOFq{en!p?2ggQ=ni^xe};tGZaKpl(ak;x3^DBoJCiKSGOYMT-z^wdlQ=(RHAi z>@V%4!8FY@t?6`ha!lnys5|Ik$EBEv07F>p^R| zX@t5$)>7L(P1t4h#E|qM) zwow{ZZkB!GpvI6=C}dFVZJgp)x>AsI+84BJ)wGWol(!xtq?#`6lToDFhmM5+((bNPyF19~DRbC%eYnFWx zazn4=h+_D@(!6}JG(7rTGd=7wTJGdKWQ}E9jA{su%n=^=h30{K^>{c?cwm&~fl=@P zofVwjlQLYc>nkR=hpb;nL5gVp1#(xB?mg@%v#clNhJoKS&y@R(A+xIIhP9vu)gwnZ zFM?Mu!5`r*o`=d3!7^LOU2Y2hD#|DtWRb1x!>-qR<-^S-#dW5&-JHE$utCfWJQOig zvBZo8dc*<|GFnQB9cNk>)P^qacTPMv$E@m{In*EbrDFZy2_Op1_}MvTEXR1F-`2CS zz|H9MQl6{vASHsgp1{4d5E0=4v6R$sWC+5;5gkf~r~#wpQ1n&??NH<@Ekwo}Pi!<= z-$Z{tEdyxlOPra>fGt&V?1oydWr2-ofS2I?8Y>~Mw77t3H?1&~sp~eYR?PIG(7-le zoAJO#GrHSj8r6Y~HEp^1%WCkUx(Wiu6DYm#M*Dln2Qyv=(5!BOs@oXim5_jkC@|z+ zK@sajh*omap`B>tqw=$8@Dy9`WGF8;nHK4b(qmakLdmDr=^Ofk9I@E3~r`1 z337%z&9YZa_eK#1!_Cx6(;aBVp z#j?dBe9g-}rhC0~`+>$2j9;xlcXm zzij(P)hYT$)d~Wr^O5;8zaQP5isTzl_)}Gj8ow*Jr05{DLMp!^5ly9xnjR@#Mk`o} z7Q9PZDY9xNk0aNZ(VO6Y!)H8!weZd;H3Aw}g`|l1c!Z88GA3k=DfYFU9<&&fiy{cn zsFp#}?);z|`^?hPs8EcR>dLYe(T?j(QO>BP{Jp9NlZ?f*mph^C3GW5Ha^l@WM^4m~ zG$~a}V;lQdB(~Pcn6%FInN~kBc!zU75wQ_+CxTUpnVwY9zpAn3+A6K&)?)=UZHvSn zE165{jh6o0#rQ<9`e~z*6~9zk)rv{m97Cgzavd`TJ55Ne2x`HK~CsCYxU_C#vBqcAHNwYt?O?{gn82TYNS6p@Jxu@XNc_e{OG-( zr^nALcpLM?a1h5)n~9O{BM<0~>IM@%_uY^c)!lKIVzpSI;^~;DrVM#fU0V}#HQ#iz zD{>&?$Hr|D(VKBX{^3iz2)*`cjf4VJc)*DUFpxe<(hIbU4$J$igU#%Y`P@hq-AEbj z@*Fh0VUojdVgio+C}aN?JOfLF$N(Piq5 zc-}unV8z@R^BDBkL1Lbr!ZR}&ZKf*uLqWbU)Um@ezKci-d%I{oEJb9FuG+l@r2O$( zq5|vAQYc{nDRWQke+gjp>7O+H&!vD@L?_Ka;T~urqrb@^J5n67oC3kI+M^ImRu?NR z$So!67;k=|d9S>}{4PC(FxHZ<@2ki1BoJ?tJAv5G^TkIsXLpESYybQ!Q2>^9Rj>VlR1LYW;l#Hy znG-2|$|J%dZppj$aD|#!k8$n$_6p6kJXZ9pr+>y2WCYVhWg|jQqeWP!`6t&QUjD3_ zt35}t5Sz63Xtc!C14IeKup9x4t&Z*%p)gTIL1n7Q2X=_G(x{yiIVRfEukk|RlleKK zA(~`(PL$z!@Bl^o`imB8E)wk_?_<{W5doEH6E0Ph6fUdkX*{s`CQ!UP(e?02iLSp$ z!A_aa9h5FJ-QK7)EKm_e;_VLN#T&dra@h^Q66%)SI62oXcfZluRXee3}Kl?kx zI#Na7QRVkAMvNAl2jVklhS{1kh$-xp;t;m@0P=M2h<=lD||$6cK$mzgENpms@NbJ!IvuX z=vwlciUnVZ1y}{!tK7)ELwRCapg1butZFKrX_%HtWkWy5z-pXAcW!EKDse>yr;3&U zuRsb+%O@aEd{ZNuNJI~3Rk*cMotY~7iGX7IM9$Pt>CsvdW&ZwBnOI1v+I;8Huy==m zlScD8c@GOsj25B|_CL3$QtiSI-n#SsPNSxJOl5L1dT#|5gZgu`44331D$Fr%^NNm- zT~T6&;#cN`q}xN*b=Y=<8J8Po)yf-&2SJlM)^9Vha;v&;7=+((lCW4+r#Nb6d<+)6 z=<(T~t9TXGw*MFtUH{YPRCjjT|Bzur-bVb%KU^KhoS z2#62$5KEw^Ue{ju>@QR=jiBG?rIp4{pP_N~fCE$)87&Vee@?J?JDzf|Ccm>>&6}~oIj;KScJ9G!v#-G zQNwAa{hM5Q13OcwAw$0p`)T{4X6nJGv^)xrzEY70St~%$KYP)%%MUv>F!fb=;Gex% zu4-b38-@OSe@9n;j>UnKUgc2Ar;-o!_fJgv^9NCH(mxcwb4~3hFXzdtQ#<8!c88qD z4(iz2zoK)&?B?d?U2k=4J80^np8hUZnZCoUM{G=qf9ip~FVsx!&{!lCPO%(+huy!X zq9a*-oK)lAwK-ErO*sQFF0 z@`{5+Uf0d(*xb*!fJwB#eDo{2bV@StBBrX+F9;0B*?|QEbCZE}G9St*oQY8S#JCj) zowJFYg>9pdx87ulbPCIf1Ym!{aMqDDpwwYME7X17&cFJr+fxPe#k27tEx3q;_Uv1dw5$jF_1fBf7W zns~f!Vh`o?5P?{y6fN$APxS?@g$V;2IWp!kLil)Njhl%sy(LH_rnoK9 zC0DF*U@{;UD*$R1K2>xSQo^b}&c9ILKQ=toB{=T&rll;Ig4Lc}S1f?ptPv;$0nv#d z+z3XE8!1?|Hr8l!y4`v7>Br#qCG#hg-P`Kfl;yPgDZ$adpqY}S$^Wn<|Fff|9Nme8guKfCP4!bDAsHWpga`-CEL9;PW+j)3ZGudl zV&Ak|9E_qDUrFB>i<`tWchTFC^qq+sz%+A(YZ<-)7zWM>#ly|W1FspsM{r;yTsbJ$ zWiObdhp2}rW-v%!YlVMmLZJ7Rz=lX* z1y(vbKJ@xgv4Oww$E$NE%_ca@$)+Uu)N1tuA&mjjJK z3{6P}B7%liVS%O)!X0-G&r+dLR}T&^liZdnI?};mEz&O8Dr!w~zS1O->L5uE2Z)eQ zk;&Fix!|9&Ys4N`52bvcl<(8clyaydqN-SPl5XZ5R6)VWQX;7GMm++5gffbmj<;|4 zT|Y`+z?-N^-Hz4-SJb~w6({BpT8p{AB-N^Wv1f%$(5@X4x9hs41nTa|m*zd?)P1UI zo`(hu%W7UR*A!o>50(00>cd11R5OJ`Qb8Qdi^yNiVcKba6AgmQ&>(vQB&xjXmKm>Vl0qvVdVq{T7m7c zfX51S#{z?stwQx9HTEE#&lQJa4$0QReDlwlTvLJcd_Gusxs-~Vq;r}yfdo?ezrPTu z(5de7y5&+gXuW=bwEPYStq0KNbd-tpG*MYmbYKIc4ZlCoOwDsClc7J41D3&j z4q{`ean{-_4JmAG*N3_KFkc@M`mjzPHtRz-hopM#D9$8=IK_;`<$Wu#4l%Bct1$9C{IXp^7q}y6R()}PB#Tgp$Ha`umlCwd4c`2f^9oq^={h% z(3aWIHper9!Q=7waf(QVRkyV8s5X$nol>_ju{4W-9V4uP(qO zs8vv@9&O-}J?U5dFqzg)&e%)U@xj3wEB7wORE;$>8b7JGK^E>pHf1YOHns zj&1q=)A5L!X+Yrg7mU^$IBDKpV6f4h3i=vkcEHQ>9@Q^pHQE~ zEn2(b`jGXJy^(VL(Xquj!T2Qz+)3@kR`WyFO2vZ(f6WmNT6L@*>o?QeFz`gvIt1?e zg?hFQMyc3|M_#Lhip?@by2~6ac4;MZ>1^+vYU2(O~>IuguPYGiy zIL_}pz)eLnL5Vu!oC&bt2WAaaM0=_0eEhX*~^6VQB_Ah-PpUSbys zbV*6Fh!0&#HK4T^To?s^-_y@Uu)8XV5To#cC1Gn+L#V7H7)|sKcG&J<)!2rRF?v~; z*vf!l$7VOd&?erY0m|+{u{0tZNPM}CVnOBkbQPu(g*`44g`G%O*{$d@lfnjt;tj_H zqwjAH#zysYk#y5^w6J(O5PJz=A*;K~9kO;x?6+ZT{EP~;T62);B8EIcbk%}2_O`G3 z;h1AVq0qbXB)Zy=MvhsT2>M8{YnDdG&$u<%u_ZS+J0&LBjN^jwamNI!)*3%uf~>c@ zK6EfM;}Z$tzq6TH9EI5%C14h&(gLB_5&^R|b}?n~hVbRYpu}#eeToDufhr7JNoHAy zCyW!+oTv3&1gn7#TW1iPIr^j&{0i{ZqD)YNn472&u|^=G7{@A=k&uuy!3zfp+s5mB z(xHP67DP80EjI!#Q86*sLqx@|D5^??HdVFTaFGBqV zOU>wqIgQW5;z)ILMj#O*kBGPuaUF@|sFLAm0(yZSKKXo#`OvNa6Rd#*$6_a%6^iFo z>_Jm1B3K3eIVW%RdwPf-quN+-FgF>go6|tMzY?G;2*yi*?kIpvQN?1>Xk|;GZvf-B z$d4;{OhMnPifl4PN=~#TI*L%lrm`RB)U@IvK_v9^#183cRDy_@*-J#yh)VEJ@?R`! zfz+z+ZT+iAp?J~LN-l?e_6!2`T(3+j@#nKgebG+|?sKp}kcU3|Tn+HoG{DgSh)n*A zs9gal*8s6JK(155#x#JT0j8t@-q}qR_VRVii`k3io6@GGt9yHk!lx?G~c|F;j5Gmsl}R!j>?BN{@;7 z$nb8G4DaaMJ!zF(EGk(ty|c5tC&|3X-$`g_hrwgjQ}`fLs+*{DkKibY`{V1SqCzdX zyT6bgKOAY%t|kozDa%TR+hi%F@2mm-;E|&9EHuN!Vu`S&HAr-Otrio$d4UQLPTUJLIlLhWY9d`cI#2s*US*KO> z^W8LKk$XKWWJ>kqdli#Xk;B5)`wDwAc0}y_d^5U?@lTApYp9+WN5n8r%59P!z=sDi zr|1n?dqPZQm50l|3U;J&5tK%YBmg`x1nsBMd$m}%^Nq%L!>v0aXNZC83zoga zaOw^+eeBE(Ds&D86t=;iSbvMDJ(y9l0LZ-yR&8u7p)HYHBpo+?o+lJ5HDl*= zTP6}F;fbBo!^6gRx-K=V7Dvi@{rj(j2CVTNDVu^L$0|F2r7_$GmE56N8Ajn@9;-T^ zL$R{psQo=PKP(v}49Sa4>l#Mm>)$XMUvGR@rJG1{#ohyP-z1Z>WyYR?I8c!VdP_!x zidkZDhhnD&JKoI=yWbb1+e>B(WTETK80&VTOG+iXo7)$Pkq--Gal%ylc^FNazU$S#q|0=>`%8 z`9Rv(6ts5wM?y8@r;^}_$J)5gD4mt4F-imT`3leFtFB#!RYQAC{NzD3Mqyn$U-CfB zZO=;J;WnVID+?^SJc97_o`SS;~&Xd}`=A0>2e}UJx64ihUu;Mq)NMDGVvbOf8eX zH_6VQc^JLy+d2w?R}-6=zYw<+Ie7;pZwKOJe-&Ue50RP{d+1dPF&HB_w4n!M#OdSwg zkZn+E5%fc49|b%1U>@&`j71zoZ_0NWEk~kPQ$@v~IkGz6XpyX3!{ata1iB^ZG~A8c z;h6+1-UK1#6tO~bnO0>xXFR2653G)0)#}J0(I$#)eN`|=lLo7nHtvwL{RWNG7{Tee zw0$KJ_ga;{93m&PWgy&NkrKU`j&C6O{aDbots9IMnQe$}%Q0G77$`DKyy$YhM7RoeCs%VWmhbo*elJiv2CJ3@BQ!o}Ha~2<)9Uq(}D@WZQr;6?b zP6?6aa-xMu=RQItJ{0RC_xe!$I2GL!Qq%_Bt7WMijx(AH*#(#SLe?n@x4T{8_$aTx z@|NNdVf>&qHs7DRS7*fRjEq6!b)80jEV4p0lWZhlozlWfQqrLz-t;+dvQ9BSb#D{V zMPY-3Sq~vzqEC5Q_Fwz;qm?fjf;}BSz`=fxIdyOB_n7VuvutrNXLM<>YP5G&uE^Ek z$kFBMtUS|}__@W>&l4s2auIYu09&!6Y4-1 z3|cr6Q1Wvs@}%#Srtg$8ub{9-aM#Jn*U{YFX_l=G#th|>P%d#swXl5xLt4c>;DhvH zw;9fCMBjyOD8Hz%f&K6%6$27+{nQ`^xoV8Ko)ZMU`n~ug%YqjV!Ywv(Uw_btKbXk& z2Zu^EVun;xlcZI~W%Z)OxHi0sxQi3xLK~9aR7rXhF~*xrzfn4~o3EQT2aM9{b$pFU z@HKuuxld^)vUgdWuZ{%sUZp&}q?5?J1T#%5uk<4O?%8tXB!n%dQ;t2%5Q! z1rej!inf z**fOE&bDe|Jec`0l1Ab#>4ZWsY2&f11e$L7CmhIq{TOWo|Dqf^`E2B4hcT*WBm)V_ zvkJu~Z6v7K%xT!V#*-@AHBguvHaVdn!zSJP3{CRrMeI|uQno%hLt7wioVn$?1fuz< zt%&C9EBm>&%1kpgNEYZ;%X8` zWrk+ItD!^J}IaA$&*rHl~Zt*A7fwEVul#Ro-+>>;Uou32QLu{S}LMq06wmEVJCo zVay-y#Aju^FQRa>V{@LBo6n%%5wKnjcD%z58PtV$1*y*qTI`?0!qrp#I;S?e{Y?=sV?4pKG5O}MkAiMqlen8KK9qGxc)NtH@Iw~+t?Hrvs_Np#qS)wM z!c==bR@XEvE1|JQSM69CHL*c{Ys^r8*_dKK!^~gNvFjthdwg+hNX3S!2V_R%*S@4s z>HFpdgir*vUT2E4edM!^d@iPIiRH!W>Ph`1V-qXA$u9@yq5{^3YGO*hYT5e4Z<(fa zqE85d&{OBda*jA_pouL1+4WJ4g(E{+1SK&W8m`CSZBUzgupT|%-ohfh8Y{r!^l(Fs z@kmDqi>y5CX2H$knKy_xpkyObGSK7*NlL(~vY1O7=dtH}o=UOg@vLvCp_Lk}I#q%3 z$a+&I0qQD+by7!3PUJ!a$;HZuA$Z&= zG2JPqdqvQ_#;n4!HKH?-%3nhWMS^=+@*(E)NiyS1J5&?4p2=I;;(MdQM6G>@O{%w6 zYWdw)G7)P>Fd5Ndyc@EvLiS;dj$(m~6u&|yK&;W;kOiBY`JpP7G(HWp)J$EeN2Xd3 zvA2a>S05}}Y4*lE{{uT2T|ziUo2;?MHrQp}Io5*& z)~y(4vsD-dt-C-@zScNXyCc*~D`Z;I%@RYkEywAmH4#(zVsX1p`Nvx_mpIDXd`q$3 zkq~=0p{-hN4sVK#m%aveP1jkb)xeufc3ZMeZP<0ZEGF@H(m62;M9b+CBr!(pVm5kF zi7~vhQk%th?ZWFTYfLahN~xEET)542BmWR;V&G!izW*_TH(H%{dX zw6zR#>gx>X5aIytrho6H6zSi$AZ9P0S8NKVh~)tks+u*|h^lQaWPofv0LBhheHMBB zTRYxbZI-Q(5%iyRdMIA9jLzN|WCTcOAHA8*?m0+xcDHexEZNnaeYe{oz)Cs!1_B_3 z>LoQodSql!iD5E6=;IY{erq33(0=)vE`N|_OCQe>#H5pd&fEWKC(p@r@;^RPo!l** z97IeMhpnabtW4b>NQf#J-9Zor;gc$Qte?}qE;;#z_U+rjbX!JL^?FOHv$vMv_=sI` zC8f5@$;F(I^fbD>TP&J!l`5QyQcV@jU{+gR@+nyouKLPo`8VtV#$ju9#-0wbrq?p8 zb8(;}jX2Md^KqOTr%{xzMz4AL8n?MHT!x3aB)H4|Hm8~Wce)M_<53CpR`Gh(oAs!?|vIoh)0aIuoBj)*CYQ|pXA^WFNWNz0lVeo8yZlC=FAyY zYF3THBW69I*Bm(tkC?Oay;$mr4}_(b+QMYQRrDL(__Ro)UJfx@N5T`5!*Y>Wv$esp zwS7djjy&w^S@un*3zJS4EbEg_w}_6wvs`O$U8U?rF)I4li^>iWiA%f;yD7a4nRy-k*e)4aE9q+rvzDTVM$FD~o_77SovmBhHGq~*lM9`TBDx5b&hJ@my z3B6n^K^vAfkIPTpCrXO^$DNTwL`&7CTW+85k+=mczn&Mi`b!vLVh{sLMG-_o)7M~< z)z^LJ0o4?!W%fuCSlq{q0gH`KPp_KFDrNBAFDa7m}%dCpCr% zhQG0Ds=e0)mHuZ8vHDc)$C;gn!ScgbFh;xS)v!fq?QKlbkTs-YleE!Xkf9@UgeaGI zb&CBxBt*7{HZ0R~ncb0dg2~0QQY;i7voT!uYA}Abr@6_)UQVd}VAYE=1_x#3dH*q0 z6AC>u`_q`Q@qxu=O73s<3S=pDn-m39-!01bUvM!AExvDy5}iVU(;xG35dyN(ws5C2P;GD>}53v zd&%>{nF;lyli@*i%5+Cq?LKk8%2LBMlrHNX>Uf4$!NnUHVDZ3*L|jzFgXqOtC(e)a ztCog3(T_@*<@JI49m@i@vkhh4lgYr75@u0Zg?JEGuI1(DlYy5pMkNyRW-@RW#;RJu zc3(1Z2PUwbhaX}kwn&YzA#p&4bK@lvh`Ug=iEv3J4yT|_0s_t-?(m4TSFN0C@u?-- z?RLEDv%Ny2(ooJ-#aj3{tU&Y?@RntqB!|e%>Cp1>DocB~{jI^k?^$bVgNmxHNiG0RMYkeo-Fns|N7%h^t zZ^p074?de75oYuU#N40bKFi|E0e^(gL-;3r0*}a!2J!Hd_HC>TYDqNC^tF(c^8&zj z_m361o`*nBDw(i!ADIw28cCHMKZhw?Uh4Oinxg#=kaxSbf!^NL9ipl;T1-LL3OvLX zj)Fbei%uiSsj zgz@`Cf3aiRj+RPdlj!(KLl`&1;XKY^Fememy>YC%M|f@ZOY+(sq^)A=k~h>8uKLor z?P)rbsw1ZT`qXbH$#?gnhg;}zQ6G9Jg1?2E3O61j!PUm4I=Cv`ogG~56GMf6>LhFx z55H`moKXA}f55rUe?e#Km81a<(E!ua09!U_fOm-bs1iPYUX?H=4Y14s_@OM~l`7V2 zfMe4De^LM=oo)s0Ga+Rxa398MlUaq5xUGm0 zDCA6nsXcMB^w`?09-A7Rwu~4@9lf@QUR&22-w#`7JN@?+tsGtLJ{#*N>_g`9mRWGZl^fHZhYw!4{|7i2=l5FS?maS5`DDlCoX&EfM zBt1bhOsuOgSu)tsOR{HZZrsU077y|F9eOS(Y2Wvmk|f_3Nm9mLnWm9}_)U^zfLO^e zO}V|59dQsXXa6RBv?2Kn;W>36PoKwiz1(yT#V z$$*S^K*nW2CTWl-G9cv+$dXgi<({rV?#h4^I3Rz?lrltvG-N=wt=26Xn*sS0$CgHi zGayL;$&N?Y$^O0AoD0#yLQG|ogzrFxv2g?wUWGXon*+6oJdL~Ce&V2G!D_`{= z^X+diJpJV8H9Y5dacdKa#NogLd>#=q$*wv= z4{e!5BmdwtX8BgeMqynBp2sAjIae9?boi^*7_EN+BG9t4k$tk5%?(^dnSZ8Cd-_Fb0P)BOs&jAJ|^VyFKG4D^+)xNKgzu-HgFC@OZI9`iC5FltlBtZib^xO1?wXUnQGh=wiRu?hm``!^5Dn6h0ojH( zA|TgfKt3g9NBTbll5{}+mH}C>L5|IUJSZT0{V9JXOCJiy`~{AYnJn>4*va}ZGj<`u z??NU5N3oKOeu|AQmcFP+Bm;}lDlTCnZmd=OfO#2slYPkmJ({W4=2`tyozc$jR04zb zxKxpw`|O~q+#UZeo9KtNqGRiD_xkw2JKf7`$~ye1gui3+;I8kHkMW6u_0Qg%a#K)& zKh^1<-RYu_1W3UhM6a$}C6TXj`C!Hj3e}5Vz+i(T;(_7Gz!tH#6^EiEwkSIlpbs6z z!Kq=t_Z=GM3Bd8;T}I((cr?HsI^#%%@q~wPL#Cw0)zX4lsI9XIoIQzu(Ky7ka8^+( zRzV0H>}$Ui&T707W9&4XtDTErD@*EjtinSi|2goa<|lZm>eU$^N;&WmMHS>r8C}SE z;Unn)Jo4i-z(8gR9xD}(e?hEG{}Dw9<9CVQyvq*8Pxj!XVu7ZeRHLOs5gbQI zA_ujSU*Qc++u1}o0J~;lwtX424B`Q8xc>*O1g+E>!r~|9pJNR@Q8?2lwsf(I1>hEn zpDZx}?G<);1ysel+4qEKK_3Vml-{KGJ<*vO;@^C=8HEkS+Xz6YTuuqXOccMqRy=%@ zM2URK&?BRBG1)?y^9)r~{xh(w0>%86giWiUmT3h0C<%oUp7DwEUr&staTr;Z0#y&l z@d8r2Td_w(!0Kgkq|zE+tc|l~2v)H?ZIK;pEn<>yWNxhSXk71LRp*QkOqSsJ*tAx! z%zFcO%I^4rwnUfIvhQxZXggsD5guOq)yEWHRNO7SEH@rbYQ{J>1M;K>@nk@L=79W8 z@s7N7w+7j9SGts|1SDI(WNlje{ilHvYgx@8DAHge329CdMDy8qfD}@k|GYe|xqYY{ z=-TP2q8Er0^I&_YjA3RWt%A=vWjil#s_1#1Nf>{zu#*&^ZLfltfk+koQj#EL(_Xf9 zHI3VZ=h(KF5@coLGl19+Kp}a5IgiLpCW|#yv{Ki1v#!qrXe?9TLr#6NiJCx5edR!0 zrRw{OTBs+x>`Mg~Nd<${fHzwIpa!2&)a7M)@t4obs?aoI6ncPxI<~44A z6-&e(@}f+8^pJ%tEQ4K<`xUfe8O?Es>FFgtSyR|)f5BQsxvbP{9q9;SQ>loTkZ87k z?iY;Zu9XN?{5*{9wKI04aWO;IJA%r@5Ge7YnL*_&7L6LW*MSO#y#4tg8M!tH2{t$( zxz7qVMAY#e$nw_MTn#pISu5D!oS9Zj$wt7mUg1Inwp@5I?a8wy7+|j*tZkJ=@(2uA z|Kg9{{9Dpg;L%452mgt;V4!aeOpoZIvm_)| z`veBHM9NMNmLV|S>yaeB*sLYn(L1gbH?EPg>S?;$_U2yd*1iJiITf z026}l>?O?{`b53rMISgUQ*TG+E5=)Whi2A#d-P%|w|5ZXZnwAa?MO@$k03S?^FgK* zn~JmYndg}jVw%0Z9UsjY(a>p(Xj(u5vu_?><{ZW z-|!9*@_JG1ba!vY6Uw|zV&_e=fkHCSOc#?T#6AxRfn+-p4ivbVL$Y-V-xTEXKZnsr z{wX=h=%L$|NSyuFd?K4N%TR8{Z}75As&aI(gd|lylf>}rp?K;(!2pe44-%@Hc8a6? zxg0`qwYh}MePaj$TMMkbPHK-r$GS(rL@S-M=GqGBc~q4LbKl|SStSTHG)FyVFea@SYG5x z(IlyMpb&C#=Tm+7QXg`;OZ@|7xFlO`ZVI`QDuyg)&OE*%>i*~;M0C=?G(|GF4H4Xa zxJ~2s`2fKeVu@m4eOAHei+H-~yO3t&!*i+CXl(-|H1gp&>f$DSArvRj%LQN$s*B6G za402DY0z8_e(S3mktV_C(`Jm=A>zmv?D`VM`q$m09HjilJxglZt|;+7=iwdGdRA3- z0ULbXsyfY~7xa+9&z>*|4meax6i>*Elh1DY7@|}?JC`Ss$wsNed;N`4wcQ7Xq=%cE zd8#bU(s;Kz9aqj><)~q90_%a^VsvuXt4>GPV~xgT8xJu?8wg2|J)-dI8s@N+ic6?H zN$f}WWY9OGACUWd8eQdIz}pZ+M|(}{aiNcz&`wGWhyDCJc4Nq;XG}s>i;U=Ic_aRW zLUK6r==}Dubqm?>HqelLVBo(Bb3kt^X{q~tc@QqgA@aL;A@ zbZtKLi>i!Ht~$7iJ}cG(d-2|TAkurV3R$doK!){L2%l!XQC{wy650y|J(!RE{Y$vsjNXylzS*f&<=?R>wy}kMG#pnLV{I`;fRJBSr!++mjC;az8ngaXbzctdXjF|a`7ApR$F`hu)2p6Kb zYGr`Ri76UP79o`FQU!d#o(_ky>KN8cYS!!#`Q@;uvW$u8iZ%)E%wo_Tvd}-npl@;& zOf6$G=G+-egVT1woV!?JEED)^?IS-CwnV6~<~YNaUw)KIJ$HrRq(z}lS=4!k97O$J< zY|b!Cmi#%C-g9?+CfK1v_>ez(QrCWj92b+}<}~$UpU!-jp;)4k`Y|s4Qe91)Z1B zotLl{t2|FOdGzn)evXbHJayYtVlil%kg`thPMBC?mV_mZC#RR4jn;f2=hsWjaq+=V1UugDmrcL7LuDI+ z>$ip68(2Yd0K6U`?M7z%w#yK=)@0_7b>f|qU6@5oMXrhtzqQ6+)=4`2M;6(How&wE z%ddnxr**)~%lwAtFg}+NU-V2Rw&=Nzc%|njzJTHJ*Yc%8k)Cr2MY;$z<`^DRMIt?h z$EPBZ#C=TOP_ap$PsJv=Q>(&~z|_kf5rt-h3RN~3g#^OtJx1XaFKedCSv=*FRaCXI zo(j0a+6EL8@l2-S78$pBp_?c%NHJ{%=(37Ln-3KU`)+K8EN#JnTw}M3FyC8GO#6V0 zClW_eNjRi3n(AlVR=G=UYKET38i28@i{*xw(O90bh}Ezp=qvWCwpCVbr4D5<=OE|e z;bOJ>O6Kvy^4O}ICoG5qHfgRnRHazS7cUfleY981RojIWfX7ZS ztzpLjPeJpgAfmC=yg1Eyu{Vbh<*zb{SV5rlzdd%XAeC0Y{OSku=iy@eDuj|&!6+A5 zTa8gDO4|78CN31n1js~v-ZbLHX~h4y;6Fkfc#Zf>;3=r|zeD_`)DMZ5G&;$8@D-3O6PT?T>!1Fgr&9 z$&Dp|NQF%bFS)ZugB+6q`Mm@3r!3U}qJjG9$`XR+jRMvi|B(1N?yLN$Tkq1Jzn6GK z4wBF#6u0t@od<=KyJ}MeUd4LqurF@IRSImz2G)*h@Ag1!TG*q#R5ALMmx}rqSGHcl z2n`I%3F4hTPc13x_A-jze_VXinQ7mY4Dy*?@lC5UzA3lrHsj2v?s8nyNokjCE@k1G z&gX!)psrw0;>y6LT~n{v5w+Gm0>ntPf0rYU>9lOeRKFlbJyHniGQDJi_O-xU{N)Cb zCKJUU1?SqZ^`6}H2A@kiT~Y%`>g~D@r9F0#EM0L@_q0c$Lhw`D z&yJzt#n326wBbvKF`W|9Y7uCq_80HcDVQ|pVKX3<#l%1^D-*-#m>3XQnHcqsiP4}< zjMiqVa;ywx$YvQD)Zaz^Gh0E6!-x-WkN-$W6p=s>56x&7qUch3swO^-oFZ(Ei-{(b zt<>u%_v2Y@Gor6iUnu^xn70}I$6A*5pmjr=uv|Imo1Z=kSADzw{~qt9{i|s&|@u)f0C7EWZQx$y|)xyD$c1ocbJ zSa^Po)p$1+oq%>Rx2N#KYm?Nuld-k3eYnV>;=4I3g?~o0hedc&utXGf36f^X&OC$L z*%!v-*B4RQ#1l!QTHCmTWz%;{sx<4P*dIqW41fy?F8UXnJTjATAmN`pzqPb$#F%*Q z6^yI}f^j@IAt4VheA#X{y&}q>U<7Z7PVfq||AC<`{hDWQE9~czSEJ7??c`OI*yZw! zODTy@^R%UaYrIv@uOuk9zkQHU=(4lcV><`cyd(-cgVylt7 z)I_9K2BE2xnsmiJe7~1cQ$>fZKC3v5+kZ>ZK?1#E4W9&=$BYJ&wnBK>nPqx zMQNi|%s&=#^F309!qU-r70@zA>gY>rhk|-nL9OE3X#F?e=u0K6(U*_T)%sGTdA7dn zqZ?C2&%8u)nRn(Os^;OXqT2}k+n4_a)Z#_Y+$efdZk+lL4f3 zpa%NtCu#I=a7sEP)56&ryacTt~#ucSL-`5%KFB z5x-fBcz(*%@glQhXw;*GJA+>d_fq?MA`e=EBize_Dt?f0 z`(bsKsNWf6Q?P6|sIMETN=qtdQkc<+50Mu{P(&3OA6iHM6+a&2iCZ#ru`Q=kK*w}dPXY>sI@lb51i;?FPqUVDq z{k5N~>mbo{4JyG`9-}7L$o$JNRB3uYJ*%JDJ3kd91A7P4QQ@-fLH6!R<5(*LhB@OM zS<_`_g{o}h_P3DzC>^_wki7g*8JN|A)Wg|G)oX-S{e}JjiHWlPCZ?BYyn;!LUVGy# z`l0BgwLG_Ap{a864GS`;1EXfxjem3V`ztc==JA=&hvCX*bg{-4V~ww&xbG%!Zw^Uu zbN5o=r1u>dxTSZn^b3x6Cpo_J!1@aqQwx zj0^LgDRaAwA9hYQjaya#SSU1lOaQGnqz}Fuwzfpicz{Vd$x<62!X~vi7+uoD-YGNK z0g7yH>Ey%Ic$IlK`%M8Ms+I&~=Zx(#)fbS=!Ft(|nf)`!IB%66lbva^_b)K_-L&~) zI*0kVwRZH^h-k^NQzdzWWef{;yLEEcWt2E2eQly$p%f)esH7;7@}>3(Z!kS40n1WR z);|AZN&AqKSK<=9k9LBjsAVC{py>)mu!~#)!Ey<_!X#} zpZ(fVIjw9FL9qoRx6tp;+?Yx&%X{g!+|r{l(8e0>0KdK&t83;n=efhll1K);%7bG! zS7sO`A-5A%1gwc4D}zmK9H%H;34-$e;E4)U42}wclm0?13<| zFd6Vgh3y!i$Prf;xw5`PoEw5OEtVJ&ep_7w_&1UD{*OukM&1#pu zJwaAm6EP@dF?1v@BgEVe#2}#F+Fy#TP#{;%9z35T7xvH}uIC*KIYrN1auG z{;63_Vb})CR_k#8egeKSqr~Pp%UN@;H_w^&Dyy|$mqZg0g@eh0c^_p2@pf@wKUXEN zS&{ENT&^F!svh32WTe`7={rJyW?1=h^mV~=z}SV);C95vJ8@l6q>WE9zEIf+Z4%FA zQt$*cLy+A}5lo^)&tUQ^dxk+=LTj}>WQ`h*KDIo-i;{4KUBi}aX8ayGXDB`KDnseI z8w838Tzm98;_!$;kYw{T33|Sk&L_?+bkjdeivON>q0FbGi$Wl=PacVinWb)rv($~> ziiEhSqMa)M6`_?XssaX5z4)LQJE_Qb)j~HCbM!(t(gK+aIWV=Zi}h~2_}k?waZ$w< zYQ?vKWIp+-mvP)JXC}s|B%B6ND{OZy$pHK=0OpIFm#g((YQtBV6^CJZNCfn-i!5UZ zaWIz;wr3y_p7w8yvX^8e1TCVO1r;D@A3z+FpJeZZ;=h;It1e~_+QOjN25ww53}(^W z>`1=I*)^-y{v$g_X&s_aC7duZBryek01sT*88R|ZrKRW6nLV=OmeSh7+uin%H-xvZ zRA{P~f>obH3fRSvXfky*dNe$Z!bS+^+oOp@gse%d)s>(H?P4&9HCZ06+GX5!I6WvP zj>+c1@yTdOj0>~uO)OJ)GB7tgAAcSsL>|tEDd^Fko8tEMTh?i_KEF{viy0ZCA`r*8k;= z3@nI@NM{)+5MBRcylU?v#v#>{=m<@C!+z;hxCgc&pAJ4L_=P}S#zs#3GMLrKh}#r7 zQpcO3XFTU(H}q)(_b^sh+h1)2Ay(E@eKF&`=(F9Rf`k5VanPgBO08UVaut16QYg3> zEj31;6(^Ickz9%Cpj0}F7m1Lq(lZ{nqhj|-);UXZ@FY`b@}1(prAso!G4Eq$^et&G z-(8gTXDZo@l7_017*e&emdr04=ab#@vk?0aHh2276lbsdCH}gW827AF661r-GPJeC zICwpzNDuRZ7Kmn_H8U+SSi(xrTr3m$OU`aS<0x0-PKhJ>gl>q4Q&&kjjE5ex%i}f zJTBSKIet-_WFMyGuwP2!_kTE~if%@*NJ5|^qmS0lPF2r(U(Ii<3xBKxgwORJ98zc{)QSi)a`y^%pOe?O8A1t%Q zcWBE@tfQ~B%&@_J^9HYpA#czAnd;M5r_y|NW5REB6ro3aQg!DN4f13LR(Z zDh+aX24oN*5=!|iOO13X#Tw+g3`p1g8f07sm(OAfm$4a;P66SMd^0xaO>cc3pRxc0 zP*!Towu7;Wod}+!-sB2lEfPjJ%x~=s#IHFLGijp)mFK@^}~_jeSbJ|VtRDh z&pevrTKGL$Y`^~tVW7Ol%s)LPH)Io5aW6k65pbbb(FCtin$9nN2#wMdkeCjB^a4UO8#Swi9I@~m8ve!oYWYWCt{voOIvwg9rm52g&PK~tu|29@Fj_Xt3HCgg z*mM4&Q-=Q{_b_?Rhzr-(O%#gL?1Bd=*1jPr(uQB`i5KL`OP4z@ovU6dY6gau74it; zPP8YgP=9Y3^-@NKDkIQVbGp}Pl^{XQ=?$oNNm((iqB8+eoA~qkVSBxPq`dy=GU?7n z`bG9+1etdFWg`9J=IQ^TUrPSPrVGoWdkB(V$Yv(8BYeJU&HW`FInG`pqadBmsekIn zw_cC9a{JFeRl_NDr5>f__D}HJWKiY_4H(+xc2tABmH|260r~Z7X^?sivM>Wu;eZ^I z0Xb8H+?xUMI3T$hki#{|%nZnmIU1K=Zc10Qt5u;}n*mwjfLxxx6Jj$Cf$!g(<~za#;j#Hw8CaVkdW&1a8ZM_ZZ1}yK?6LT1}Jp^w!b3m#~T$I;OA+8{sJKTm+4h| z|Ad>+M$%ay-6!HGd@UqQ2G&YX@GIc)z(X)l64J=-0b7uzEFdS#mp5P&6wNh*sxevbtUgpCZr@%vep0u~WuU&LuAf(W>X6$}Pa18qi^~x_tbjr)ttgAwtCpc&I zGp70tj^4OQg_$M1jNVA5e z|1YSX4XW0fG_e*?A~B~~kG`;3c!M^qz31R-W}Q4-)KF* zFIsJs@LyB#Z?w&{bmK+qXl~I=6yiD|6q~(7c-gPj&T?_$*}TCnZ&rgScBwE0*SUA; zK{PK7U}%6TX@GZdRzxek{IXNR2e+ycMyCN5IRKN>C9Ku}-%A7h-T}BLUBcfrKwcW4 z*#USr4Pa@2cQ0{}ywm}3r>pp}23VX1_<;j(@J0v8pa%Fu8eo_Jr2mu@XO|dRcbV28 z_AWKed1j9+zKSO6BZsOO#xIH9;7J@P+gwQ`2TF{qwa2gp4tAF~vl{HzSzu#1Z#R=} zVHPofXXeLd4&~rcGwrum7f()BADQFwwaq*#S?x>l7n@nLtlFES!O$@?%a>JGij9VA zjsQ|5#Pa=aB1yg8bpG~wfoN^WpcuH-n3PyC3-5_M_-x#XSH zc=+3TRGzJvdlsOxe29m?@eBc1sl=AdjH%yB?=v$dG!(IwUM{%OUNesg3nsKlJNwqk z&ymW1t8!Ty>yek~ick8#R9r{JcDW?vqJ>OpiPl2=(8Sgl>3$4?+r+n3rkO2s7x5zh z#loUu{5*|sC*$OKW~ud^r5faj49FY@Y*3I z!d{LTNz6W2d2`#TAr{Ez^iTTK!|9#+w3aTd=V_%(11*=}$8hzFE{w24pPCQ5>aA4* zaesduBk(*W7R5qG-_3uWuzs80KH#JntJvjV1g`UL&hJ5&ZLdnXyK*Z)tzeQ|~JR8g*HAD&n>uCOFKHbTHEhJE&Q_{ntNsK*bSk%jr(X-j* znk!q3=oxG0$LmWS!xF(ShMlP`x_Diu#E*8qp~naT8(gS2BZtUNL8ehC!AOsEq4Psn zrW1}Vx9?s8B%w3tDltNtjos64#+_)O2X%7-#O!7z*uo?hm>u1fFOmc|un(gX%OVXzfz-YigazH#McqY095uko-qYS-yDR zrW`!u-u)nzMo7BBLB#P@_a*5cUzfSfJw~g{2FVtK<-xMo)mCT(o+g`YE7B@33cXBK!!G9hPU84+x|D))SFRHoy;iAKQZ_HvCSaBFona$U7DYJdukl>qQO36hsdiWLA6PlFd zy8Qx?Ib8R%wBY)48ld3+QTHa`RaMvjcOZ#ICESY|jn*Np(W0?!Dq4dPy;pMKT)kIQ z6~zIK6Nc6yVj?)8fh0nDyp^_U(Vs&)_$zH~#kSgLMH8l=DBw_ybJQv)hSoR|9Jv3_ zckgqDFw^&W-{=4GkbBPAXPrH)z4qE`uf5jV7GQD;;O(DSl~aoW5U=YqyADNF20{r> z_#hYhAda`(f_&2lalHQlMEo&nmW!18zZN2ShF_2C1YrJcm7je@?Xmx4c7m@Q#u&H! z%#(s9QTPhEd*_~q{U>AV#qM43IMj$W!(21r=8miHYMBm54moz2^NwfnV6@&^Eb&P< z7dWQJrK?5DAO0&{YeX()rf6-M$dluaX?Kwb-Dy~h!eeGor7TCrE+$V>ZdZ+_*oaherP^ znT>LsXUn%JB>Y6qf;@&*0|Woz5E*bnJHKYC?`o;$mjAFf(O&T@4?F&T7|+GuVg9$T1+x!kig7#~oUuvW{C>p&9LESJfS z_3}o`p)*mU*9aB`%?)tB$42CZgZe+}wJEUH&F=6@LUFS9cyX&^k5?AmWs7uZQ?9)1 zc5$Y3^b5Ug_cnDL$X;)MtQGces$_gEnWl_-41R7rE`7(A$e1ss_b%AX1a96yip*k*K!s;$Mlp@x^|VL3LAESw|5Wac>kxJoA5!f# zXC*ci#Bw=cLhj06UYx-|VAdCGlPYvo;1SMxiV$bI`6(xWw4|cZz$J?wVs!@}sgVYw z1zUKLRENFbL$9aR_R`G-lg}P5Rc^o7(rD=vF^$Rg_Z~+l3?rG$5zB5@hRNzsSZB(t zEaKgc%RlrKP>1#%k_Ihe(tg;))}@cf#xttm}mHmdnx-LdDsrBeu0(^ zP;0F6LmR!x*!&tM-Uu3Vwy?kN!qL0p_GCqE`=%;DqY1Wy+l>5#q@2BY0FyOVFtBSXr zfn+bCjQJegFjW+2qi3QCQ>AOuz|gA;4e7%xdiO(tII6?#jy{>9^9=q6(|eV*NeHJR z*hBJJHVs`nO7BMDkwx!4peaS~dY4V_uiXs2f0qcpqW7a1`Ge{GsNMP0r+0mdO~GJ# zH)W;h{fvd`{VaO-={zuN7?=w$WbnuydDQ1~$%L*|x3NuV`s`FHlJ2uj7ZvI=P1yzM z4!iblrfiM7s16kVvoLMSHuBE)c|d5*LbDic3e9?#jpq6m(A?0K$&lM%%nbE0vpeQ97z|}mpZo|aj2Vi=mDjK~*%&8cv4L4vfs|3tw`-Pk);08K zf2IA_cPoCX{~UK~-L!L^+zwVTK{GoAn!iJnC0?fe2@F=_iA#f=-j%pw7ksx3%P9uV zvYcNuZ5J-}K^m8Tzti^_KsH65T$eKXQMT4dgi^WkLRqjCeaZxA}w&7plz$0%qzB{CT zXVfOOp}zd4i%V;t{QrQdMd+r?h^-@ux*2eq!=1n*i#dX0P!EKsJiA#b z6#=!%_0n_pe?6x}re~qQrBP%pl{1Ts>DfJS$W8RXwfIJ=2krpjsd0o(aHH`(J&o2! zAI?Ur9p8HfX6=yWmc%N3kRB5++?G9G#NDqrZOTwO zE1SS0pM)FV-x`XyCK&zKNN$-Uyk^MUMpLnPPUu}Ws{b(qR1bf42qV*jV_i+WLaCL^Ib_WwYwDC@dBgv< zQCGC%CbjkISD1<96ycu`v2z1W?-b}06lT8E zs?V|!-*+3>Hsz$S-S(GkZ1+lDP)s|fmUS4?+V~-opEywhl`N+GhTZ)7`fVdirezXZ z=cbXhKlf>qh+rfz29?v_0yy7 zr<@LMmW$2gsX=#*mV6@(Z(_0@vj^4id6T^9FZGvvsZ$S9OFn(zcLwpIP+(xn88i!s zKbb-|>Ip*gqilRVR@TR187Oh(1~3if+DVDL!-bHF6u)%ye?+&azb@oTe>HI#)L%b( z@c+I3Y6m0P{nepof7s|o1$Xgv9y>{r+(HTc>;n=Pwa1bC}mXR!MUndM5#qOa9@_Uo&6+4Vg}^-W+Uq`B^pd;q0OaVpWF z8!e3B2aWH2ATU!vYJ7M6+5gC%AC|Zf%DGsY{K!0W)QemA(lpBW{jWt0Gum=?n}w)8uWCz{mCu>D&sX%U&-i`WNQR}3^d~x zf?n$_Vy}zqRv7cuSlK73(}KTi_b)P?bttv}!(x#w0HgE9 za^^A~%@zQZxV0^SC4bLMICBuNG{W1v5#_es0wktc0B^?-mR8-f^aGCTWrn zcBlnw6xbye>iU^XIFLBm^u#Z3^Js zI*WugkN5!pnPf09J_WGI2ROjggdCo=0EeUie&qw~p8|Nm0_3Lv8hwCLQ-?%_+A_z& zynU>}j7d7n2Wzq2Q7y0wEZAcf%p@J*gB@bQY6W(T1^a~sGfBJoU=RMzbS_HZ9B&T` zc9{h;N&mXiHh+!4c+EGh^ zi|=bo%_Uci+>L#@#1P7rkF8tymn&iM@1gya9CEYD4o2E3x*uP@dvh05fXR9!eY7+xo$$}jtAoh6joyx@x z<1m1-5*nFoPd)Cvf_i+k(AJ}zdi1gZjI9m(KbK65mdVvNPn#lvo3G)e#ENJlPWQZ7 zQOw>}mN4+ox!T*B!H!`A+lQP}+WK%Kl)+_=z05Ti6QxsvQ90WF<=OlHgT)VMr7mkT zYt_`AjNEY{Md3;`j|_(fT82|v_^aAlWO&f1R?R=9etZgXpgSNAU`5PRIZbVJO>ZsQ$IPmKdCmM*n zo@r_0trn@;FpQweL%G!2(nveG2(4VQ&}y~{ll6yKyly`}cc&B|pF;w(Ut~Zte4ysR z^aEKLQnobiJDAyBR}u7t%OIrrzG=%cxS6le+K8AD?M0aq>>+0F*FG_COveS#aqkV5 z5}h)bLYfRGQa$Q6S-un7KivNQV`{gnU%OwC#rD+h#H`vS7dL&GKh-q@K*T?|pStm_ z*b(9{74dI>2VEuCjWoftEQQY3;Icc>hRDu~KDV~M)=0@&`yHA6B52tP%@6%3iVr4bYi<$VFEJbHTOA+wi&>cQ@vrR~AJ1g- zn~zZ!q{l}~h*oHGZnBT?l>T5d_zue{E5$pu3*VRCWbv)7xj*~NL93H>wczn=Jmj!Z zO3FrQozwI_HcCWM*pP~9z6=|sP0s4v3q>9_N-t?|>X@@=hYhwT)BY6`?E*zo!`2ok z2i?nOiZ=6;(~N}m?h&*~&*x3HQrOTGz!VFxCDCMvYza*<}%C`{b83^e!x&hJ3=hHOEJExj@R;EE7_CeOCL7ucA z#c7bA`yf9}gWPRFKI617Tk@4Yh?@qv)`C2r28sC~{kVDAkIt|l52is5^+9e==Q7HI z+>!>_$p`s^$pu7@un<2o5Inz!kHS{tJ%sv`$@Y#QBIPw;*eUCA-2B^E*;%P@L4fg< zn1JL^c;95`>eL${x8V0+Eprkq$ewM~r>uEC!Pi+D7sc0Vl${ z!zD6GFm&{TG^eS-9djH7Sg~*`G2|!AA0!qcpr*w_=FCV5Vqs8XVfi4jQ0kwN3Tz2! zCsCzJEZjJ9JW^yzEHuVx2&~mPBWVOC)wBhz7IuNExo#%v#zeZelN4g31CFl8Ez0{d zT3?B3&+-*w;(Rrd;Hh!s$9N+N$d8e^k{i1vH@2CGeJM^^t*2V6@kecih;(^STkFMU z{^BgW$ea>YAra{j+Kkv3O7qjfhTZ?Un979zW-D_6l~GkIh;&Kwr5tijgi$(rmgSt(cop+-D~53d^R0UYSZ0tiIWiHXNo>XZWSQn=LAA zrL={2WlEDFdPqe!ZZF#Yei23P>KBPMer6upN|7gK6}dxbjjFV}@k12FINMp;>qOkh zMkk|p`#SM8mV4fJ{nFMz!`st&S7euFdBHD~&$#OlUfsM>W5dQ^MwP#@>aed_lP-44 z(D6wA%K59{FT@`!qZ!o^_cP5>-^15>a>jloYV54i`b8Mf$Uy@BTN$x;CMB40XoF}B zMN`N){Nw@{7@4rz>8L-*M7bbRNVqu8<8C?_(%mI&!(8AN^2p6(;m!zZrasf?AG7D@ zaw`x0N;#(HXGQg)c%z5L>>}=(Do#)w^^O7{k3JX%2 z2Dujy&73C~5ctRMEyPd*!Sf71k8h^)m~A0?4oektwx7oa*}cfR-n-a>EKGwO?Ss6Q z1_@h`yV4+g`XKFTkOM5pv^2;^lWb*gPlJ4UqG|H!X^@oyN&l1o`)OyKnel+1KW76U z%v@W60LL*a^EqZ^9`oW2Kcp?A+m zqPj9soPPfCW**GUl16{R6wnW!FqTxfETm`2VqPFAM=H7^`)P{dF~narNi|H7-#CBJ z6j?h+b7GEJA<1|vWNeea#_f*j#Z1Bo=vY0;*?}ptHfxHEhe$1UCop%e^4|EvW@bnW zoth!%lPUFgazc0KRPAy}758RJZb4TVF@C;u=*IREuYWTh|M z!d`AUXPk69wMME4zIHmr)}RDgKn4@>!U$<-PCO1^sMdJE!Z#j!0N62atXG}^qNtVNdpDZgoHw_6}mDz zn;9P7c^N*c{FLDEY{T~o13S}FZ{IqL+fxg~)7RNESkVCNU(RZz_U~^ITt``DY?eyI(#S zA6X%{5K&I|&w)^Elq{RxXyVwHbaXfn1XI9$$Smu8=2ANbODT~a-B<1#l@UZ()djD^5d$-#E?J0uV{I2|e zMFugE0daB%kwMNmplpvTEE!yeq6;f5pA4d{I}>KFK$iMeE@OvXN|i?MYT_se6T*nx zlV)znFNET;!J}_y718m@qVL`4<7l#Ogb-)S@{MuiaI8StN+)+cA!O>vv9YOlNTB&X z*k{vv0z4cCAsg?>@WK#TN4pj)>oh*&iOZAG=lWum-P1me%fxRNjXN}+fHE-XT5E69 z{1GWt%5q^ErCRWb}o%!6i zE|Dw(LgxnrnR7<1j#j=fZFOw7r)?JR#B-mI@AiWB9{)%=z)$b9N6@K0e(N=;c4|~BhC+>c#16*UR@%iz}Re_c= zzSV{!O211Qt5BuXB#VA`gWnHt>SoKdioG>b*{53=S+B6P^A5j~k(KW5sjHJkC#Eu= znaX@Co&1U!N?3OhaB5CCxzr4*aMRbj24>y=l`0M|5x0m{eqMj1dI}~q;Begf<_G&Y zRq0MBSHqfb8W7Jo^MLao^(HF~1ECGw;zSduTHbfC3BB};cfk0eIlc3k^kbaC zzzkXV3i8;n3;>_Ni&ovynr!5n3M~-G~U1hGsaQDECVq>;#Wa(-MmG@QwgvW0P+?b z3Pzh|v~%9MIeV`w!kQH3-4!WkZJx6%QcSk7(uv8UCuXRG)8VIyc!+Z#d1Q)ZV$ZLj zLXS1-t3*PVWYJv)_I8`b;Sh%*fq<>=`Pe$Z$JQZisatG;+xOLiK-GX6JLXXy`gZ1K zJ~u*2i9yN;gONo3%@(#>u=`)-!|s0rH&m&Z_LK)>fwA%8z$3)8H|=*!`$IJQ3jD}U zbn|+J1~dj3xSN=Xu5Jghqd3f)`l;gPhyN)9lBXM^l zFohq#9_p1nPi8!T1#+uLL=}0*SxRcy?alM#5FhndVOu*&M|MrH+|u{1-+|kFkLyY z=fb6{g`Ez#jwyW(xeLTZ1UQwiy@vaUn>C71`G0yqAogrQH!`Qyn#^^zEFd{2XYLRh z)Xt5O2D@51xCJ}ZRx)Ga_W9gX-Q=lcc?3#fwPrV3Bhx7aJ_hMTERJgBSBNBgYooyN z+&(~yXktH(EtdR6?8oOEcQ+QrJ0**LI}LK-?E$?q*&zfWwWnmN;>j zWYI75fx8@~R{ngBnPe#E1pc0XKev-x!%W|{P!6|E6wM*g`!-rhRnwJvQ8jc@HGEd( zepB_!4of*G;@nOY7HfUbw1e}XX?D9XGuzlpR#i;Nt>=7z*(s0l$ZZJzzeOHoMzLGb z^9i9)%m+rLR_&jeQG<|ZW?aozM$$&^rXQ_6_5iC5Mu8!lU$O}FK46Wf223zk?r$1* zi-9ax@QEfiI+GrDTLcL5eu5aPd9lWnpq>(OBYq7AeAt=(q-|i<&cc*Fe(VW7jjiHZ7Fl1QSWC zYTdN3(LA-B&XX~!T5OD}7M+qf_K|pQGCKtOnpoKv(dRyl<$e+E{BS2UHi702axybL z_EuXlM_wE&>)MR}1##YAW;X_j=Mwh$Cor~-I-Yt;!?NYGxU~2btCo>%yCFVSu-^HT zwTC(ZKMcxRq@aC^FMt}c&og3*%smPJmV~RAHI6z#`c-X$#oe!cd2os3L3==3mS|Yz zzTMfo^AXD%-yTwbgY3KTeYCra7YCY()lXWIK`0bu38f&b=dK`%f!BGjC6qD9)lTJ` z^_-d&DewuUceUv&mM$qWxv1G9)h82maj%#Fp)&)`zvCu6<(bV&t`v{RwQXc~_{e_# zay zWr4UFN9meIVK80zPK-hxmPV4jVbiFV7eH;yJ&sl3a>qSmfDyP5AVy%r&Qi%9)wivI zXrn4DPt(Rr7t;9T5^H1q6`fC%aHNr6hFFX`Wv@b>TEicL{?17pS!s+?FszNZFA_R9 zR`yo3^UJ(AJ#z%~k!b0llA=}Weu(P6{u-Hp-Y@H_K=UokMuuZ8g=5hl*oR|o%etXy zS-*loxch&6lBMsh_ymiKtTvTb$isc8ys46QQn5&37shPh8w-}#t13#^P0li5+5L*t zF1~`Kzz6Q1XD@B`GT&Ynn9IU;E)n-rq4nE{imcCMyOc7YWeQgwgEZW4h(=i^;t77A zlpbv2!sngQ4=evb%f%v-t`>cklM_P8vrq-X=kC;tnG02}#GgRRgEm36vk6O;pp~)C zm>{}FEO*^pC%H0CJPqF=uG{*DJb2#L z(LWni>G^a#<#>1D94Y$W+c?p%VPNRLBE6$T6oEd`e}(VhRP9yVL_1)R(7*AnpL&-@ zL$zYDgdabG#+p5Me|)=Fi#~cV)`mWg`e!uVGTCBZVa@@|w#Bx796f%^R(fBZzp){9 z%{k(Fc!`+!29#;69)2mu(Q3}ua5|HDzTR;nYkOunsOeLMN*Z*uJLjoSDo`_C_D17v zjwVV$snAWv{KMT(P8vZr~SO0M*dm{01$7Xif_>r(9M zMCVa!0Ip+{KI3aXPg_zSVvkW8Y)L&LS@a_Y#at1L&Oht>lSc4tRz^a|1r9-dOxPHL z;n@Cn6pvW(V&q0btZc&~RuN`e^)f8N-_cnzct=MpqCZXFpHC8fCmSB}gIW|O$e~?= z@$Bq5;K~`A1HSTw$woCOMgP?)`ggMFpIp4Va86Wn`o$~L{NLGx|2rA}e}fQ}=Kp!3 z|H3a>F10gR4X)7}H;8;$Xh)kC6@(Xx{nKA1bb^hxzLc-Lc~=orIdLk4jCW)YORon> zt#aF~pFn--^r*`*Gvb8ekhPl{pnZsNiLFvU&PbypHP;;BE>DmDs5>r;-$mSUxC^|z zHFtskAuq*B3bg#l_<-bpYtzce3~sP#)#Zb0P%h)PMjA^qcd-0#sC>Cs>~4$yO(Zub z?ithuF_RXr7ao5NU z(5Mlxxjhc!`J$I>bJR<}U7yi!->zjd)V)6~^2*QjmqPa{v1vvlliV-3wL7d|j0I#8 z1{h|C^;m6l)kMo)mVbt^fck<-F=whDDt;3Ss6D3`UCt`6lK9l9V!BlXs+ea+NpE#` zsgx31+hZ-gmd}XX&It47a7qNr-M0(r1wZMmu+^n}J>7s+le>3;1$)ebnWQ6pu$L@Y zv2r`cg8jmRnWWu(um>%eaOCY_!7j64Ch1=xs{)#1!AuEjIl-N}MY0NA=!2~{>a~Oc zTWY}$$O5|qFsXySU}KGD8L)dT*t%h+r6%c0Keun7cm&K*6Q)_P)fUVoIX>9qw$O=? zj#q8Les94{(l>purP4AaOnf5mPzyH8g0cIR<9%_wZRx!hY>v`~TCj60m`QrU2ODn- zEmz%MJKP}TNDF3?9`M2DWFh2l7Oc>MnU=QrVC#+gE5SM)|1}Ht{%!^#Ch0sMY-(0+ zlP%bj7R=;!v=4TD7TEC?Y+e>v&6W9<7cD4mGNzV&x&_DM7iF02} zMA0l0fPt^U(ag20p$|*|+A#r`UllksG>@sVUe;uc9QR{~?YQcu>+(3R;tr-? zcVEXnfyJIVO%Yxlmi5QUBc00S^#SRZa!1G{g~x`^I54TJr45$JYD`QP1)}tMT%_^i zvYd;r{}XGq>c2%KcD0o7jP6EIBe~^LVK0uoOthC;E?q50^2>kjj@8Aah0=Fb-07h! z9XPD3C6-Q8wg>YT5%F|xyIM5f5L~%a8OSW$RddIG7-f7ps?zG?L=CsMkpk;Jo2O(^ zDN~!IoL?X`A%Qdkj&#WKv+x-6{?p0YWO;Zl>Etk6IoQ|VFt6X>HMz6g%l~+c$-Ttn zQ1}&3oR{L~eumAxz~;W1++Vlv`P^MtY%_mI8MqVl_6hUW<82%|P(Qij%I$F;`Hr@x znOb6_FCGz`b|nXsBaoKFDm$j4JX)f+`=;IoX8)VEW`zva+kS!B z9U1tnBFQ|^bSR(nb(4XUGX?1ymqN{S?;LJtI#E3{9f!CNI`}&4Tu*|k zE=I^ABuF$DW?6P^~^nnX(*#cJKftsyB{+aw~*B-Kt?yjj&Cdcjf48TCY~yD_!Y>p?zt zS|`opuU~8ZqmgpG8b_OoEEFR>C;O|q6V1Vh7S68hBBQB#>m*N^_2sd5+7ou)@)wW; z+J#bxgVsoaHrhtJFL=9|Og)n3@HfD6@eNvlW=YWD7uZXiC7kRr1$#*~Bc+;*!=)bXwybI7&6UJ0`>-Z>m7m+$17 zEyze)l{LhgQ5_gToZ{AaUDO@Mc~|iuf74lol~YM4cSUQW5kx`UbGXFtTCWK-H*ouC zH9y|(4`pz1hMjgtMobR|M%0yPPl6)DbQ!%@JVk7jLan{)|d7#k09qcIqI1cjtJqaY0#Ll4~IyhEo@FEXF5JZcQGl8c2p zcU)d&_tpFMcB83{v|d{9sJMBOxX2O*RJ*2uP+;~{BwrO=-gF~crJMfYAOs5T4AIJ|ltxM9@@j{}jBCmn^#XY_OhO%zLM@dum^pqeO``)o!?fPpSA@ zi%I?Ktf4u{uF4yOQ*TG}(GNj03(Mk%Q8BnpBzLHVEH`E4rQUOA%-8xGRICzkty8w# z>0HmcB;Lk0Q=s{F+M?wKUC>P=R~;~gxk=OY1t=O3B*4WbkjLn;1%YPxD8!Y^xqfr` zNS4&5Yp^2%LL8}50Gh;eMYZbG`HnlRAX)SnEl}ws@$`WI6!K#UhD-$ECSG%RcBF0U zEK^Y;%n(;Y_9{)&sZ7gIGG|Z)NpJXfvgnsWpU#e1sT=s-mz(mvFR{yU%4oMVW35=e zPUv=s|M>&>Xhk!<^O#W1znfyMr=c3TC>Z?*4b#8ISnD~(q?VA%YU~`AWfxWO7vc|+ zyr>!#N7d-bd4ZeX2ilxFhXqS8?tT%)^2S}OVV7S2$1s#p>{||YUlezL*dME09Sbmz zQ)t}XCtA6Jr&m-U`;Eb9Zg@aFM}^0d-?f;8e8GFpmb|_s>i!UW+C@=5c3Mv>kGtVu zEO#vR8#^+ddqGJw_u7$Bm!UIcti#peN7BsZ1#8}TH~Ia7pv?I%({Tq zv!|p(3hS9WRqUP7bziA$DU*gN^r)FrC_;ToD0FCsp$G0|YEkx_)BeXln16>k>psAG z0Og#5lpgQouEvhwRHyTu{48sP@m8S~B{V=MooPb@9FZ)#lTMubC_N0lEuDyf`Y0@v z`$x^a#zeB{Pr7HG6R0=uV19KfX>FXL6;j=5bSi1n+x@EZ%=M|2ZYRDzo18m(7Bgt!w433J|22b!dxZpb9}*!)fO2MF7OB)WR{TbK=B zo3c&PH9pwBS@pTmg1v0POiNAyY_50I&i>J?#+pwtbAp-&3kKUFUsl@7GQ@)dB06Zf zH);&&?4TWrmWEE_l##ju$5`zF)~FO_-JpFFVpJK35(H^C;YCrg)ghz>f(rumOo-8 zQsp}PMZ`1y#Y3d>>4se~8viSQ5B8lqsEEO4q>-|xX@Y4sC|&naIQRM12@i&+bZk}{ zt#a2(AmxbE6zE@ddSwX$5IEi`Fydr6szo{9b=^<9)b0M73l#7^Vv z2Zr72*ou4bi;Q)Gvu=%3_J#A@hfeMn4%P{A*gA3#ehP(D8 zE10Lw7a9x(!&AC44Y4MzeiLy`U|)B3#66)n3}J*vb%xy&_X~?&A*DoKP=qp-A-dU? zGmbo3-ob{AQ^uUVNlz?_^0IOu(DWw+|EO-XZ}Wd2zCW$mGQRIUJ`3O5Lw!!=7lB#d zN_Pb4RcB-)a4@wB{${hk1|60Rl83fMk03s(Gm(Y(?V(2}vENcUAcupIW0eiJ)*k|0 zhJC{1nxaf@$CX4G{f5T+4uUlOLk&XSQ|H_DLAAJfX3&a8Q}*{OydNFMOb3k`?yjfShyS5k2fz%0aAp$>N zh6sHB8Ekko%~%8bKUc5Z%P&n9g-)T3QYTE)&6d;&xt-t%J;iBkx=_}PU*eo|BYA2= z5fAn8C5<-~=SYJmGh+r)Dl%PPsRb63|lo#(1w9T_ICJ(-9y$odfy#xlD|?kyWU#m|Rz}))^VAjNBKPbuhCE zh2DhyU<}n<{K{l!Yy3*h?v+jumjnh_d|F`E%JqPyCzN>Er-U4duKQ1nr3TyV+SW1b zY9P=o-CjI#<&aYnhd;>QTC+_C|K~hfTnxHdhSI_3$AvuBO?T*Ki|ZzJ@O{j6NYk7G z(K_RN$KC(#Lv0VEsZu1djknbL4g`K6y{9}FK>ex}h4$RePw%=_R)xOlt zR;pG;)rK&ZE616B9Y?>8GyOVlB-#_qKQ-hu>1Oa|W(=ncyFpGZ2YDvgodk1(y#7G* zz6Nk=m{tir4@{Cj^V^h41{6W5q<$6)~OmKI+kGcy+ zZWDE9?ilJW#i=ASBwA1MQP-iHEu&7$8!+b>%sH*&iXDSF?!X)yz9Z6@lZ=u^4EHtBmE~3XH3Rl+*_*`G-IdR zrDfTQt!15M7GX9p9e1!<1Ua9koTX*Ej+`+T*Q#M-WAQ7m=2as8miInwWlePaNB;9; zEW5Nw`twvjVW|Z;AO&!z4=^DG@LLP;b-(|?bRXdH6hM;&cs&JhrU1-&!|b=9zo|un ztV8)Xy@ZXIGs0&&O>1j3Xw8Bn^mtWk%`-8HGBwcNt2(;E-4(aE@?!B-7dEfGWXaag zkq~vIAajsQ$HP3zlSS7=sg~=3Z`~wLDzRo5cWRAQ!W^*jV4NuvCk35#Ut1@B_X{j= zAlm|Ow+4j(W)e8Upoq8me22!_@ zPA-U64xf=5Z5z3Z{2>-`3# zPIr&5(`O2g@lUo0NcirDsf798GTrq|v~u~?yCL|Fh_W~F%Z|m@>~>Nj4^>sC9u^E) zyj6RCac}JTW$WYSAF~&1!0eo@);b_jI091fE+Z^5=2{W=J?o!^-G3=?ZebZ0MIHU} zpj0eN-@bd-vxivy+iGT|aC;7l6EBC_^36J69qf>Jfse5JzrU!sf-S zS`poyI;|px4iC2;O#LGhRVTzRL%^%Ni}8?@+L0I!ImV=L%opFvC9oN5O!x7wkuL=jbOW+=OJCH zHl6$m9Z7}M|H_sM@gl1)pB-=d5@oG#-{ZKq1tBT%lyVh^R1p{&E~gnKc_PF_5ePKRr+sRw874&H+{tc(vG%^-Gm`)Hq!1K;hT(Th2);Y(7u|XeSIi3yeEavHLg1!ouR=NAL&gT zW(MCweg5;|2U>2t+6+%LQb${WxfWo7x0?@;#1xerLf&2$;7SV+LdRuuIKbwx-1`i% zfbo5@1z3)b%L4rAN|Qs6_o4;(js@uP=KBDLUnKw(jNV@?#BK&c2`xUzwWbiI+-gC* z4^rP;=!1N2D>~p^ZXuQ#i1>gP_5oTfK+ua>fcq^#&?^x@*1s+Do6Ab)!fdoX4YPT6 z1k@vDqusp1HPp}>`tb&i6$n2G>q}O-|4GpgYi>l;_wivI(h$al4GqFd>}jCD-{a?` zQD_c*PE05;ZuABCj$_1+{dsF-r1!*0b`;uRTNjsdD)VZ8H=pgsdFI%Aoj{1I5QNlv z$y~nl;3-Vb#7vI#Q(1V52`4z9&9_FXF|=W~rsYEz?9;VygpD|fNz%CKh{g>9(nF*= zRe$42ze0QgtpYAPoPT_Ptv6hQO>QzO@qXYt2mhIRu3wA$l5xRY%wKQee>x64et@A4FQgfk1-RGKq0nH0`AF4Qf&%Ks30 z@IU07TwW^M(ExM6wt1d_DP$F!GQ|J#zo_*l`Co*9NNKnO&BR~gDeg&BLc9N*H<_8G z8SeKv?coHCoba5+tP1q+&kFB_QzRpr3iarDvHy$=-bRtnDD6I2oR5xHVaA=HhCifN zw^?vmYYO}xrPXD?k2c_iHN7`aI zrQOsR9RXAO^KJME@JM|djG$%hBRA#ef8lG5vO1riUz*L&mu$q(>(a~A7mo1xx!oLb z3xA|qJUaz`om>i8=U%<@sLy*7#z{C{BZGshhFLzTA-gp``P2_BJ1O_Rht?b}Hs}3R z!q9y!8~fih$S@0XNgCv>eJsdsmC@c|8qsj0O2c8l=z%8Idk% zZwpeF2Kk`aHu}$(r3(5q-!wX&2I=xaPD_J4XF(22gZ$P98TfH3mp@yOozoyQeUR^@ ztLs{jfBh@<&3OVz|BJb=v&SJ@t7ziK^I+H^L*n`S4TI_o!>(Wz5N*A_AkMMNVLT^V zuP=^p*z=xNK9rainQNsqV{;+F16v5V==`q80*0k*Q08j~OmbN*%vbcKkQ%j;Wq_N< zU%OsTH)h5i`o!J;ANz=FYL_oDVJd=OBD_+_oA|=URC_pVv%Ema#GQ1UD!zHXT&?1Gw-SL?z^TyP-q)V^ZF zn)<1al^iKLr1rql#KJW%82)Q^$kk|S+s~g+6!h}Ym`T2TmRzM13~7nntj!TOg5oRx z7P1e!w{(!kJ4%V`0QD-)B0w>I>izj4RAuhL8h(VY( zR*1{7LTr~6qD&E;dHht*;b$HPz9zZ0)!OU)iT1hxGa-c1{3QkcxH5)&46O*8_p;_d zEGhvHUZ1x?2dN{3jw`ST$6 z0ljUFbc?D&5L7o*cnOO>Z{7)(mVR$0O=yXjY`&Dlr=q(y{uVH9+pJtPpZ*e6L8CPY zI}kLoQzNy6%RpDq({$=Hv|(o}DAj0x1Y$0H@StS!F-AUu%_8LDI`6uj(XwEzf(TXj zv223CU@#5_gA>4DaMBzlUed@a?dJwGzTu}-JffF621CdC1}?l5pKCR@mxL7gO9Q*Am$-(F}Fu4P-DB&&G|L9UoOKN8jt`nSk-Jk$p!PW;=kW?n5}8NLlZL!q2q_RtoIHTM%i_oA zB5>5OvaSLM6kfYKl<^FdAqqOzbo9<{LDTwVLqXIHxRK)4A)}shS`+=$Upek$xU_vX zD+;8ooZj1bn;4%YnD{k&YZ^R~jGWQ&ia?8}*RSy!V^QT{e7Op9Rq7!=hrwcmWK)94 z@hYC1lDQ3IeCIX3($@p&ua~k;^gMQ0ROhu>Uyn`*DA3ZaG<0#nEWz94PaS^`jVBvo zwjS3jr}M@dt5sGJ^1Q88QYE^grsR-@Jy~eflHngRh4hU`)pc~dHqi1AZ?@2JRqo<2 z1_4#0I*i3pcwNtPA0+Zltt#uN9~N%H)vhRyb-rt(Mq2xV{Eo%ZY6yC+y^=5!*q@3wC zX||HiuGAvR#960#g)}1Oj>1vM(5*QlXUzG)NdVZ=#+UW(w`cY0v$Ozk<00fN-TY)Q zEj@flOPV?<)jJ1j*24ZDzD|(bMv6>d);5J2RxgdveFALML zW{I+?ZxGQUrL`aI8#FvwG=NJG5yL*x1%b^gCL_nayA0s@v= z?%lv~&#;nzzLH8f1q_L~^j)YF&Qd?yLj2W0@cdmL;MIu+pxqm70e)@)+Py*_;Grr5 zkmD6wfU7J3XI!wbQV}5opjv#s-qhlhbS<9pK^B@?2;>C|a(Ei#e|?ZsZ9P_d4_Sy^ zZ859879ZgEwk4i7*8=o1W@wq`UF-t{O%5vL3JcL?Ae0amNcKP02hrAZf^byU20;)U z4jg)QH$T@ej|2`K+s@BP^Z7Y#9zW;I;paD!fRJ=vO;W5@5Y44?>5-_rJ}Rf$UiDNp z8ASqT{_B%i;IM0 zHZDbT+_rNY;C5Ma>2i~la1}->SyV0;vczqr9i%#mTS~PRlPo%n)R_Oo41eDV>A+04 zlm@AAvM9&@PEYzyxq5De9&R%aPSfM1JtPL5z*w8|31L?b{^?Kxnw-@iIQw%h1A((Y z{G=*yR!2B+c8_kBbMuOBR&(>bZb0YRD|FMt4Q>x(tA(@$WXwG)gXYrt_CBQhHhW*8 z`+3|mBmAv&uDyAnbdJ6GZE2&uIk$8=0H>GM@r&^>zszFp_!1_JiSGFQG|Oo_16`0i zeornT_As_~xiTZS#!GwwYRAC}N zS$t*LTlza?gY7NZDLeH0(42SLSJIE%VrWH6g?GOcXS>_PT0%k@xgC-T!iZcUvdQa)->=Pj-^hDD*XypxS_K~H zn?V+DXMs%0fb^ZsyEn4lh5hW|O*ws4yzI_;S!zGjyHwua1mxK)kRgLWE(TJufm$au z8ohDK|Gjlm9cfJ13k`k}54QoxeBI7Pe8hiF2Cp6w2x2aX!n`XoT?p*E%5mRvnpOm& zm2X7@)luC)qYlFasR9mgn!F+P0fxqqhHugGTv|?CpG48eH8%WQ(JS0A z&(wGW-&fP$wfj@8li+5PkgI1PFypY%G-JA&sk=-YL$q>W!ku(38a+e z=i;~VNnrdohO*jNx{qn&MAOD$z6<=oj%@`MR%@_BGcY~E`uo40*6Af0l z11tNQo^NRsM3;%9CfxMSG+!7JaMG5?IBYn9@!gvzhW{wk5k30Y=NUw;WvRb8Vz>hs zizriY7On>N7OqT%g|3Ba0Jc8HImpn%el&d)P46RoSkb-)2gdux`_K1OzIHt(bW35? zB0U9|CR!JG13?8r@-hTSK=5S4u&#(!VmZBE@WVYof(i=CshrS*--=o34`mt8^611M znRmmuOH@Fg?0H0itGzo;H05?@vM31oS?OvE+>s0;n`WrWscyRNc!r-wH>sgop2^5$ zP0IE*`8R%sBHIjlMW5S7ub_4W8%J-Z@;ITIDs#;=VtXt9zOyMda!ULROa6-tZ{J*o zZCM%Fy0&dMdaL{lqv+j;P&kN;aq)x21-l}}qTMagF=52@dPnfQYW!fdWC|)ECo4!|iy3N!k>QRGwC`*&!xF!0WUAZkrG(eV*(O^uK2c*V(`pU1t)N%0cLW=Cepx9l zkyQ}=OT}}z>_~0~Ljnto(L~b-%wMoThmJV7;1Xn;)W2BL=nXkX8IVfQKJehuS&oWbRjyLsC ziu!T9{rosyW9yN6Bua9aq=Jz9Qb-m3kBQKR6=Wq2X<(>}lt@UMCmJ=w8Am z$LF)FrEcu|2H&2X`Zhn6EB=bDlNNyCa{gFF5!XG@K$B+_oB5r)3}#EfY{h?r**Eho zX5al!2D3XWZ8MmC5*Qz|C0Ur&x=J-Pm_?(sSSCTo8GIgS=JY7dTX&|xWr=slNRjWS z3U=C8&Wn|)7lo-8O#XZG;{Mc&PrvPdp&G_1fSv!!r?1{0Ih9!35i*ICXt9VW7%7?D zl~-_hPT#QbLx(ecmv~+8ZAfD7>m>3of0Ctyd)w;9sc5Y9>TdF7_keF_ROsVLCB{68 z*n@>#)9MP35y73?(o_)_mqMVPDMKegi7EKSVz&~NdoC+dcW8P0NAKb17zEMWr zJ79`WOr}i>Rf^&~o99o$fwMl7dV=fM(oaMJXDvnd(4(7Yxp_r5|K#R*-Mqog3f;WN z4f=_6jMO^r4Jy$Pu*ca_tm3(^LCt^}55Je0kkV{&a(`}Vh+j5W`9;^nuhA=@uct}v zEO()wg+G-4(X-ycyBMXy?W%TGG-=x!+!K5a<33unv$D^2;S9|FjB0qfYuOSpWG8dN zBWy70k}P$^=D+RGw_Sbq+hSAn_wBdP@ixkJ^{vad(d07ZgrUZPH!!R93+cmdH}byf za-_*G(Ws_vD@$zB@eejxDvak)?B*N&Z2$6!vYjw7yN;o4W+?9gA8O{=vO zhEY%GNhxhIRoIfoY8u}@lk_tdZF9Y80`{&lzdts=m+ovQ|72P_jn>2q5e)lnF@ zO^4CS2oEixenJ}h)h1Y(Z1~8NjbP3n&~Emn&mJU`kI-^HJDnvZDwj%-nMlxL!^s9@)^syUR;e1X0n#z+4FP2 z>R=88MnO2_yW5d9K{v@%qIFU?Dwx%n*UBk;V-?JN&}dXJztoM^-Zydsayq<*5;gFB z#rJJkz+XGddQG$P`F8qDaq(f)6Io>R&6U4I}eh(^Uj3C8DQArVxbHPpMr2K zhg402vfd+uijkYiHOJy(uCD)GuFoI6XAvfLW6*chHPC#q_P$L2Wz{#k|9U3? z!Et+;T2D3k0~5v6njKxHEu)$H12txZ%;9e?ZWbaJ)0H2R?ssKZxmRL0Bl>C>u7Hu}y zHb2+4>|6uQwcG5xvo`L$hmR62Oy_Cz{T>8o^_hsy^x4}M@#;hROo{@(&j_)-jXpcW ze#);tRSsKX6IY|KwF*LjbDxUb3>Iy9>S3~87E8eutUaA8k>^ggfbD8j->kYfr164S|gIe>~`OeT-?yKS4 z^(Mr92hj#!2+W$oH|{E(Cq__!kBIbiIGrGQmMN?lKZa zBW!%0kuVxk62_xe3T6wn@)fppIH6^8`+N7nrzK&m!F3@eTYjeQ$(As7m28>sEf!2` zq%ljlIDCVW6!31wTz_ZpI-~WOWPU^D7sDH*ZRvCVInGEKjb7^u|!@g zLS0p2SZn9odF=rJ>WkFJHHZ zTFuK|3^!)2Q#Y?i5QFt@dM&LB2+VrNSYYCmt|hOpQ|Q@dKHpS6N1J?%0wDYZ7{W8| zNFq(LXl>8Vt!|pjml9)vUJ{fL-*P7mS6%pLuLUGW>Y*FuAK`0@dmq8y(8R zp(H5l#aFu`CA0XeLduW(TedVk-kNX9Rk%NNb^7$!?cC6UVZ8hchNYxETs1QfM zkZnw>5oUD?6g<41*`x7%Q zZ%=t|?YD7xqOI*H@6Gop@B4mvmD^q3l^d5=Cy5917|opYT5So%i&m-~cmL}sBi(VE zi*rvW(z)e=H(_|#Nywb#yTUtlz|#3kOs@2Jg=lr60y?Y@7>9Q^;yCLX>ae55H%OE6 zc6HGM-^fOp0<4%b+aoyUyt(m_?G>m<;_eKH)NImmnPb}bFv}g9`S3h@X)~9F^SL1O z*O!laieO)v_?~#GXPxC;l-Z-{LlmqGWNOJ7vJ9}ZXoKNC#8icc zJogT5Ig+g%jG;fTKPFoCxzqGMnjZo+Zjj%c&PZ5>9rPxF8vCIS9F|^!-+Ft#VCE?^ zRWMK8|Gb^2G?!%icMO`RkiNd&TZ1HC>s|b;(Je20z<;jj(H2Oe==Bu9SPO7>3Se&l zWYqkR6u`GE!1XDB&)>2++?4_tVgb%h0sIpH<#25Zpa-Qj&!bZSfAaw*rU0I_0L3YQ zU-$q=rvUD?0PFtfw_>UfaNeFQKLz_kw2|2+Bj3_PNdeDdt<>Uj4e5yB$l|Q1c$|namBGfm6@}vnWWII zu1emKnzL`qnzOYs2*TK?uFj(om_KJXYF3$OPM}}uor3`Hc84l%RJQ9VAOoJ7vyZcL zHq0q#=595DHc3XJ5K}cKE-KRqwZHooxY%o$Wd;ZHC7M>ogV=Y!sGX~)tDUN8IT>80 zT!e;+Ocm5uxq+Cv#F-a+?po~-_tO}vy+9}FXrh;2j_$Qmy7~>q0tzjE@~28Of{(7* z9f|cfs~9v)dCj|P3Q9~QNcOuu7~&4FLW1Z2qXQr~ft3V$V3XSnB6yD}rYXiF zUz+C7#Z--Jg=uw4U?^A3vF&ARB|W=%@>%%wBRjijIalSr%yPr})1K(=$#`Dn-L{K_ z^hJ1QmPebuxOnQCDuP9!GDw_M;4~dWaJ5@i<)&*1o!Q*1TOAKN8dcCV9^Bl~;ekNQ zW!w^t6Ll!xbe7|oa`DtfNL`OzY_M23@lCqokDoGaxbMfx-j6md**V&|HaA-Nc`Pt~ zjSM13#0h)f*^`Sv1CKe3=3_wO;Hu_-QURow$rT)$c7kT1S!PtgS~=2eEvXHT*k8F@}QBRM0awlEr^hx-fsX zDY@YXwm-}|aL)~TF@$}58=aw?l|08z<}oPy-lPtJ7A$6SdavFJ8P~|6A#f8%vZqF~ z$QklibyvOq-&gmKA6h~>j~c`bA*D#@hdXaXLVCLl3gTcXh3DIiFQ6bIfi{CRLp1$? zmd~JHr)e}uX4g3fCm}*Hi?kr9=5|sHO&WRr{rr(aDnhpdE9f|#M9su_3-?;UiBE5F zVoVm@4o28V{;4iZNiPNIAi26Hx;nWnsqZVNI6hOky;kh69b(m)XKKiZye3_p^ zu);VU`wiijq$r<`CqZ6{14tz{^!PsL+`Y=&awYuWu4J=o}xT=ez8+l zboU=WKYiP+>+jk^>wbstkuT$=+J`R$XN-2#pX<0kERdeHauMfX9%$nKH^iChU}TFL zKFUz<*0K97QE%Or%D+kFCyPol)ksU6srul*lub|RIQJ=f8k&U+8|prH+X#7!P~h4% z+hjQ1fm@QT0^U<28?PyXY*41$tlvj?8koGWH~A@Krhd*Xdep zM7!kT#$)%*X<+#?t{7{rprYcJb;9eX5tEYBPn<;FK7@S?Ixcoo1Hq{r*|3w2i7}J! zD(^;2B$nkJ2oFd26u5h?T&tIqpSL*XKCKc>J>0p0=$P+Fg2bhEIkZM!5S?r-5cTDcl~-UAyE4sx2VE68aWjtIwD z6RV*&VLMrLa{5EHuXw_lCSGF+aabL9y^nP(zYsRu;@)wm6iXxuN#Ef(m2XUAk-N@m z`r4rT`%ddwtXmQ6R(b&}HkRcbkkcz|vGas_kbmq-ycw8{umM_DI89FloXVBc4s^7F zUB+&dQ?|&d^rj7`>4&N3E0;Tg6Z)OR$!QlQ_5gerrQe!NmV2d3K$XPrTS$l{>b}jS z-V<#dXU?d3s(x257XS|I>C2T0kjk~559z$@v`#D5lJ|o5h-IXTnnrxbaRV$dD9$<` zZ&AfNP7NZnGcZV8`%{v;55`v5)T9r!!6w%(&D-K{#w^bdgn z8E(;;17>*+NuM}?p#JTwb0ntij?O&F&NZBaF6(We%w*B=%60HR1t9Y4^wr-ZOVk;;XFaR;z3W)1qdaYv0dt?7>^4nIED`ham;jVERVrBkkm0Wg=2 zwg>Qx2`^Bf=p!MZuK>V5PR(!AY%t1+?k(e!?X6kZ}?b8-fhYFY| z_|lAzTm11c#F%C=GBC{w1Q{4wadV)KJ+UfWVNR?HhwO1xVaFa>KvMeU&C~z?KgLJT!W|zUFR};D_-Np=@%Xs2U*n^%P2=PKNBr>- zvgcT8R4@SG=uazHdirdQI9!_<+l|787Dw0hM$4X#yI#zFC)#e#?3g@xr)cL_L{=xj zh7N-0*~}3TtC0)>&A(Q!xu-BeE+!LA@+Gmv)FGRk+#%Tup$V53NnoorK`he*p@_oE zm>{r2)l>*eov2Y;qlsqrNy7wFaH=qWrscDv>qtYp@fgA^{@k+Rvr3onB7u`Jw>)#3<4>fnIG;-pfd@3CqN$0 zcn`cJ@>q7SPaeppmz5g1EE9ISgpkMtg-2i`zFm(~=EchTozAbbCVwO6eH5+q0?p%0 zw=?}GmlEPyeHYRZ4yKnS38cgT$9+S+yx*=!en@6-NbYu`mED2ayDEpycM${ZS%QcG z{#k-3!mwd@%FqX~HYk8%}asBM~#&Xv&U+;v}4}$jEr2Bq{ zRfFC|6DJ4#?z@d7$4-Sv-J4Ezn~T#BQs)$@2Cc`@A4uKcK)WZM@8vnUA8N(mIIUMu z1)NbFGx=ejPTwHwh0hD0OV|7k5$73i#6Q(FW%s1I#t3S{=%B7a7E}Cl$!6eI9fVwl zl$H_Akll=Qc2}xv7~}M^=@%zai?sHfuwN}3u8f@KxL>P-j-`XXrh~rL;G=^E0<$NY z4q8J8C5^mE2c3ePwkmM*alG-~Z1+3pAi*I;vwMV`h7^sQmQ)9=@*Wcmg7i=V?%EDo zLkF#lp8#8^tt*vdps^RT$k=%N_Q`{BbPp}HVk(s)0bOf zww?y&`;Ykj{;V08n`O3(1Y?(1;R+GISwV)}<(`XYw*H+72Q@pRNsb(B{0OmvD)Rku$ZloEHZH~BwiBNRrU*Zc&)omR+PT0-Rb2~zhDl&VbV3CkE$Rrd4#uk~*xRIIbxtw^ z=fDhvB7&k2dnrb#8j~3a@-Q%oFg=c?SFg4Avse4N)mv}1xBV>YRTCZw59Q?x#Rv9z zVg%7@0AKU{*FN*ifc3k-%a6&NIcJ}}*Is+=wbyH}{de(+73T}#b1PdmIfhj5IVCv) zzLc@U2tE&$;PaLjbNI|s=sa$f;`0ko=$pS)_T9-T~b*^n-LG( zVkTq_nWsomB+!NHWIak5ZLC#mF&)r?aj)1C`28Tisoz*Hh6H{SDn=U6kp`h+K`PfI zR7`JXv6F;Z>?mcW`>(zigkPZNUzO8${`czN7$?6wonWP;H;8Ynl&q&}eQdK2vb)2J zQ=NMxKO5QMm3SZS(}_F0qP=sUj&yj}+xO|r9o{YWeLB?P-ODwdnkopp!z+sht1h8r zuf~5AF^7tbJT*@}$09Pl(5!we+4!=IY<$n73^n2xbhzl*HaYHSj_xAmGS(F=4vH;_ z%-pENFPkl0Gw&L)H(Y=b?^$c{L&E7Fy=(AndKQ0%N=|L7PbbK9s@iQlkrnEhQHHre z%_Y;qvBI*OSDZwP8l*dIC{Y2F?o^$dM;oX?tX1evw|*hrsW&@`dYMGMvb3=o&%9jxn z9FrrfPwhmX>dnkE$&?c<)TaujPK}y6_X*M1_GWwj_?ZvP3pIaaUIcy23qNF}sd@2g z|BW&!{z1{J%(u@izcG%yY}5Ha+H_tdUn+X{+w>msvN;@Tr=^e=6aPlPQ0u-7wUXIW zcpYQ(KUC#H8FKyWe=1e(8Aw)AZTe8cE~aG{Q?J%qS+q_nH*2wFD(2&(f8|YnhhRb z-xvS6^-m9HXtrFHKc)zJnUpEk_ZJlC`@+#7PNC4_$)vYEXUn9h`QD5K^<8zVP|eRG zI7b@=C}4Qy?B~2g>{zTUtLAV2m7SBB^^4=_`=h0X?mw27>iZwV2CVP1|4*&#`(?d2w!Xhe%H&pd zrSI?0>-&soq>^==!!D1f`adjD7`E!~%M9s{xK*n9e}0NarTU*Cz?7)|XK6l9I~Bd+cVCxjoCrUIm=$Lon?E~ejj`7Sin-5Ii)-AHhW731Y5^}2QwoiyDo}G zXrw4wnffIU326gLyJ7fG(H;3UDX>&bbzs{jeNA1B?Rh&^wezKxSYi1RXElqjbY z`6Yg|`ku1$u=8b{X}UQTYZ$pUs@Rr9e4IqsU|GN`z1{i|&GnB>kG>Y$n}nlUTL@Fg zSNH_K?8-zy=n;q-^UT%ezrtPTY1d%%w|-^HP=tSy8H$YCd-xO0bhht8nksNM%Y0&B za`}iZ!=SljHtNv7P#ECtbI!k-aXc>mreN=pUkY+$PkwA9iyGFF{rfqqjxH(B>V2RJ@tcK&`u<2;K?#@rWlZq;p5}yQ_ZJ_4}M!i=Yx!HAYB-Ze46+) z^J$ADlkHT?m&l8JiPwoQJ3>79fc;BkMs7Z8e~Hw{uP*yba?)*oRoGu%`%4xFUhvyr)%I77{S~yobo;Bp{+eTdHQHZI_E)q0)n|;7>qZW8qK1W1gH2@FYR2WNsV*e40#}^mY)-sWBUzU@ucb|y zEst8uZWnhP4pT|yi%-4S7YDBzk{`;_Z>Cp#?>dJ+K{6v1J zsZv1i8GH@X)8}4`*@FNB6~-dJHT63=!(E8s4E|E(GbJJ$29tCSY;eYgKj8&^)`dTp z$-9w8vNOw^0YB54F~!=o@WWSFAHTgtzlC3z&UAxU7P-6asa*u`D&p+&Ohz|X`9wRY z(!9D$a|6HT7oRMzs%qCu@Nz)|A-YnQ1|W!BkceAzNG$$3YO#+rJsDs!)0#-A-C9Dp)@yB?n^^MGBZ zI$K8A17(!Xx2E2&$_QuVUQM>ldbfCc9|MgX1!fT&z9L@ zm(lGqK~<*9F4K@Lv&$~iV3(0Ft~Cka#?(D0TV}6ahHP^JPlGD6%P!MsKiY49HBv&J z*3VI8_S$8dvh`SYsV2LgMpb6NU8Xr(=8#>c*)G$h%E$@;JZ;%BN9;0fc9~{X=8#>c zJzK^h50iJb+hy8RnIm?YwemXCIC+=bF0_`fHFr7Wc7AFrf)@KE{xQyz5g9C~o8_y2 z!o-+}y^6hCoGa54syv^{`Xt`q{Dtc{E~uh*&bG#&+7LU8TDVax8b~*9cgY>GSext< zmYCw2`{fR2$cmYpSdC4=dAT`L3jc-&a`4x{4S@e*-d6BmY&)Dm8wD^jrh0slpZI+b!fmrK{|qlR*_h~?gNHEViQvruM>(7#{C16$ay_hH%~7d zg0q1}0D1fyK5VN%(_fufdBm}J+@NxYotbhMWXfTpnz+Z}ha*imKET!p*g=7~T4uPG zn;>dx=YjS-_I4KT@9}mdRmMwNMP2*y_D>w~TQhwiSX9-PB^IX@&p^;qHf*>dQKpFZ zb*hiSjsrMF)4C^gNW#|qgAjg+dU2}T^ZWA76Nb>qGLN1(=#+$D3TlNj)tGqmia=NM zG(W#Z*zyf%`bPpr_+m`oKvF6#_}Mo@()lSrA<8AfPc+(<0lTcL=CsMdKKS zcbhEOU9l5INHTY6>0SMN6KH!s`;;QdB^AP=z8$KGd-dKfnRC2OH8B^t3xdx0hsx1N zAIIq8ai=0;T2Iy=rqSxs)AjjCKXOT^sQmzR%+GN;g%0IUqPtlm$LtKRsE*3twd8=MRslI_9s z*rc%`I_r7j{b5?_24_c?<}uz5nVT)`JM2G!gFGMrbA&MgBQ+0 zYcU4V*%Jg)XL7yHoZQTBpKEh+aUQ>av@Z_p?p@hpH>N5@l^A^Gh6WV5w1%C~HBr%+5TP^7KN? zXLd<@|3b$;fpY|UbG9;vlo>WH1F_S0;) zjvOs{>BCPmfaM@^Shtkcy(3#JHF^d2zEBlr}p)TRPwDKzN)prjysQ!umg@)gSr9?tB5p zJRSEywSqM}x;cZnrvbPBHfwfi9ly)eLHO#?GP1jp3&ucz zgYAVry|+iGRZsV{UsA2)mjQ{mSc!$46Qf3b-MW@4RTL_Fl6?p-Y}K;$Tht4`&LJxn&mZ*-9$>Y#m5wzy1dQW8FDhK49?N+3;rH8Wb zrbaIw)Y8h*mX>8oXOQnOS9qn~4}>sGY3T_vr6g8_9I+eZ{%h)f5dv!S?VT~Gy^~AZ zJ26|juxBBwBiG&(m6=5jE=4pv^IrttS4$QLQNa-nVFtOy50)wXz%Beztr6ZFzqC1} z^$)7r0ujM!eUBIh71ltA211syG=|o)%apZm8OOl0;drLg`asR%NwAF(b8)FaFWA`2 z)K)rN2^Ql}V^&o9Q}(;XS8Eb zQ(X!dMZJ0|TRPvAVa}_tzGgSY+H5_MX=`k0TeoH3PL2M#vlxSym$o${Te_$%ueDWS zfNh@7ThnMuOROw&dTy5-k}`0=D#edGTTyECHwQKQx&pSSi?1FoArb3}(n^1uEe2UD znnp45JBw)Ar&!S6qv?-IdpL19B|HZVGojiidF7;Lsa-PbTE^5nfeJ$VC6XZFPx5t*YbzAmr@`9#?(d6gq<)v-S z$d)c@tJ>PCP+*TgZT%OqDa_Z>)<$OEXN2h13Y@xLJ-y9J!Z9EkH$+pFA)3XdSbhG( z9A5l`V0}>aum~@|$d=B-YMoPB>B?-e;}cE4n#?6c6G@e28KIU8x~)y6_&O(7`DoeS zS%}>MmBG3Q;=iGx4&sE&(FYv90c$aa?$j49YUYoNuqMcf%wM(d>@BzT!!f z_4TIG`nR(|KC?blf5QF)bEgcp)-#y}_Wpw<;M|ufUQmwL=eey@RMj5g+V>ui*LGTt z($=oYx3>D@L9KnYw6zP5(VF!T!^?rO=#SQgnU?NRw~FxgHxgQ8`el7IsHI-@T2b*$ znc{{0vM#e*LRhvoy<_+3g3^|f`Ihb++|o6rEnRi2mR_Xql4hWpj#+auZFQ9*yb{ef*Iy)S-}P)HOE#Sffv|pCHMDp@hK;qBDh;i6lD}G4=)_dP=+j?S;GQ#;Dp$A<-Q>RKBl0c%WMEKB`_*ej#a};=oe(?7SoC#FB{sL4us$g5^^8n8kaY0FL7<;oTJ6|lRr_OA?a8v$Xsl&Z z+78a=5Ofvw`_Jzb47Z{*B`Y15(!%f=MPnKIiitkBywYo1MxiO8=^fUN(q1hqZs{8K zQ7EbGZ%knOr5}~PG^zL{CPEH8*2tW>7WXc0n1cQ{Hfip-?A~gP> zU2GPn(I&>skz#@t8ze!xC!}|+>mLrsNsoRJ^W!=KU8=30vD9!?zDT|93J&x-38A=G zRk7U)-!A3wxv=6Zi*eS1rtl-}2W88#q-J=fSMw^HW^#s4(i{oiYSg+ffB1QMrQiCq za^nz=-bN~$WzF%CdXh5rje2jrIKCYHm`dxLR5#>{oXhF@W+LgEh;|`1Q5c@gQi*IL z{8l5P((vi#lgf{on%ZW+EPAzQn-419X*)t)q-B@4MRGv_moSrHwl9Lz9Z`Oi zOuKAQF|Gbe&GXn4AF*bMK4-klz^`otHhMa5=S_LZsGZ`DFW1d)xpmhoQnSj9cmqbN zi1~d%RV46S{Aym0LLd`#^M~!+^HdC3=xN>SUZ{Ikb|;ql9r15KLtZ1WMUv!pN#+BI z+6;8JkZEA2_1zO44*GJc9+>Zr)6?60@!_Gs5^uchQD^^<30;Edplzmxj>SEqwt3}H z4w78+K#!n#8mNV{p)VXoOpy%Ss5rl3d z2%$>zChN+edsaPc`561_utjNZqpC~qt@9~sU9zr1GH%pCmvtnitgBIXO|4Pp%FKo9 z5^a8P+2D=&jKB<^;i>135VomElb$glIayEJX)SB;B9wiIke#WHzsWtq? z^RY`efBZwPLXuYDJJ;b~>aDMlNAcm2+H1)vc}bbj?{9=I%+Bwtk~iMQ%H!#f!TqKj zSHSrQsJ0RF@pc|#bTfN0{!Sw`szxIEaKgIqTvU|x=BT+VQrpNxs&nd|`re4AegiRi zZ0>4#RwrXv;+IquF^?ceRT$lWEhEV!Ip2dU-FHe8!nH^g|Gb3r%n6$trkG{5q`3Rx z6f;zdbh(4;`xR^QhkqzYZeYUxQpQ3@xCrt(iRd^b>E;lYMMw?KB)da=a;oz$t+j5M zL!QoC=^ZxZ`2s`8oHbiu2$|PRC&`(S=w*A}XP(vHRkL@+&BV2&1fSs!c*uz)Wy8|k z7)?#`Pwa{S7u&!A>E+;r0nhj_xlh7x^8MFj7#_Xie&W!3*^21tcn%yUZu2{0P|9py z`>j6m)$OCw_FE+%*>0}PS<~qWDLzQ`OE;L}SFd_X23oTGdOApI0CQTF%Od;8dsBn0QE@O1u89-2!V_0%nX zJsD@1?OHl+#1$-9B=>A;raS^gY-CH?9cFQ*LC^=)NK$%1+3$s%8Wh<;A&}MIC6eD; z|1?w(7034woiD_p2&1qwOX*DCTO>7?u4lkUAAq7(+$l z48tM2AN?1}V1I#;mcg`Fo%>WqIepcp{h&ZOnG(NyjooVh+(72ti9oi}kL9UGMz;SKC;J?T)$^P3iL>;&$`-WdJD%RW{xW~^{+P>i z)}x?qUPWsxaTB8ETb>G*NAav_k}#?ja(^#kk|en5ppEHMPLe4;Y~les>r;oF2qsw% zy8g+VT;`8fz2oWFDa69&Hk{2KJvGm7xDW{8*!eX?rm#=$)yTwFnQn9wA(oxpNKhA9 zBa}O8i=KoLa637SpqtnT7_dmN`oshMlk9JxsOkTP^}6!zP`n8_c#$r0FfZ2EAP4KP z9$O9$+Hx>ox~hdmKbVn$LAC0%5`={|*qD};hRGa-aE80s)6q>;bY6AIybWW)RD>XQ z|H@)Sz^Ph&Gqgiu80pM~(wWP$&=qz@vP>&5`oq!{)scWTDqEC}B$nxp|K*;9nJ0vi zr1W%h8Zj9IvGU|3FB?{2YXCkMg2bO8o080oTc9{P=Ce$ zNBy6|H;d|zm@1?k>MOR3k|86>pP}Amw1O4@2-4+2E|y?r-SDQ`GE!$;qp-~3FnKD;z^{pi20V0 z9HJ+OvdP^ruXNYgv(D4uL}00{_s0pRsmI;u5h>H_;nmwySJXc4A=&5h^=%1xS=6#jz0z~Tibj0O!gNE5a!jEl+tHEoGW25?u@gOOsl6))X?30It(xrFU_1T0S66CoXxXx<@-Ez2U4?N({SMI>am ze)vPOiy29G|3!(9%46GXKs%eLN>xzwTDGo!7it><6_aFU1(34^a(G1WI)br~NVaBD zxkO!?r=-e;81&rjS@S+}SQahB2Q6+P+hgoT!Lgf(Hb>1D+3SgY0W?uqsf&!MC@Vwz zC$cX2G+ARjoxhZ-WTEkN+$Wb5VO&vG6DfYGVb#2blVRm6(A8QIsp^XVOv0@)joAYw zaj7Z+q^R1<_>mcue10&=q$Q{`z?M!gU0Vp()W_9T7~{60GkH40ycII*7@Upaz}}TZ zQLw`H=v<&iXMJ{bv{cX@p4ch<-;^JW&|-K01kyH_$1fm=oW8Y5-`FTc-`b>agl^Ke zV770+;iu{wR$$Z~0^B>VW{@6r_Sw4y>j?^s!LgDNW@eIEzFJ|Huemr=uMuEyQG@bEUrwP9q^rBI zIOa&#)9(?|eKQ)^6i=v9%A?V(SJhV-t{y#5?_ILk?$F)Y4(0h;1okWtFPDBqQ}dXY zdm^q^qT^m&C)-iS1u;bIjnCusD2BN^6xasL8#Hrw9%icq=CK)=$JjOtu~by#Ru1Gw z0ryXatP5!5tO{(g?tf|Fx=I3g4zgkRH9mjgb2h)_-X_BQ?&WhUpEZ2`nUCCi6NB5+ zd>-cW7@t@9$h|uOsD)1>pBwlj`N+NCOk0*i%L6Oru@b%LSV>He_iF*Hd^g*>5;JbvCWp33g{6oqt+5HbR1 zn_;%F_Iy_1S^X<&kC+Kr7DVo7j!IPKucS?7fa;1}qWHtw^+il#`Cq30sCGu*M0jWoIIx+|iXt`7E-Frg`p z!K-ytw5nTA%|OfFUuGn%3hR-77N_fr2t{qyiq~WY0v<@g^iB^v72QDain50l;*)dW z48`a)Z+a>yKY?Gu31dU`q~`7~LoRAW#-WeL6c-pGu6jMs zzoKRX=^BHFSWcpWZ7rjicW!)|BrAHW%y4as1h%#yQtpYr+&`8_BebM5%2L2Sf0awi zC3X*$r(&0uY#5=Zr#6Q>2v0*SmW_Qu9IKqA4$cu@7&HqvI^C6gSqRV0$FQay~vXKR6 zF_V0%hr|RY+Psh^js=9Q$AvVZO)+poy2$spwBgyUh*zPoI>qzf_^M!wP+r$QVX(?D zPm|Db#wdOb`EMo5B$$?H`+YH^(3;u>+k$>a1#sfl$n_`gb{sZ*RW_}We$(9JV(phhQU+7uD6jK0~0v)7W1FT2v zxbMU!pB-RV!n^c&eF%*xi8~AlU}I^>Ky0@7PolS z{Eeo{T*hw8AcEPomG12HUb)wlh_2+@B7ezM z>^N2m)(jnCCMYC+9B0XcKT%GQdcQKjQf_oMLVScQ@8$_ah%3hm5zWh0*;M(MH>LKh zJ4G-EFq z6Y83{N1O|HW2d~NhB3t0b$1sDRK`*^b;}XBcK37>%UntV-2X(DG1z>wmN@E+>-O?j zBTO(TBctaQ!Hv8OtJOWBo+;*t8XV0{805@A%rOGpTLnIV) zrvXe1Z8>&R264HY68A*SB~4V)EbBeG79_A~$trG;5vA9&Mhrp|4}>}D1F$@u|3%j( z4ouu9UFi_(F;%aZi7z#C!UEb`JHMdYDHRj9BH+<65YRobE3Ebvibv%fs*IRtL<6sS zR*&YIC$S50p%^~=C$X}LUH$k_$lxhHln>Qr(>k|NtGPX$f0bV@tDmGfu*P%`S)8M( zQ7)Vz7~pak3_n47x+WMPz30V&@vEUmfzW zLavmChQr~dmi-(<6%BmgN&G8i?P?@+nIT~2mrrp?za>3xu0G^a)&D87b0O1z@X)3D zPu;oxa}9~8{_BPP4`%wWPDhmfbM|THU*%V}|3*>&jlgRy--`s8!nmv`rX_A$FvQdO zbKuR4mKb(rv=n-nnzHl52L4jcLpSRVk;iv`$h^usajTx*nFo7c2J9QCHDV5DIrOZa z$8{LSD#KO+HbZ==0LmEIU{}kpEZFv#u^6Z0-!lU9+dQ2kdCbVUBjoE`Qzm7rHXF5* zy`Ij)g!&_;zt2}zvCn*CI?zOfj z@SmE`ivN(a5SEKY*`5AYH7+#74RT*!Z8N#~8_lT;LS}uV;o1nv|GrurdpR8(Xuj?j-t|Rvx2Ei zvox_?TB8}ZItlJdTFJFw_sQ;$C-lDEqN>0wI}5O>Ko)#qLRHJ%0K41`wD^w|hUB(6 zg7i*1S%8iTvRO<@?2pIew<0yzJQuU#QaALhsNg9hwYIhpCfymVP{zOl;<&&oaqjeeKt9h&F?d-`RL))RY;9x;ncS|HnLuMBE#mS z1t^>_z@N|%y9dDc0g$Shdl)_#u41XQa{+{XAa*NH!{%#hs)7E!?7s}W+*&!^95GQz zhWpD65=WvG3$uyemSHrMX*n1Pyx4kv8vg)kCy>XSGrjUgU}g>2!X6ozsVsf`kc*kv z(57MudQrjmq&>6gGjR(|fSZ~B>}#}n775KDwH&MrOP^4&z_!+wg3F_>?x^XG26nfe z2N1}#5vNGi-I2gl8v-sA1PK09^+g+^m)x)zZ!6 zR1_st9~Y|Oi=NeghW+(j#u{LlC>PeiU zmQc}K{uf5(81<}{fG%SwS!!Q1%_=T2X7z8LVe>XEn`!MB-NS0cB{IEHXiT^PZe=TDx^NK1&l#=&)^KMe}O)Pcz40PedJ* zNzc@9Z4psHP5j23gt12^esAlS4a^22rjY^BiOyPUNT>sUB=3pYE5JN0liZ%)9}kHy zoN7kC#^lB#(rZg2Sw_UyZ`66EJ6e0C4<&#< z$t!)_$9{_0SaU~QP5|<(u4Rn-*N}u)z?1Gp5QIFTH}$~tGCxP<`Pmfd+MxOQdo>@# z&W(Kbyv)xp)JG6LB!2BwGxRlP;+9BYbL-{OvM2Nz_VaY?eA*?ut>`GAl(Pq1yVt41 z-#YJ6?ZH*wX8z$V>yvj?ca18`a9$5auNRE+CwaY3CKoz{IA54=%uMvf>^$2Dyq-ja z-sjM_jXdSiz=kaPc14{tK;H~OAAbl&IR^Sjot*9)FSP)Ur{hLd-!55!4HxF+FMWaf zwji1@97E`eXZ0siUr1`P^^r)WyD-c{IU#r3f{|E+Bj(#8XC&`X&H=Sg_eFj zaGx3|)gr_xD{fKO>7BTD9;Ai%wPd488-X`k=hXhU-FJnULbMCgW!3T@r+tn!lcg@V zT)nL@9(W_yY(&hOXoc9QqAvCV{7#JknaME2kQdAP_nm}XtXu#|h&4Mm2ud_0DWMPu z^!J2d1Y#31f>01It8wH&DCyXIN`%b!5gy-*xCY3<-g<#yo+<&3A|_%*Q52F}U&X|a z{$TTy*IV8;0_j%HVq^wS&)5_*uZbMut=~@A=yGU^mD2QK znnrzUJ+Gu`dsTlh->PU?Z%ZxYIe#wS>Sud|Pkfqf6_gBNQ$8aY)NvHZaOvik_4M|l z_SHy1C`U*)4*&W%9V6NIX~lgX#7}QgkZ{b9$QK{O-xMf%)w==;gbo5)0flefyifUG zkR1w6GP$PjcQ5cb@Pa3?PHAWx46rGv{(F?K2Ovk!>MGvqyHQ?M62P-^RWyON{k;kF zhG+G6q>}sP)xhhXL=7xWH~+?oJLIN&pOls)cNcpShKv`ZxR%Xc>;B!Md6F<+(pKT5&!p`cKZ|@Xrn`UY=tf9v5PXEGcm=;leI!U{9vW( zsBF*t@L5ykDzRzKM$cn5>st#?`(m#il4&om=A z#IAq}C0$)ZH1J0UbIBVXFMdcv6J9wxr+EavruyxfGW%F>>g~*b$&VXKp+nuz=rm^bWCi!v{dl<_S0oA{GPjrfhvJNa!Q`k) z!R$0JEA%!_?lCO*VDkzp_`Mw7;ksO8-%*v()XH?k^^sHoQ4Po`EsE-FegV}9zsOJ> z11t#qq*4we*k_D;llpDC>n)_apjr2}z z_pVPApdSEeBqP^M+-l%#=Ti|i!%a1JsAbaAaUl!?iA#~9GQncN5sE~?KQz@GaUtO| ztv8GNWG~qHOc*h4kHeDo7vIH2x{E0?VevHFZ;n`vxG*wdGqo()nXs7)boW{egM%A7ZhhJhb z5ZKbs8LoHraR&u3+rGr`UL?ahuIzNqlZ+dNdHLxT;=Z0>hl~FZHe`p3r?`St^YAU_ zhQMc-q0<$B8Q`V|$}VjAWhf)mD>SLCpR5VWM#AJUTrW$g6G{%N|9CXeIOnnuGQAi? zZuTU`QnQp6@mftSVMexIt|oP0l+&~3Q;hdE3jQy}WGA4!`jA`;U$d8_)U9b9Ive+K zBz5i&#(pNXDy;zlP%Tey!Qe)K;f=;PjvP4>zfmJjmf08z?6G4?_Ar|~Ykojm`n{TY zN5?uyi>T4`TWY!azW}P($}BGW*7GMzas9c~X%_EhR;MXaO`0=TyD?jQ*s@j@DR(p( zhy)z1X91cTEv4iLj^MuZc087IM?cC9(bxvjGkO*IpOf|ON1YlrWMaD0F_&ybe93c}n5i`RHZBDRtgv_M`EO%~=npZW6T-Bfs%FzBh z2&@uN+o+i@NVKwFd&l9m*k=T3-1~Byd$l{8TM*s|bv5 z#7A^)MOKG1y+Gk81E)lcI(L}hk=Wd*$$^&4A~EMExhxy69rpZYX+gX;bRKkvlg-{} zvbn-w=Z#@*(#$D9P0gDP7nbo|@u5b#t{Ib6|E$Q6u4VzONQ`2;X9bi)36Oj}X+t~^|B9z`D(0W2|5%e^1 zz~)E5H%8!-(ZmIi0q@daO-oIzCIeoz4c_=t@J`hjQbUF`UEfv=mXUbd8UKk46h;Ej zDpt8hVbpV!RDp8^WBPXM9cC19q=XgQ0TdDQH6uCKZ6p^}7)eZY$z{H58ZkmukD616 zop_J=xK}1}`(Ayj&Z1OpD{2rdWNQ6A(t$zP zErEG%k^Ah|Syy=-qLLcqvDEPJv1^D^gS0Q3Y?aBlwMiJ8ZM--nGddVeU5pCb8)cVP z)efWkXt_vbUm>2(nTawrTK6wpSKR)z+EFUP z2~&7U`%%}%2<7SRdpa^9aap>>N;Q69nlAeX6^TvdJQ32@$*c(hcIx zzfe^2o!0BWksuJ=e9n4auGpZ{%9_{O%%?5cx&WfHQ+X2<$h4W-EF7IbiV59Zp*Xcp zptjgy@XNv74Q$5~GCot~&mn$cN@BUA!V$+!KebuRx+o6GnN3Eb%ZLA}nKxQqk*KB# zcKPYh{$$7y4L`BmdB_nzL&5|BmOwy7g5!adJsi!BB>+CNP01T6%^gZzyB{x=C7Xyl z{sT;O4us7Q@H!#mzL$Vm!mJLh!^Ms(zU-`m`o~az8z><9;4C5Wt&a*V&tzNrp7<_d z5UK@{DQ9;MM9mN2`0wTHkE*Uj8{PW`gbVf8Q&qe|a)QQ2;qyO>aaJ=SHN$89xe0ZM z@EFj&prDZ_+1%QsDY2Y(n>F5W?Mf_bl-QwO#>5=q)e}d3p4)#aG*Pt;jDLxkOM`8O zp4E49FC=q{Naom0A@e0$VavwvM9le6KCw+XFPmQb)%fT<{0QVJ!^h3o2Lz(VNSCV$ z*AW}%ttTSy6s{uP3N9n3uq<^Ev}zDm6b(Gr@-t;m-D%zXi10hi;Wq8STpBwO4j>Y= z&(CZD!}YOI`*qfc)&-H;$rbTyZStGPoAMgZV$%}K77*VBS8M}|&6MQs;_6&r4($FV zP>=RmHb$?FRaC@BDZ-E-+6_WUO-8`e@>Zgi^Ua}NStOgYf=od^diXUuB>56-rv1Le zxTMNoCnQ=0*)8=aZgUS2TAl5K<9n^`!zAy3`nBD9+WvvJ5_)AnI8I48`H5=haW-qg z&h+TBZ&g_f%AbL;s^GdF$yMMN-pvyIqi|tx9RxB%4XfZ=heDoY>Ybb8*x3+HPY zp6(_xA#wC9Ecp_vKo_yzNzibY^z{VgCJUve><*>s_NvsdZYoMm@ux>mTPiu-^<)F6 zZD1_e1D?cU#jcYiiSv^xBC%RMBDD5P_H%+ZlJ(Wn^|@sB)_FtY&Fr1*607jhpfF98 zFrts)4->Z~c3&LRAz6I|MSNGwAM9f|7p&XWX4H%c6v3uiuT50Ybx-F5fGna;kUN45 zPp3>EHuo^SFUP*8!G2Ski_O`(S+-HS{*OfA`W*2as^nS2} zoLw8NA$Yo0^Tq3B69M;L*U}q9fmd4|Nqlrx>sJKJDFQ_ZLdJ4Lu7)Fy`02{keTs5( zRZyzMQu;^3Tyh406}|-rY>FYGo(-J9H;OZcL0F9=ev%MI zr1>k|Y_qPq5-T$CJSyWrlDI%gFF-y4l}SJ{3S_eh;HsLar=CB_tAvO-NkHTwx0+gtbYy4hUL8nO+5r1# z1lLAM9zZe$84*byz@^u|L{PC42uw%8+@gExws793Pa>7e^z>w&N~mytvVb3H&pVqf z{Oi=fmfu}J#Lo7f@d=3B_L15V2brWBY8d(&rmNV}iC4k%k844w$!ER)Tk%pzfVm_a z@XJhnm+8(m*qG{$R&9~oBrjX%uSW^yd-W6YZEt&#)Schfgt^~mdn{IM5_pK-B4<<( zjfkb;Au^Yy<7X#68WuYv!tH7?D)@;gihAmHv(=6B;CA;9&p%N#FOh%$hnk>u9cI9B zH9mANUuFv9|I-3nTTjwp;=3(qg7di#YKbmq>;^5pCCv7NlnyDQaE{n6)7iUl9SFv} zb@+W*&WPwU6al}D?W!NC@bbzz&;-rV5hn>h^du*XAw9w%pdZMyx2{4x?X45j2HNnH z>OmPU)UM?0VHZNbvLAJ(BrevaLv}x+DBNs+4QyFLD(75p+NH{({t)=M_#jD1K-Cb< z+-jt*q&NF?bIcohtt)ntEicUV^Mm~HY@SNUc6bqwo3zyRtOCR>C>2x*EMe19@`@5u zBB_ubpM6@4g=w;zC3@N>Wi9xVO7dZ_2lFuvQI*TKxFfO zJ=D21UT!3Zsk=Toa!yeFMLFlF7|9|?hF~7?jAVaukW4Yb|L;n6whHO(q8=)NJ(|zu zYjUy2H*kRL-kgySabz*T0ZvsIcd z$l3-hinXNg6p$k0?-521+t4{LD$k!1x4O}Q*~D-ZR!o8$wc5YV9HlXS?6mNNa*a63 zaFQb3Uh7X`AygUAvz$mz?}t_7ITHuf_*(Kl7S*1RBq$^PDwnU5#S_&gv%9MTC^ z6U%&#{w=Z=x3RSc0-6km>3>ody@G$inX~P~aq&g5;xiye1qci?+ca}0(tTo?4C7=k zmMs-;XwIdR7TZ_|o8Hh;rkiuUX*4YfF5D(%W3TJ!HEOv@e_yCXZHscQ5fTX{m$_v( zdM~IGR?!eiEvZ4SRa=J+$sh*dpXBSPZ6oGfg8U`3f-ME?K?+DtQ>F673s80V>A;2-nLFz3+R zOZsktF!1`JzCCCC8sKC>?cajT!c*i$C&##(8`6^ypRSN_*h$r#MNj=3`0bP52!(vA zK8j6Evu6m`v~#6buU)CjGo5ETKO`WCKgpFf{pU(4DPr;@K=7ZOvdX17i6G(Z&l-Ea zLaJP0LCDJ#gXe3e)9Q={=`t1)9Eu zpu37EMA&~^beQz$`8NuU?!_mUD&NO(irV`9Qd5$n>&x%@70;4W-8It?HlZs|2#PTk zKTeu5%g__Z=f*NqAuseMgm`(|VSS8V)Q5(g1Bo>hLjWM5eR!T|rwrQ1DzuNa1=>ej zdh{-KD`mlnsM8%?LMJ&OyZ}K&8oq~A`G|)EJb9i4kPzC;b0}?UjeQ%!n%ZE)zAVV~ z96pVFn)o#HY3q9ia6S)r_wu|LcXB5^dRzgp_ve72O2JqX@l!Hp<>7sYAgdg_I8555 zS^F_KL?}tt3w$=bgWyzMF*9$-D9D-s;@h}XD~Jeuy1Cs*l8X?OD5}c_e9Dy2=IQB1 zcL6uf(O;G+h>Rui#CE=1NL|Ej4!&gi5frnOsolh!t(zmGcrwcjRy$47bnQ&BGrTVAflqX#hJx4ifoK zt~2M2jM7{^>cEkK*klNuK^fYAX(V-Bn~1D_*sgEz`6AOfU*v~!zKFSnwpF)>VGXI| z%}{blv)Pw#v$LShTGi%e>2hO6+>%ZGV4{sdwj+CU7@$|44q@Me5TR5$Ng^nW|ETKk zzI<<4QnJ0>cU``>&u}fh4Qy^Xt4dB+iJzwTPHv-ihD1csY3}qremb-+|Ni!Z_ivN; zKaU%h&|^mPgb9)e3o4n*jxCyj${C9hN3Cz-;-tn&+!%92H!qZSC%}(<>CtDX#!^uc z=!jj%s9sdRS%&BHtgOnecU8$k=tRaZS{8Ux=bJ)49A4w_~m6}eB zx!LG^R-QSqa}olXPP`H@FHJXJ4|nXbN$kGL2Qs4+lumdRseR=;azu|EHAj@rg9_1~ zN}7hfTt>{FSMK7QEtRnr1H&j00bA7l|E}!fTeR2pe2ZR{(|?eIswHKX?YxV?Es*&n z4#Kn`LV`Du6?)u8;FCe^wm@(;jM?S|Or#iaxMTq|av)YKBQ&S?!NN&x17o7y)09t_$KD3TR4|e$HL8?k)7=TZ!f9DCO2DK778pW#f{N~tNulv z<3l9OPOnYLkBFykPXw5n#C#h`UehjiisrCctqt@H5p`v9qaK*-Z}mipqQ;T3FIKMo z-r4UWfkN0ksI3BB!yM-HAPl}SakMO6;dyM2P7XMy=9#>kdK)|T#YV`3aq8}pF>L6G zouj2XS)tMorPH6J<0ojVK6N-;j(CMSva;_QY$4iHvQ$R`*Lgi_bbfd2AxUUQ+SBnA zYq*y9%e%TcU$u7)W9{jftZ+V=Npkt#Bjm|jCwSF`n1W`fmxuhUQGy^B5Sh|MBs zE!ql5uEmYg;&pb59qf%pnIzlCl14QEEkEhU47e|LOMXAA1TWi7?#(s%xjh`zp6cOY zx9VYsgp5+ZYAgN=(ViiIYubf01k1A(KIaqP@m~9FmpI~am}sK}G@%JzCb35V5=o8N zRWyIuv6V88NR|f^-o)02KsWZgEqY*kt6MVeprY(kwAY={pPm2Eclxrf1$7tK}jQ9@HBBr}MJxX3UENL6@3nPu6X7U_%i7C8EmyuJ$LAtEd zN&_DTlSHnAyNr5Dmu2ec|C9crhlS^4`pbeiKz5ZtZ;Q>u${cZQy?>*l)tQb5GaVOj zq~neGj^mLP##iPb3tHzuLC@9pd}{V|Tn4vmU$NF<3rZ35>ue7xJZWAIpoke93!!@QG~~)jQG2a z7qa5-ujOULtp-bSBt$rA8nA6C`T2rkYou7jym4JL87ER_C@nc8u#vter;Xv87^z-u z%_Q$at#^{o;ndbn8*7H|)z(fL7f!AWQYb{np)tdR`01dmCgzW228D=SP0f0gSpuuT z_!crpYMhj+wg15>r*oLI9*wdqSnJVzL`Ja|MM+?jyq0#gF=lve*ZyJJT5YVh_R4dN zOuN?&S)Zmk>q3GrIb?2a3!2J9-U>?CXre4GS1xG`3&A-DUptp|Cr;Kbo-E7rq`>o zQOz&H<3Pwfh(xM!NI;QT!lEe2FdLo{)Q0eV<6H|`7tM1pf&_2swLJ6O1>!ITdmeKe zsY#?~?I3hEd_+{DYLVQ~w9v19dzBiiW&ZYMV;w7QjhbIEQj@{P8(Phn%B(h2lON|N z=jO@bey*XV$<0_&TF%C%qKS@hs*zmMCPyt83=k^M-Iaq>ga-?%xLT?Z6~V6(bg{}k zpKjpod5uwXA<%nl`Xn90v=Btv(t*3K2A4$aT2`XPS4Yiv*)!V6D(LADMh=2u8&B`WJIcTzD;P&FN_+L}WyFq^b+KbThfA$zL?XZJl6>lG zlW*JZftzilp2`$zKw%O|pQ3g)Y<_2@)6iOF6zQmB8CINx1sCdxn$xP;AzwoRMYY^| zIzHk#N5?W)=0Dnpk7myvy{~dVZRaPz6QDZF5C4tpj5**+IPqk)EZF>TV?nVcQViuH zM=|A!Jmd@s#cc1Zv}hu>Sn>a>>=&;Wu6?O`@$=6uwY6|%Rtqd-eV!}=G9-$h|LzCEItuu?tKhBQ%UePZeuc$}dWNMFF>r-Dc?E8TE8v!LgbcYV zgsm&CzV?c-p|uOgC8q_GSHRCbN@l=orP%p%glBuHO>_i!SEDd=;d0`{Y{ZF~P1s!@`?j;mxq{HduH=wbuPE3&3BU;k9kB@{UST0o9hr6Rqf4 ziIqK7YA#^s4-aDJSq6Sz)14J$72$#w#b+D1vPRy^29FDQ_6X5;sKty zmF@^V5|D{N_8w7#Q3AW*%tmtNUh|HPvapzm{gmg(ho5a}Z2<1=Vj)AKcXg4HbEBWi z2-@3AC=t%(CFf@1X9*m^oc5c$q%6^Ov2z4r4WwA1(BeO+g-EUJVspD&)flW!Xp~= z!>>pKcYG{hAReuiQznpv_2lpDeSL{;-yj!iJ0*^7{@s0ruqV7NN&gc_W)32IAx_rQ zL&>I5WG?m+pE8S#g*U+sZfeuaX(-auz~>}l8croKuZB3r00%*DjjVnR%IhUaGMKy-` zN1=>tVi#rlDKh)4dPfWcs1Yi4^jlFI6kbkOVCT~#<^iMo&t;M1!-_=+!^ie%Th-49rKUMUDM16(SgS7MdN_1a_O?<*A4Oq1c@y z+Vw)#Mm8HGX9EY4il-lPt8R3IDOb!&o&LQ zR*yI|;KI$sGSn84G|@>COmxLh3vr?~hNDU=!09zwlDFfo#EC;hdrxcxYut#f7g`j6 zgca@QTbkhD7?6#oi*+2lG7aZoVz7-jED$0kHPZo42Qn$D;Q`hm!8)!WPsZQqHe9c( z<@`O}H4rhExudRhB0VI2a~9$)YRv?*X!G?If}<`{Y1pHbDN zyTnr=8A-Q@fjg6vl+21m#1b5j$x7gjq<}Ov8#343>2)>CLbkpPfXbO{w26Gi#Z=^q zdY{!CbUFl_RzbZ2DPopwQ87aT5_i1?&FIumKs@6YbVsVX0m-ZL| z21wNcQev}TPdu!U&QRM}_jL9m?~47|uL6-JXRM+m3EE{DaYS7QbMc96`H7}(JfsbT z9YbO_8QAclfr}4D%}Xk?TG!cGgXn%4mz*B-tr@b;#^<7SiFoNlykw%sISYMK8wD9b zQKytmJttq<8kBCoc|J49)45Do3Df3Wrj2qijFALqGF|$|$P&A+L6&eX_Q(a~pC0Y| zmMnLxHpx6LSOru-7yKWOb~Z`;s&}?1NXlP7D=Mza1LTOq<5(Qx8ftaO&2SvSQZy} zW^WC_vN}M6VSdImZ-72!x;L|9!Xa7aoA|Eyo17YOIe#OSF<}ql<=5z-N#yUl*mIbU zWI4d{HnU=&Y=TqHDF|b9tDF!`p{&T7$WnaC5lLpx#I*I#NM%!~rkO=F=#!iHxO&p- z8fiZ1f5zWP6w_@bO8IjQNpVaj8w;lY`yDn#qZI_tVAxk}5|YnN zi`>CL8I3^n0qW14ACa3X?AcP905*DO#v39Yx2!uvd|OO?bW)5i7h#)N2Yl99D}>Q} zJz_4dFj7}Q+B>Xew+T>_+!_afFO!CRa=acHr*CGoaH>&E6revPD3%(rn89IGN3G4B zi9Lj6$WJs})Vz*;%zyH9L=m*2cvjl!mb&rZ(!cggDzOg{sZL`%t$UW2!11@0c{s+( zX`UQ2w`8r%pq*ClttG`b4Jxk6T~=D{eS^w56(q3}4f6%5`NqYSrH&+P`g3aY2($svc0CRA^eZM7E{g z=1;e(MqexKe(j)I1Y0XIjhf(Kaic4#aQuQhM*6v+wpFh0Q`gLi0a|D(&bw z1#f0&^y?k=V0=iEgJ|~sTZ=m;6Qo9}zMiV>335?f(D=+MOI^c{!KZpx9}V)VWt)3CyXJR`NxZ5USo={T19^$nXAPT-+khfwQ|5 z`)3WRdl2_|m;MaG!aGX`VWD4<-FHgs-Y}@7bo1X5HYoR$R(#i>;yIQuTve@T{re>G zm7W|f#nR=2UYFJ`UTwGLFKzAILB$n<9w@E$Q$){WtUiS-;RfLvpSSWbI~yH~SK9VK z0l%iSoqs84N6{jAWJP(h%o!3)Wxd!^G7{e&^a=>GUs2K zOI!YOK{bW*=PuZQ{Zg%Z=`vl`1GOmcwEnV0&@!1rc83w}TZB`tqlDnjdcHS& zzmiPD&)9-#ScLnEu=&0O1o*`g6RMf%MTp!GLFDw~&A4Br?(|(EQ6f)%9seN_R+P1G zi<}!W<9}^m=0(b>_dQN^1QyJ<&`Kc%D>mTx4303)<);<7v3~Ogg_Q`r`x}F}* zo=!*4q%z_U9%JV1uzoQ{1k24GB(V!&c8Q3>x#Ihh&4K{1ka(&&3`+O4v&(zEz)P_$ zB6XtkU=@=;4UEkiY?nInplyn3@N(=98~v&su|VblR&g<2s8S=--vT3OOcCc-omvGE z5GO>(#~s@EVf}3N6>=E=Rc(A(W#UrDa-V3|K};49IR$Z7Mt^8&99G{y)S7Zog%AlW zC^@5*_ze4`j>{#;Of2H6K6-r`1iKEhdRJ`Xbsng9)h40Eob)@-cIxD;;j*8TxSwi~ zOKJWU73wV3oCe*z)hqhY98wpmZ44Z%A?jQm`HI-qS~l@O);|ztRxLiH;+`(ACVX;F zjCc`Ou%;=efH3%*)9Yl+sUiNHmVo1U?)ZzK*<94vQ;!=@REQV3p*Bkt#S@tIbI{4r z!7bajsGNUxx&yQ?HWJo1dTtlJLNbecwDctS%}}KaIj0eDP~R9$wULeN-Bv>C>*qwO zup^GJ#Dg*|<4v)ifyl@UtIW!0E*7A0I_$7kzbq^(pr@wclDJVe+oWV`P@zjgajKUX z04(L`;rBvx{blqA6A_xch9 zW&LCfyks}bDKZObeH|e>jc}7+GxZ{=3my}DUexstE;%3Ce!HBPXt+L6E-)2u!1%!D zGfZ3DdhB`<$8Rv~{BLv;=J$6iLz?s9$}+A)uv0zkypQ9Q1Y}IJQRf|%75or#o?|%g zuJrQ5K#TLK5;3u45>NjghJ|he6;W=><7)Me3M|BFwj=vkZp-5u^)}l<$Ur9fBQtNy zZF#J#$F@R>d5qJ1vnAw7*tx=?Id3crJFjs^olz2A%tBRW|94!HmJ&me4ErPrOl@2a zybW{UEgy43G%!m}ybagzyM|h$wPD%2#vg(aLe9&aH<&QJ6Y!kf0C1-7|g=#zJek72#yRaYV@pLs;pb$H_EMC z_k2@Ut~+e+6TILbPn6&HDUZkJx(n?6ZNm8muj3k%(xvnO#pGD(VFU*y&XpL?xB_LxdJy;535sN^uQM%BCBMqAn-W_O7 zOD%EBelZL>#nyN`l8u;Mj`aDu&G1f!RX$z=)e|2H$ts>(?(v8%OEFyRl#K2`oTidp+MB0sU z>$5`R)&n#x+)xADnn-HYr~Kx|R*7o2H?W?XgW6zEq;P4mX~CObA{7ejld@eYBiCV= zlx_qpV(>PLjcb%JCRLv~GboJc^eP!Vxn@TvZGb-8C5p*M`9sw{jxS4%$z?24t-+_= z0#0%frp0FP!c z2v3u=UkPHfaUv+Gr})fJVIY`xisQ3o`<;(;qAGH?eARMACme}F*zQ0qUKGDW1~UXP zKpAsLH*aS7*cY2lXMMnj_4BxauKxgmufsyD7&2J35rX0Gd4-c~@a#}kjKGw8?M9|6 z1b)sjB`>l?fqKi!mkG?n2!E8F)N=%#h@aDOKZ2BAK}xkSZ}ca;6Uy$Ta5RtoE3)fK z)>LvoVL)Qvp~^U{(oUI%j&#R%*`T0}_pb5_>h!6p3${ykhjUeah>@~`+AMosubqP_ zNF}G(00SVo15UH8OK_n{MVXfpeeQmj5+=wm)#h)-=2u1*lXrz(G$Vt^Y9ujthKt>R;!rnq z-`>wmCLt>QzvunDe8}wQ+0VYNz4qE`uf6tK4M-~w$GnyE&^gB^zExVTWeiTXF0+3@ zH!OK?=~{+Vcej0|w}L$5au`wS5Q<&qBuRW=j0LBQko@qBE=q492>bj(Z%GO1%T2*$ zjDXRKqigAE>B1fFdfze?xRq};%J2KMr3LuB#h~hw&NsWzgbErZ&$paapH$;m`04-@ zdDPZ{3jm%MDNlD*wwJm@IIE807p~5DU#+~ol=BrL3rwV0|5)wxLTAMYh&gSEWezss zg#Z();1rj>wDLWcxX;L0Q^#MawUD#9q;0Ki2dV|=E(xhvX==?8I3=^%SPdo}-od2u zbpk?Il?MKh%nDr*Df49sX%0)>^>rOxp2>{vYMR_5b%wlj1YQ`cOx~Gg@nk(r+5SfC z9xMvV#%%th681*%KPLA@saYs=sHWtilGMA`(J6>6c4l`D{2vs>L?n3GKJZOmbec0v z;T(G+pB^$zy3eXl_$nNdTL-9Ldf_R)vj7UCF}nqJW}khYxJsgCO&!qR_uVcJSv9RU zl(J)a7rb&|h`oX4!`p7)mi{z~Xxm&9zEG}|Awz5xz$u{viyfqaLzN8NBi!oMTK6nX za2~q1w3SfouJu@x)n~-r;3Dsg{zyf0sq9S&pir4xYXyPO<*TdaEGuh5t@66EX!0xw z%>1Ak9mArtHJgyyeythRpqu}yv4q5APZ=lQ%s6bmsyzOKsU?gS{^}k=!Tv1FsB~e< z$GIDO4|1TjE8IChkg9H`D6Je;*zByl7}P{SEtg_zXnn@avJM2qfs5H?dc;E<^k-KR zgxTGxhmh0g48aY1*vs70d~}s;MWc)SghXAP?^Et3^b0XJ-_S3zRL$m4n58Q-K5%p7 z_4dBMXsb+VT(Hz%Ue0#WHx7NsqA`4$CGKU-%8~IwRcm^(J=K8S0?3nD@ye;!`aE5dCe&jUcZ#tuqC2 z+KspAj zRdX83oDS{z<)d`VfQl%st3eW>TV3(*Sq4{cmaZ~rd;ccEz*0GP#jb+lDek6>mregAiayU8G;gS`Mx8BE56w;cfVv`kv2S#me|@XH~mRja-(~MiCy;`G$wd>L{T+j!c zz@i`~CtUQ$`v?PqC-B9~Q$?(DNvqRwj9ECuKDf>;y;7)Wq=rC1;0V)G9-XkbJeSE;}8g`MS+K;`LJc{dU~BYoA_F@0>{6Qx6ns z{K23^WUbbE2nII}cwh$_>2ebnuA`$HU^~{ZtgKDFU903qW}(R?%o=!*S2Yoh#E&u!lVhQV1(x#k+))7gdw^A!11#hZ2LZ3cfN}FvKp`+7 zFLr+i*a8EaMLiHx)N(JTFXk~5lV3tn=6S6Xd-uAto{{sswk{^EfK$%?HCZq_TDjTU z{Ep3f0gJ1F2CPp>D{F2#mRyiRWH_lh-EBtF%NQt zvzD$B>?GAT?9hGfjV2M)9kRfL0QbJKg}vU*TWVl7w$!SPWmw!~TEc`Z@=n@KXs}tN zXEp{b=mXTooFdEL-?_{JHMySKUVS1ycK#&KI6^(@__UAqEmBG^i&nnp+|#x67&&;( zYbxe4O{1COv*fd2G85adwNCrDfkSN8u4vnPfriVmQAwY}^f{W-=X2HP$42^muI+QT z>9dRs<@6b<#+?3;j-RWJFJ)rsYN;Xm`R^HeXVG0G)MDx(a2Ozazd`2&HX{>DK=B%8 zZ*{rQJDd)IkSa+NB11I|4c7dKC9YvMELqR2*pPbp!VDQzjRQY^PelJrU=6ObayWsd zLDWZ>5an8#G$Gy~UwKO0ljawRASbqL8jf?LmU2_QAt3%78ME+yBni1{)U3b*Vun9B zi233B&pl{*Vt@b-+UzcQhC=O1B!PMfYDe1vs zF<)3Gwa&Hg9L7_oF8zm6iwxD;o;nZ2bjrAO3R*j550>^B^!`<8zX?$+G~xZFLngeh zbeK?FZaK>jo$`|FHNz34y}Flh#b$AVR+et`YZn$S2``Bzulk-Yekvt%Pd>_DrcE64 zNZ1v*)iD2`;fw|Qs43^63$H-Gsvq_bw(o0wuztPpeO;?F(-z4T&K@c_d#gv|^42n( zgBCJPmpL8Mv=Q{fJ@d7V$)k?Fe8Cjpk|~KLPU>HmsR4iYSZExW3O$U)UcgNlpQ52~ zim=wlT^_E&(uxJHX0R_nKUHoy$wB%a+4$A-1amL3(JBQX8Nse z)vOfRY3MbXhKdVAYxlI&fRVYwIfDcBg>GW9B>B@MmcvGiJNvOg*M@Fle#PJ!sfS4} zj<*;21fq}gUEx|lAGzzT4RhWg@_R%|2_y{)TvLvlIE&}yPjTY*y!x2iKfE*q8gPm9 z^G*xf7AfzfR$QV^t!gDMp1+4YPtAU8F54-14z`EU6X(M@(Ag*!zS&D%TFSQfZ9$`B zm_-97W*G;2*F`J0I&C{CA_I-stRV}C?1+)4sXXePQkr_64VURyIWiSgO$$l|B&=Op zPz;_aK=@#Iz^1iR&P7ISrX0OIC@}mLFuZ;s81@I2ekwWw1|65CZmi9M0ew^Q{8ccB zd#eO2yMMg1l}Bp|R-4DvG9z$`UlC1jd6+LSx7S=3tGwn`XXVGujvaEX&3daop~<9z zG~0~yf_S^Pv@#kdn`Tt_LjNL%_SX#d&7~#AtT3o~0qfe3ByC6qko)9uA{1yuM)c)E zVw&H;d65x}e_nJQk~}+gLsJIIECJwKzJTobK!zrfY;YlvwvT|j7ObnXnX=%v6b^9L zf_3#-tgEwFM_{n7o&gH$cGfuJtYzcq&bg>|X=!$UqYFUOb|V(G zyM8x+SpIq{FRE>LDOL&Jaq_bRGiX1^3bk2Yjz`r$0PwhX8D%{uJw#C2_((VU$8m2t zD{`7t_mK)=fJz^7J=8oA)lIRda~*a>=hsF~e$2m5C^1ldEP3h~oA;%WqLpFyL4sZ+ zjdP|V`JNiC+>HS^XVLbsvuJnQyOWlkuNPN;eV5GJqZspny|?Q)#>7g z5L;Ct0AUixyhsJBQ(5WVL5?JxT1hPaEAw*x3Zodq{ zR{|m4+#pv)xI*HVL^^AOm|idCib+`>_SegKsc6MD0?(W;Rc$4#CVPkwZZP8dDw~L> zC39&J#u;4JEqu+8D73Q;LmU@f$cbYu7rOC+ElPd4e2$FlNl3ZD)J!q=rwcZlMz#Fy!xX~(0^-lZStUqkG z$`BVc2$LHj4@q zWm`i9Xk(&B5KUGygjbSvBY`eUY>A3H!r@^!5e-F?cWC*JW7#jtkr{s+8(!(!tcfdY zNdE*8wcPovmPl7+)p1X>9%>5XlbQ!lBdQV{xSw`-x1iShmHix<(1l+Rk?F#bnJ&Ox zPE9UusY))KFuDWSl%NBAW&)na8g~1;Wo-82$#BqihJ#F8Zj``hU`h<-X>|nQ5`^=r zAbw}d2+OeuRFU9>iX*2?S_b#3+8AkLiFwsL*KM5#CzGI!2)acd!W#edmSu% zTmWH<%>B{L(d4uhoCL^B@>R8nJ0Ph#JC~FqmRycg%wgxYJ_>M?r=WrUn%lO&5Q~;L zwb;**>t4AXx7x7K_IYHl<|Hknf_{8P1-%5_bKg#e(Lk5F0G1I4xmnwnE*?0+Tq`j# zlV&rAx5O)lCIemD72ufs(jH|`3GENXugLu z%UvyAwBp{N|V(a+ZS7mnO#;F!_sJva|d+|yS& zp>u*aQEF11VIGXRl+N%(J>@G7Y?=!S(`0WhD9Qe~?Z#jpLhnvS%fqx|a{BVWF_In9 zkD!~&f=*z9Q#9ELL}7y$AuI|9ouV^?=GGUSZEd>vGMeiqey;67&#Ddl=Am&xL>Eu2 zLb1fpdwC)dsuJubs7n02pTJFiw~QGOPF@STpl!Ad?C0)Kp(~a4SKZ{Dx~rBtDa!aJ ze!c-cDRG<3x>a2~Q${aA&nhWUv9KZHyt7Y_#ce9a+Zw94PRH*U$zHXac#7z^LCOY0 z1Qaq%fN0YxnqNKpvG4}@N1>z?%}f1ZSbR39CR&@kGf2l$y~L?y5D0zJHYoL=pH48~ zTOMjYskOwZxn-IJ9M1xh`PDXp3kfhqHM)5K&hAVtG{xVeDqZhR^(}pm%5anSsLE_y zA#p09MAR*i8KcCV1~O=2q5E|X7boW2Svn~%Z|VHZ{@2^3Oe};2eMXQ_>aFUh0OyCj z3G?9M{aKW~LPN_YyWIo%gPhBoX2p`%9~W)=OTYL_I0%?{K_k14z&@--Y?#AA)TfJ^j@9t( zcD+?00P_o~%){)u>&$0)F|xTzT%m(DoJn5AHn|a#onTpGkk~SV2bh;j%&VyCY&-+$ ze~7S3>P6||tBy8!QB|?b$BTK@Pbb37 zz0u9(qT?2WZM`7eNWl|giR%I7^)&DLk_8FOsv)>eZ>jvT0prStjY!R$p+i8i-7cb4 zr`euWG1xT1K^XnCpiX+)x~o%%EfGfGcM~JtC`&y>pGK0JrxE(rdV@O5A%oAg~pBvuHe_&fmrimt(N%RSm%g{BO>(e&Z8j~w- zbFDSG^7CW{Y$0rG@yAWBBkk99d^KFz^`I}C0--&}&uw{%*9oNmUTEJnna%freK#wo z(wErxVCH+!z8j*V?`8I#?VZhEZr>|1?-lkvlz9)?cQ^Cy+V|?rd$oOM3Ag3d*!SAZ zd#!!1%e>dw_xj9xy?t-VytkNlBS6SRwc4moO>4iFP8+p4Cu+5gT9XsC#zw8piCSx; z*5yR4Gf~;alNk}hJQ-3cQ#$AS{Yvb;nK=o^T}OarEfnCoksG``?A-F0Q^bXKPNJ+H zP!(r|@E+)1g!gPLXgXp~`@2#|o`|`wwin+wU!j49V?_4W%zDmJx(mg$p`}NXVSl4ORTPt4 zpH4H*w^l*CYr}iGCN@nmcismP3)=RE@t}haPz}3ZWv*7g$ohA5A>5s!?N5eV`%Q1E zI;ohxM7*BVKhiYzHxs2CVWBL!i=eI!tykzlBBp`X6JfYHV=`b~yO>;44&n7!FW zk))3psY+l#iR+6-r+q*Qhc$u`@pWQCYt8ikRcRfe>TMy!F{ip$E4h!vCivbB5#%*3 zfDH*dMf29^XPxEB8S^btVT~piuaP<5^pR@#)~NI2&2GNc%yH3@=_UWtB5O-vkitv_ zgN|TM({vk>A1V6Ovs8=Sk!37%;$;;;s}i?c859`VN{SwPIq|56@2zx-?4?BYSre@y zGNI{2ZI%(rSs&qS9ns7vcERGcByf}d%|<%eA{p>|-g^@8T^;qFL;CQm(rOyW!~I6L zhw~!%@sJ?Kk}Y{o=hdJNNLFv~hhbH}m%$29UX5;Co~jPY2;wFgK^)V^hV@n6Fr1kz zW_F0Xbdv?c*ym|o&Z8sEgs-sP(tI@KU^%Zi!no1!?%$^++6a37l|G2i&+t!jE`v5Y z2*yhKq&S1mvfItEN0%)491|Xk|J_!Jw$H_9i&3X#i653Zn?KlF7mud8Tv}n3ej=<# zGltz+(j~`=?*exITT`c@fr0FSJt#^`1+tQl!Rc2f7!jh=!3`3l`D5>9+;=!;fYB2G z=Y)%r&7a**2-=kkLMt}&mZSKNc8=r(h5Dwsh)SA4Exd&a`n6SXBGuAomOaR0_B#*Z znFK#%PTRZOG?=|-ko|FE*&tv*iNfPveWvA&^Tg2p><$3SZM9D_QmUTo8r8{KZV$Zx!OlUeo zdXCu=*?#xZ3bSaQpxs;UwdX$en_(DAV8lkQ5V@WNmO9qPcWAsewf_ylkP9Kj0CQ1} znadriS6=}y*+bS0{3i^Wp#}Oe{M1xu2xS&X(su;`m@zwc!`a&2 zmdDs%%MTu=wszo;TmawB#c_K_RnY9^%^;OxQW9ZV{UZQQclpxn@&?E9c*e2_4Yfm>q!LKN5 zDDX?cn!T8K6R*2;@);AGnXs$!c*QamyQkgA-e*SVTwF+aW&jD%#f5K593Q;gxutJ3 z%cIrFa6Ib@nx@f;<|%Fc?<>-~N1On#7W#0~8~3n=Eae&2eRH@VR5lEPq1~x(tmCAt ziAyucmkVRBP5P(P8Uu~X*QqEvLC#7OBEWv}O9jQiDE6VUOyy#h7;W4D= zl%6riZFm?nFBRKQtnJTF-Vrb3v`?d%&I9kzc<+f!x73YYr`c|({n_(pzdy0DU2!tQ zgRPAJANum=w+&xbHC{ia+J3a_{*GZPgtJ`&1M_^hLd!F;T{UW-*w_2x2)&fRdod6a zMt~bKS8mkdMM#;~Ll#}UH<5dL?_RzdsqG$w(deWh|I}!--h_M6a*QBVG=18~xP`{a z=yi_lzf^8(n&ov5IX_uk;%!4ph5OOw!NJAeod!4Ol~iI!j;{+#nhGkro8QT-V~4Yj zHGjsa$77Eanmib^OBvD_d1vtEvEfISVbr`HPfdnxHBpNT-M!D~14w90H0`v+WL0)` zI$e?`2&KvkusA)cea!(26AMy~J&x<9v(O_yLo6JiO{psewJhy%I$krf0nH~Q+bjao z05x(=HvIOSOkf;!AIjQkK+WEWu~zEBkyEr%H;M>!S%^TFf(SwcZjXu7?Bh|_f%J%- zomk@2vBcMrTYMe4#n(&tE90-6zYu>eu84v*)7%P$PSIR6`{vg2S5MKcj2wZMJW|%% zlq)-VwTV}*wF$ILkgm%HnzX$26VRA00zad$%+EN)BWW~g2?90<+Q4u+Jtor6SjGoG zW5}ivze&bg8`RsNm4F%*>1Pyg?q^(W)2y|@dK+}vppSrziu5z~`j6^|O*3Qz2?y0; z8w3f+s7ODf{4n@6O3i|#AsbZNpw1SN$Ka#P_rs=amzYT_L zkf+@o^N}|{TS?!gVi=zOF%|N`We^w zk7QhL({$OO&j$TA7$P8}BK?dh|B;M&>^%trHVE3F+y)^6GAh!~Sm8gCquQpawL!fN zT5YhJfQ*XtGj{rqWL#_0thYgz4f<@*Pe4XR`Wbiok7OLOY4Tvr)nXe2ZBR}?Mn(D= z%lt=@hHRQ@8`RpM-Uh7%WK^V|vBiHR<7%5`tqs=Opvwk*1Y}gCpHY079?95m(+t@l zj}59?Yy)j|$*4#_qc*U9#&Vk`WP@rO)Y_n)fQ*XtGfFJ&XKb};R@-2$4c6PBi-3%Z z^fPYoA8A#eP1A3KAsggPw=E_hqayu`g~a$Z25p*h8-#37ZG&0@GAh!~SmQrZW4%q& zYJ=4_SZjmz1Y}gCpK+c4NX9Okrq2fbHW;!&-eD%ABK?fR{-YqzM}nXY%54y`K{Ww2 zD$>vB`j6zOwQ1^Y&}xI#HdsqQMn(D=*Z7ZQTyN8K*`Ut`{WcgPAfqDvj4A&y?EP`h zw}UK}OOL&LwYSMgIBwsnl_mAuZ%MnU@;mz4@FzEUoA57+U!Y?%(!QV-R!Z8JNOOJ} z^Bzi>G_Oj_@|e}GcZbl@6gq7nm83vpbLF*$KP#sdw#_GJ#M@Uj=YLd@bK7ijc*nKE znG(JCOz*xu+8 zM3YFbx$V&!Md=`x&&G9L;R0`3AGWFs)2qbYr&r04fIHzH@%WsyipQ5?fxYCB)i8>5w|=s5F2=+=aSdY@CR3;iLqaYEecm=I2fNqV+T zdbW~=Ny^`xvz3k?q%YAl1_qvRR-VI9jDT#$epS{}RrwnOvX#GQXXBZcvpqVh%IiX{ zV%GqhVAG5IZZ5p+HP^w>tyxt@OTASxkuWB4iTX4qv34~8vue)27##UhEO{38N5gNE z)lns>Xg)4j-Mw$fqM}rgO87d=*O{4CM5V=%TPlgvttdyX-fb!s$EXcI#3EwVoIA|% z`d8c)Jpl+W_&9&0A~#HTl@#Hx{#c5ey;C*Xnh30#5T3!qT zu=!n_pSYFVqKJ=3+ppso#aT55<=Q|l;|qCSFD|8{i3O>u%0D)A8u`RYLUECj(`e+t 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 literal 0 HcmV?d00001 diff --git a/docs/html/allocation_annotation.html b/docs/html/allocation_annotation.html index 6951c23..bfca504 100644 --- a/docs/html/allocation_annotation.html +++ b/docs/html/allocation_annotation.html @@ -79,16 +79,16 @@ Allocation user data

VkBuffer buffer;
VmaAllocation allocation;
-
vmaCreateBuffer(allocator, &bufferInfo, &allocCreateInfo, &buffer, &allocation, nullptr);
+
vmaCreateBuffer(allocator, &bufferInfo, &allocCreateInfo, &buffer, &allocation, nullptr);

The pointer may be later retrieved as VmaAllocationInfo::pUserData:

VmaAllocationInfo allocInfo;
-
vmaGetAllocationInfo(allocator, allocation, &allocInfo);
+
vmaGetAllocationInfo(allocator, allocation, &allocInfo);
MyBufferMetadata* pMetadata = (MyBufferMetadata*)allocInfo.pUserData;
-

It can also be changed using function vmaSetAllocationUserData().

-

Values of (non-zero) allocations' pUserData are printed in JSON report created by vmaBuildStatsString(), in hexadecimal form.

+

It can also be changed using function vmaSetAllocationUserData().

+

Values of (non-zero) allocations' pUserData are printed in JSON report created by vmaBuildStatsString(), in hexadecimal form.

Allocation names

-

There is alternative mode available where pUserData pointer is used to point to a null-terminated string, giving a name to the allocation. To use this mode, set VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT flag in VmaAllocationCreateInfo::flags. Then pUserData passed as VmaAllocationCreateInfo::pUserData or argument to vmaSetAllocationUserData() must be either null or pointer to a null-terminated string. The library creates internal copy of the string, so the pointer you pass doesn't need to be valid for whole lifetime of the allocation. You can free it after the call.

+

There is alternative mode available where pUserData pointer is used to point to a null-terminated string, giving a name to the allocation. To use this mode, set VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT flag in VmaAllocationCreateInfo::flags. Then pUserData passed as VmaAllocationCreateInfo::pUserData or argument to vmaSetAllocationUserData() must be either null or pointer to a null-terminated string. The library creates internal copy of the string, so the pointer you pass doesn't need to be valid for whole lifetime of the allocation. You can free it after the call.

VkImageCreateInfo imageInfo = { VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
// Fill imageInfo...
@@ -102,27 +102,27 @@ Allocation names
VkImage image;
VmaAllocation allocation;
-
vmaCreateImage(allocator, &imageInfo, &allocCreateInfo, &image, &allocation, nullptr);
+
vmaCreateImage(allocator, &imageInfo, &allocCreateInfo, &image, &allocation, nullptr);

The value of pUserData pointer of the allocation will be different than the one you passed when setting allocation's name - pointing to a buffer managed internally that holds copy of the string.

VmaAllocationInfo allocInfo;
-
vmaGetAllocationInfo(allocator, allocation, &allocInfo);
+
vmaGetAllocationInfo(allocator, allocation, &allocInfo);
const char* imageName = (const char*)allocInfo.pUserData;
printf("Image name: %s\n", imageName);
-

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

+

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

-
VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT
Definition: vk_mem_alloc.h:2339
-
vmaCreateImage
VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateImage(VmaAllocator allocator, const VkImageCreateInfo *pImageCreateInfo, const VmaAllocationCreateInfo *pAllocationCreateInfo, VkImage *pImage, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
Function similar to vmaCreateBuffer().
-
VmaAllocationCreateInfo::pUserData
void * pUserData
Custom general-purpose pointer that will be stored in VmaAllocation, can be read as VmaAllocationInfo...
Definition: vk_mem_alloc.h:2433
-
vmaCreateBuffer
VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateBuffer(VmaAllocator allocator, const VkBufferCreateInfo *pBufferCreateInfo, const VmaAllocationCreateInfo *pAllocationCreateInfo, VkBuffer *pBuffer, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
+
VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT
Definition: vk_mem_alloc.h:2342
+
VmaAllocationCreateInfo::pUserData
void * pUserData
Custom general-purpose pointer that will be stored in VmaAllocation, can be read as VmaAllocationInfo...
Definition: vk_mem_alloc.h:2436
+
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:2251
-
VmaAllocationCreateInfo::usage
VmaMemoryUsage usage
Intended usage of memory.
Definition: vk_mem_alloc.h:2402
-
VmaAllocationInfo::pUserData
void * pUserData
Custom general-purpose pointer that was passed as VmaAllocationCreateInfo::pUserData or set using vma...
Definition: vk_mem_alloc.h:2748
-
VmaAllocationCreateInfo::flags
VmaAllocationCreateFlags flags
Use VmaAllocationCreateFlagBits enum.
Definition: vk_mem_alloc.h:2396
-
VmaAllocationCreateInfo
Definition: vk_mem_alloc.h:2393
-
VmaAllocationInfo
Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().
Definition: vk_mem_alloc.h:2710
-
vmaGetAllocationInfo
VMA_CALL_PRE void VMA_CALL_POST vmaGetAllocationInfo(VmaAllocator allocator, VmaAllocation allocation, VmaAllocationInfo *pAllocationInfo)
Returns current information about specified allocation and atomically marks it as used in current fra...
+
VMA_MEMORY_USAGE_GPU_ONLY
Definition: vk_mem_alloc.h:2254
+
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:2405
+
VmaAllocationInfo::pUserData
void * pUserData
Custom general-purpose pointer that was passed as VmaAllocationCreateInfo::pUserData or set using vma...
Definition: vk_mem_alloc.h:2772
+
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:2399
+
VmaAllocationCreateInfo
Definition: vk_mem_alloc.h:2396
+
VmaAllocationInfo
Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().
Definition: vk_mem_alloc.h:2734
Generated by   diff --git a/docs/html/annotated.html b/docs/html/annotated.html index 1a81e3a..453ca9e 100644 --- a/docs/html/annotated.html +++ b/docs/html/annotated.html @@ -69,14 +69,14 @@ $(function() { - + - + - + diff --git a/docs/html/choosing_memory_type.html b/docs/html/choosing_memory_type.html index 181538b..fca2628 100644 --- a/docs/html/choosing_memory_type.html +++ b/docs/html/choosing_memory_type.html @@ -67,10 +67,10 @@ $(function() {

Physical devices in Vulkan support various combinations of memory heaps and types. Help with choosing correct and optimal memory type for your specific resource is one of the key features of this library. You can use it by filling appropriate members of VmaAllocationCreateInfo structure, as described below. You can also combine multiple methods.

    -
  1. If you just want to find memory type index that meets your requirements, you can use function: vmaFindMemoryTypeIndex(), vmaFindMemoryTypeIndexForBufferInfo(), vmaFindMemoryTypeIndexForImageInfo().
    2. -
  2. If you want to allocate a region of device memory without association with any specific image or buffer, you can use function vmaAllocateMemory(). Usage of this function is not recommended and usually not needed. vmaAllocateMemoryPages() function is also provided for creating multiple allocations at once, which may be useful for sparse binding.
    3. -
  3. If you already have a buffer or an image created, you want to allocate memory for it and then you will bind it yourself, you can use function vmaAllocateMemoryForBuffer(), vmaAllocateMemoryForImage(). For binding you should use functions: vmaBindBufferMemory(), vmaBindImageMemory() or their extended versions: vmaBindBufferMemory2(), vmaBindImageMemory2().
    4. -
  4. If you want to create a buffer or an image, allocate memory for it and bind them together, all in one call, you can use function vmaCreateBuffer(), vmaCreateImage(). This is the easiest and recommended way to use this library.
    5. +
  5. If you just want to find memory type index that meets your requirements, you can use function: vmaFindMemoryTypeIndex(), vmaFindMemoryTypeIndexForBufferInfo(), vmaFindMemoryTypeIndexForImageInfo().
    6. +
  6. If you want to allocate a region of device memory without association with any specific image or buffer, you can use function vmaAllocateMemory(). Usage of this function is not recommended and usually not needed. vmaAllocateMemoryPages() function is also provided for creating multiple allocations at once, which may be useful for sparse binding.
    7. +
  7. If you already have a buffer or an image created, you want to allocate memory for it and then you will bind it yourself, you can use function vmaAllocateMemoryForBuffer(), vmaAllocateMemoryForImage(). For binding you should use functions: vmaBindBufferMemory(), vmaBindImageMemory() or their extended versions: vmaBindBufferMemory2(), vmaBindImageMemory2().
    8. +
  8. If you want to create a buffer or an image, allocate memory for it and bind them together, all in one call, you can use function vmaCreateBuffer(), vmaCreateImage(). This is the easiest and recommended way to use this library.

When using 3. or 4., the library internally queries Vulkan for memory types supported for that buffer or image (function vkGetBufferMemoryRequirements()) and uses only one of these types.

If no memory type can be found that meets all the requirements, these functions return VK_ERROR_FEATURE_NOT_PRESENT.

@@ -88,7 +88,7 @@ Usage
VkBuffer buffer;
VmaAllocation allocation;
-
vmaCreateBuffer(allocator, &bufferInfo, &allocInfo, &buffer, &allocation, nullptr);
+
vmaCreateBuffer(allocator, &bufferInfo, &allocInfo, &buffer, &allocation, nullptr);

Required and preferred flags

You can specify more detailed requirements by filling members VmaAllocationCreateInfo::requiredFlags and VmaAllocationCreateInfo::preferredFlags with a combination of bits from enum VkMemoryPropertyFlags. For example, if you want to create a buffer that will be persistently mapped on host (so it must be HOST_VISIBLE) and preferably will also be HOST_COHERENT and HOST_CACHED, use following code:

@@ -99,7 +99,7 @@ Required and preferred flags
VkBuffer buffer;
VmaAllocation allocation;
-
vmaCreateBuffer(allocator, &bufferInfo, &allocInfo, &buffer, &allocation, nullptr);
+
vmaCreateBuffer(allocator, &bufferInfo, &allocInfo, &buffer, &allocation, nullptr);

A memory type is chosen that has all the required flags and as many preferred flags set as possible.

If you use VmaAllocationCreateInfo::usage, it is just internally converted to a set of required and preferred flags.

@@ -113,7 +113,7 @@ Explicit memory types

VkBuffer buffer;
VmaAllocation allocation;
-
vmaCreateBuffer(allocator, &bufferInfo, &allocInfo, &buffer, &allocation, nullptr);
+
vmaCreateBuffer(allocator, &bufferInfo, &allocInfo, &buffer, &allocation, nullptr);

Custom memory pools

If you allocate from custom memory pool, all the ways of specifying memory requirements described above are not applicable and the aforementioned members of VmaAllocationCreateInfo structure are ignored. Memory type is selected explicitly when creating the pool and then used to make all the allocations from that pool. For further details, see Custom memory pools.

@@ -127,16 +127,16 @@ Dedicated allocations -
vmaCreateBuffer
VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateBuffer(VmaAllocator allocator, const VkBufferCreateInfo *pBufferCreateInfo, const VmaAllocationCreateInfo *pAllocationCreateInfo, VkBuffer *pBuffer, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
VmaAllocation
Represents single memory allocation.
-
VMA_MEMORY_USAGE_GPU_ONLY
Definition: vk_mem_alloc.h:2251
-
VmaAllocationCreateInfo::requiredFlags
VkMemoryPropertyFlags requiredFlags
Flags that must be set in a Memory Type chosen for an allocation.
Definition: vk_mem_alloc.h:2407
-
VmaAllocationCreateInfo::usage
VmaMemoryUsage usage
Intended usage of memory.
Definition: vk_mem_alloc.h:2402
-
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:2313
-
VmaAllocationCreateInfo::flags
VmaAllocationCreateFlags flags
Use VmaAllocationCreateFlagBits enum.
Definition: vk_mem_alloc.h:2396
-
VmaAllocationCreateInfo
Definition: vk_mem_alloc.h:2393
-
VmaAllocationCreateInfo::preferredFlags
VkMemoryPropertyFlags preferredFlags
Flags that preferably should be set in a memory type chosen for an allocation.
Definition: vk_mem_alloc.h:2412
-
VmaAllocationCreateInfo::memoryTypeBits
uint32_t memoryTypeBits
Bitmask containing one bit set for every memory type acceptable for this allocation.
Definition: vk_mem_alloc.h:2420
+
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:2410
+
VmaAllocationCreateInfo::usage
VmaMemoryUsage usage
Intended usage of memory.
Definition: vk_mem_alloc.h:2405
+
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:2316
+
VmaAllocationCreateInfo::flags
VmaAllocationCreateFlags flags
Use VmaAllocationCreateFlagBits enum.
Definition: vk_mem_alloc.h:2399
+
VmaAllocationCreateInfo
Definition: vk_mem_alloc.h:2396
+
VmaAllocationCreateInfo::preferredFlags
VkMemoryPropertyFlags preferredFlags
Flags that preferably should be set in a memory type chosen for an allocation.
Definition: vk_mem_alloc.h:2415
+
VmaAllocationCreateInfo::memoryTypeBits
uint32_t memoryTypeBits
Bitmask containing one bit set for every memory type acceptable for this allocation.
Definition: vk_mem_alloc.h:2423
Generated by   diff --git a/docs/html/custom_memory_pools.html b/docs/html/custom_memory_pools.html index 73a042f..3092425 100644 --- a/docs/html/custom_memory_pools.html +++ b/docs/html/custom_memory_pools.html @@ -76,7 +76,7 @@ $(function() {

To use custom memory pools:

  1. Fill VmaPoolCreateInfo structure.
    2. -
  2. Call vmaCreatePool() to obtain VmaPool handle.
    3. +
  3. Call vmaCreatePool() to obtain VmaPool handle.
  4. When making an allocation, set VmaAllocationCreateInfo::pool to this handle. You don't need to specify any other parameters of this structure, like usage.

Example:

@@ -87,7 +87,7 @@ $(function() {
poolCreateInfo.maxBlockCount = 2;
VmaPool pool;
-
vmaCreatePool(allocator, &poolCreateInfo, &pool);
+
vmaCreatePool(allocator, &poolCreateInfo, &pool);
// Allocate a buffer out of it.
VkBufferCreateInfo bufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
@@ -100,13 +100,13 @@ $(function() {
VkBuffer buf;
VmaAllocation alloc;
VmaAllocationInfo allocInfo;
-
vmaCreateBuffer(allocator, &bufCreateInfo, &allocCreateInfo, &buf, &alloc, &allocInfo);
+
vmaCreateBuffer(allocator, &bufCreateInfo, &allocCreateInfo, &buf, &alloc, &allocInfo);

You have to free all allocations made from this pool before destroying it.

-
vmaDestroyBuffer(allocator, buf, alloc);
-
vmaDestroyPool(allocator, pool);
+
vmaDestroyBuffer(allocator, buf, alloc);
+
vmaDestroyPool(allocator, pool);

Choosing memory type index

-

When creating a pool, you must explicitly specify memory type index. To find the one suitable for your buffers or images, you can use helper functions vmaFindMemoryTypeIndexForBufferInfo(), vmaFindMemoryTypeIndexForImageInfo(). You need to provide structures with example parameters of buffers or images that you are going to create in that pool.

+

When creating a pool, you must explicitly specify memory type index. To find the one suitable for your buffers or images, you can use helper functions vmaFindMemoryTypeIndexForBufferInfo(), vmaFindMemoryTypeIndexForImageInfo(). You need to provide structures with example parameters of buffers or images that you are going to create in that pool.

VkBufferCreateInfo exampleBufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
exampleBufCreateInfo.size = 1024; // Whatever.
exampleBufCreateInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT; // Change if needed.
@@ -115,7 +115,7 @@ Choosing memory type index
allocCreateInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY; // Change if needed.
uint32_t memTypeIndex;
-
vmaFindMemoryTypeIndexForBufferInfo(allocator, &exampleBufCreateInfo, &allocCreateInfo, &memTypeIndex);
+
vmaFindMemoryTypeIndexForBufferInfo(allocator, &exampleBufCreateInfo, &allocCreateInfo, &memTypeIndex);
VmaPoolCreateInfo poolCreateInfo = {};
poolCreateInfo.memoryTypeIndex = memTypeIndex;
@@ -134,7 +134,7 @@ Linear allocation algorithm

With this one flag, you can create a custom pool that can be used in many ways: free-at-once, stack, double stack, and ring buffer. See below for details.

Free-at-once

-

In a pool that uses linear algorithm, you still need to free all the allocations individually, e.g. by using vmaFreeMemory() or vmaDestroyBuffer(). You can free them in any order. New allocations are always made after last one - free space in the middle is not reused. However, when you release all the allocation and the pool becomes empty, allocation starts from the beginning again. This way you can use linear algorithm to speed up creation of allocations that you are going to release all at once.

+

In a pool that uses linear algorithm, you still need to free all the allocations individually, e.g. by using vmaFreeMemory() or vmaDestroyBuffer(). You can free them in any order. New allocations are always made after last one - free space in the middle is not reused. However, when you release all the allocation and the pool becomes empty, allocation starts from the beginning again. This way you can use linear algorithm to speed up creation of allocations that you are going to release all at once.

Free-at-once

This mode is also available for pools created with VmaPoolCreateInfo::maxBlockCount value that allows multiple memory blocks.

@@ -176,21 +176,21 @@ Buddy allocation algorithm

-
vmaFindMemoryTypeIndexForBufferInfo
VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForBufferInfo(VmaAllocator allocator, const VkBufferCreateInfo *pBufferCreateInfo, const VmaAllocationCreateInfo *pAllocationCreateInfo, uint32_t *pMemoryTypeIndex)
Helps to find memoryTypeIndex, given VkBufferCreateInfo and VmaAllocationCreateInfo.
-
vmaCreateBuffer
VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateBuffer(VmaAllocator allocator, const VkBufferCreateInfo *pBufferCreateInfo, const VmaAllocationCreateInfo *pAllocationCreateInfo, VkBuffer *pBuffer, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
-
VmaPoolCreateInfo::memoryTypeIndex
uint32_t memoryTypeIndex
Vulkan memory type index to allocate this pool from.
Definition: vk_mem_alloc.h:2558
-
vmaDestroyPool
VMA_CALL_PRE void VMA_CALL_POST vmaDestroyPool(VmaAllocator allocator, VmaPool pool)
Destroys VmaPool object and frees Vulkan device memory.
-
VmaAllocationCreateInfo::pool
VmaPool pool
Pool that this allocation should be created in.
Definition: vk_mem_alloc.h:2426
+
VmaPoolCreateInfo::memoryTypeIndex
uint32_t memoryTypeIndex
Vulkan memory type index to allocate this pool from.
Definition: vk_mem_alloc.h:2561
+
VmaAllocationCreateInfo::pool
VmaPool pool
Pool that this allocation should be created in.
Definition: vk_mem_alloc.h:2429
+
vmaDestroyPool
void vmaDestroyPool(VmaAllocator allocator, VmaPool pool)
Destroys VmaPool object and frees Vulkan device memory.
VmaAllocation
Represents single memory allocation.
-
vmaDestroyBuffer
VMA_CALL_PRE void VMA_CALL_POST vmaDestroyBuffer(VmaAllocator allocator, VkBuffer buffer, VmaAllocation allocation)
Destroys Vulkan buffer and frees allocated memory.
-
VMA_MEMORY_USAGE_GPU_ONLY
Definition: vk_mem_alloc.h:2251
-
VmaPoolCreateInfo::maxBlockCount
size_t maxBlockCount
Maximum number of blocks that can be allocated in this pool. Optional.
Definition: vk_mem_alloc.h:2583
-
VmaPoolCreateInfo
Describes parameter of created VmaPool.
Definition: vk_mem_alloc.h:2555
+
VMA_MEMORY_USAGE_GPU_ONLY
Definition: vk_mem_alloc.h:2254
+
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:2586
+
VmaPoolCreateInfo
Describes parameter of created VmaPool.
Definition: vk_mem_alloc.h:2558
VmaPool
Represents custom memory pool.
-
VmaAllocationCreateInfo::usage
VmaMemoryUsage usage
Intended usage of memory.
Definition: vk_mem_alloc.h:2402
-
vmaCreatePool
VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreatePool(VmaAllocator allocator, const VmaPoolCreateInfo *pCreateInfo, VmaPool *pPool)
Allocates Vulkan device memory and creates VmaPool object.
-
VmaAllocationCreateInfo
Definition: vk_mem_alloc.h:2393
-
VmaAllocationInfo
Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().
Definition: vk_mem_alloc.h:2710
+
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:2405
+
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:2396
+
VmaAllocationInfo
Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().
Definition: vk_mem_alloc.h:2734
Generated by   diff --git a/docs/html/debugging_memory_usage.html b/docs/html/debugging_memory_usage.html index 6e4cd7d..d1bf839 100644 --- a/docs/html/debugging_memory_usage.html +++ b/docs/html/debugging_memory_usage.html @@ -96,7 +96,7 @@ Corruption detection
#include "vk_mem_alloc.h"

When this feature is enabled, number of bytes specified as VMA_DEBUG_MARGIN (it must be multiply of 4) before and after every allocation is filled with a magic number. This idea is also know as "canary". Memory is automatically mapped and unmapped if necessary.

This number is validated automatically when the allocation is destroyed. If it's not equal to the expected value, VMA_ASSERT() is executed. It clearly means that either CPU or GPU overwritten the memory outside of boundaries of the allocation, which indicates a serious bug.

-

You can also explicitly request checking margins of all allocations in all memory blocks that belong to specified memory types by using function vmaCheckCorruption(), or in memory blocks that belong to specified custom pool, by using function vmaCheckPoolCorruption().

+

You can also explicitly request checking margins of all allocations in all memory blocks that belong to specified memory types by using function vmaCheckCorruption(), or in memory blocks that belong to specified custom pool, by using function vmaCheckPoolCorruption().

Margin validation (corruption detection) works only for memory types that are HOST_VISIBLE and HOST_COHERENT.

diff --git a/docs/html/defragmentation.html b/docs/html/defragmentation.html index 6c2ee9c..5eb4fb8 100644 --- a/docs/html/defragmentation.html +++ b/docs/html/defragmentation.html @@ -66,15 +66,15 @@ $(function() {

Interleaved allocations and deallocations of many objects of varying size can cause fragmentation over time, which can lead to a situation where the library is unable to find a continuous range of free memory for a new allocation despite there is enough free space, just scattered across many small free ranges between existing allocations.

-

To mitigate this problem, you can use defragmentation feature: structure VmaDefragmentationInfo2, function vmaDefragmentationBegin(), vmaDefragmentationEnd(). Given set of allocations, this function can move them to compact used memory, ensure more continuous free space and possibly also free some VkDeviceMemory blocks.

+

To mitigate this problem, you can use defragmentation feature: structure VmaDefragmentationInfo2, function vmaDefragmentationBegin(), vmaDefragmentationEnd(). Given set of allocations, this function can move them to compact used memory, ensure more continuous free space and possibly also free some VkDeviceMemory blocks.

What the defragmentation does is:

What it doesn't do, so you need to do it yourself:

@@ -103,8 +103,8 @@ Defragmenting CPU memory

defragInfo.maxCpuAllocationsToMove = UINT32_MAX; // No limit.
VmaDefragmentationContext defragCtx;
-
vmaDefragmentationBegin(allocator, &defragInfo, nullptr, &defragCtx);
-
vmaDefragmentationEnd(allocator, defragCtx);
+
vmaDefragmentationBegin(allocator, &defragInfo, nullptr, &defragCtx);
+
vmaDefragmentationEnd(allocator, defragCtx);
for(uint32_t i = 0; i < allocCount; ++i)
{
@@ -121,11 +121,11 @@ Defragmenting CPU memory
// Bind new buffer to new memory region. Data contained in it is already moved.
VmaAllocationInfo allocInfo;
-
vmaGetAllocationInfo(allocator, allocations[i], &allocInfo);
-
vmaBindBufferMemory(allocator, allocations[i], buffers[i]);
+
vmaGetAllocationInfo(allocator, allocations[i], &allocInfo);
+
vmaBindBufferMemory(allocator, allocations[i], buffers[i]);
}
}
-

Setting VmaDefragmentationInfo2::pAllocationsChanged is optional. This output array tells whether particular allocation in VmaDefragmentationInfo2::pAllocations at the same index has been modified during defragmentation. You can pass null, but you then need to query every allocation passed to defragmentation for new parameters using vmaGetAllocationInfo() if you might need to recreate and rebind a buffer or image associated with it.

+

Setting VmaDefragmentationInfo2::pAllocationsChanged is optional. This output array tells whether particular allocation in VmaDefragmentationInfo2::pAllocations at the same index has been modified during defragmentation. You can pass null, but you then need to query every allocation passed to defragmentation for new parameters using vmaGetAllocationInfo() if you might need to recreate and rebind a buffer or image associated with it.

If you use Custom memory pools, you can fill VmaDefragmentationInfo2::poolCount and VmaDefragmentationInfo2::pPools instead of VmaDefragmentationInfo2::allocationCount and VmaDefragmentationInfo2::pAllocations to defragment all allocations in given pools. You cannot use VmaDefragmentationInfo2::pAllocationsChanged in that case. You can also combine both methods.

Defragmenting GPU memory

@@ -158,14 +158,14 @@ Defragmenting GPU memory
defragInfo.commandBuffer = commandBuffer;
VmaDefragmentationContext defragCtx;
-
vmaDefragmentationBegin(allocator, &defragInfo, nullptr, &defragCtx);
+
vmaDefragmentationBegin(allocator, &defragInfo, nullptr, &defragCtx);
vkEndCommandBuffer(commandBuffer);
// Submit commandBuffer.
// Wait for a fence that ensures commandBuffer execution finished.
-
vmaDefragmentationEnd(allocator, defragCtx);
+
vmaDefragmentationEnd(allocator, defragCtx);
for(uint32_t i = 0; i < allocCount; ++i)
{
@@ -182,12 +182,12 @@ Defragmenting GPU memory
// Bind new buffer to new memory region. Data contained in it is already moved.
VmaAllocationInfo allocInfo;
-
vmaGetAllocationInfo(allocator, allocations[i], &allocInfo);
-
vmaBindBufferMemory(allocator, allocations[i], buffers[i]);
+
vmaGetAllocationInfo(allocator, allocations[i], &allocInfo);
+
vmaBindBufferMemory(allocator, allocations[i], buffers[i]);
}
}

You can combine these two methods by specifying non-zero maxGpu* as well as maxCpu* parameters. The library automatically chooses best method to defragment each memory pool.

-

You may try not to block your entire program to wait until defragmentation finishes, but do it in the background, as long as you carefully fullfill requirements described in function vmaDefragmentationBegin().

+

You may try not to block your entire program to wait until defragmentation finishes, but do it in the background, as long as you carefully fullfill requirements described in function vmaDefragmentationBegin().

Additional notes

It is only legal to defragment allocations bound to:

@@ -210,22 +210,22 @@ Writing custom defragmentation algorithm -
VmaDefragmentationInfo2::allocationCount
uint32_t allocationCount
Number of allocations in pAllocations array.
Definition: vk_mem_alloc.h:3046
+
VmaDefragmentationInfo2::allocationCount
uint32_t allocationCount
Number of allocations in pAllocations array.
Definition: vk_mem_alloc.h:3070
VmaAllocator
Represents main object of this library initialized.
-
vmaBindBufferMemory
VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindBufferMemory(VmaAllocator allocator, VmaAllocation allocation, VkBuffer buffer)
Binds buffer to allocation.
-
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:3095
-
VmaDefragmentationInfo2::commandBuffer
VkCommandBuffer commandBuffer
Optional. Command buffer where GPU copy commands will be posted.
Definition: vk_mem_alloc.h:3109
-
vmaDefragmentationEnd
VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragmentationEnd(VmaAllocator allocator, VmaDefragmentationContext context)
Ends defragmentation process.
-
VmaDefragmentationInfo2
Parameters for defragmentation.
Definition: vk_mem_alloc.h:3040
-
vmaDefragmentationBegin
VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragmentationBegin(VmaAllocator allocator, const VmaDefragmentationInfo2 *pInfo, VmaDefragmentationStats *pStats, VmaDefragmentationContext *pContext)
Begins defragmentation process.
-
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:3100
-
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:3085
-
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:3061
-
VmaAllocationInfo
Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().
Definition: vk_mem_alloc.h:2710
-
vmaGetAllocationInfo
VMA_CALL_PRE void VMA_CALL_POST vmaGetAllocationInfo(VmaAllocator allocator, VmaAllocation allocation, VmaAllocationInfo *pAllocationInfo)
Returns current information about specified allocation and atomically marks it as used in current fra...
+
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:3119
+
VmaDefragmentationInfo2::commandBuffer
VkCommandBuffer commandBuffer
Optional. Command buffer where GPU copy commands will be posted.
Definition: vk_mem_alloc.h:3133
+
VmaDefragmentationInfo2
Parameters for defragmentation.
Definition: vk_mem_alloc.h:3064
+
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:3124
+
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:3109
+
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:3085
+
VmaAllocationInfo
Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().
Definition: vk_mem_alloc.h:2734
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:3055
-
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:3090
+
VmaDefragmentationInfo2::pAllocations
VmaAllocation * pAllocations
Pointer to array of allocations that can be defragmented.
Definition: vk_mem_alloc.h:3079
+
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:3114
Generated by   diff --git a/docs/html/deprecated.html b/docs/html/deprecated.html index 6791566..27f376e 100644 --- a/docs/html/deprecated.html +++ b/docs/html/deprecated.html @@ -66,10 +66,10 @@ $(function() {
-
Member vmaDefragment (VmaAllocator allocator, VmaAllocation *pAllocations, size_t allocationCount, VkBool32 *pAllocationsChanged, const VmaDefragmentationInfo *pDefragmentationInfo, VmaDefragmentationStats *pDefragmentationStats)
-
This is a part of the old interface. It is recommended to use structure VmaDefragmentationInfo2 and function vmaDefragmentationBegin() instead.
+
Member vmaDefragment (VmaAllocator allocator, VmaAllocation *pAllocations, size_t allocationCount, VkBool32 *pAllocationsChanged, const VmaDefragmentationInfo *pDefragmentationInfo, VmaDefragmentationStats *pDefragmentationStats)
+
This is a part of the old interface. It is recommended to use structure VmaDefragmentationInfo2 and function vmaDefragmentationBegin() instead.
Member VmaDefragmentationInfo
-
This is a part of the old interface. It is recommended to use structure VmaDefragmentationInfo2 and function vmaDefragmentationBegin() instead.
+
This is a part of the old interface. It is recommended to use structure VmaDefragmentationInfo2 and function vmaDefragmentationBegin() instead.
diff --git a/docs/html/general_considerations.html b/docs/html/general_considerations.html index 7df6dec..f778788 100644 --- a/docs/html/general_considerations.html +++ b/docs/html/general_considerations.html @@ -71,7 +71,7 @@ Thread safety
  • The library has no global state, so separate VmaAllocator objects can be used independently. There should be no need to create multiple such objects though - one per VkDevice is enough.
  • By default, all calls to functions that take VmaAllocator as first parameter are safe to call from multiple threads simultaneously because they are synchronized internally when needed.
  • When the allocator is created with VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT flag, calls to functions that take such VmaAllocator object must be synchronized externally.
    • -
  • Access to a VmaAllocation object must be externally synchronized. For example, you must not call vmaGetAllocationInfo() and vmaMapMemory() from different threads at the same time if you pass the same VmaAllocation object to these functions.
    • +
  • Access to a VmaAllocation object must be externally synchronized. For example, you must not call vmaGetAllocationInfo() and vmaMapMemory() from different threads at the same time if you pass the same VmaAllocation object to these functions.

    • Validation layer warnings

    @@ -109,7 +109,7 @@ Features not supported

    Cache control

    -

    Memory in Vulkan doesn't need to be unmapped before using it on GPU, but unless a memory types has VK_MEMORY_PROPERTY_HOST_COHERENT_BIT flag set, you need to manually invalidate cache before reading of mapped pointer and flush cache after writing to mapped pointer. Vulkan provides following functions for this purpose vkFlushMappedMemoryRanges(), vkInvalidateMappedMemoryRanges(), but this library provides more convenient functions that refer to given allocation object: vmaFlushAllocation(), vmaInvalidateAllocation().

    +

    Memory in Vulkan doesn't need to be unmapped before using it on GPU, but unless a memory types has VK_MEMORY_PROPERTY_HOST_COHERENT_BIT flag set, you need to manually invalidate cache before reading of mapped pointer and flush cache after writing to mapped pointer. Vulkan provides following functions for this purpose vkFlushMappedMemoryRanges(), vkInvalidateMappedMemoryRanges(), but this library provides more convenient functions that refer to given allocation object: vmaFlushAllocation(), vmaInvalidateAllocation().

    Regions of memory specified for flush/invalidate must be aligned to VkPhysicalDeviceLimits::nonCoherentAtomSize. This is automatically ensured by the library. In any memory type that is HOST_VISIBLE but not HOST_COHERENT, all allocations within blocks are aligned to this value, so their offsets are always multiply of nonCoherentAtomSize and two different allocations never share same "line" of this size.

    Please note that memory allocated with VMA_MEMORY_USAGE_CPU_ONLY is guaranteed to be HOST_COHERENT.

    Also, Windows drivers from all 3 PC GPU vendors (AMD, Intel, NVIDIA) currently provide HOST_COHERENT flag on all memory types that are HOST_VISIBLE, so on this platform you may not need to bother.

    Finding out if memory is mappable

    It may happen that your allocation ends up in memory that is HOST_VISIBLE (available for mapping) despite it wasn't explicitly requested. For example, application may work on integrated graphics with unified memory (like Intel) or allocation from video memory might have failed, so the library chose system memory as fallback.

    -

    You can detect this case and map such allocation to access its memory on CPU directly, instead of launching a transfer operation. In order to do that: inspect allocInfo.memoryType, call vmaGetMemoryTypeProperties(), and look for VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT flag in properties of that memory type.

    +

    You can detect this case and map such allocation to access its memory on CPU directly, instead of launching a transfer operation. In order to do that: inspect allocInfo.memoryType, call vmaGetMemoryTypeProperties(), and look for VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT flag in properties of that memory type.

    VkBufferCreateInfo bufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
    bufCreateInfo.size = sizeof(ConstantBuffer);
    bufCreateInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
    @@ -135,17 +135,17 @@ Finding out if memory is mappable
    VkBuffer buf;
    VmaAllocation alloc;
    VmaAllocationInfo allocInfo;
    -
    vmaCreateBuffer(allocator, &bufCreateInfo, &allocCreateInfo, &buf, &alloc, &allocInfo);
    +
    vmaCreateBuffer(allocator, &bufCreateInfo, &allocCreateInfo, &buf, &alloc, &allocInfo);
    VkMemoryPropertyFlags memFlags;
    -
    vmaGetMemoryTypeProperties(allocator, allocInfo.memoryType, &memFlags);
    +
    vmaGetMemoryTypeProperties(allocator, allocInfo.memoryType, &memFlags);
    if((memFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
    {
    // Allocation ended up in mappable memory. You can map it and access it directly.
    void* mappedData;
    -
    vmaMapMemory(allocator, alloc, &mappedData);
    +
    vmaMapMemory(allocator, alloc, &mappedData);
    memcpy(mappedData, &constantBufferData, sizeof(constantBufferData));
    -
    vmaUnmapMemory(allocator, alloc);
    +
    vmaUnmapMemory(allocator, alloc);
    }
    else
    {
    @@ -164,7 +164,7 @@ Finding out if memory is mappable
    VkBuffer buf;
    VmaAllocation alloc;
    VmaAllocationInfo allocInfo;
    -
    vmaCreateBuffer(allocator, &bufCreateInfo, &allocCreateInfo, &buf, &alloc, &allocInfo);
    +
    vmaCreateBuffer(allocator, &bufCreateInfo, &allocCreateInfo, &buf, &alloc, &allocInfo);
    if(allocInfo.pUserData != nullptr)
    {
    @@ -179,23 +179,23 @@ 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.
    -
    vmaMapMemory
    VMA_CALL_PRE VkResult VMA_CALL_POST vmaMapMemory(VmaAllocator allocator, VmaAllocation allocation, void **ppData)
    Maps memory represented by given allocation and returns pointer to it.
    -
    vmaCreateBuffer
    VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateBuffer(VmaAllocator allocator, const VkBufferCreateInfo *pBufferCreateInfo, const VmaAllocationCreateInfo *pAllocationCreateInfo, VkBuffer *pBuffer, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
    -
    vmaUnmapMemory
    VMA_CALL_PRE void VMA_CALL_POST vmaUnmapMemory(VmaAllocator allocator, VmaAllocation allocation)
    Unmaps memory represented by given allocation, mapped previously using vmaMapMemory().
    -
    VMA_MEMORY_USAGE_CPU_ONLY
    Definition: vk_mem_alloc.h:2261
    +
    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
    VmaAllocation
    Represents single memory allocation.
    -
    VMA_MEMORY_USAGE_GPU_ONLY
    Definition: vk_mem_alloc.h:2251
    -
    vmaGetMemoryTypeProperties
    VMA_CALL_PRE void VMA_CALL_POST vmaGetMemoryTypeProperties(VmaAllocator allocator, uint32_t memoryTypeIndex, VkMemoryPropertyFlags *pFlags)
    Given Memory Type Index, returns Property Flags of this memory type.
    -
    VmaAllocationInfo::pMappedData
    void * pMappedData
    Pointer to the beginning of this allocation as mapped data.
    Definition: vk_mem_alloc.h:2743
    -
    VmaAllocationCreateInfo::usage
    VmaMemoryUsage usage
    Intended usage of memory.
    Definition: vk_mem_alloc.h:2402
    -
    VmaAllocationInfo::pUserData
    void * pUserData
    Custom general-purpose pointer that was passed as VmaAllocationCreateInfo::pUserData or set using vma...
    Definition: vk_mem_alloc.h:2748
    -
    VmaAllocationInfo::memoryType
    uint32_t memoryType
    Memory type index that this allocation was allocated from.
    Definition: vk_mem_alloc.h:2715
    -
    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:2313
    -
    VmaAllocationCreateInfo::flags
    VmaAllocationCreateFlags flags
    Use VmaAllocationCreateFlagBits enum.
    Definition: vk_mem_alloc.h:2396
    -
    VmaAllocationCreateInfo
    Definition: vk_mem_alloc.h:2393
    -
    VmaAllocationCreateInfo::preferredFlags
    VkMemoryPropertyFlags preferredFlags
    Flags that preferably should be set in a memory type chosen for an allocation.
    Definition: vk_mem_alloc.h:2412
    -
    VmaAllocationInfo
    Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().
    Definition: vk_mem_alloc.h:2710
    +
    VMA_MEMORY_USAGE_GPU_ONLY
    Definition: vk_mem_alloc.h:2254
    +
    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:2767
    +
    VmaAllocationCreateInfo::usage
    VmaMemoryUsage usage
    Intended usage of memory.
    Definition: vk_mem_alloc.h:2405
    +
    VmaAllocationInfo::pUserData
    void * pUserData
    Custom general-purpose pointer that was passed as VmaAllocationCreateInfo::pUserData or set using vma...
    Definition: vk_mem_alloc.h:2772
    +
    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:2739
    +
    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:2316
    +
    VmaAllocationCreateInfo::flags
    VmaAllocationCreateFlags flags
    Use VmaAllocationCreateFlagBits enum.
    Definition: vk_mem_alloc.h:2399
    +
    VmaAllocationCreateInfo
    Definition: vk_mem_alloc.h:2396
    +
    VmaAllocationCreateInfo::preferredFlags
    VkMemoryPropertyFlags preferredFlags
    Flags that preferably should be set in a memory type chosen for an allocation.
    Definition: vk_mem_alloc.h:2415
    +
    VmaAllocationInfo
    Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().
    Definition: vk_mem_alloc.h:2734
    Generated by   diff --git a/docs/html/quick_start.html b/docs/html/quick_start.html index 9d04f15..0384593 100644 --- a/docs/html/quick_start.html +++ b/docs/html/quick_start.html @@ -84,21 +84,21 @@ Initialization

    At program startup:

    1. Initialize Vulkan to have VkPhysicalDevice and VkDevice object.
      2. -
    2. Fill VmaAllocatorCreateInfo structure and create VmaAllocator object by calling vmaCreateAllocator().
      3. +
    3. Fill VmaAllocatorCreateInfo structure and create VmaAllocator object by calling vmaCreateAllocator().
    VmaAllocatorCreateInfo allocatorInfo = {};
    allocatorInfo.physicalDevice = physicalDevice;
    allocatorInfo.device = device;
    VmaAllocator allocator;
    -
    vmaCreateAllocator(&allocatorInfo, &allocator);
    +
    vmaCreateAllocator(&allocatorInfo, &allocator);

    Resource allocation

    When you want to create a buffer or image:

    1. Fill VkBufferCreateInfo / VkImageCreateInfo structure.
    2. Fill VmaAllocationCreateInfo structure.
      3. -
    3. Call vmaCreateBuffer() / vmaCreateImage() to get VkBuffer/VkImage with memory already allocated and bound to it.
      4. +
    4. Call vmaCreateBuffer() / vmaCreateImage() to get VkBuffer/VkImage with memory already allocated and bound to it.
    VkBufferCreateInfo bufferInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
    bufferInfo.size = 65536;
    @@ -109,24 +109,24 @@ Resource allocation
    VkBuffer buffer;
    VmaAllocation allocation;
    -
    vmaCreateBuffer(allocator, &bufferInfo, &allocInfo, &buffer, &allocation, nullptr);
    +
    vmaCreateBuffer(allocator, &bufferInfo, &allocInfo, &buffer, &allocation, nullptr);

    Don't forget to destroy your objects when no longer needed:

    -
    vmaDestroyBuffer(allocator, buffer, allocation);
    -
    vmaDestroyAllocator(allocator);
    +
    vmaDestroyBuffer(allocator, buffer, allocation);
    +
    vmaDestroyAllocator(allocator);
    VmaAllocatorCreateInfo::physicalDevice
    VkPhysicalDevice physicalDevice
    Vulkan physical device.
    Definition: vk_mem_alloc.h:1982
    -
    vmaDestroyAllocator
    VMA_CALL_PRE void VMA_CALL_POST vmaDestroyAllocator(VmaAllocator allocator)
    Destroys allocator object.
    VmaAllocator
    Represents main object of this library initialized.
    VmaAllocatorCreateInfo
    Description of a Allocator to be created.
    Definition: vk_mem_alloc.h:1976
    -
    vmaCreateBuffer
    VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateBuffer(VmaAllocator allocator, const VkBufferCreateInfo *pBufferCreateInfo, const VmaAllocationCreateInfo *pAllocationCreateInfo, VkBuffer *pBuffer, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
    VmaAllocation
    Represents single memory allocation.
    -
    vmaDestroyBuffer
    VMA_CALL_PRE void VMA_CALL_POST vmaDestroyBuffer(VmaAllocator allocator, VkBuffer buffer, VmaAllocation allocation)
    Destroys Vulkan buffer and frees allocated memory.
    -
    vmaCreateAllocator
    VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateAllocator(const VmaAllocatorCreateInfo *pCreateInfo, VmaAllocator *pAllocator)
    Creates Allocator object.
    -
    VMA_MEMORY_USAGE_GPU_ONLY
    Definition: vk_mem_alloc.h:2251
    +
    VMA_MEMORY_USAGE_GPU_ONLY
    Definition: vk_mem_alloc.h:2254
    +
    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:2402
    -
    VmaAllocationCreateInfo
    Definition: vk_mem_alloc.h:2393
    +
    VmaAllocationCreateInfo::usage
    VmaMemoryUsage usage
    Intended usage of memory.
    Definition: vk_mem_alloc.h:2405
    +
    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:2396
    Generated by   diff --git a/docs/html/search/all_11.js b/docs/html/search/all_11.js index ac3c021..4f2f091 100644 --- a/docs/html/search/all_11.js +++ b/docs/html/search/all_11.js @@ -43,98 +43,98 @@ var searchData= ['vma_5fallocator_5fcreate_5fkhr_5fbind_5fmemory2_5fbit_119',['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_120',['VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT',['../vk__mem__alloc_8h.html#a4f87c9100d154a65a4ad495f7763cf7cace7da7cc6e71a625dfa763c55a597878',1,'vk_mem_alloc.h']]], ['vma_5fbind_5fmemory2_121',['VMA_BIND_MEMORY2',['../vk__mem__alloc_8h.html#a88bef97f86d70a34a4c0746e09a2680d',1,'vk_mem_alloc.h']]], - ['vma_5fcall_5fpost_122',['VMA_CALL_POST',['../vk__mem__alloc_8h.html#aab7d949b3d77783f0ba704ae5e3136e0',1,'vk_mem_alloc.h']]], - ['vma_5fcall_5fpre_123',['VMA_CALL_PRE',['../vk__mem__alloc_8h.html#a3f0fa870030b4d421bf71e3928d5fe31',1,'vk_mem_alloc.h']]], - ['vma_5fdedicated_5fallocation_124',['VMA_DEDICATED_ALLOCATION',['../vk__mem__alloc_8h.html#af7b860e63b96d11e44ae8587ba06bbf4',1,'vk_mem_alloc.h']]], - ['vma_5fdefragmentation_5fflag_5fbits_5fmax_5fenum_125',['VMA_DEFRAGMENTATION_FLAG_BITS_MAX_ENUM',['../vk__mem__alloc_8h.html#a6552a65b71d16f378c6994b3ceaef50cab87ec33154803bfeb5ac2b379f1d6a97',1,'vk_mem_alloc.h']]], - ['vma_5fmemory_5fbudget_126',['VMA_MEMORY_BUDGET',['../vk__mem__alloc_8h.html#a05decf1cf4ebf767beba7acca6c1ec3a',1,'vk_mem_alloc.h']]], - ['vma_5fmemory_5fusage_5fcpu_5fonly_127',['VMA_MEMORY_USAGE_CPU_ONLY',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305cca40bdf4cddeffeb12f43d45ca1286e0a5',1,'vk_mem_alloc.h']]], - ['vma_5fmemory_5fusage_5fcpu_5fto_5fgpu_128',['VMA_MEMORY_USAGE_CPU_TO_GPU',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305cca9066b52c5a7079bb74a69aaf8b92ff67',1,'vk_mem_alloc.h']]], - ['vma_5fmemory_5fusage_5fgpu_5fonly_129',['VMA_MEMORY_USAGE_GPU_ONLY',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305ccac6b5dc1432d88647aa4cd456246eadf7',1,'vk_mem_alloc.h']]], - ['vma_5fmemory_5fusage_5fgpu_5fto_5fcpu_130',['VMA_MEMORY_USAGE_GPU_TO_CPU',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305cca7b586d2fdaf82a463b58f581ed72be27',1,'vk_mem_alloc.h']]], - ['vma_5fmemory_5fusage_5fmax_5fenum_131',['VMA_MEMORY_USAGE_MAX_ENUM',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305cca091e69437ef693e8d0d287f1c719ba6e',1,'vk_mem_alloc.h']]], - ['vma_5fmemory_5fusage_5funknown_132',['VMA_MEMORY_USAGE_UNKNOWN',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305ccaf50d27e34e0925cf3a63db8c839121dd',1,'vk_mem_alloc.h']]], - ['vma_5fpool_5fcreate_5falgorithm_5fmask_133',['VMA_POOL_CREATE_ALGORITHM_MASK',['../vk__mem__alloc_8h.html#a9a7c45f9c863695d98c83fa5ac940fe7af4d270f8f42517a0f70037ceb6ac1d9c',1,'vk_mem_alloc.h']]], - ['vma_5fpool_5fcreate_5fbuddy_5falgorithm_5fbit_134',['VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT',['../vk__mem__alloc_8h.html#a9a7c45f9c863695d98c83fa5ac940fe7a97a0dc38e5161b780594d998d313d35e',1,'vk_mem_alloc.h']]], - ['vma_5fpool_5fcreate_5fflag_5fbits_5fmax_5fenum_135',['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_136',['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_137',['VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT',['../vk__mem__alloc_8h.html#a9a7c45f9c863695d98c83fa5ac940fe7a13c8a444197c67866be9cb05599fc726',1,'vk_mem_alloc.h']]], - ['vma_5frecord_5fflag_5fbits_5fmax_5fenum_138',['VMA_RECORD_FLAG_BITS_MAX_ENUM',['../vk__mem__alloc_8h.html#a4dd2c44642312a147a4e93373a6e64d2a20dd17d69966dbffa054739d6090b85e',1,'vk_mem_alloc.h']]], - ['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#a6e40022ab443f88bfa8b13c2fcfd05cc',1,'vk_mem_alloc.h']]], - ['vmaallocatememoryforbuffer_143',['vmaAllocateMemoryForBuffer',['../vk__mem__alloc_8h.html#af34f6d2ec25537ac0179ff614bae0012',1,'vk_mem_alloc.h']]], - ['vmaallocatememoryforimage_144',['vmaAllocateMemoryForImage',['../vk__mem__alloc_8h.html#a25e3b30b93063b921d5078e538b1bf30',1,'vk_mem_alloc.h']]], - ['vmaallocatememorypages_145',['vmaAllocateMemoryPages',['../vk__mem__alloc_8h.html#a35b49cebb7d7c128db38d3949f54e325',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#a055cbf8d000a019a6270c66b46f0cb40',1,'vk_mem_alloc.h']]], - ['vmabindbuffermemory2_156',['vmaBindBufferMemory2',['../vk__mem__alloc_8h.html#aa06d8fe2e969c048182e019f4b857ccf',1,'vk_mem_alloc.h']]], - ['vmabindimagememory_157',['vmaBindImageMemory',['../vk__mem__alloc_8h.html#a9681b4996d0d33ad0bc811fc7394d272',1,'vk_mem_alloc.h']]], - ['vmabindimagememory2_158',['vmaBindImageMemory2',['../vk__mem__alloc_8h.html#a82e760a2db3b517b965320ba71ebbfbb',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#a4d7fc62aef0239d260e647447605aad4',1,'vk_mem_alloc.h']]], - ['vmacalculatestats_161',['vmaCalculateStats',['../vk__mem__alloc_8h.html#a27abba9dd2d1ea2026f7f4dfb548638b',1,'vk_mem_alloc.h']]], - ['vmacheckcorruption_162',['vmaCheckCorruption',['../vk__mem__alloc_8h.html#a6e53d9caa4368576cf351300b64ef8f4',1,'vk_mem_alloc.h']]], - ['vmacheckpoolcorruption_163',['vmaCheckPoolCorruption',['../vk__mem__alloc_8h.html#a6bdc403637fe34c4dbb7f7de39357e02',1,'vk_mem_alloc.h']]], - ['vmacreateallocator_164',['vmaCreateAllocator',['../vk__mem__alloc_8h.html#af2bacace15ecc6886e4e4de5d1b77e4d',1,'vk_mem_alloc.h']]], - ['vmacreatebuffer_165',['vmaCreateBuffer',['../vk__mem__alloc_8h.html#aafee10cbb01be73c643ed7e02c31003f',1,'vk_mem_alloc.h']]], - ['vmacreateimage_166',['vmaCreateImage',['../vk__mem__alloc_8h.html#a001bd7a2077a42caf256a6fb2f2ba131',1,'vk_mem_alloc.h']]], - ['vmacreatelostallocation_167',['vmaCreateLostAllocation',['../vk__mem__alloc_8h.html#af70dc16d3b2818d514face3ed916f492',1,'vk_mem_alloc.h']]], - ['vmacreatepool_168',['vmaCreatePool',['../vk__mem__alloc_8h.html#aee3406ab6b195cd85207ca2ef2d13a57',1,'vk_mem_alloc.h']]], - ['vmadefragment_169',['vmaDefragment',['../vk__mem__alloc_8h.html#a2c33b164a2597db181db3ca8e5812e4c',1,'vk_mem_alloc.h']]], - ['vmadefragmentationbegin_170',['vmaDefragmentationBegin',['../vk__mem__alloc_8h.html#a696fc71963b7711cc0db3cc2225d0cd7',1,'vk_mem_alloc.h']]], - ['vmadefragmentationcontext_171',['VmaDefragmentationContext',['../struct_vma_defragmentation_context.html',1,'']]], - ['vmadefragmentationend_172',['vmaDefragmentationEnd',['../vk__mem__alloc_8h.html#a5e9d96ef2cbd8263cc523da91d1b40c9',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#a288d938ca902469760248ebd3633dde5',1,'vk_mem_alloc.h']]], - ['vmadestroybuffer_179',['vmaDestroyBuffer',['../vk__mem__alloc_8h.html#a3fa3daa743fcc950253f676aa8a323ea',1,'vk_mem_alloc.h']]], - ['vmadestroyimage_180',['vmaDestroyImage',['../vk__mem__alloc_8h.html#a6d7d34a7e2ef515a2734bdfdf7a76a9f',1,'vk_mem_alloc.h']]], - ['vmadestroypool_181',['vmaDestroyPool',['../vk__mem__alloc_8h.html#a11693ab08f65761a142c466c5eceb849',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#a21530f0bd74d92b40cc1873e5037662c',1,'vk_mem_alloc.h']]], - ['vmafindmemorytypeindexforbufferinfo_184',['vmaFindMemoryTypeIndexForBufferInfo',['../vk__mem__alloc_8h.html#a425905e868e4b487b5188f9d834dacbc',1,'vk_mem_alloc.h']]], - ['vmafindmemorytypeindexforimageinfo_185',['vmaFindMemoryTypeIndexForImageInfo',['../vk__mem__alloc_8h.html#a359c5187b7004880945f0e3debba91b9',1,'vk_mem_alloc.h']]], - ['vmaflushallocation_186',['vmaFlushAllocation',['../vk__mem__alloc_8h.html#aca66f515fb5c3b370eaa9d826785c2c6',1,'vk_mem_alloc.h']]], - ['vmafreememory_187',['vmaFreeMemory',['../vk__mem__alloc_8h.html#a0438b3d982473eb1c93c77c7ab3212e1',1,'vk_mem_alloc.h']]], - ['vmafreememorypages_188',['vmaFreeMemoryPages',['../vk__mem__alloc_8h.html#aab00eabeaf43039298442591bcfba836',1,'vk_mem_alloc.h']]], - ['vmafreestatsstring_189',['vmaFreeStatsString',['../vk__mem__alloc_8h.html#aff001c5ec4ab2aeef3176804d6a865a9',1,'vk_mem_alloc.h']]], - ['vmagetallocationinfo_190',['vmaGetAllocationInfo',['../vk__mem__alloc_8h.html#ae10b53588f197141c6e88a1f5ec34789',1,'vk_mem_alloc.h']]], - ['vmagetbudget_191',['vmaGetBudget',['../vk__mem__alloc_8h.html#a2d9ae6d97e48d85f5b6a685742d5f6f0',1,'vk_mem_alloc.h']]], - ['vmagetmemoryproperties_192',['vmaGetMemoryProperties',['../vk__mem__alloc_8h.html#ada321efa19065e5a87f79dcbe11369a5',1,'vk_mem_alloc.h']]], - ['vmagetmemorytypeproperties_193',['vmaGetMemoryTypeProperties',['../vk__mem__alloc_8h.html#ad0b03b51a0dff5dab25ac9c194fef3e1',1,'vk_mem_alloc.h']]], - ['vmagetphysicaldeviceproperties_194',['vmaGetPhysicalDeviceProperties',['../vk__mem__alloc_8h.html#a236c3299ad132eb753dbcbf6e309849e',1,'vk_mem_alloc.h']]], - ['vmagetpoolstats_195',['vmaGetPoolStats',['../vk__mem__alloc_8h.html#abb343b27164d08d2b97e3b0c30ecdcbf',1,'vk_mem_alloc.h']]], - ['vmainvalidateallocation_196',['vmaInvalidateAllocation',['../vk__mem__alloc_8h.html#a7489ab3d91f0011e2ed22f266f76966c',1,'vk_mem_alloc.h']]], - ['vmamakepoolallocationslost_197',['vmaMakePoolAllocationsLost',['../vk__mem__alloc_8h.html#aaf235cb916f4c56feafdce45227fd17a',1,'vk_mem_alloc.h']]], - ['vmamapmemory_198',['vmaMapMemory',['../vk__mem__alloc_8h.html#ae98119383e8e5754b6c09679386677d3',1,'vk_mem_alloc.h']]], - ['vmamemoryusage_199',['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_200',['VmaPool',['../struct_vma_pool.html',1,'']]], - ['vmapoolcreateflagbits_201',['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_202',['VmaPoolCreateFlags',['../vk__mem__alloc_8h.html#a2770e325ea42e087c1b91fdf46d0292a',1,'vk_mem_alloc.h']]], - ['vmapoolcreateinfo_203',['VmaPoolCreateInfo',['../struct_vma_pool_create_info.html',1,'VmaPoolCreateInfo'],['../vk__mem__alloc_8h.html#a211706e9348dcee25a843ed4ea69bce7',1,'VmaPoolCreateInfo(): vk_mem_alloc.h']]], - ['vmapoolstats_204',['VmaPoolStats',['../struct_vma_pool_stats.html',1,'VmaPoolStats'],['../vk__mem__alloc_8h.html#a2e5612d871d64c5624087b837a338c34',1,'VmaPoolStats(): vk_mem_alloc.h']]], - ['vmarecordflagbits_205',['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_206',['VmaRecordFlags',['../vk__mem__alloc_8h.html#af3929a1a4547c592fc0b0e55ef452828',1,'vk_mem_alloc.h']]], - ['vmarecordsettings_207',['VmaRecordSettings',['../struct_vma_record_settings.html',1,'VmaRecordSettings'],['../vk__mem__alloc_8h.html#a0ab61e87ff6365f1d59915eadc37a9f0',1,'VmaRecordSettings(): vk_mem_alloc.h']]], - ['vmaresizeallocation_208',['vmaResizeAllocation',['../vk__mem__alloc_8h.html#a36e0067f27609620651eefdf98ce624e',1,'vk_mem_alloc.h']]], - ['vmasetallocationuserdata_209',['vmaSetAllocationUserData',['../vk__mem__alloc_8h.html#a402558851f800ecd733800962c227f6a',1,'vk_mem_alloc.h']]], - ['vmasetcurrentframeindex_210',['vmaSetCurrentFrameIndex',['../vk__mem__alloc_8h.html#a763d86a0fa9613d81b19dc724d418f67',1,'vk_mem_alloc.h']]], + ['vma_5fdedicated_5fallocation_122',['VMA_DEDICATED_ALLOCATION',['../vk__mem__alloc_8h.html#af7b860e63b96d11e44ae8587ba06bbf4',1,'vk_mem_alloc.h']]], + ['vma_5fdefragmentation_5fflag_5fbits_5fmax_5fenum_123',['VMA_DEFRAGMENTATION_FLAG_BITS_MAX_ENUM',['../vk__mem__alloc_8h.html#a6552a65b71d16f378c6994b3ceaef50cab87ec33154803bfeb5ac2b379f1d6a97',1,'vk_mem_alloc.h']]], + ['vma_5fmemory_5fbudget_124',['VMA_MEMORY_BUDGET',['../vk__mem__alloc_8h.html#a05decf1cf4ebf767beba7acca6c1ec3a',1,'vk_mem_alloc.h']]], + ['vma_5fmemory_5fusage_5fcpu_5fonly_125',['VMA_MEMORY_USAGE_CPU_ONLY',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305cca40bdf4cddeffeb12f43d45ca1286e0a5',1,'vk_mem_alloc.h']]], + ['vma_5fmemory_5fusage_5fcpu_5fto_5fgpu_126',['VMA_MEMORY_USAGE_CPU_TO_GPU',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305cca9066b52c5a7079bb74a69aaf8b92ff67',1,'vk_mem_alloc.h']]], + ['vma_5fmemory_5fusage_5fgpu_5fonly_127',['VMA_MEMORY_USAGE_GPU_ONLY',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305ccac6b5dc1432d88647aa4cd456246eadf7',1,'vk_mem_alloc.h']]], + ['vma_5fmemory_5fusage_5fgpu_5fto_5fcpu_128',['VMA_MEMORY_USAGE_GPU_TO_CPU',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305cca7b586d2fdaf82a463b58f581ed72be27',1,'vk_mem_alloc.h']]], + ['vma_5fmemory_5fusage_5fmax_5fenum_129',['VMA_MEMORY_USAGE_MAX_ENUM',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305cca091e69437ef693e8d0d287f1c719ba6e',1,'vk_mem_alloc.h']]], + ['vma_5fmemory_5fusage_5funknown_130',['VMA_MEMORY_USAGE_UNKNOWN',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305ccaf50d27e34e0925cf3a63db8c839121dd',1,'vk_mem_alloc.h']]], + ['vma_5fpool_5fcreate_5falgorithm_5fmask_131',['VMA_POOL_CREATE_ALGORITHM_MASK',['../vk__mem__alloc_8h.html#a9a7c45f9c863695d98c83fa5ac940fe7af4d270f8f42517a0f70037ceb6ac1d9c',1,'vk_mem_alloc.h']]], + ['vma_5fpool_5fcreate_5fbuddy_5falgorithm_5fbit_132',['VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT',['../vk__mem__alloc_8h.html#a9a7c45f9c863695d98c83fa5ac940fe7a97a0dc38e5161b780594d998d313d35e',1,'vk_mem_alloc.h']]], + ['vma_5fpool_5fcreate_5fflag_5fbits_5fmax_5fenum_133',['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_134',['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_135',['VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT',['../vk__mem__alloc_8h.html#a9a7c45f9c863695d98c83fa5ac940fe7a13c8a444197c67866be9cb05599fc726',1,'vk_mem_alloc.h']]], + ['vma_5frecord_5fflag_5fbits_5fmax_5fenum_136',['VMA_RECORD_FLAG_BITS_MAX_ENUM',['../vk__mem__alloc_8h.html#a4dd2c44642312a147a4e93373a6e64d2a20dd17d69966dbffa054739d6090b85e',1,'vk_mem_alloc.h']]], + ['vma_5frecord_5fflush_5fafter_5fcall_5fbit_137',['VMA_RECORD_FLUSH_AFTER_CALL_BIT',['../vk__mem__alloc_8h.html#a4dd2c44642312a147a4e93373a6e64d2a8e7ab322e8732654be627c4ea8f36cc7',1,'vk_mem_alloc.h']]], + ['vma_5frecording_5fenabled_138',['VMA_RECORDING_ENABLED',['../vk__mem__alloc_8h.html#a1f0c126759fc96ccb6e2d23c101d770c',1,'vk_mem_alloc.h']]], + ['vma_5fstats_5fstring_5fenabled_139',['VMA_STATS_STRING_ENABLED',['../vk__mem__alloc_8h.html#ae25f0d55fd91cb166f002b63244800e1',1,'vk_mem_alloc.h']]], + ['vmaallocatememory_140',['vmaAllocateMemory',['../vk__mem__alloc_8h.html#abf28077dbf82d0908b8acbe8ee8dd9b8',1,'vk_mem_alloc.h']]], + ['vmaallocatememoryforbuffer_141',['vmaAllocateMemoryForBuffer',['../vk__mem__alloc_8h.html#a7fdf64415b6c3d83c454f28d2c53df7b',1,'vk_mem_alloc.h']]], + ['vmaallocatememoryforimage_142',['vmaAllocateMemoryForImage',['../vk__mem__alloc_8h.html#a0faa3f9e5fb233d29d1e00390650febb',1,'vk_mem_alloc.h']]], + ['vmaallocatememorypages_143',['vmaAllocateMemoryPages',['../vk__mem__alloc_8h.html#ad37e82e492b3de38fc3f4cffd9ad0ae1',1,'vk_mem_alloc.h']]], + ['vmaallocation_144',['VmaAllocation',['../struct_vma_allocation.html',1,'']]], + ['vmaallocationcreateflagbits_145',['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_146',['VmaAllocationCreateFlags',['../vk__mem__alloc_8h.html#a5225e5e11f8376f6a31a1791f3d6e817',1,'vk_mem_alloc.h']]], + ['vmaallocationcreateinfo_147',['VmaAllocationCreateInfo',['../struct_vma_allocation_create_info.html',1,'VmaAllocationCreateInfo'],['../vk__mem__alloc_8h.html#a86c44f9950b40d50088ed93a17870a7a',1,'VmaAllocationCreateInfo(): vk_mem_alloc.h']]], + ['vmaallocationinfo_148',['VmaAllocationInfo',['../struct_vma_allocation_info.html',1,'VmaAllocationInfo'],['../vk__mem__alloc_8h.html#a795e6ff02a21d5486c0565f403dd9255',1,'VmaAllocationInfo(): vk_mem_alloc.h']]], + ['vmaallocator_149',['VmaAllocator',['../struct_vma_allocator.html',1,'']]], + ['vmaallocatorcreateflagbits_150',['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_151',['VmaAllocatorCreateFlags',['../vk__mem__alloc_8h.html#acfe6863e160722c2c1bbcf7573fddc4d',1,'vk_mem_alloc.h']]], + ['vmaallocatorcreateinfo_152',['VmaAllocatorCreateInfo',['../struct_vma_allocator_create_info.html',1,'VmaAllocatorCreateInfo'],['../vk__mem__alloc_8h.html#ae0f6d1d733dded220d28134da46b4283',1,'VmaAllocatorCreateInfo(): vk_mem_alloc.h']]], + ['vmabindbuffermemory_153',['vmaBindBufferMemory',['../vk__mem__alloc_8h.html#a6b0929b914b60cf2d45cac4bf3547470',1,'vk_mem_alloc.h']]], + ['vmabindbuffermemory2_154',['vmaBindBufferMemory2',['../vk__mem__alloc_8h.html#a927c944f45e0f2941182abb6f608e64a',1,'vk_mem_alloc.h']]], + ['vmabindimagememory_155',['vmaBindImageMemory',['../vk__mem__alloc_8h.html#a3d3ca45799923aa5d138e9e5f9eb2da5',1,'vk_mem_alloc.h']]], + ['vmabindimagememory2_156',['vmaBindImageMemory2',['../vk__mem__alloc_8h.html#aa8251ee81b0045a443e35b8e8aa021bc',1,'vk_mem_alloc.h']]], + ['vmabudget_157',['VmaBudget',['../struct_vma_budget.html',1,'VmaBudget'],['../vk__mem__alloc_8h.html#ab79b48b6d25aada0de91a913896e1c38',1,'VmaBudget(): vk_mem_alloc.h']]], + ['vmabuildstatsstring_158',['vmaBuildStatsString',['../vk__mem__alloc_8h.html#aa4fee7eb5253377599ef4fd38c93c2a0',1,'vk_mem_alloc.h']]], + ['vmacalculatestats_159',['vmaCalculateStats',['../vk__mem__alloc_8h.html#a333b61c1788cb23559177531e6a93ca3',1,'vk_mem_alloc.h']]], + ['vmacheckcorruption_160',['vmaCheckCorruption',['../vk__mem__alloc_8h.html#a49329a7f030dafcf82f7b73334c22e98',1,'vk_mem_alloc.h']]], + ['vmacheckpoolcorruption_161',['vmaCheckPoolCorruption',['../vk__mem__alloc_8h.html#ad535935619c7a549bf837e1bb0068f89',1,'vk_mem_alloc.h']]], + ['vmacreateallocator_162',['vmaCreateAllocator',['../vk__mem__alloc_8h.html#a200692051ddb34240248234f5f4c17bb',1,'vk_mem_alloc.h']]], + ['vmacreatebuffer_163',['vmaCreateBuffer',['../vk__mem__alloc_8h.html#ac72ee55598617e8eecca384e746bab51',1,'vk_mem_alloc.h']]], + ['vmacreateimage_164',['vmaCreateImage',['../vk__mem__alloc_8h.html#a02a94f25679275851a53e82eacbcfc73',1,'vk_mem_alloc.h']]], + ['vmacreatelostallocation_165',['vmaCreateLostAllocation',['../vk__mem__alloc_8h.html#ae5c9657d9e94756269145b01c05d16f1',1,'vk_mem_alloc.h']]], + ['vmacreatepool_166',['vmaCreatePool',['../vk__mem__alloc_8h.html#a5c8770ded7c59c8caac6de0c2cb00b50',1,'vk_mem_alloc.h']]], + ['vmadefragment_167',['vmaDefragment',['../vk__mem__alloc_8h.html#a6aced90fcc7b39882b6654a740a0b9bb',1,'vk_mem_alloc.h']]], + ['vmadefragmentationbegin_168',['vmaDefragmentationBegin',['../vk__mem__alloc_8h.html#a36ba776fd7fd5cb1e9359fdc0d8e6e8a',1,'vk_mem_alloc.h']]], + ['vmadefragmentationcontext_169',['VmaDefragmentationContext',['../struct_vma_defragmentation_context.html',1,'']]], + ['vmadefragmentationend_170',['vmaDefragmentationEnd',['../vk__mem__alloc_8h.html#a8774e20e91e245aae959ba63efa15dd2',1,'vk_mem_alloc.h']]], + ['vmadefragmentationflagbits_171',['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_172',['VmaDefragmentationFlags',['../vk__mem__alloc_8h.html#a88a77cef37e5d3c4fc9eb328885d048d',1,'vk_mem_alloc.h']]], + ['vmadefragmentationinfo_173',['VmaDefragmentationInfo',['../struct_vma_defragmentation_info.html',1,'VmaDefragmentationInfo'],['../vk__mem__alloc_8h.html#ae67f8573a0cf20f16f0a1eecbca566a0',1,'VmaDefragmentationInfo(): vk_mem_alloc.h']]], + ['vmadefragmentationinfo2_174',['VmaDefragmentationInfo2',['../struct_vma_defragmentation_info2.html',1,'VmaDefragmentationInfo2'],['../vk__mem__alloc_8h.html#abac0e85abaa6ea1ffd63bde29c5c3a29',1,'VmaDefragmentationInfo2(): vk_mem_alloc.h']]], + ['vmadefragmentationstats_175',['VmaDefragmentationStats',['../struct_vma_defragmentation_stats.html',1,'VmaDefragmentationStats'],['../vk__mem__alloc_8h.html#ab0f9b06441c840fee560de4a2967f8c9',1,'VmaDefragmentationStats(): vk_mem_alloc.h']]], + ['vmadestroyallocator_176',['vmaDestroyAllocator',['../vk__mem__alloc_8h.html#aa8d164061c88f22fb1fd3c8f3534bc1d',1,'vk_mem_alloc.h']]], + ['vmadestroybuffer_177',['vmaDestroyBuffer',['../vk__mem__alloc_8h.html#a0d9f4e4ba5bf9aab1f1c746387753d77',1,'vk_mem_alloc.h']]], + ['vmadestroyimage_178',['vmaDestroyImage',['../vk__mem__alloc_8h.html#ae50d2cb3b4a3bfd4dd40987234e50e7e',1,'vk_mem_alloc.h']]], + ['vmadestroypool_179',['vmaDestroyPool',['../vk__mem__alloc_8h.html#a5485779c8f1948238fc4e92232fa65e1',1,'vk_mem_alloc.h']]], + ['vmadevicememorycallbacks_180',['VmaDeviceMemoryCallbacks',['../struct_vma_device_memory_callbacks.html',1,'VmaDeviceMemoryCallbacks'],['../vk__mem__alloc_8h.html#a5e2eb68d727cfd4df25702b027b7aa31',1,'VmaDeviceMemoryCallbacks(): vk_mem_alloc.h']]], + ['vmafindmemorytypeindex_181',['vmaFindMemoryTypeIndex',['../vk__mem__alloc_8h.html#aef15a94b58fbcb0fe706d5720e84a74a',1,'vk_mem_alloc.h']]], + ['vmafindmemorytypeindexforbufferinfo_182',['vmaFindMemoryTypeIndexForBufferInfo',['../vk__mem__alloc_8h.html#ae790ab9ffaf7667fb8f62523e6897888',1,'vk_mem_alloc.h']]], + ['vmafindmemorytypeindexforimageinfo_183',['vmaFindMemoryTypeIndexForImageInfo',['../vk__mem__alloc_8h.html#a088da83d8eaf3ce9056d9ea0b981d472',1,'vk_mem_alloc.h']]], + ['vmaflushallocation_184',['vmaFlushAllocation',['../vk__mem__alloc_8h.html#abc34ee6f021f459aff885f3758c435de',1,'vk_mem_alloc.h']]], + ['vmafreememory_185',['vmaFreeMemory',['../vk__mem__alloc_8h.html#a11f0fbc034fa81a4efedd73d61ce7568',1,'vk_mem_alloc.h']]], + ['vmafreememorypages_186',['vmaFreeMemoryPages',['../vk__mem__alloc_8h.html#ab9e709de044c5d8476bea77a4e755840',1,'vk_mem_alloc.h']]], + ['vmafreestatsstring_187',['vmaFreeStatsString',['../vk__mem__alloc_8h.html#a3104eb30d8122c84dd8541063f145288',1,'vk_mem_alloc.h']]], + ['vmagetallocationinfo_188',['vmaGetAllocationInfo',['../vk__mem__alloc_8h.html#a86dd08aba8633bfa4ad0df2e76481d8b',1,'vk_mem_alloc.h']]], + ['vmagetbudget_189',['vmaGetBudget',['../vk__mem__alloc_8h.html#aec0ed24ebea2d0099eed5f801daaefba',1,'vk_mem_alloc.h']]], + ['vmagetmemoryproperties_190',['vmaGetMemoryProperties',['../vk__mem__alloc_8h.html#ab88db292a17974f911182543fda52d19',1,'vk_mem_alloc.h']]], + ['vmagetmemorytypeproperties_191',['vmaGetMemoryTypeProperties',['../vk__mem__alloc_8h.html#a8701444752eb5de4464adb5a2b514bca',1,'vk_mem_alloc.h']]], + ['vmagetphysicaldeviceproperties_192',['vmaGetPhysicalDeviceProperties',['../vk__mem__alloc_8h.html#aecabf7b6e91ea87d0316fa0a9e014fe0',1,'vk_mem_alloc.h']]], + ['vmagetpoolname_193',['vmaGetPoolName',['../vk__mem__alloc_8h.html#af09b4e4eafdbee812e8d73ddf960f030',1,'vk_mem_alloc.h']]], + ['vmagetpoolstats_194',['vmaGetPoolStats',['../vk__mem__alloc_8h.html#ae8bf76997b234ef68aad922616df4153',1,'vk_mem_alloc.h']]], + ['vmainvalidateallocation_195',['vmaInvalidateAllocation',['../vk__mem__alloc_8h.html#a0d0eb0c1102268fa9a476d12ecbe4006',1,'vk_mem_alloc.h']]], + ['vmamakepoolallocationslost_196',['vmaMakePoolAllocationsLost',['../vk__mem__alloc_8h.html#a736bd6cbda886f36c891727e73bd4024',1,'vk_mem_alloc.h']]], + ['vmamapmemory_197',['vmaMapMemory',['../vk__mem__alloc_8h.html#ad5bd1243512d099706de88168992f069',1,'vk_mem_alloc.h']]], + ['vmamemoryusage_198',['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_199',['VmaPool',['../struct_vma_pool.html',1,'']]], + ['vmapoolcreateflagbits_200',['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_201',['VmaPoolCreateFlags',['../vk__mem__alloc_8h.html#a2770e325ea42e087c1b91fdf46d0292a',1,'vk_mem_alloc.h']]], + ['vmapoolcreateinfo_202',['VmaPoolCreateInfo',['../struct_vma_pool_create_info.html',1,'VmaPoolCreateInfo'],['../vk__mem__alloc_8h.html#a211706e9348dcee25a843ed4ea69bce7',1,'VmaPoolCreateInfo(): vk_mem_alloc.h']]], + ['vmapoolstats_203',['VmaPoolStats',['../struct_vma_pool_stats.html',1,'VmaPoolStats'],['../vk__mem__alloc_8h.html#a2e5612d871d64c5624087b837a338c34',1,'VmaPoolStats(): vk_mem_alloc.h']]], + ['vmarecordflagbits_204',['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_205',['VmaRecordFlags',['../vk__mem__alloc_8h.html#af3929a1a4547c592fc0b0e55ef452828',1,'vk_mem_alloc.h']]], + ['vmarecordsettings_206',['VmaRecordSettings',['../struct_vma_record_settings.html',1,'VmaRecordSettings'],['../vk__mem__alloc_8h.html#a0ab61e87ff6365f1d59915eadc37a9f0',1,'VmaRecordSettings(): vk_mem_alloc.h']]], + ['vmaresizeallocation_207',['vmaResizeAllocation',['../vk__mem__alloc_8h.html#a0ff488958ca72b28e545880463cb8696',1,'vk_mem_alloc.h']]], + ['vmasetallocationuserdata_208',['vmaSetAllocationUserData',['../vk__mem__alloc_8h.html#af9147d31ffc11d62fc187bde283ed14f',1,'vk_mem_alloc.h']]], + ['vmasetcurrentframeindex_209',['vmaSetCurrentFrameIndex',['../vk__mem__alloc_8h.html#ade56bf8dc9f5a5eaddf5f119ed525236',1,'vk_mem_alloc.h']]], + ['vmasetpoolname_210',['vmaSetPoolName',['../vk__mem__alloc_8h.html#adbae3a0b4ab078024462fc85c37f3b58',1,'vk_mem_alloc.h']]], ['vmastatinfo_211',['VmaStatInfo',['../struct_vma_stat_info.html',1,'VmaStatInfo'],['../vk__mem__alloc_8h.html#a810b009a788ee8aac72a25b42ffbe31c',1,'VmaStatInfo(): vk_mem_alloc.h']]], ['vmastats_212',['VmaStats',['../struct_vma_stats.html',1,'VmaStats'],['../vk__mem__alloc_8h.html#a732be855fb4a7c248e6853d928a729af',1,'VmaStats(): vk_mem_alloc.h']]], - ['vmatouchallocation_213',['vmaTouchAllocation',['../vk__mem__alloc_8h.html#a05304fd2aa5736517feee653e1d579d1',1,'vk_mem_alloc.h']]], - ['vmaunmapmemory_214',['vmaUnmapMemory',['../vk__mem__alloc_8h.html#a3128786cae5f317f51307074a487c278',1,'vk_mem_alloc.h']]], + ['vmatouchallocation_213',['vmaTouchAllocation',['../vk__mem__alloc_8h.html#a43d8ba9673c846f049089a5029d5c73a',1,'vk_mem_alloc.h']]], + ['vmaunmapmemory_214',['vmaUnmapMemory',['../vk__mem__alloc_8h.html#a9bc268595cb33f6ec4d519cfce81ff45',1,'vk_mem_alloc.h']]], ['vmavulkanfunctions_215',['VmaVulkanFunctions',['../struct_vma_vulkan_functions.html',1,'VmaVulkanFunctions'],['../vk__mem__alloc_8h.html#a97064a1a271b0061ebfc3a079862d0c5',1,'VmaVulkanFunctions(): vk_mem_alloc.h']]] ]; diff --git a/docs/html/search/defines_0.js b/docs/html/search/defines_0.js index 277f366..e55c466 100644 --- a/docs/html/search/defines_0.js +++ b/docs/html/search/defines_0.js @@ -1,4 +1,4 @@ var searchData= [ - ['nominmax_427',['NOMINMAX',['../vk__mem__alloc_8h.html#a9f918755b601cf4bffca775992e6fb90',1,'vk_mem_alloc.h']]] + ['nominmax_429',['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 12e720f..1635f50 100644 --- a/docs/html/search/defines_1.js +++ b/docs/html/search/defines_1.js @@ -1,8 +1,6 @@ var searchData= [ - ['vma_5fbind_5fmemory2_428',['VMA_BIND_MEMORY2',['../vk__mem__alloc_8h.html#a88bef97f86d70a34a4c0746e09a2680d',1,'vk_mem_alloc.h']]], - ['vma_5fcall_5fpost_429',['VMA_CALL_POST',['../vk__mem__alloc_8h.html#aab7d949b3d77783f0ba704ae5e3136e0',1,'vk_mem_alloc.h']]], - ['vma_5fcall_5fpre_430',['VMA_CALL_PRE',['../vk__mem__alloc_8h.html#a3f0fa870030b4d421bf71e3928d5fe31',1,'vk_mem_alloc.h']]], + ['vma_5fbind_5fmemory2_430',['VMA_BIND_MEMORY2',['../vk__mem__alloc_8h.html#a88bef97f86d70a34a4c0746e09a2680d',1,'vk_mem_alloc.h']]], ['vma_5fdedicated_5fallocation_431',['VMA_DEDICATED_ALLOCATION',['../vk__mem__alloc_8h.html#af7b860e63b96d11e44ae8587ba06bbf4',1,'vk_mem_alloc.h']]], ['vma_5fmemory_5fbudget_432',['VMA_MEMORY_BUDGET',['../vk__mem__alloc_8h.html#a05decf1cf4ebf767beba7acca6c1ec3a',1,'vk_mem_alloc.h']]], ['vma_5frecording_5fenabled_433',['VMA_RECORDING_ENABLED',['../vk__mem__alloc_8h.html#a1f0c126759fc96ccb6e2d23c101d770c',1,'vk_mem_alloc.h']]], diff --git a/docs/html/search/enums_0.js b/docs/html/search/enums_0.js index 433c013..4c09ecd 100644 --- a/docs/html/search/enums_0.js +++ b/docs/html/search/enums_0.js @@ -1,9 +1,9 @@ var searchData= [ - ['vmaallocationcreateflagbits_385',['VmaAllocationCreateFlagBits',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597',1,'vk_mem_alloc.h']]], - ['vmaallocatorcreateflagbits_386',['VmaAllocatorCreateFlagBits',['../vk__mem__alloc_8h.html#a4f87c9100d154a65a4ad495f7763cf7c',1,'vk_mem_alloc.h']]], - ['vmadefragmentationflagbits_387',['VmaDefragmentationFlagBits',['../vk__mem__alloc_8h.html#a6552a65b71d16f378c6994b3ceaef50c',1,'vk_mem_alloc.h']]], - ['vmamemoryusage_388',['VmaMemoryUsage',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305cc',1,'vk_mem_alloc.h']]], - ['vmapoolcreateflagbits_389',['VmaPoolCreateFlagBits',['../vk__mem__alloc_8h.html#a9a7c45f9c863695d98c83fa5ac940fe7',1,'vk_mem_alloc.h']]], - ['vmarecordflagbits_390',['VmaRecordFlagBits',['../vk__mem__alloc_8h.html#a4dd2c44642312a147a4e93373a6e64d2',1,'vk_mem_alloc.h']]] + ['vmaallocationcreateflagbits_387',['VmaAllocationCreateFlagBits',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597',1,'vk_mem_alloc.h']]], + ['vmaallocatorcreateflagbits_388',['VmaAllocatorCreateFlagBits',['../vk__mem__alloc_8h.html#a4f87c9100d154a65a4ad495f7763cf7c',1,'vk_mem_alloc.h']]], + ['vmadefragmentationflagbits_389',['VmaDefragmentationFlagBits',['../vk__mem__alloc_8h.html#a6552a65b71d16f378c6994b3ceaef50c',1,'vk_mem_alloc.h']]], + ['vmamemoryusage_390',['VmaMemoryUsage',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305cc',1,'vk_mem_alloc.h']]], + ['vmapoolcreateflagbits_391',['VmaPoolCreateFlagBits',['../vk__mem__alloc_8h.html#a9a7c45f9c863695d98c83fa5ac940fe7',1,'vk_mem_alloc.h']]], + ['vmarecordflagbits_392',['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 14dc76a..2de52dc 100644 --- a/docs/html/search/enumvalues_0.js +++ b/docs/html/search/enumvalues_0.js @@ -1,39 +1,39 @@ var searchData= [ - ['vma_5fallocation_5fcreate_5fcan_5fbecome_5flost_5fbit_391',['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_392',['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_393',['VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a3fc311d855c2ff53f1090ef5c722b38f',1,'vk_mem_alloc.h']]], - ['vma_5fallocation_5fcreate_5fdont_5fbind_5fbit_394',['VMA_ALLOCATION_CREATE_DONT_BIND_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a2310568c62208af432724305fe29ccea',1,'vk_mem_alloc.h']]], - ['vma_5fallocation_5fcreate_5fflag_5fbits_5fmax_5fenum_395',['VMA_ALLOCATION_CREATE_FLAG_BITS_MAX_ENUM',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597ae5633ec569f4899cf8f29e7385b2f882',1,'vk_mem_alloc.h']]], - ['vma_5fallocation_5fcreate_5fmapped_5fbit_396',['VMA_ALLOCATION_CREATE_MAPPED_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a11da372cc3a82931c5e5d6146cd9dd1f',1,'vk_mem_alloc.h']]], - ['vma_5fallocation_5fcreate_5fnever_5fallocate_5fbit_397',['VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a89759603401014eb325eb22a3839f2ff',1,'vk_mem_alloc.h']]], - ['vma_5fallocation_5fcreate_5fstrategy_5fbest_5ffit_5fbit_398',['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_399',['VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a33eb2052674f3ad92386c714a65fb777',1,'vk_mem_alloc.h']]], - ['vma_5fallocation_5fcreate_5fstrategy_5fmask_400',['VMA_ALLOCATION_CREATE_STRATEGY_MASK',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a8e16845d81ae3d27c47106d4770d5c7e',1,'vk_mem_alloc.h']]], - ['vma_5fallocation_5fcreate_5fstrategy_5fmin_5ffragmentation_5fbit_401',['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_402',['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_403',['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_404',['VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597ad242a04f802e25fef0b880afe8bb0a62',1,'vk_mem_alloc.h']]], - ['vma_5fallocation_5fcreate_5fupper_5faddress_5fbit_405',['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_406',['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_407',['VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597ab8b1764f3e9022368e440c057783b92d',1,'vk_mem_alloc.h']]], - ['vma_5fallocator_5fcreate_5fext_5fmemory_5fbudget_5fbit_408',['VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT',['../vk__mem__alloc_8h.html#a4f87c9100d154a65a4ad495f7763cf7ca4d4687863f7bd4b418c6006dc04400b0',1,'vk_mem_alloc.h']]], - ['vma_5fallocator_5fcreate_5fexternally_5fsynchronized_5fbit_409',['VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT',['../vk__mem__alloc_8h.html#a4f87c9100d154a65a4ad495f7763cf7ca4816ddaed324ba110172ca608a20f29d',1,'vk_mem_alloc.h']]], - ['vma_5fallocator_5fcreate_5fflag_5fbits_5fmax_5fenum_410',['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_411',['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_412',['VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT',['../vk__mem__alloc_8h.html#a4f87c9100d154a65a4ad495f7763cf7cace7da7cc6e71a625dfa763c55a597878',1,'vk_mem_alloc.h']]], - ['vma_5fdefragmentation_5fflag_5fbits_5fmax_5fenum_413',['VMA_DEFRAGMENTATION_FLAG_BITS_MAX_ENUM',['../vk__mem__alloc_8h.html#a6552a65b71d16f378c6994b3ceaef50cab87ec33154803bfeb5ac2b379f1d6a97',1,'vk_mem_alloc.h']]], - ['vma_5fmemory_5fusage_5fcpu_5fonly_414',['VMA_MEMORY_USAGE_CPU_ONLY',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305cca40bdf4cddeffeb12f43d45ca1286e0a5',1,'vk_mem_alloc.h']]], - ['vma_5fmemory_5fusage_5fcpu_5fto_5fgpu_415',['VMA_MEMORY_USAGE_CPU_TO_GPU',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305cca9066b52c5a7079bb74a69aaf8b92ff67',1,'vk_mem_alloc.h']]], - ['vma_5fmemory_5fusage_5fgpu_5fonly_416',['VMA_MEMORY_USAGE_GPU_ONLY',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305ccac6b5dc1432d88647aa4cd456246eadf7',1,'vk_mem_alloc.h']]], - ['vma_5fmemory_5fusage_5fgpu_5fto_5fcpu_417',['VMA_MEMORY_USAGE_GPU_TO_CPU',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305cca7b586d2fdaf82a463b58f581ed72be27',1,'vk_mem_alloc.h']]], - ['vma_5fmemory_5fusage_5fmax_5fenum_418',['VMA_MEMORY_USAGE_MAX_ENUM',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305cca091e69437ef693e8d0d287f1c719ba6e',1,'vk_mem_alloc.h']]], - ['vma_5fmemory_5fusage_5funknown_419',['VMA_MEMORY_USAGE_UNKNOWN',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305ccaf50d27e34e0925cf3a63db8c839121dd',1,'vk_mem_alloc.h']]], - ['vma_5fpool_5fcreate_5falgorithm_5fmask_420',['VMA_POOL_CREATE_ALGORITHM_MASK',['../vk__mem__alloc_8h.html#a9a7c45f9c863695d98c83fa5ac940fe7af4d270f8f42517a0f70037ceb6ac1d9c',1,'vk_mem_alloc.h']]], - ['vma_5fpool_5fcreate_5fbuddy_5falgorithm_5fbit_421',['VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT',['../vk__mem__alloc_8h.html#a9a7c45f9c863695d98c83fa5ac940fe7a97a0dc38e5161b780594d998d313d35e',1,'vk_mem_alloc.h']]], - ['vma_5fpool_5fcreate_5fflag_5fbits_5fmax_5fenum_422',['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_423',['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_424',['VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT',['../vk__mem__alloc_8h.html#a9a7c45f9c863695d98c83fa5ac940fe7a13c8a444197c67866be9cb05599fc726',1,'vk_mem_alloc.h']]], - ['vma_5frecord_5fflag_5fbits_5fmax_5fenum_425',['VMA_RECORD_FLAG_BITS_MAX_ENUM',['../vk__mem__alloc_8h.html#a4dd2c44642312a147a4e93373a6e64d2a20dd17d69966dbffa054739d6090b85e',1,'vk_mem_alloc.h']]], - ['vma_5frecord_5fflush_5fafter_5fcall_5fbit_426',['VMA_RECORD_FLUSH_AFTER_CALL_BIT',['../vk__mem__alloc_8h.html#a4dd2c44642312a147a4e93373a6e64d2a8e7ab322e8732654be627c4ea8f36cc7',1,'vk_mem_alloc.h']]] + ['vma_5fallocation_5fcreate_5fcan_5fbecome_5flost_5fbit_393',['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_394',['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_395',['VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a3fc311d855c2ff53f1090ef5c722b38f',1,'vk_mem_alloc.h']]], + ['vma_5fallocation_5fcreate_5fdont_5fbind_5fbit_396',['VMA_ALLOCATION_CREATE_DONT_BIND_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a2310568c62208af432724305fe29ccea',1,'vk_mem_alloc.h']]], + ['vma_5fallocation_5fcreate_5fflag_5fbits_5fmax_5fenum_397',['VMA_ALLOCATION_CREATE_FLAG_BITS_MAX_ENUM',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597ae5633ec569f4899cf8f29e7385b2f882',1,'vk_mem_alloc.h']]], + ['vma_5fallocation_5fcreate_5fmapped_5fbit_398',['VMA_ALLOCATION_CREATE_MAPPED_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a11da372cc3a82931c5e5d6146cd9dd1f',1,'vk_mem_alloc.h']]], + ['vma_5fallocation_5fcreate_5fnever_5fallocate_5fbit_399',['VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a89759603401014eb325eb22a3839f2ff',1,'vk_mem_alloc.h']]], + ['vma_5fallocation_5fcreate_5fstrategy_5fbest_5ffit_5fbit_400',['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_401',['VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a33eb2052674f3ad92386c714a65fb777',1,'vk_mem_alloc.h']]], + ['vma_5fallocation_5fcreate_5fstrategy_5fmask_402',['VMA_ALLOCATION_CREATE_STRATEGY_MASK',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597a8e16845d81ae3d27c47106d4770d5c7e',1,'vk_mem_alloc.h']]], + ['vma_5fallocation_5fcreate_5fstrategy_5fmin_5ffragmentation_5fbit_403',['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_404',['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_405',['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_406',['VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597ad242a04f802e25fef0b880afe8bb0a62',1,'vk_mem_alloc.h']]], + ['vma_5fallocation_5fcreate_5fupper_5faddress_5fbit_407',['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_408',['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_409',['VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT',['../vk__mem__alloc_8h.html#ad9889c10c798b040d59c92f257cae597ab8b1764f3e9022368e440c057783b92d',1,'vk_mem_alloc.h']]], + ['vma_5fallocator_5fcreate_5fext_5fmemory_5fbudget_5fbit_410',['VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT',['../vk__mem__alloc_8h.html#a4f87c9100d154a65a4ad495f7763cf7ca4d4687863f7bd4b418c6006dc04400b0',1,'vk_mem_alloc.h']]], + ['vma_5fallocator_5fcreate_5fexternally_5fsynchronized_5fbit_411',['VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT',['../vk__mem__alloc_8h.html#a4f87c9100d154a65a4ad495f7763cf7ca4816ddaed324ba110172ca608a20f29d',1,'vk_mem_alloc.h']]], + ['vma_5fallocator_5fcreate_5fflag_5fbits_5fmax_5fenum_412',['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_413',['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_414',['VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT',['../vk__mem__alloc_8h.html#a4f87c9100d154a65a4ad495f7763cf7cace7da7cc6e71a625dfa763c55a597878',1,'vk_mem_alloc.h']]], + ['vma_5fdefragmentation_5fflag_5fbits_5fmax_5fenum_415',['VMA_DEFRAGMENTATION_FLAG_BITS_MAX_ENUM',['../vk__mem__alloc_8h.html#a6552a65b71d16f378c6994b3ceaef50cab87ec33154803bfeb5ac2b379f1d6a97',1,'vk_mem_alloc.h']]], + ['vma_5fmemory_5fusage_5fcpu_5fonly_416',['VMA_MEMORY_USAGE_CPU_ONLY',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305cca40bdf4cddeffeb12f43d45ca1286e0a5',1,'vk_mem_alloc.h']]], + ['vma_5fmemory_5fusage_5fcpu_5fto_5fgpu_417',['VMA_MEMORY_USAGE_CPU_TO_GPU',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305cca9066b52c5a7079bb74a69aaf8b92ff67',1,'vk_mem_alloc.h']]], + ['vma_5fmemory_5fusage_5fgpu_5fonly_418',['VMA_MEMORY_USAGE_GPU_ONLY',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305ccac6b5dc1432d88647aa4cd456246eadf7',1,'vk_mem_alloc.h']]], + ['vma_5fmemory_5fusage_5fgpu_5fto_5fcpu_419',['VMA_MEMORY_USAGE_GPU_TO_CPU',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305cca7b586d2fdaf82a463b58f581ed72be27',1,'vk_mem_alloc.h']]], + ['vma_5fmemory_5fusage_5fmax_5fenum_420',['VMA_MEMORY_USAGE_MAX_ENUM',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305cca091e69437ef693e8d0d287f1c719ba6e',1,'vk_mem_alloc.h']]], + ['vma_5fmemory_5fusage_5funknown_421',['VMA_MEMORY_USAGE_UNKNOWN',['../vk__mem__alloc_8h.html#aa5846affa1e9da3800e3e78fae2305ccaf50d27e34e0925cf3a63db8c839121dd',1,'vk_mem_alloc.h']]], + ['vma_5fpool_5fcreate_5falgorithm_5fmask_422',['VMA_POOL_CREATE_ALGORITHM_MASK',['../vk__mem__alloc_8h.html#a9a7c45f9c863695d98c83fa5ac940fe7af4d270f8f42517a0f70037ceb6ac1d9c',1,'vk_mem_alloc.h']]], + ['vma_5fpool_5fcreate_5fbuddy_5falgorithm_5fbit_423',['VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT',['../vk__mem__alloc_8h.html#a9a7c45f9c863695d98c83fa5ac940fe7a97a0dc38e5161b780594d998d313d35e',1,'vk_mem_alloc.h']]], + ['vma_5fpool_5fcreate_5fflag_5fbits_5fmax_5fenum_424',['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_425',['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_426',['VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT',['../vk__mem__alloc_8h.html#a9a7c45f9c863695d98c83fa5ac940fe7a13c8a444197c67866be9cb05599fc726',1,'vk_mem_alloc.h']]], + ['vma_5frecord_5fflag_5fbits_5fmax_5fenum_427',['VMA_RECORD_FLAG_BITS_MAX_ENUM',['../vk__mem__alloc_8h.html#a4dd2c44642312a147a4e93373a6e64d2a20dd17d69966dbffa054739d6090b85e',1,'vk_mem_alloc.h']]], + ['vma_5frecord_5fflush_5fafter_5fcall_5fbit_428',['VMA_RECORD_FLUSH_AFTER_CALL_BIT',['../vk__mem__alloc_8h.html#a4dd2c44642312a147a4e93373a6e64d2a8e7ab322e8732654be627c4ea8f36cc7',1,'vk_mem_alloc.h']]] ]; diff --git a/docs/html/search/functions_0.js b/docs/html/search/functions_0.js index a9d6723..b2d389a 100644 --- a/docs/html/search/functions_0.js +++ b/docs/html/search/functions_0.js @@ -1,48 +1,50 @@ var searchData= [ - ['vmaallocatememory_235',['vmaAllocateMemory',['../vk__mem__alloc_8h.html#a6e40022ab443f88bfa8b13c2fcfd05cc',1,'vk_mem_alloc.h']]], - ['vmaallocatememoryforbuffer_236',['vmaAllocateMemoryForBuffer',['../vk__mem__alloc_8h.html#af34f6d2ec25537ac0179ff614bae0012',1,'vk_mem_alloc.h']]], - ['vmaallocatememoryforimage_237',['vmaAllocateMemoryForImage',['../vk__mem__alloc_8h.html#a25e3b30b93063b921d5078e538b1bf30',1,'vk_mem_alloc.h']]], - ['vmaallocatememorypages_238',['vmaAllocateMemoryPages',['../vk__mem__alloc_8h.html#a35b49cebb7d7c128db38d3949f54e325',1,'vk_mem_alloc.h']]], - ['vmabindbuffermemory_239',['vmaBindBufferMemory',['../vk__mem__alloc_8h.html#a055cbf8d000a019a6270c66b46f0cb40',1,'vk_mem_alloc.h']]], - ['vmabindbuffermemory2_240',['vmaBindBufferMemory2',['../vk__mem__alloc_8h.html#aa06d8fe2e969c048182e019f4b857ccf',1,'vk_mem_alloc.h']]], - ['vmabindimagememory_241',['vmaBindImageMemory',['../vk__mem__alloc_8h.html#a9681b4996d0d33ad0bc811fc7394d272',1,'vk_mem_alloc.h']]], - ['vmabindimagememory2_242',['vmaBindImageMemory2',['../vk__mem__alloc_8h.html#a82e760a2db3b517b965320ba71ebbfbb',1,'vk_mem_alloc.h']]], - ['vmabuildstatsstring_243',['vmaBuildStatsString',['../vk__mem__alloc_8h.html#a4d7fc62aef0239d260e647447605aad4',1,'vk_mem_alloc.h']]], - ['vmacalculatestats_244',['vmaCalculateStats',['../vk__mem__alloc_8h.html#a27abba9dd2d1ea2026f7f4dfb548638b',1,'vk_mem_alloc.h']]], - ['vmacheckcorruption_245',['vmaCheckCorruption',['../vk__mem__alloc_8h.html#a6e53d9caa4368576cf351300b64ef8f4',1,'vk_mem_alloc.h']]], - ['vmacheckpoolcorruption_246',['vmaCheckPoolCorruption',['../vk__mem__alloc_8h.html#a6bdc403637fe34c4dbb7f7de39357e02',1,'vk_mem_alloc.h']]], - ['vmacreateallocator_247',['vmaCreateAllocator',['../vk__mem__alloc_8h.html#af2bacace15ecc6886e4e4de5d1b77e4d',1,'vk_mem_alloc.h']]], - ['vmacreatebuffer_248',['vmaCreateBuffer',['../vk__mem__alloc_8h.html#aafee10cbb01be73c643ed7e02c31003f',1,'vk_mem_alloc.h']]], - ['vmacreateimage_249',['vmaCreateImage',['../vk__mem__alloc_8h.html#a001bd7a2077a42caf256a6fb2f2ba131',1,'vk_mem_alloc.h']]], - ['vmacreatelostallocation_250',['vmaCreateLostAllocation',['../vk__mem__alloc_8h.html#af70dc16d3b2818d514face3ed916f492',1,'vk_mem_alloc.h']]], - ['vmacreatepool_251',['vmaCreatePool',['../vk__mem__alloc_8h.html#aee3406ab6b195cd85207ca2ef2d13a57',1,'vk_mem_alloc.h']]], - ['vmadefragment_252',['vmaDefragment',['../vk__mem__alloc_8h.html#a2c33b164a2597db181db3ca8e5812e4c',1,'vk_mem_alloc.h']]], - ['vmadefragmentationbegin_253',['vmaDefragmentationBegin',['../vk__mem__alloc_8h.html#a696fc71963b7711cc0db3cc2225d0cd7',1,'vk_mem_alloc.h']]], - ['vmadefragmentationend_254',['vmaDefragmentationEnd',['../vk__mem__alloc_8h.html#a5e9d96ef2cbd8263cc523da91d1b40c9',1,'vk_mem_alloc.h']]], - ['vmadestroyallocator_255',['vmaDestroyAllocator',['../vk__mem__alloc_8h.html#a288d938ca902469760248ebd3633dde5',1,'vk_mem_alloc.h']]], - ['vmadestroybuffer_256',['vmaDestroyBuffer',['../vk__mem__alloc_8h.html#a3fa3daa743fcc950253f676aa8a323ea',1,'vk_mem_alloc.h']]], - ['vmadestroyimage_257',['vmaDestroyImage',['../vk__mem__alloc_8h.html#a6d7d34a7e2ef515a2734bdfdf7a76a9f',1,'vk_mem_alloc.h']]], - ['vmadestroypool_258',['vmaDestroyPool',['../vk__mem__alloc_8h.html#a11693ab08f65761a142c466c5eceb849',1,'vk_mem_alloc.h']]], - ['vmafindmemorytypeindex_259',['vmaFindMemoryTypeIndex',['../vk__mem__alloc_8h.html#a21530f0bd74d92b40cc1873e5037662c',1,'vk_mem_alloc.h']]], - ['vmafindmemorytypeindexforbufferinfo_260',['vmaFindMemoryTypeIndexForBufferInfo',['../vk__mem__alloc_8h.html#a425905e868e4b487b5188f9d834dacbc',1,'vk_mem_alloc.h']]], - ['vmafindmemorytypeindexforimageinfo_261',['vmaFindMemoryTypeIndexForImageInfo',['../vk__mem__alloc_8h.html#a359c5187b7004880945f0e3debba91b9',1,'vk_mem_alloc.h']]], - ['vmaflushallocation_262',['vmaFlushAllocation',['../vk__mem__alloc_8h.html#aca66f515fb5c3b370eaa9d826785c2c6',1,'vk_mem_alloc.h']]], - ['vmafreememory_263',['vmaFreeMemory',['../vk__mem__alloc_8h.html#a0438b3d982473eb1c93c77c7ab3212e1',1,'vk_mem_alloc.h']]], - ['vmafreememorypages_264',['vmaFreeMemoryPages',['../vk__mem__alloc_8h.html#aab00eabeaf43039298442591bcfba836',1,'vk_mem_alloc.h']]], - ['vmafreestatsstring_265',['vmaFreeStatsString',['../vk__mem__alloc_8h.html#aff001c5ec4ab2aeef3176804d6a865a9',1,'vk_mem_alloc.h']]], - ['vmagetallocationinfo_266',['vmaGetAllocationInfo',['../vk__mem__alloc_8h.html#ae10b53588f197141c6e88a1f5ec34789',1,'vk_mem_alloc.h']]], - ['vmagetbudget_267',['vmaGetBudget',['../vk__mem__alloc_8h.html#a2d9ae6d97e48d85f5b6a685742d5f6f0',1,'vk_mem_alloc.h']]], - ['vmagetmemoryproperties_268',['vmaGetMemoryProperties',['../vk__mem__alloc_8h.html#ada321efa19065e5a87f79dcbe11369a5',1,'vk_mem_alloc.h']]], - ['vmagetmemorytypeproperties_269',['vmaGetMemoryTypeProperties',['../vk__mem__alloc_8h.html#ad0b03b51a0dff5dab25ac9c194fef3e1',1,'vk_mem_alloc.h']]], - ['vmagetphysicaldeviceproperties_270',['vmaGetPhysicalDeviceProperties',['../vk__mem__alloc_8h.html#a236c3299ad132eb753dbcbf6e309849e',1,'vk_mem_alloc.h']]], - ['vmagetpoolstats_271',['vmaGetPoolStats',['../vk__mem__alloc_8h.html#abb343b27164d08d2b97e3b0c30ecdcbf',1,'vk_mem_alloc.h']]], - ['vmainvalidateallocation_272',['vmaInvalidateAllocation',['../vk__mem__alloc_8h.html#a7489ab3d91f0011e2ed22f266f76966c',1,'vk_mem_alloc.h']]], - ['vmamakepoolallocationslost_273',['vmaMakePoolAllocationsLost',['../vk__mem__alloc_8h.html#aaf235cb916f4c56feafdce45227fd17a',1,'vk_mem_alloc.h']]], - ['vmamapmemory_274',['vmaMapMemory',['../vk__mem__alloc_8h.html#ae98119383e8e5754b6c09679386677d3',1,'vk_mem_alloc.h']]], - ['vmaresizeallocation_275',['vmaResizeAllocation',['../vk__mem__alloc_8h.html#a36e0067f27609620651eefdf98ce624e',1,'vk_mem_alloc.h']]], - ['vmasetallocationuserdata_276',['vmaSetAllocationUserData',['../vk__mem__alloc_8h.html#a402558851f800ecd733800962c227f6a',1,'vk_mem_alloc.h']]], - ['vmasetcurrentframeindex_277',['vmaSetCurrentFrameIndex',['../vk__mem__alloc_8h.html#a763d86a0fa9613d81b19dc724d418f67',1,'vk_mem_alloc.h']]], - ['vmatouchallocation_278',['vmaTouchAllocation',['../vk__mem__alloc_8h.html#a05304fd2aa5736517feee653e1d579d1',1,'vk_mem_alloc.h']]], - ['vmaunmapmemory_279',['vmaUnmapMemory',['../vk__mem__alloc_8h.html#a3128786cae5f317f51307074a487c278',1,'vk_mem_alloc.h']]] + ['vmaallocatememory_235',['vmaAllocateMemory',['../vk__mem__alloc_8h.html#abf28077dbf82d0908b8acbe8ee8dd9b8',1,'vk_mem_alloc.h']]], + ['vmaallocatememoryforbuffer_236',['vmaAllocateMemoryForBuffer',['../vk__mem__alloc_8h.html#a7fdf64415b6c3d83c454f28d2c53df7b',1,'vk_mem_alloc.h']]], + ['vmaallocatememoryforimage_237',['vmaAllocateMemoryForImage',['../vk__mem__alloc_8h.html#a0faa3f9e5fb233d29d1e00390650febb',1,'vk_mem_alloc.h']]], + ['vmaallocatememorypages_238',['vmaAllocateMemoryPages',['../vk__mem__alloc_8h.html#ad37e82e492b3de38fc3f4cffd9ad0ae1',1,'vk_mem_alloc.h']]], + ['vmabindbuffermemory_239',['vmaBindBufferMemory',['../vk__mem__alloc_8h.html#a6b0929b914b60cf2d45cac4bf3547470',1,'vk_mem_alloc.h']]], + ['vmabindbuffermemory2_240',['vmaBindBufferMemory2',['../vk__mem__alloc_8h.html#a927c944f45e0f2941182abb6f608e64a',1,'vk_mem_alloc.h']]], + ['vmabindimagememory_241',['vmaBindImageMemory',['../vk__mem__alloc_8h.html#a3d3ca45799923aa5d138e9e5f9eb2da5',1,'vk_mem_alloc.h']]], + ['vmabindimagememory2_242',['vmaBindImageMemory2',['../vk__mem__alloc_8h.html#aa8251ee81b0045a443e35b8e8aa021bc',1,'vk_mem_alloc.h']]], + ['vmabuildstatsstring_243',['vmaBuildStatsString',['../vk__mem__alloc_8h.html#aa4fee7eb5253377599ef4fd38c93c2a0',1,'vk_mem_alloc.h']]], + ['vmacalculatestats_244',['vmaCalculateStats',['../vk__mem__alloc_8h.html#a333b61c1788cb23559177531e6a93ca3',1,'vk_mem_alloc.h']]], + ['vmacheckcorruption_245',['vmaCheckCorruption',['../vk__mem__alloc_8h.html#a49329a7f030dafcf82f7b73334c22e98',1,'vk_mem_alloc.h']]], + ['vmacheckpoolcorruption_246',['vmaCheckPoolCorruption',['../vk__mem__alloc_8h.html#ad535935619c7a549bf837e1bb0068f89',1,'vk_mem_alloc.h']]], + ['vmacreateallocator_247',['vmaCreateAllocator',['../vk__mem__alloc_8h.html#a200692051ddb34240248234f5f4c17bb',1,'vk_mem_alloc.h']]], + ['vmacreatebuffer_248',['vmaCreateBuffer',['../vk__mem__alloc_8h.html#ac72ee55598617e8eecca384e746bab51',1,'vk_mem_alloc.h']]], + ['vmacreateimage_249',['vmaCreateImage',['../vk__mem__alloc_8h.html#a02a94f25679275851a53e82eacbcfc73',1,'vk_mem_alloc.h']]], + ['vmacreatelostallocation_250',['vmaCreateLostAllocation',['../vk__mem__alloc_8h.html#ae5c9657d9e94756269145b01c05d16f1',1,'vk_mem_alloc.h']]], + ['vmacreatepool_251',['vmaCreatePool',['../vk__mem__alloc_8h.html#a5c8770ded7c59c8caac6de0c2cb00b50',1,'vk_mem_alloc.h']]], + ['vmadefragment_252',['vmaDefragment',['../vk__mem__alloc_8h.html#a6aced90fcc7b39882b6654a740a0b9bb',1,'vk_mem_alloc.h']]], + ['vmadefragmentationbegin_253',['vmaDefragmentationBegin',['../vk__mem__alloc_8h.html#a36ba776fd7fd5cb1e9359fdc0d8e6e8a',1,'vk_mem_alloc.h']]], + ['vmadefragmentationend_254',['vmaDefragmentationEnd',['../vk__mem__alloc_8h.html#a8774e20e91e245aae959ba63efa15dd2',1,'vk_mem_alloc.h']]], + ['vmadestroyallocator_255',['vmaDestroyAllocator',['../vk__mem__alloc_8h.html#aa8d164061c88f22fb1fd3c8f3534bc1d',1,'vk_mem_alloc.h']]], + ['vmadestroybuffer_256',['vmaDestroyBuffer',['../vk__mem__alloc_8h.html#a0d9f4e4ba5bf9aab1f1c746387753d77',1,'vk_mem_alloc.h']]], + ['vmadestroyimage_257',['vmaDestroyImage',['../vk__mem__alloc_8h.html#ae50d2cb3b4a3bfd4dd40987234e50e7e',1,'vk_mem_alloc.h']]], + ['vmadestroypool_258',['vmaDestroyPool',['../vk__mem__alloc_8h.html#a5485779c8f1948238fc4e92232fa65e1',1,'vk_mem_alloc.h']]], + ['vmafindmemorytypeindex_259',['vmaFindMemoryTypeIndex',['../vk__mem__alloc_8h.html#aef15a94b58fbcb0fe706d5720e84a74a',1,'vk_mem_alloc.h']]], + ['vmafindmemorytypeindexforbufferinfo_260',['vmaFindMemoryTypeIndexForBufferInfo',['../vk__mem__alloc_8h.html#ae790ab9ffaf7667fb8f62523e6897888',1,'vk_mem_alloc.h']]], + ['vmafindmemorytypeindexforimageinfo_261',['vmaFindMemoryTypeIndexForImageInfo',['../vk__mem__alloc_8h.html#a088da83d8eaf3ce9056d9ea0b981d472',1,'vk_mem_alloc.h']]], + ['vmaflushallocation_262',['vmaFlushAllocation',['../vk__mem__alloc_8h.html#abc34ee6f021f459aff885f3758c435de',1,'vk_mem_alloc.h']]], + ['vmafreememory_263',['vmaFreeMemory',['../vk__mem__alloc_8h.html#a11f0fbc034fa81a4efedd73d61ce7568',1,'vk_mem_alloc.h']]], + ['vmafreememorypages_264',['vmaFreeMemoryPages',['../vk__mem__alloc_8h.html#ab9e709de044c5d8476bea77a4e755840',1,'vk_mem_alloc.h']]], + ['vmafreestatsstring_265',['vmaFreeStatsString',['../vk__mem__alloc_8h.html#a3104eb30d8122c84dd8541063f145288',1,'vk_mem_alloc.h']]], + ['vmagetallocationinfo_266',['vmaGetAllocationInfo',['../vk__mem__alloc_8h.html#a86dd08aba8633bfa4ad0df2e76481d8b',1,'vk_mem_alloc.h']]], + ['vmagetbudget_267',['vmaGetBudget',['../vk__mem__alloc_8h.html#aec0ed24ebea2d0099eed5f801daaefba',1,'vk_mem_alloc.h']]], + ['vmagetmemoryproperties_268',['vmaGetMemoryProperties',['../vk__mem__alloc_8h.html#ab88db292a17974f911182543fda52d19',1,'vk_mem_alloc.h']]], + ['vmagetmemorytypeproperties_269',['vmaGetMemoryTypeProperties',['../vk__mem__alloc_8h.html#a8701444752eb5de4464adb5a2b514bca',1,'vk_mem_alloc.h']]], + ['vmagetphysicaldeviceproperties_270',['vmaGetPhysicalDeviceProperties',['../vk__mem__alloc_8h.html#aecabf7b6e91ea87d0316fa0a9e014fe0',1,'vk_mem_alloc.h']]], + ['vmagetpoolname_271',['vmaGetPoolName',['../vk__mem__alloc_8h.html#af09b4e4eafdbee812e8d73ddf960f030',1,'vk_mem_alloc.h']]], + ['vmagetpoolstats_272',['vmaGetPoolStats',['../vk__mem__alloc_8h.html#ae8bf76997b234ef68aad922616df4153',1,'vk_mem_alloc.h']]], + ['vmainvalidateallocation_273',['vmaInvalidateAllocation',['../vk__mem__alloc_8h.html#a0d0eb0c1102268fa9a476d12ecbe4006',1,'vk_mem_alloc.h']]], + ['vmamakepoolallocationslost_274',['vmaMakePoolAllocationsLost',['../vk__mem__alloc_8h.html#a736bd6cbda886f36c891727e73bd4024',1,'vk_mem_alloc.h']]], + ['vmamapmemory_275',['vmaMapMemory',['../vk__mem__alloc_8h.html#ad5bd1243512d099706de88168992f069',1,'vk_mem_alloc.h']]], + ['vmaresizeallocation_276',['vmaResizeAllocation',['../vk__mem__alloc_8h.html#a0ff488958ca72b28e545880463cb8696',1,'vk_mem_alloc.h']]], + ['vmasetallocationuserdata_277',['vmaSetAllocationUserData',['../vk__mem__alloc_8h.html#af9147d31ffc11d62fc187bde283ed14f',1,'vk_mem_alloc.h']]], + ['vmasetcurrentframeindex_278',['vmaSetCurrentFrameIndex',['../vk__mem__alloc_8h.html#ade56bf8dc9f5a5eaddf5f119ed525236',1,'vk_mem_alloc.h']]], + ['vmasetpoolname_279',['vmaSetPoolName',['../vk__mem__alloc_8h.html#adbae3a0b4ab078024462fc85c37f3b58',1,'vk_mem_alloc.h']]], + ['vmatouchallocation_280',['vmaTouchAllocation',['../vk__mem__alloc_8h.html#a43d8ba9673c846f049089a5029d5c73a',1,'vk_mem_alloc.h']]], + ['vmaunmapmemory_281',['vmaUnmapMemory',['../vk__mem__alloc_8h.html#a9bc268595cb33f6ec4d519cfce81ff45',1,'vk_mem_alloc.h']]] ]; diff --git a/docs/html/search/typedefs_0.js b/docs/html/search/typedefs_0.js index c5622f9..7b43687 100644 --- a/docs/html/search/typedefs_0.js +++ b/docs/html/search/typedefs_0.js @@ -1,5 +1,5 @@ var searchData= [ - ['pfn_5fvmaallocatedevicememoryfunction_358',['PFN_vmaAllocateDeviceMemoryFunction',['../vk__mem__alloc_8h.html#ab6a6477cda1ce775b30bde96d766203b',1,'vk_mem_alloc.h']]], - ['pfn_5fvmafreedevicememoryfunction_359',['PFN_vmaFreeDeviceMemoryFunction',['../vk__mem__alloc_8h.html#aef2545dc2e9dd4f29ab9ba6ac6fe2f49',1,'vk_mem_alloc.h']]] + ['pfn_5fvmaallocatedevicememoryfunction_360',['PFN_vmaAllocateDeviceMemoryFunction',['../vk__mem__alloc_8h.html#ab6a6477cda1ce775b30bde96d766203b',1,'vk_mem_alloc.h']]], + ['pfn_5fvmafreedevicememoryfunction_361',['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 25020fe..1763f42 100644 --- a/docs/html/search/typedefs_1.js +++ b/docs/html/search/typedefs_1.js @@ -1,28 +1,28 @@ var searchData= [ - ['vmaallocationcreateflagbits_360',['VmaAllocationCreateFlagBits',['../vk__mem__alloc_8h.html#abf6bf6748c7a9fe7ce5b7835c0f56af4',1,'vk_mem_alloc.h']]], - ['vmaallocationcreateflags_361',['VmaAllocationCreateFlags',['../vk__mem__alloc_8h.html#a5225e5e11f8376f6a31a1791f3d6e817',1,'vk_mem_alloc.h']]], - ['vmaallocationcreateinfo_362',['VmaAllocationCreateInfo',['../vk__mem__alloc_8h.html#a86c44f9950b40d50088ed93a17870a7a',1,'vk_mem_alloc.h']]], - ['vmaallocationinfo_363',['VmaAllocationInfo',['../vk__mem__alloc_8h.html#a795e6ff02a21d5486c0565f403dd9255',1,'vk_mem_alloc.h']]], - ['vmaallocatorcreateflagbits_364',['VmaAllocatorCreateFlagBits',['../vk__mem__alloc_8h.html#a4ddf381b6ce795bdfbc6c614640b9915',1,'vk_mem_alloc.h']]], - ['vmaallocatorcreateflags_365',['VmaAllocatorCreateFlags',['../vk__mem__alloc_8h.html#acfe6863e160722c2c1bbcf7573fddc4d',1,'vk_mem_alloc.h']]], - ['vmaallocatorcreateinfo_366',['VmaAllocatorCreateInfo',['../vk__mem__alloc_8h.html#ae0f6d1d733dded220d28134da46b4283',1,'vk_mem_alloc.h']]], - ['vmabudget_367',['VmaBudget',['../vk__mem__alloc_8h.html#ab79b48b6d25aada0de91a913896e1c38',1,'vk_mem_alloc.h']]], - ['vmadefragmentationflagbits_368',['VmaDefragmentationFlagBits',['../vk__mem__alloc_8h.html#a96df0eddab2e1735782fe4e7cd05ea7f',1,'vk_mem_alloc.h']]], - ['vmadefragmentationflags_369',['VmaDefragmentationFlags',['../vk__mem__alloc_8h.html#a88a77cef37e5d3c4fc9eb328885d048d',1,'vk_mem_alloc.h']]], - ['vmadefragmentationinfo_370',['VmaDefragmentationInfo',['../vk__mem__alloc_8h.html#ae67f8573a0cf20f16f0a1eecbca566a0',1,'vk_mem_alloc.h']]], - ['vmadefragmentationinfo2_371',['VmaDefragmentationInfo2',['../vk__mem__alloc_8h.html#abac0e85abaa6ea1ffd63bde29c5c3a29',1,'vk_mem_alloc.h']]], - ['vmadefragmentationstats_372',['VmaDefragmentationStats',['../vk__mem__alloc_8h.html#ab0f9b06441c840fee560de4a2967f8c9',1,'vk_mem_alloc.h']]], - ['vmadevicememorycallbacks_373',['VmaDeviceMemoryCallbacks',['../vk__mem__alloc_8h.html#a5e2eb68d727cfd4df25702b027b7aa31',1,'vk_mem_alloc.h']]], - ['vmamemoryusage_374',['VmaMemoryUsage',['../vk__mem__alloc_8h.html#ad63b2113c0bfdbeade1cb498f5a8580d',1,'vk_mem_alloc.h']]], - ['vmapoolcreateflagbits_375',['VmaPoolCreateFlagBits',['../vk__mem__alloc_8h.html#a8f93195158e0e2ac80ca352064e71c1f',1,'vk_mem_alloc.h']]], - ['vmapoolcreateflags_376',['VmaPoolCreateFlags',['../vk__mem__alloc_8h.html#a2770e325ea42e087c1b91fdf46d0292a',1,'vk_mem_alloc.h']]], - ['vmapoolcreateinfo_377',['VmaPoolCreateInfo',['../vk__mem__alloc_8h.html#a211706e9348dcee25a843ed4ea69bce7',1,'vk_mem_alloc.h']]], - ['vmapoolstats_378',['VmaPoolStats',['../vk__mem__alloc_8h.html#a2e5612d871d64c5624087b837a338c34',1,'vk_mem_alloc.h']]], - ['vmarecordflagbits_379',['VmaRecordFlagBits',['../vk__mem__alloc_8h.html#ade20b626a6635ce1bf30ea53dea774e4',1,'vk_mem_alloc.h']]], - ['vmarecordflags_380',['VmaRecordFlags',['../vk__mem__alloc_8h.html#af3929a1a4547c592fc0b0e55ef452828',1,'vk_mem_alloc.h']]], - ['vmarecordsettings_381',['VmaRecordSettings',['../vk__mem__alloc_8h.html#a0ab61e87ff6365f1d59915eadc37a9f0',1,'vk_mem_alloc.h']]], - ['vmastatinfo_382',['VmaStatInfo',['../vk__mem__alloc_8h.html#a810b009a788ee8aac72a25b42ffbe31c',1,'vk_mem_alloc.h']]], - ['vmastats_383',['VmaStats',['../vk__mem__alloc_8h.html#a732be855fb4a7c248e6853d928a729af',1,'vk_mem_alloc.h']]], - ['vmavulkanfunctions_384',['VmaVulkanFunctions',['../vk__mem__alloc_8h.html#a97064a1a271b0061ebfc3a079862d0c5',1,'vk_mem_alloc.h']]] + ['vmaallocationcreateflagbits_362',['VmaAllocationCreateFlagBits',['../vk__mem__alloc_8h.html#abf6bf6748c7a9fe7ce5b7835c0f56af4',1,'vk_mem_alloc.h']]], + ['vmaallocationcreateflags_363',['VmaAllocationCreateFlags',['../vk__mem__alloc_8h.html#a5225e5e11f8376f6a31a1791f3d6e817',1,'vk_mem_alloc.h']]], + ['vmaallocationcreateinfo_364',['VmaAllocationCreateInfo',['../vk__mem__alloc_8h.html#a86c44f9950b40d50088ed93a17870a7a',1,'vk_mem_alloc.h']]], + ['vmaallocationinfo_365',['VmaAllocationInfo',['../vk__mem__alloc_8h.html#a795e6ff02a21d5486c0565f403dd9255',1,'vk_mem_alloc.h']]], + ['vmaallocatorcreateflagbits_366',['VmaAllocatorCreateFlagBits',['../vk__mem__alloc_8h.html#a4ddf381b6ce795bdfbc6c614640b9915',1,'vk_mem_alloc.h']]], + ['vmaallocatorcreateflags_367',['VmaAllocatorCreateFlags',['../vk__mem__alloc_8h.html#acfe6863e160722c2c1bbcf7573fddc4d',1,'vk_mem_alloc.h']]], + ['vmaallocatorcreateinfo_368',['VmaAllocatorCreateInfo',['../vk__mem__alloc_8h.html#ae0f6d1d733dded220d28134da46b4283',1,'vk_mem_alloc.h']]], + ['vmabudget_369',['VmaBudget',['../vk__mem__alloc_8h.html#ab79b48b6d25aada0de91a913896e1c38',1,'vk_mem_alloc.h']]], + ['vmadefragmentationflagbits_370',['VmaDefragmentationFlagBits',['../vk__mem__alloc_8h.html#a96df0eddab2e1735782fe4e7cd05ea7f',1,'vk_mem_alloc.h']]], + ['vmadefragmentationflags_371',['VmaDefragmentationFlags',['../vk__mem__alloc_8h.html#a88a77cef37e5d3c4fc9eb328885d048d',1,'vk_mem_alloc.h']]], + ['vmadefragmentationinfo_372',['VmaDefragmentationInfo',['../vk__mem__alloc_8h.html#ae67f8573a0cf20f16f0a1eecbca566a0',1,'vk_mem_alloc.h']]], + ['vmadefragmentationinfo2_373',['VmaDefragmentationInfo2',['../vk__mem__alloc_8h.html#abac0e85abaa6ea1ffd63bde29c5c3a29',1,'vk_mem_alloc.h']]], + ['vmadefragmentationstats_374',['VmaDefragmentationStats',['../vk__mem__alloc_8h.html#ab0f9b06441c840fee560de4a2967f8c9',1,'vk_mem_alloc.h']]], + ['vmadevicememorycallbacks_375',['VmaDeviceMemoryCallbacks',['../vk__mem__alloc_8h.html#a5e2eb68d727cfd4df25702b027b7aa31',1,'vk_mem_alloc.h']]], + ['vmamemoryusage_376',['VmaMemoryUsage',['../vk__mem__alloc_8h.html#ad63b2113c0bfdbeade1cb498f5a8580d',1,'vk_mem_alloc.h']]], + ['vmapoolcreateflagbits_377',['VmaPoolCreateFlagBits',['../vk__mem__alloc_8h.html#a8f93195158e0e2ac80ca352064e71c1f',1,'vk_mem_alloc.h']]], + ['vmapoolcreateflags_378',['VmaPoolCreateFlags',['../vk__mem__alloc_8h.html#a2770e325ea42e087c1b91fdf46d0292a',1,'vk_mem_alloc.h']]], + ['vmapoolcreateinfo_379',['VmaPoolCreateInfo',['../vk__mem__alloc_8h.html#a211706e9348dcee25a843ed4ea69bce7',1,'vk_mem_alloc.h']]], + ['vmapoolstats_380',['VmaPoolStats',['../vk__mem__alloc_8h.html#a2e5612d871d64c5624087b837a338c34',1,'vk_mem_alloc.h']]], + ['vmarecordflagbits_381',['VmaRecordFlagBits',['../vk__mem__alloc_8h.html#ade20b626a6635ce1bf30ea53dea774e4',1,'vk_mem_alloc.h']]], + ['vmarecordflags_382',['VmaRecordFlags',['../vk__mem__alloc_8h.html#af3929a1a4547c592fc0b0e55ef452828',1,'vk_mem_alloc.h']]], + ['vmarecordsettings_383',['VmaRecordSettings',['../vk__mem__alloc_8h.html#a0ab61e87ff6365f1d59915eadc37a9f0',1,'vk_mem_alloc.h']]], + ['vmastatinfo_384',['VmaStatInfo',['../vk__mem__alloc_8h.html#a810b009a788ee8aac72a25b42ffbe31c',1,'vk_mem_alloc.h']]], + ['vmastats_385',['VmaStats',['../vk__mem__alloc_8h.html#a732be855fb4a7c248e6853d928a729af',1,'vk_mem_alloc.h']]], + ['vmavulkanfunctions_386',['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 986f388..7626897 100644 --- a/docs/html/search/variables_0.js +++ b/docs/html/search/variables_0.js @@ -1,9 +1,9 @@ var searchData= [ - ['allocationbytes_280',['allocationBytes',['../struct_vma_budget.html#a7e2a6583ebd63e194951c542563804d8',1,'VmaBudget']]], - ['allocationcount_281',['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_282',['allocationSizeAvg',['../struct_vma_stat_info.html#a1081a039964e566c672e7a2347f9e599',1,'VmaStatInfo']]], - ['allocationsizemax_283',['allocationSizeMax',['../struct_vma_stat_info.html#a17e9733a5ecd76287d4db6e66f71f50c',1,'VmaStatInfo']]], - ['allocationsizemin_284',['allocationSizeMin',['../struct_vma_stat_info.html#ade8b40bd3139c04aabd2fc538a356fea',1,'VmaStatInfo']]], - ['allocationsmoved_285',['allocationsMoved',['../struct_vma_defragmentation_stats.html#aefeabf130022008eadd75999478af3f9',1,'VmaDefragmentationStats']]] + ['allocationbytes_282',['allocationBytes',['../struct_vma_budget.html#a7e2a6583ebd63e194951c542563804d8',1,'VmaBudget']]], + ['allocationcount_283',['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_284',['allocationSizeAvg',['../struct_vma_stat_info.html#a1081a039964e566c672e7a2347f9e599',1,'VmaStatInfo']]], + ['allocationsizemax_285',['allocationSizeMax',['../struct_vma_stat_info.html#a17e9733a5ecd76287d4db6e66f71f50c',1,'VmaStatInfo']]], + ['allocationsizemin_286',['allocationSizeMin',['../struct_vma_stat_info.html#ade8b40bd3139c04aabd2fc538a356fea',1,'VmaStatInfo']]], + ['allocationsmoved_287',['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 f944ee1..79f8694 100644 --- a/docs/html/search/variables_1.js +++ b/docs/html/search/variables_1.js @@ -1,9 +1,9 @@ var searchData= [ - ['blockbytes_286',['blockBytes',['../struct_vma_budget.html#a58b492901baab685f466199124e514a0',1,'VmaBudget']]], - ['blockcount_287',['blockCount',['../struct_vma_stat_info.html#abc4bb7cd611900778464c56e50c970a4',1,'VmaStatInfo::blockCount()'],['../struct_vma_pool_stats.html#aa0b5cb45cef6f18571cefb03b9a230e7',1,'VmaPoolStats::blockCount()']]], - ['blocksize_288',['blockSize',['../struct_vma_pool_create_info.html#aa4265160536cdb9be821b7686c16c676',1,'VmaPoolCreateInfo']]], - ['budget_289',['budget',['../struct_vma_budget.html#ab82e1d1754c2d210d0bdf90220bc6cdd',1,'VmaBudget']]], - ['bytesfreed_290',['bytesFreed',['../struct_vma_defragmentation_stats.html#ab0cb9ac0dbc106c77e384ea676422f28',1,'VmaDefragmentationStats']]], - ['bytesmoved_291',['bytesMoved',['../struct_vma_defragmentation_stats.html#a36f9d5df2a10ba2a36b16e126d60572d',1,'VmaDefragmentationStats']]] + ['blockbytes_288',['blockBytes',['../struct_vma_budget.html#a58b492901baab685f466199124e514a0',1,'VmaBudget']]], + ['blockcount_289',['blockCount',['../struct_vma_stat_info.html#abc4bb7cd611900778464c56e50c970a4',1,'VmaStatInfo::blockCount()'],['../struct_vma_pool_stats.html#aa0b5cb45cef6f18571cefb03b9a230e7',1,'VmaPoolStats::blockCount()']]], + ['blocksize_290',['blockSize',['../struct_vma_pool_create_info.html#aa4265160536cdb9be821b7686c16c676',1,'VmaPoolCreateInfo']]], + ['budget_291',['budget',['../struct_vma_budget.html#ab82e1d1754c2d210d0bdf90220bc6cdd',1,'VmaBudget']]], + ['bytesfreed_292',['bytesFreed',['../struct_vma_defragmentation_stats.html#ab0cb9ac0dbc106c77e384ea676422f28',1,'VmaDefragmentationStats']]], + ['bytesmoved_293',['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 11fd7fd..7f9eb81 100644 --- a/docs/html/search/variables_2.js +++ b/docs/html/search/variables_2.js @@ -1,4 +1,4 @@ var searchData= [ - ['commandbuffer_292',['commandBuffer',['../struct_vma_defragmentation_info2.html#a7f71f39590c5316771493d2333f9c1bd',1,'VmaDefragmentationInfo2']]] + ['commandbuffer_294',['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 ff118b4..f62cf20 100644 --- a/docs/html/search/variables_3.js +++ b/docs/html/search/variables_3.js @@ -1,6 +1,6 @@ var searchData= [ - ['device_293',['device',['../struct_vma_allocator_create_info.html#ad924ddd77b04039c88d0c09b0ffcd500',1,'VmaAllocatorCreateInfo']]], - ['devicememory_294',['deviceMemory',['../struct_vma_allocation_info.html#ae0bfb7dfdf79a76ffefc9a94677a2f67',1,'VmaAllocationInfo']]], - ['devicememoryblocksfreed_295',['deviceMemoryBlocksFreed',['../struct_vma_defragmentation_stats.html#a0113f1877904a5d1ee8f409216ff276b',1,'VmaDefragmentationStats']]] + ['device_295',['device',['../struct_vma_allocator_create_info.html#ad924ddd77b04039c88d0c09b0ffcd500',1,'VmaAllocatorCreateInfo']]], + ['devicememory_296',['deviceMemory',['../struct_vma_allocation_info.html#ae0bfb7dfdf79a76ffefc9a94677a2f67',1,'VmaAllocationInfo']]], + ['devicememoryblocksfreed_297',['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 777d252..3153b20 100644 --- a/docs/html/search/variables_4.js +++ b/docs/html/search/variables_4.js @@ -1,5 +1,5 @@ var searchData= [ - ['flags_296',['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_297',['frameInUseCount',['../struct_vma_allocator_create_info.html#a21ea188dd212b8171cb9ecbed4a2a3a7',1,'VmaAllocatorCreateInfo::frameInUseCount()'],['../struct_vma_pool_create_info.html#a9437e43ffbb644dbbf7fc4e50cfad6aa',1,'VmaPoolCreateInfo::frameInUseCount()']]] + ['flags_298',['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_299',['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 19a1666..eb8c78a 100644 --- a/docs/html/search/variables_5.js +++ b/docs/html/search/variables_5.js @@ -1,4 +1,4 @@ var searchData= [ - ['instance_298',['instance',['../struct_vma_allocator_create_info.html#a70dd42e29b1df1d1b9b61532ae0b370b',1,'VmaAllocatorCreateInfo']]] + ['instance_300',['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 8f3ba41..67940c4 100644 --- a/docs/html/search/variables_6.js +++ b/docs/html/search/variables_6.js @@ -1,15 +1,15 @@ var searchData= [ - ['maxallocationstomove_299',['maxAllocationsToMove',['../struct_vma_defragmentation_info.html#aa7c7304e13c71f604c907196c4e28fbc',1,'VmaDefragmentationInfo']]], - ['maxblockcount_300',['maxBlockCount',['../struct_vma_pool_create_info.html#ae41142f2834fcdc82baa4883c187b75c',1,'VmaPoolCreateInfo']]], - ['maxbytestomove_301',['maxBytesToMove',['../struct_vma_defragmentation_info.html#acb311c940a777270e67e1b81c5ab6a1d',1,'VmaDefragmentationInfo']]], - ['maxcpuallocationstomove_302',['maxCpuAllocationsToMove',['../struct_vma_defragmentation_info2.html#a94c2c7223d52878445a8cccce396b671',1,'VmaDefragmentationInfo2']]], - ['maxcpubytestomove_303',['maxCpuBytesToMove',['../struct_vma_defragmentation_info2.html#af78e1ea40c22d85137b65f6b384a4d0a',1,'VmaDefragmentationInfo2']]], - ['maxgpuallocationstomove_304',['maxGpuAllocationsToMove',['../struct_vma_defragmentation_info2.html#a40d53d33e71ba0b66f844ed63c05a3f6',1,'VmaDefragmentationInfo2']]], - ['maxgpubytestomove_305',['maxGpuBytesToMove',['../struct_vma_defragmentation_info2.html#a4ddbc898d0afe1518f863a3763628f08',1,'VmaDefragmentationInfo2']]], - ['memoryheap_306',['memoryHeap',['../struct_vma_stats.html#a0e6611508c29a187f0fd14ff1a0329c0',1,'VmaStats']]], - ['memorytype_307',['memoryType',['../struct_vma_stats.html#a13e3caf754be79352c42408756309331',1,'VmaStats::memoryType()'],['../struct_vma_allocation_info.html#a7f6b0aa58c135e488e6b40a388dad9d5',1,'VmaAllocationInfo::memoryType()']]], - ['memorytypebits_308',['memoryTypeBits',['../struct_vma_allocation_create_info.html#a3bf940c0271d85d6ba32a4d820075055',1,'VmaAllocationCreateInfo']]], - ['memorytypeindex_309',['memoryTypeIndex',['../struct_vma_pool_create_info.html#a596fa76b685d3f1f688f84a709a5b319',1,'VmaPoolCreateInfo']]], - ['minblockcount_310',['minBlockCount',['../struct_vma_pool_create_info.html#ad8006fb803185c0a699d30f3e9a865ae',1,'VmaPoolCreateInfo']]] + ['maxallocationstomove_301',['maxAllocationsToMove',['../struct_vma_defragmentation_info.html#aa7c7304e13c71f604c907196c4e28fbc',1,'VmaDefragmentationInfo']]], + ['maxblockcount_302',['maxBlockCount',['../struct_vma_pool_create_info.html#ae41142f2834fcdc82baa4883c187b75c',1,'VmaPoolCreateInfo']]], + ['maxbytestomove_303',['maxBytesToMove',['../struct_vma_defragmentation_info.html#acb311c940a777270e67e1b81c5ab6a1d',1,'VmaDefragmentationInfo']]], + ['maxcpuallocationstomove_304',['maxCpuAllocationsToMove',['../struct_vma_defragmentation_info2.html#a94c2c7223d52878445a8cccce396b671',1,'VmaDefragmentationInfo2']]], + ['maxcpubytestomove_305',['maxCpuBytesToMove',['../struct_vma_defragmentation_info2.html#af78e1ea40c22d85137b65f6b384a4d0a',1,'VmaDefragmentationInfo2']]], + ['maxgpuallocationstomove_306',['maxGpuAllocationsToMove',['../struct_vma_defragmentation_info2.html#a40d53d33e71ba0b66f844ed63c05a3f6',1,'VmaDefragmentationInfo2']]], + ['maxgpubytestomove_307',['maxGpuBytesToMove',['../struct_vma_defragmentation_info2.html#a4ddbc898d0afe1518f863a3763628f08',1,'VmaDefragmentationInfo2']]], + ['memoryheap_308',['memoryHeap',['../struct_vma_stats.html#a0e6611508c29a187f0fd14ff1a0329c0',1,'VmaStats']]], + ['memorytype_309',['memoryType',['../struct_vma_stats.html#a13e3caf754be79352c42408756309331',1,'VmaStats::memoryType()'],['../struct_vma_allocation_info.html#a7f6b0aa58c135e488e6b40a388dad9d5',1,'VmaAllocationInfo::memoryType()']]], + ['memorytypebits_310',['memoryTypeBits',['../struct_vma_allocation_create_info.html#a3bf940c0271d85d6ba32a4d820075055',1,'VmaAllocationCreateInfo']]], + ['memorytypeindex_311',['memoryTypeIndex',['../struct_vma_pool_create_info.html#a596fa76b685d3f1f688f84a709a5b319',1,'VmaPoolCreateInfo']]], + ['minblockcount_312',['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 ff9a3bb..f81084e 100644 --- a/docs/html/search/variables_7.js +++ b/docs/html/search/variables_7.js @@ -1,4 +1,4 @@ var searchData= [ - ['offset_311',['offset',['../struct_vma_allocation_info.html#a4a3c732388dbdc7a23f9365b00825268',1,'VmaAllocationInfo']]] + ['offset_313',['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 dff0212..4384f4b 100644 --- a/docs/html/search/variables_8.js +++ b/docs/html/search/variables_8.js @@ -1,21 +1,21 @@ var searchData= [ - ['pallocationcallbacks_312',['pAllocationCallbacks',['../struct_vma_allocator_create_info.html#a6e409087e3be55400d0e4ccbe43c608d',1,'VmaAllocatorCreateInfo']]], - ['pallocations_313',['pAllocations',['../struct_vma_defragmentation_info2.html#a8943f8d65969ce8e2189a1cdf3205e96',1,'VmaDefragmentationInfo2']]], - ['pallocationschanged_314',['pAllocationsChanged',['../struct_vma_defragmentation_info2.html#a76d51a644dc7f5405d0cdd0025ecd0cc',1,'VmaDefragmentationInfo2']]], - ['pdevicememorycallbacks_315',['pDeviceMemoryCallbacks',['../struct_vma_allocator_create_info.html#af1380969b5e1ea4c3184a877892d260e',1,'VmaAllocatorCreateInfo']]], - ['pfilepath_316',['pFilePath',['../struct_vma_record_settings.html#a6cb1fdbf6bcb610b68f2010dd629e89d',1,'VmaRecordSettings']]], - ['pfnallocate_317',['pfnAllocate',['../struct_vma_device_memory_callbacks.html#a4f17f7b255101e733b44d5633aceabfb',1,'VmaDeviceMemoryCallbacks']]], - ['pfnfree_318',['pfnFree',['../struct_vma_device_memory_callbacks.html#abe8a3328bbc916f6f712fdb6b299444c',1,'VmaDeviceMemoryCallbacks']]], - ['pheapsizelimit_319',['pHeapSizeLimit',['../struct_vma_allocator_create_info.html#a31c192aa6cbffa33279f6d9f0c47c44b',1,'VmaAllocatorCreateInfo']]], - ['physicaldevice_320',['physicalDevice',['../struct_vma_allocator_create_info.html#a08230f04ae6ccf8a78150a9e829a7156',1,'VmaAllocatorCreateInfo']]], - ['pmappeddata_321',['pMappedData',['../struct_vma_allocation_info.html#a5eeffbe2d2f30f53370ff14aefbadbe2',1,'VmaAllocationInfo']]], - ['pool_322',['pool',['../struct_vma_allocation_create_info.html#a6272c0555cfd1fe28bff1afeb6190150',1,'VmaAllocationCreateInfo']]], - ['poolcount_323',['poolCount',['../struct_vma_defragmentation_info2.html#a7e70aa2a1081d849dcc7829b19d3ec9d',1,'VmaDefragmentationInfo2']]], - ['ppools_324',['pPools',['../struct_vma_defragmentation_info2.html#a0b3effd57f3fcdeb2ed62210b4ef20e1',1,'VmaDefragmentationInfo2']]], - ['precordsettings_325',['pRecordSettings',['../struct_vma_allocator_create_info.html#ace2aa4877b16a42b0b7673d4e26000ee',1,'VmaAllocatorCreateInfo']]], - ['preferredflags_326',['preferredFlags',['../struct_vma_allocation_create_info.html#a7fe8d81a1ad10b2a2faacacee5b15d6d',1,'VmaAllocationCreateInfo']]], - ['preferredlargeheapblocksize_327',['preferredLargeHeapBlockSize',['../struct_vma_allocator_create_info.html#a8e4714298e3121cdd8b214a1ae7a637a',1,'VmaAllocatorCreateInfo']]], - ['puserdata_328',['pUserData',['../struct_vma_allocation_create_info.html#a8259e85c272683434f4abb4ddddffe19',1,'VmaAllocationCreateInfo::pUserData()'],['../struct_vma_allocation_info.html#adc507656149c04de7ed95d0042ba2a13',1,'VmaAllocationInfo::pUserData()']]], - ['pvulkanfunctions_329',['pVulkanFunctions',['../struct_vma_allocator_create_info.html#a3dc197be3227da7338b1643f70db36bd',1,'VmaAllocatorCreateInfo']]] + ['pallocationcallbacks_314',['pAllocationCallbacks',['../struct_vma_allocator_create_info.html#a6e409087e3be55400d0e4ccbe43c608d',1,'VmaAllocatorCreateInfo']]], + ['pallocations_315',['pAllocations',['../struct_vma_defragmentation_info2.html#a8943f8d65969ce8e2189a1cdf3205e96',1,'VmaDefragmentationInfo2']]], + ['pallocationschanged_316',['pAllocationsChanged',['../struct_vma_defragmentation_info2.html#a76d51a644dc7f5405d0cdd0025ecd0cc',1,'VmaDefragmentationInfo2']]], + ['pdevicememorycallbacks_317',['pDeviceMemoryCallbacks',['../struct_vma_allocator_create_info.html#af1380969b5e1ea4c3184a877892d260e',1,'VmaAllocatorCreateInfo']]], + ['pfilepath_318',['pFilePath',['../struct_vma_record_settings.html#a6cb1fdbf6bcb610b68f2010dd629e89d',1,'VmaRecordSettings']]], + ['pfnallocate_319',['pfnAllocate',['../struct_vma_device_memory_callbacks.html#a4f17f7b255101e733b44d5633aceabfb',1,'VmaDeviceMemoryCallbacks']]], + ['pfnfree_320',['pfnFree',['../struct_vma_device_memory_callbacks.html#abe8a3328bbc916f6f712fdb6b299444c',1,'VmaDeviceMemoryCallbacks']]], + ['pheapsizelimit_321',['pHeapSizeLimit',['../struct_vma_allocator_create_info.html#a31c192aa6cbffa33279f6d9f0c47c44b',1,'VmaAllocatorCreateInfo']]], + ['physicaldevice_322',['physicalDevice',['../struct_vma_allocator_create_info.html#a08230f04ae6ccf8a78150a9e829a7156',1,'VmaAllocatorCreateInfo']]], + ['pmappeddata_323',['pMappedData',['../struct_vma_allocation_info.html#a5eeffbe2d2f30f53370ff14aefbadbe2',1,'VmaAllocationInfo']]], + ['pool_324',['pool',['../struct_vma_allocation_create_info.html#a6272c0555cfd1fe28bff1afeb6190150',1,'VmaAllocationCreateInfo']]], + ['poolcount_325',['poolCount',['../struct_vma_defragmentation_info2.html#a7e70aa2a1081d849dcc7829b19d3ec9d',1,'VmaDefragmentationInfo2']]], + ['ppools_326',['pPools',['../struct_vma_defragmentation_info2.html#a0b3effd57f3fcdeb2ed62210b4ef20e1',1,'VmaDefragmentationInfo2']]], + ['precordsettings_327',['pRecordSettings',['../struct_vma_allocator_create_info.html#ace2aa4877b16a42b0b7673d4e26000ee',1,'VmaAllocatorCreateInfo']]], + ['preferredflags_328',['preferredFlags',['../struct_vma_allocation_create_info.html#a7fe8d81a1ad10b2a2faacacee5b15d6d',1,'VmaAllocationCreateInfo']]], + ['preferredlargeheapblocksize_329',['preferredLargeHeapBlockSize',['../struct_vma_allocator_create_info.html#a8e4714298e3121cdd8b214a1ae7a637a',1,'VmaAllocatorCreateInfo']]], + ['puserdata_330',['pUserData',['../struct_vma_allocation_create_info.html#a8259e85c272683434f4abb4ddddffe19',1,'VmaAllocationCreateInfo::pUserData()'],['../struct_vma_allocation_info.html#adc507656149c04de7ed95d0042ba2a13',1,'VmaAllocationInfo::pUserData()']]], + ['pvulkanfunctions_331',['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 d5dd409..ed35151 100644 --- a/docs/html/search/variables_9.js +++ b/docs/html/search/variables_9.js @@ -1,4 +1,4 @@ var searchData= [ - ['requiredflags_330',['requiredFlags',['../struct_vma_allocation_create_info.html#a9166390303ff42d783305bc31c2b6b90',1,'VmaAllocationCreateInfo']]] + ['requiredflags_332',['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 f922772..cc3913d 100644 --- a/docs/html/search/variables_a.js +++ b/docs/html/search/variables_a.js @@ -1,4 +1,4 @@ var searchData= [ - ['size_331',['size',['../struct_vma_pool_stats.html#a326807b2de2b0931cee4ed9a5f2e420c',1,'VmaPoolStats::size()'],['../struct_vma_allocation_info.html#aac76d113a6a5ccbb09fea00fb25fd18f',1,'VmaAllocationInfo::size()']]] + ['size_333',['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 5792243..b8b2627 100644 --- a/docs/html/search/variables_b.js +++ b/docs/html/search/variables_b.js @@ -1,4 +1,4 @@ var searchData= [ - ['total_332',['total',['../struct_vma_stats.html#a2e8f5b3353f2fefef3c27f29e245a1f9',1,'VmaStats']]] + ['total_334',['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 d34d538..0fc03e2 100644 --- a/docs/html/search/variables_c.js +++ b/docs/html/search/variables_c.js @@ -1,11 +1,11 @@ var searchData= [ - ['unusedbytes_333',['unusedBytes',['../struct_vma_stat_info.html#a1859d290aca2cd582d8dc25922092669',1,'VmaStatInfo']]], - ['unusedrangecount_334',['unusedRangeCount',['../struct_vma_stat_info.html#ae06129c771bfebfd6468a7f4276502a9',1,'VmaStatInfo::unusedRangeCount()'],['../struct_vma_pool_stats.html#ae4f3546ffa4d1e598b64d8e6134854f4',1,'VmaPoolStats::unusedRangeCount()']]], - ['unusedrangesizeavg_335',['unusedRangeSizeAvg',['../struct_vma_stat_info.html#a2f9b3452af90c9768a30b7fb6ae194fc',1,'VmaStatInfo']]], - ['unusedrangesizemax_336',['unusedRangeSizeMax',['../struct_vma_stat_info.html#a5ba1a2476c4d39b10f7e2f7ebbb72ac4',1,'VmaStatInfo::unusedRangeSizeMax()'],['../struct_vma_pool_stats.html#ab4c8f52dd42ab01998f60f0b6acc722b',1,'VmaPoolStats::unusedRangeSizeMax()']]], - ['unusedrangesizemin_337',['unusedRangeSizeMin',['../struct_vma_stat_info.html#aedeba931324f16589cd2416c0d2dd0d4',1,'VmaStatInfo']]], - ['unusedsize_338',['unusedSize',['../struct_vma_pool_stats.html#ad7c54874724fce7b06aba526202d82a8',1,'VmaPoolStats']]], - ['usage_339',['usage',['../struct_vma_budget.html#a84dd1ecca8b0110259eb206dbadb11f6',1,'VmaBudget::usage()'],['../struct_vma_allocation_create_info.html#accb8b06b1f677d858cb9af20705fa910',1,'VmaAllocationCreateInfo::usage()']]], - ['usedbytes_340',['usedBytes',['../struct_vma_stat_info.html#ab0c6c73837e5a70c749fbd4f6064895a',1,'VmaStatInfo']]] + ['unusedbytes_335',['unusedBytes',['../struct_vma_stat_info.html#a1859d290aca2cd582d8dc25922092669',1,'VmaStatInfo']]], + ['unusedrangecount_336',['unusedRangeCount',['../struct_vma_stat_info.html#ae06129c771bfebfd6468a7f4276502a9',1,'VmaStatInfo::unusedRangeCount()'],['../struct_vma_pool_stats.html#ae4f3546ffa4d1e598b64d8e6134854f4',1,'VmaPoolStats::unusedRangeCount()']]], + ['unusedrangesizeavg_337',['unusedRangeSizeAvg',['../struct_vma_stat_info.html#a2f9b3452af90c9768a30b7fb6ae194fc',1,'VmaStatInfo']]], + ['unusedrangesizemax_338',['unusedRangeSizeMax',['../struct_vma_stat_info.html#a5ba1a2476c4d39b10f7e2f7ebbb72ac4',1,'VmaStatInfo::unusedRangeSizeMax()'],['../struct_vma_pool_stats.html#ab4c8f52dd42ab01998f60f0b6acc722b',1,'VmaPoolStats::unusedRangeSizeMax()']]], + ['unusedrangesizemin_339',['unusedRangeSizeMin',['../struct_vma_stat_info.html#aedeba931324f16589cd2416c0d2dd0d4',1,'VmaStatInfo']]], + ['unusedsize_340',['unusedSize',['../struct_vma_pool_stats.html#ad7c54874724fce7b06aba526202d82a8',1,'VmaPoolStats']]], + ['usage_341',['usage',['../struct_vma_budget.html#a84dd1ecca8b0110259eb206dbadb11f6',1,'VmaBudget::usage()'],['../struct_vma_allocation_create_info.html#accb8b06b1f677d858cb9af20705fa910',1,'VmaAllocationCreateInfo::usage()']]], + ['usedbytes_342',['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 bdc31b8..64aa40d 100644 --- a/docs/html/search/variables_d.js +++ b/docs/html/search/variables_d.js @@ -1,20 +1,20 @@ var searchData= [ - ['vkallocatememory_341',['vkAllocateMemory',['../struct_vma_vulkan_functions.html#a2943bf99dfd784a0e8f599d987e22e6c',1,'VmaVulkanFunctions']]], - ['vkbindbuffermemory_342',['vkBindBufferMemory',['../struct_vma_vulkan_functions.html#a94fc4f3a605d9880bb3c0ba2c2fc80b2',1,'VmaVulkanFunctions']]], - ['vkbindimagememory_343',['vkBindImageMemory',['../struct_vma_vulkan_functions.html#a1338d96a128a5ade648b8d934907c637',1,'VmaVulkanFunctions']]], - ['vkcmdcopybuffer_344',['vkCmdCopyBuffer',['../struct_vma_vulkan_functions.html#ae5c0db8c89a3b82593dc16aa6a49fa3a',1,'VmaVulkanFunctions']]], - ['vkcreatebuffer_345',['vkCreateBuffer',['../struct_vma_vulkan_functions.html#ae8084315a25006271a2edfc3a447519f',1,'VmaVulkanFunctions']]], - ['vkcreateimage_346',['vkCreateImage',['../struct_vma_vulkan_functions.html#a23ebe70be515b9b5010a1d691200e325',1,'VmaVulkanFunctions']]], - ['vkdestroybuffer_347',['vkDestroyBuffer',['../struct_vma_vulkan_functions.html#a7e054606faddb07f0e8556f3ed317d45',1,'VmaVulkanFunctions']]], - ['vkdestroyimage_348',['vkDestroyImage',['../struct_vma_vulkan_functions.html#a90b898227039b1dcb3520f6e91f09ffa',1,'VmaVulkanFunctions']]], - ['vkflushmappedmemoryranges_349',['vkFlushMappedMemoryRanges',['../struct_vma_vulkan_functions.html#a33c322f4c4ad2810f8a9c97a277572f9',1,'VmaVulkanFunctions']]], - ['vkfreememory_350',['vkFreeMemory',['../struct_vma_vulkan_functions.html#a4c658701778564d62034255b5dda91b4',1,'VmaVulkanFunctions']]], - ['vkgetbuffermemoryrequirements_351',['vkGetBufferMemoryRequirements',['../struct_vma_vulkan_functions.html#a5b92901df89a4194b0d12f6071d4d143',1,'VmaVulkanFunctions']]], - ['vkgetimagememoryrequirements_352',['vkGetImageMemoryRequirements',['../struct_vma_vulkan_functions.html#a475f6f49f8debe4d10800592606d53f4',1,'VmaVulkanFunctions']]], - ['vkgetphysicaldevicememoryproperties_353',['vkGetPhysicalDeviceMemoryProperties',['../struct_vma_vulkan_functions.html#a60d25c33bba06bb8592e6875cbaa9830',1,'VmaVulkanFunctions']]], - ['vkgetphysicaldeviceproperties_354',['vkGetPhysicalDeviceProperties',['../struct_vma_vulkan_functions.html#a77b7a74082823e865dd6546623468f96',1,'VmaVulkanFunctions']]], - ['vkinvalidatemappedmemoryranges_355',['vkInvalidateMappedMemoryRanges',['../struct_vma_vulkan_functions.html#a5c1093bc32386a8060c37c9f282078a1',1,'VmaVulkanFunctions']]], - ['vkmapmemory_356',['vkMapMemory',['../struct_vma_vulkan_functions.html#ab5c1f38dea3a2cf00dc9eb4f57218c49',1,'VmaVulkanFunctions']]], - ['vkunmapmemory_357',['vkUnmapMemory',['../struct_vma_vulkan_functions.html#acc798589736f0becb317fc2196c1d8b9',1,'VmaVulkanFunctions']]] + ['vkallocatememory_343',['vkAllocateMemory',['../struct_vma_vulkan_functions.html#a2943bf99dfd784a0e8f599d987e22e6c',1,'VmaVulkanFunctions']]], + ['vkbindbuffermemory_344',['vkBindBufferMemory',['../struct_vma_vulkan_functions.html#a94fc4f3a605d9880bb3c0ba2c2fc80b2',1,'VmaVulkanFunctions']]], + ['vkbindimagememory_345',['vkBindImageMemory',['../struct_vma_vulkan_functions.html#a1338d96a128a5ade648b8d934907c637',1,'VmaVulkanFunctions']]], + ['vkcmdcopybuffer_346',['vkCmdCopyBuffer',['../struct_vma_vulkan_functions.html#ae5c0db8c89a3b82593dc16aa6a49fa3a',1,'VmaVulkanFunctions']]], + ['vkcreatebuffer_347',['vkCreateBuffer',['../struct_vma_vulkan_functions.html#ae8084315a25006271a2edfc3a447519f',1,'VmaVulkanFunctions']]], + ['vkcreateimage_348',['vkCreateImage',['../struct_vma_vulkan_functions.html#a23ebe70be515b9b5010a1d691200e325',1,'VmaVulkanFunctions']]], + ['vkdestroybuffer_349',['vkDestroyBuffer',['../struct_vma_vulkan_functions.html#a7e054606faddb07f0e8556f3ed317d45',1,'VmaVulkanFunctions']]], + ['vkdestroyimage_350',['vkDestroyImage',['../struct_vma_vulkan_functions.html#a90b898227039b1dcb3520f6e91f09ffa',1,'VmaVulkanFunctions']]], + ['vkflushmappedmemoryranges_351',['vkFlushMappedMemoryRanges',['../struct_vma_vulkan_functions.html#a33c322f4c4ad2810f8a9c97a277572f9',1,'VmaVulkanFunctions']]], + ['vkfreememory_352',['vkFreeMemory',['../struct_vma_vulkan_functions.html#a4c658701778564d62034255b5dda91b4',1,'VmaVulkanFunctions']]], + ['vkgetbuffermemoryrequirements_353',['vkGetBufferMemoryRequirements',['../struct_vma_vulkan_functions.html#a5b92901df89a4194b0d12f6071d4d143',1,'VmaVulkanFunctions']]], + ['vkgetimagememoryrequirements_354',['vkGetImageMemoryRequirements',['../struct_vma_vulkan_functions.html#a475f6f49f8debe4d10800592606d53f4',1,'VmaVulkanFunctions']]], + ['vkgetphysicaldevicememoryproperties_355',['vkGetPhysicalDeviceMemoryProperties',['../struct_vma_vulkan_functions.html#a60d25c33bba06bb8592e6875cbaa9830',1,'VmaVulkanFunctions']]], + ['vkgetphysicaldeviceproperties_356',['vkGetPhysicalDeviceProperties',['../struct_vma_vulkan_functions.html#a77b7a74082823e865dd6546623468f96',1,'VmaVulkanFunctions']]], + ['vkinvalidatemappedmemoryranges_357',['vkInvalidateMappedMemoryRanges',['../struct_vma_vulkan_functions.html#a5c1093bc32386a8060c37c9f282078a1',1,'VmaVulkanFunctions']]], + ['vkmapmemory_358',['vkMapMemory',['../struct_vma_vulkan_functions.html#ab5c1f38dea3a2cf00dc9eb4f57218c49',1,'VmaVulkanFunctions']]], + ['vkunmapmemory_359',['vkUnmapMemory',['../struct_vma_vulkan_functions.html#acc798589736f0becb317fc2196c1d8b9',1,'VmaVulkanFunctions']]] ]; diff --git a/docs/html/statistics.html b/docs/html/statistics.html index 751f5ab..38de087 100644 --- a/docs/html/statistics.html +++ b/docs/html/statistics.html @@ -68,14 +68,14 @@ $(function() {

    This library contains functions that return information about its internal state, especially the amount of memory allocated from Vulkan. Please keep in mind that these functions need to traverse all internal data structures to gather these information, so they may be quite time-consuming. Don't call them too often.

    Numeric statistics

    -

    You can query for overall statistics of the allocator using function vmaCalculateStats(). Information are returned using structure VmaStats. It contains VmaStatInfo - number of allocated blocks, number of allocations (occupied ranges in these blocks), number of unused (free) ranges in these blocks, number of bytes used and unused (but still allocated from Vulkan) and other information. They are summed across memory heaps, memory types and total for whole allocator.

    -

    You can query for statistics of a custom pool using function vmaGetPoolStats(). Information are returned using structure VmaPoolStats.

    -

    You can query for information about specific allocation using function vmaGetAllocationInfo(). It fill structure VmaAllocationInfo.

    +

    You can query for overall statistics of the allocator using function vmaCalculateStats(). Information are returned using structure VmaStats. It contains VmaStatInfo - number of allocated blocks, number of allocations (occupied ranges in these blocks), number of unused (free) ranges in these blocks, number of bytes used and unused (but still allocated from Vulkan) and other information. They are summed across memory heaps, memory types and total for whole allocator.

    +

    You can query for statistics of a custom pool using function vmaGetPoolStats(). Information are returned using structure VmaPoolStats.

    +

    You can query for information about specific allocation using function vmaGetAllocationInfo(). It fill structure VmaAllocationInfo.

    JSON dump

    -

    You can dump internal state of the allocator to a string in JSON format using function vmaBuildStatsString(). The result is guaranteed to be correct JSON. It uses ANSI encoding. Any strings provided by user (see Allocation names) are copied as-is and properly escaped for JSON, so if they use UTF-8, ISO-8859-2 or any other encoding, this JSON string can be treated as using this encoding. It must be freed using function vmaFreeStatsString().

    +

    You can dump internal state of the allocator to a string in JSON format using function vmaBuildStatsString(). The result is guaranteed to be correct JSON. It uses ANSI encoding. Any strings provided by user (see Allocation names) are copied as-is and properly escaped for JSON, so if they use UTF-8, ISO-8859-2 or any other encoding, this JSON string can be treated as using this encoding. It must be freed using function vmaFreeStatsString().

    The format of this JSON string is not part of official documentation of the library, but it will not change in backward-incompatible way without increasing library major version number and appropriate mention in changelog.

    -

    The JSON string contains all the data that can be obtained using vmaCalculateStats(). It can also contain detailed map of allocated memory blocks and their regions - free and occupied by allocations. This allows e.g. to visualize the memory or assess fragmentation.

    +

    The JSON string contains all the data that can be obtained using vmaCalculateStats(). It can also contain detailed map of allocated memory blocks and their regions - free and occupied by allocations. This allows e.g. to visualize the memory or assess fragmentation.

    diff --git a/docs/html/staying_within_budget.html b/docs/html/staying_within_budget.html index 97a0964..7bb43de 100644 --- a/docs/html/staying_within_budget.html +++ b/docs/html/staying_within_budget.html @@ -75,13 +75,13 @@ $(function() {

    Querying for budget

    -

    To query for current memory usage and available budget, use function vmaGetBudget(). Returned structure VmaBudget contains quantities expressed in bytes, per Vulkan memory heap.

    -

    Please note that this function returns different information and works faster than vmaCalculateStats(). vmaGetBudget() can be called every frame or even before every allocation, while vmaCalculateStats() is intended to be used rarely, only to obtain statistical information, e.g. for debugging purposes.

    +

    To query for current memory usage and available budget, use function vmaGetBudget(). Returned structure VmaBudget contains quantities expressed in bytes, per Vulkan memory heap.

    +

    Please note that this function returns different information and works faster than vmaCalculateStats(). vmaGetBudget() can be called every frame or even before every allocation, while vmaCalculateStats() is intended to be used rarely, only to obtain statistical information, e.g. for debugging purposes.

    It is recommended to use VK_EXT_memory_budget device extension to obtain information about the budget from Vulkan device. VMA is able to use this extension automatically. When not enabled, the allocator behaves same way, but then it estimates current usage and available budget based on its internal information and Vulkan memory heap sizes, which may be less precise. In order to use this extension:

    1. Make sure extensions VK_EXT_memory_budget and VK_KHR_get_physical_device_properties2 required by it are available and enable them. Please note that the first is a device extension and the second is instance extension!
    2. Use flag VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT when creating VmaAllocator object.
      3. -
    3. Make sure to call vmaSetCurrentFrameIndex() every frame. Budget is queried from Vulkan inside of it to avoid overhead of querying it with every allocation.
      4. +
    4. Make sure to call vmaSetCurrentFrameIndex() every frame. Budget is queried from Vulkan inside of it to avoid overhead of querying it with every allocation.

    Controlling memory usage

    diff --git a/docs/html/struct_vma_allocation.html b/docs/html/struct_vma_allocation.html index 77dc9ad..7a80640 100644 --- a/docs/html/struct_vma_allocation.html +++ b/docs/html/struct_vma_allocation.html @@ -75,7 +75,7 @@ $(function() {

    It may be either dedicated block of VkDeviceMemory or a specific region of a bigger block of this type plus unique offset.

    There are multiple ways to create such object. You need to fill structure VmaAllocationCreateInfo. For more information see Choosing memory type.

    Although the library provides convenience functions that create Vulkan buffer or image, allocate memory for it and bind them together, binding of the allocation to a buffer or an image is out of scope of the allocation itself. Allocation object can exist without buffer/image bound, binding can be done manually by the user, and destruction of it can be done independently of destruction of the allocation.

    -

    The object also remembers its size and some other information. To retrieve this information, use function vmaGetAllocationInfo() and inspect returned structure VmaAllocationInfo.

    +

    The object also remembers its size and some other information. To retrieve this information, use function vmaGetAllocationInfo() and inspect returned structure VmaAllocationInfo.

    Some kinds allocations can be in lost state. For more information, see Lost allocations.

    The documentation for this struct was generated from the following file:
    • vk_mem_alloc.h
      • diff --git a/docs/html/struct_vma_allocation_create_info.html b/docs/html/struct_vma_allocation_create_info.html index 41de63c..2c7613f 100644 --- a/docs/html/struct_vma_allocation_create_info.html +++ b/docs/html/struct_vma_allocation_create_info.html @@ -92,7 +92,7 @@ Public Attributes
    - +
     CVmaAllocationRepresents single memory allocation
     CVmaAllocationCreateInfo
     CVmaAllocationInfoParameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo()
     CVmaAllocationInfoParameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo()
     CVmaAllocatorRepresents main object of this library initialized
     CVmaAllocatorCreateInfoDescription of a Allocator to be created
     CVmaBudgetStatistics of current memory usage and available budget, in bytes, for specific memory heap
     CVmaDefragmentationContextRepresents Opaque object that represents started defragmentation process
     CVmaDefragmentationInfoDeprecated. Optional configuration parameters to be passed to function vmaDefragment()
     CVmaDefragmentationInfoDeprecated. Optional configuration parameters to be passed to function vmaDefragment()
     CVmaDefragmentationInfo2Parameters for defragmentation
     CVmaDefragmentationStatsStatistics returned by function vmaDefragment()
     CVmaDefragmentationStatsStatistics returned by function vmaDefragment()
     CVmaDeviceMemoryCallbacksSet of callbacks that the library will call for vkAllocateMemory and vkFreeMemory
     CVmaPoolRepresents custom memory pool
     CVmaPoolCreateInfoDescribes parameter of created VmaPool
     Pool that this allocation should be created in. More...
     
    void * pUserData
     Custom general-purpose pointer that will be stored in VmaAllocation, can be read as VmaAllocationInfo::pUserData and changed using vmaSetAllocationUserData(). More...
     Custom general-purpose pointer that will be stored in VmaAllocation, can be read as VmaAllocationInfo::pUserData and changed using vmaSetAllocationUserData(). More...
     

    Member Data Documentation

    @@ -177,7 +177,7 @@ If pool is not null, this member is ignored.

    -

    Custom general-purpose pointer that will be stored in VmaAllocation, can be read as VmaAllocationInfo::pUserData and changed using vmaSetAllocationUserData().

    +

    Custom general-purpose pointer that will be stored in VmaAllocation, can be read as VmaAllocationInfo::pUserData and changed using vmaSetAllocationUserData().

    If VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT is used, it must be either null or pointer to a null-terminated string. The string will be then copied to internal buffer, so it doesn't need to be valid after allocation call.

    diff --git a/docs/html/struct_vma_allocation_info.html b/docs/html/struct_vma_allocation_info.html index 1c540d1..6347688 100644 --- a/docs/html/struct_vma_allocation_info.html +++ b/docs/html/struct_vma_allocation_info.html @@ -69,7 +69,7 @@ $(function() {
    -

    Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo(). +

    Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo(). More...

    #include <vk_mem_alloc.h>

    @@ -92,11 +92,11 @@ Public Attributes  Pointer to the beginning of this allocation as mapped data. More...
      void * pUserData - Custom general-purpose pointer that was passed as VmaAllocationCreateInfo::pUserData or set using vmaSetAllocationUserData(). More...
    + Custom general-purpose pointer that was passed as VmaAllocationCreateInfo::pUserData or set using vmaSetAllocationUserData(). More...
     

    Detailed Description

    -

    Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().

    +

    Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().

    Member Data Documentation

    ◆ deviceMemory

    @@ -112,7 +112,7 @@ Public Attributes

    Handle to Vulkan memory object.

    Same memory object can be shared by multiple allocations.

    -

    It can change after call to vmaDefragment() if this allocation is passed to the function, or if allocation is lost.

    +

    It can change after call to vmaDefragment() if this allocation is passed to the function, or if allocation is lost.

    If the allocation is lost, it is equal to VK_NULL_HANDLE.

    @@ -147,7 +147,7 @@ Public Attributes

    Offset into deviceMemory object to the beginning of this allocation, in bytes. (deviceMemory, offset) pair is unique to this allocation.

    -

    It can change after call to vmaDefragment() if this allocation is passed to the function, or if allocation is lost.

    +

    It can change after call to vmaDefragment() if this allocation is passed to the function, or if allocation is lost.

    @@ -164,8 +164,8 @@ Public Attributes

    Pointer to the beginning of this allocation as mapped data.

    -

    If the allocation hasn't been mapped using vmaMapMemory() and hasn't been created with VMA_ALLOCATION_CREATE_MAPPED_BIT flag, this value null.

    -

    It can change after call to vmaMapMemory(), vmaUnmapMemory(). It can also change after call to vmaDefragment() if this allocation is passed to the function.

    +

    If the allocation hasn't been mapped using vmaMapMemory() and hasn't been created with VMA_ALLOCATION_CREATE_MAPPED_BIT flag, this value null.

    +

    It can change after call to vmaMapMemory(), vmaUnmapMemory(). It can also change after call to vmaDefragment() if this allocation is passed to the function.

    @@ -181,8 +181,8 @@ Public Attributes
    -

    Custom general-purpose pointer that was passed as VmaAllocationCreateInfo::pUserData or set using vmaSetAllocationUserData().

    -

    It can change after call to vmaSetAllocationUserData() for this allocation.

    +

    Custom general-purpose pointer that was passed as VmaAllocationCreateInfo::pUserData or set using vmaSetAllocationUserData().

    +

    It can change after call to vmaSetAllocationUserData() for this allocation.

    diff --git a/docs/html/struct_vma_allocator.html b/docs/html/struct_vma_allocator.html index 97ce081..3600402 100644 --- a/docs/html/struct_vma_allocator.html +++ b/docs/html/struct_vma_allocator.html @@ -72,7 +72,7 @@ $(function() {

    #include <vk_mem_alloc.h>

    Detailed Description

    Represents main object of this library initialized.

    -

    Fill structure VmaAllocatorCreateInfo and call function vmaCreateAllocator() to create it. Call function vmaDestroyAllocator() to destroy it.

    +

    Fill structure VmaAllocatorCreateInfo and call function vmaCreateAllocator() to create it. Call function vmaDestroyAllocator() to destroy it.

    It is recommended to create just one object of this type per VkDevice object, right after Vulkan is initialized and keep it alive until before Vulkan device is destroyed.

    The documentation for this struct was generated from the following file:
    • vk_mem_alloc.h
      • diff --git a/docs/html/struct_vma_allocator_create_info.html b/docs/html/struct_vma_allocator_create_info.html index 611b3a7..76832fe 100644 --- a/docs/html/struct_vma_allocator_create_info.html +++ b/docs/html/struct_vma_allocator_create_info.html @@ -234,7 +234,7 @@ Public Attributes

      If there is a limit defined for a heap:

      • If user tries to allocate more memory from that heap using this allocator, the allocation fails with VK_ERROR_OUT_OF_DEVICE_MEMORY.
        • -
      • If the limit is smaller than heap size reported in VkMemoryHeap::size, the value of this limit will be reported instead when using vmaGetMemoryProperties().
        • +
      • If the limit is smaller than heap size reported in VkMemoryHeap::size, the value of this limit will be reported instead when using vmaGetMemoryProperties().

      Warning! Using this feature may not be equivalent to installing a GPU with smaller amount of memory, because graphics driver doesn't necessary fail new allocations with VK_ERROR_OUT_OF_DEVICE_MEMORY result when memory capacity is exceeded. It may return success and just silently migrate some device memory blocks to system RAM. This driver behavior can also be controlled using VK_AMD_memory_overallocation_behavior extension.

      diff --git a/docs/html/struct_vma_budget.html b/docs/html/struct_vma_budget.html index 2403e24..8fcfada 100644 --- a/docs/html/struct_vma_budget.html +++ b/docs/html/struct_vma_budget.html @@ -105,7 +105,8 @@ Public Attributes

      Sum size of all allocations created in particular heap, in bytes.

      -

      Always less or equal than blockBytes. Difference blockBytes - allocationBytes is the amount of memory allocated but unused - available for new allocations or wasted due to fragmentation.

      +

      Usually less or equal than blockBytes. Difference blockBytes - allocationBytes is the amount of memory allocated but unused - available for new allocations or wasted due to fragmentation.

      +

      It might be greater than blockBytes if there are some allocations in lost state, as they account to this value as well.

      diff --git a/docs/html/struct_vma_defragmentation_context.html b/docs/html/struct_vma_defragmentation_context.html index 06ba239..e22efaf 100644 --- a/docs/html/struct_vma_defragmentation_context.html +++ b/docs/html/struct_vma_defragmentation_context.html @@ -72,7 +72,7 @@ $(function() {

      #include <vk_mem_alloc.h>

      Detailed Description

      Represents Opaque object that represents started defragmentation process.

      -

      Fill structure VmaDefragmentationInfo2 and call function vmaDefragmentationBegin() to create it. Call function vmaDefragmentationEnd() to destroy it.

      +

      Fill structure VmaDefragmentationInfo2 and call function vmaDefragmentationBegin() to create it. Call function vmaDefragmentationEnd() to destroy it.

      The documentation for this struct was generated from the following file: diff --git a/docs/html/struct_vma_defragmentation_info.html b/docs/html/struct_vma_defragmentation_info.html index 0725b95..b232cfc 100644 --- a/docs/html/struct_vma_defragmentation_info.html +++ b/docs/html/struct_vma_defragmentation_info.html @@ -69,7 +69,7 @@ $(function() {
      -

      Deprecated. Optional configuration parameters to be passed to function vmaDefragment(). +

      Deprecated. Optional configuration parameters to be passed to function vmaDefragment(). More...

      #include <vk_mem_alloc.h>

      @@ -84,8 +84,8 @@ Public Attributes  

      Detailed Description

      -

      Deprecated. Optional configuration parameters to be passed to function vmaDefragment().

      -
      Deprecated:
      This is a part of the old interface. It is recommended to use structure VmaDefragmentationInfo2 and function vmaDefragmentationBegin() instead.
      +

      Deprecated. Optional configuration parameters to be passed to function vmaDefragment().

      +
      Deprecated:
      This is a part of the old interface. It is recommended to use structure VmaDefragmentationInfo2 and function vmaDefragmentationBegin() instead.

      Member Data Documentation

      ◆ maxAllocationsToMove

      diff --git a/docs/html/struct_vma_defragmentation_info2.html b/docs/html/struct_vma_defragmentation_info2.html index 098a413..e730f4d 100644 --- a/docs/html/struct_vma_defragmentation_info2.html +++ b/docs/html/struct_vma_defragmentation_info2.html @@ -112,7 +112,7 @@ Public Attributes

      Detailed Description

      Parameters for defragmentation.

      -

      To be used with function vmaDefragmentationBegin().

      +

      To be used with function vmaDefragmentationBegin().

      Member Data Documentation

      ◆ allocationCount

      @@ -143,7 +143,7 @@ Public Attributes

      Optional. Command buffer where GPU copy commands will be posted.

      -

      If not null, it must be a valid command buffer handle that supports Transfer queue type. It must be in the recording state and outside of a render pass instance. You need to submit it and make sure it finished execution before calling vmaDefragmentationEnd().

      +

      If not null, it must be a valid command buffer handle that supports Transfer queue type. It must be in the recording state and outside of a render pass instance. You need to submit it and make sure it finished execution before calling vmaDefragmentationEnd().

      Passing null means that only CPU defragmentation will be performed.

      @@ -295,7 +295,7 @@ Public Attributes

      Either null or pointer to array of pools to be defragmented.

      -

      All the allocations in the specified pools can be moved during defragmentation and there is no way to check if they were really moved as in pAllocationsChanged, so you must query all the allocations in all these pools for new VkDeviceMemory and offset using vmaGetAllocationInfo() if you might need to recreate buffers and images bound to them.

      +

      All the allocations in the specified pools can be moved during defragmentation and there is no way to check if they were really moved as in pAllocationsChanged, so you must query all the allocations in all these pools for new VkDeviceMemory and offset using vmaGetAllocationInfo() if you might need to recreate buffers and images bound to them.

      The array should have poolCount elements. The array should not contain nulls. Elements in the array should be unique - same pool cannot occur twice.

      Using this array is equivalent to specifying all allocations from the pools in pAllocations. It might be more efficient.

      diff --git a/docs/html/struct_vma_defragmentation_stats.html b/docs/html/struct_vma_defragmentation_stats.html index 00b8c2d..f93d7df 100644 --- a/docs/html/struct_vma_defragmentation_stats.html +++ b/docs/html/struct_vma_defragmentation_stats.html @@ -69,7 +69,7 @@ $(function() {
      -

      Statistics returned by function vmaDefragment(). +

      Statistics returned by function vmaDefragment(). More...

      #include <vk_mem_alloc.h>

      @@ -90,7 +90,7 @@ Public Attributes  

      Detailed Description

      -

      Statistics returned by function vmaDefragment().

      +

      Statistics returned by function vmaDefragment().

      Member Data Documentation

      ◆ allocationsMoved

      diff --git a/docs/html/struct_vma_pool.html b/docs/html/struct_vma_pool.html index 0725e08..4b9dad1 100644 --- a/docs/html/struct_vma_pool.html +++ b/docs/html/struct_vma_pool.html @@ -72,7 +72,7 @@ $(function() {

      #include <vk_mem_alloc.h>

      Detailed Description

      Represents custom memory pool.

      -

      Fill structure VmaPoolCreateInfo and call function vmaCreatePool() to create it. Call function vmaDestroyPool() to destroy it.

      +

      Fill structure VmaPoolCreateInfo and call function vmaCreatePool() to create it. Call function vmaDestroyPool() to destroy it.

      For more information see Custom memory pools.

      The documentation for this struct was generated from the following file:
      -
      -
      - -

      ◆ VMA_CALL_POST

      - -
      -
      - - - - -
      #define VMA_CALL_POST
      -
      - -
      -
      - -

      ◆ VMA_CALL_PRE

      - -
      -
      - - - - -
      #define VMA_CALL_PRE
      -
      -
      @@ -621,7 +595,7 @@ Functions
      -

      Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().

      +

      Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().

      @@ -699,7 +673,7 @@ Functions
      -

      Flags to be used in vmaDefragmentationBegin(). None at the moment. Reserved for future use.

      +

      Flags to be used in vmaDefragmentationBegin(). None at the moment. Reserved for future use.

      @@ -729,8 +703,8 @@ Functions
      -

      Deprecated. Optional configuration parameters to be passed to function vmaDefragment().

      -
      Deprecated:
      This is a part of the old interface. It is recommended to use structure VmaDefragmentationInfo2 and function vmaDefragmentationBegin() instead.
      +

      Deprecated. Optional configuration parameters to be passed to function vmaDefragment().

      +
      Deprecated:
      This is a part of the old interface. It is recommended to use structure VmaDefragmentationInfo2 and function vmaDefragmentationBegin() instead.
      @@ -747,7 +721,7 @@ Functions

      Parameters for defragmentation.

      -

      To be used with function vmaDefragmentationBegin().

      +

      To be used with function vmaDefragmentationBegin().

      @@ -763,7 +737,7 @@ Functions
      -

      Statistics returned by function vmaDefragment().

      +

      Statistics returned by function vmaDefragment().

      @@ -986,19 +960,19 @@ Functions

      You should not use this flag together with VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT.

      VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT 

      Allocation created with this flag can become lost as a result of another allocation with VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT flag, so you must check it before use.

      -

      To check if allocation is not lost, call vmaGetAllocationInfo() and check if VmaAllocationInfo::deviceMemory is not VK_NULL_HANDLE.

      +

      To check if allocation is not lost, call vmaGetAllocationInfo() and check if VmaAllocationInfo::deviceMemory is not VK_NULL_HANDLE.

      For details about supporting lost allocations, see Lost Allocations chapter of User Guide on Main Page.

      You should not use this flag together with VMA_ALLOCATION_CREATE_MAPPED_BIT.

      VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT 

      While creating allocation using this flag, other allocations that were created with flag VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT can become lost.

      For details about supporting lost allocations, see Lost Allocations chapter of User Guide on Main Page.

      -VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT 

      Set this flag to treat VmaAllocationCreateInfo::pUserData as pointer to a null-terminated string. Instead of copying pointer value, a local copy of the string is made and stored in allocation's pUserData. The string is automatically freed together with the allocation. It is also used in vmaBuildStatsString().

      +VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT 

      Set this flag to treat VmaAllocationCreateInfo::pUserData as pointer to a null-terminated string. Instead of copying pointer value, a local copy of the string is made and stored in allocation's pUserData. The string is automatically freed together with the allocation. It is also used in vmaBuildStatsString().

      VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT 

      Allocation will be created from upper stack in a double stack pool.

      This flag is only allowed for custom pools created with VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT flag.

      -VMA_ALLOCATION_CREATE_DONT_BIND_BIT 

      Create both buffer/image and allocation, but don't bind them together. It is useful when you want to bind yourself to do some more advanced binding, e.g. using some extensions. The flag is meaningful only with functions that bind by default: vmaCreateBuffer(), vmaCreateImage(). Otherwise it is ignored.

      +VMA_ALLOCATION_CREATE_DONT_BIND_BIT 

      Create both buffer/image and allocation, but don't bind them together. It is useful when you want to bind yourself to do some more advanced binding, e.g. using some extensions. The flag is meaningful only with functions that bind by default: vmaCreateBuffer(), vmaCreateImage(). Otherwise it is ignored.

      VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT 

      Create allocation only if additional device memory required for it, if any, won't exceed memory budget. Otherwise return VK_ERROR_OUT_OF_DEVICE_MEMORY.

      @@ -1053,7 +1027,7 @@ Functions VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT 

      Enables usage of VK_KHR_bind_memory2 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.

      -

      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().

      +

      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.

      @@ -1076,7 +1050,7 @@ Functions
      -

      Flags to be used in vmaDefragmentationBegin(). None at the moment. Reserved for future use.

      +

      Flags to be used in vmaDefragmentationBegin(). None at the moment. Reserved for future use.

      Enumerator
      VMA_DEFRAGMENTATION_FLAG_BITS_MAX_ENUM 
      @@ -1139,8 +1113,8 @@ Functions

      Function Documentation

      - -

      ◆ vmaAllocateMemory()

      + +

      ◆ vmaAllocateMemory()

      Enumerator
      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 this pool and so Buffer-Image Granularity can be ignored.

      This is an optional optimization flag.

      -

      If you always allocate using vmaCreateBuffer(), vmaCreateImage(), vmaAllocateMemoryForBuffer(), then you don't need to use it because allocator knows exact type of your allocations so it can handle Buffer-Image Granularity in the optimal way.

      -

      If you also allocate using vmaAllocateMemoryForImage() or vmaAllocateMemory(), exact type of such allocations is not known, so allocator must be conservative in handling Buffer-Image Granularity, which can lead to suboptimal allocation (wasted memory). In that case, if you can make sure you always allocate only buffers and linear images or only optimal images out of this pool, use this flag to make allocator disregard Buffer-Image Granularity and so make allocations faster and more optimal.

      +

      If you always allocate using vmaCreateBuffer(), vmaCreateImage(), vmaAllocateMemoryForBuffer(), then you don't need to use it because allocator knows exact type of your allocations so it can handle Buffer-Image Granularity in the optimal way.

      +

      If you also allocate using vmaAllocateMemoryForImage() or vmaAllocateMemory(), exact type of such allocations is not known, so allocator must be conservative in handling Buffer-Image Granularity, which can lead to suboptimal allocation (wasted memory). In that case, if you can make sure you always allocate only buffers and linear images or only optimal images out of this pool, use this flag to make allocator disregard Buffer-Image Granularity and so make allocations faster and more optimal.

      VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT 

      Enables alternative, linear allocation algorithm in this pool.

      Specify this flag to enable linear allocation algorithm, which always creates new allocations after last one and doesn't reuse space from allocations freed in between. It trades memory consumption for simplified algorithm and data structure, which has better performance and uses less memory for metadata.

      @@ -1182,14 +1156,14 @@ Functions
      - + @@ -1230,23 +1204,23 @@ Functions
      Parameters
      VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemory VkResult vmaAllocateMemory ( VmaAllocator  allocator,
      - +
      [out]pAllocationHandle to allocated memory.
      [out]pAllocationInfoOptional. Information about allocated memory. It can be later fetched using function vmaGetAllocationInfo().
      [out]pAllocationInfoOptional. Information about allocated memory. It can be later fetched using function vmaGetAllocationInfo().
      -

      You should free the memory using vmaFreeMemory() or vmaFreeMemoryPages().

      -

      It is recommended to use vmaAllocateMemoryForBuffer(), vmaAllocateMemoryForImage(), vmaCreateBuffer(), vmaCreateImage() instead whenever possible.

      +

      You should free the memory using vmaFreeMemory() or vmaFreeMemoryPages().

      +

      It is recommended to use vmaAllocateMemoryForBuffer(), vmaAllocateMemoryForImage(), vmaCreateBuffer(), vmaCreateImage() instead whenever possible.

      - -

      ◆ vmaAllocateMemoryForBuffer()

      + +

      ◆ vmaAllocateMemoryForBuffer()

      - + @@ -1285,22 +1259,22 @@ Functions
      Parameters
      VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryForBuffer VkResult vmaAllocateMemoryForBuffer ( VmaAllocator  allocator,
      - +
      [out]pAllocationHandle to allocated memory.
      [out]pAllocationInfoOptional. Information about allocated memory. It can be later fetched using function vmaGetAllocationInfo().
      [out]pAllocationInfoOptional. Information about allocated memory. It can be later fetched using function vmaGetAllocationInfo().
      -

      You should free the memory using vmaFreeMemory().

      +

      You should free the memory using vmaFreeMemory().

      - -

      ◆ vmaAllocateMemoryForImage()

      + +

      ◆ vmaAllocateMemoryForImage()

      - + @@ -1337,18 +1311,18 @@ Functions
      VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryForImage VkResult vmaAllocateMemoryForImage ( VmaAllocator  allocator,
      -

      Function similar to vmaAllocateMemoryForBuffer().

      +

      Function similar to vmaAllocateMemoryForBuffer().

      - -

      ◆ vmaAllocateMemoryPages()

      + +

      ◆ vmaAllocateMemoryPages()

      - + @@ -1403,20 +1377,20 @@ Functions
      VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryPages VkResult vmaAllocateMemoryPages ( VmaAllocator  allocator,
      -

      You should free the memory using vmaFreeMemory() or vmaFreeMemoryPages().

      -

      Word "pages" is just a suggestion to use this function to allocate pieces of memory needed for sparse binding. It is just a general purpose allocation function able to make multiple allocations at once. It may be internally optimized to be more efficient than calling vmaAllocateMemory() allocationCount times.

      +

      You should free the memory using vmaFreeMemory() or vmaFreeMemoryPages().

      +

      Word "pages" is just a suggestion to use this function to allocate pieces of memory needed for sparse binding. It is just a general purpose allocation function able to make multiple allocations at once. It may be internally optimized to be more efficient than calling vmaAllocateMemory() allocationCount times.

      All allocations are made using same parameters. All of them are created out of the same memory pool and type. If any allocation fails, all allocations already made within this function call are also freed, so that when returned result is not VK_SUCCESS, pAllocation array is always entirely filled with VK_NULL_HANDLE.

      - -

      ◆ vmaBindBufferMemory()

      + +

      ◆ vmaBindBufferMemory()

      - + @@ -1443,18 +1417,18 @@ Functions

      Binds buffer to allocation.

      Binds specified buffer to region of memory represented by specified allocation. Gets VkDeviceMemory handle and offset from the allocation. If you want to create a buffer, allocate memory for it and bind them together separately, you should use this function for binding instead of standard vkBindBufferMemory(), because it ensures proper synchronization so that when a VkDeviceMemory object is used by multiple allocations, calls to vkBind*Memory() or vkMapMemory() won't happen from multiple threads simultaneously (which is illegal in Vulkan).

      -

      It is recommended to use function vmaCreateBuffer() instead of this one.

      +

      It is recommended to use function vmaCreateBuffer() instead of this one.

      - -

      ◆ vmaBindBufferMemory2()

      + +

      ◆ vmaBindBufferMemory2()

      VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindBufferMemory VkResult vmaBindBufferMemory ( VmaAllocator  allocator,
      - + @@ -1499,19 +1473,19 @@ Functions
      VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindBufferMemory2 VkResult vmaBindBufferMemory2 ( VmaAllocator  allocator,
      -

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

      +

      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.

      - -

      ◆ vmaBindImageMemory()

      + +

      ◆ vmaBindImageMemory()

      - + @@ -1538,18 +1512,18 @@ Functions

      Binds image to allocation.

      Binds specified image to region of memory represented by specified allocation. Gets VkDeviceMemory handle and offset from the allocation. If you want to create an image, allocate memory for it and bind them together separately, you should use this function for binding instead of standard vkBindImageMemory(), because it ensures proper synchronization so that when a VkDeviceMemory object is used by multiple allocations, calls to vkBind*Memory() or vkMapMemory() won't happen from multiple threads simultaneously (which is illegal in Vulkan).

      -

      It is recommended to use function vmaCreateImage() instead of this one.

      +

      It is recommended to use function vmaCreateImage() instead of this one.

      - -

      ◆ vmaBindImageMemory2()

      + +

      ◆ vmaBindImageMemory2()

      VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindImageMemory VkResult vmaBindImageMemory ( VmaAllocator  allocator,
      - + @@ -1594,19 +1568,19 @@ Functions
      VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindImageMemory2 VkResult vmaBindImageMemory2 ( VmaAllocator  allocator,
      -

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

      +

      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.

      - -

      ◆ vmaBuildStatsString()

      + +

      ◆ vmaBuildStatsString()

      - + @@ -1634,21 +1608,21 @@ Functions

      Builds and returns statistics as string in JSON format.

      Parameters
      VMA_CALL_PRE void VMA_CALL_POST vmaBuildStatsString void vmaBuildStatsString ( VmaAllocator  allocator,
      - +
      [out]ppStatsStringMust be freed using vmaFreeStatsString() function.
      [out]ppStatsStringMust be freed using vmaFreeStatsString() function.
      - -

      ◆ vmaCalculateStats()

      + +

      ◆ vmaCalculateStats()

      - + @@ -1668,19 +1642,19 @@ Functions

      Retrieves statistics from current state of the Allocator.

      -

      This function is called "calculate" not "get" because it has to traverse all internal data structures, so it may be quite slow. For faster but more brief statistics suitable to be called every frame or every allocation, use vmaGetBudget().

      +

      This function is called "calculate" not "get" because it has to traverse all internal data structures, so it may be quite slow. For faster but more brief statistics suitable to be called every frame or every allocation, use vmaGetBudget().

      Note that when using allocator from multiple threads, returned information may immediately become outdated.

      - -

      ◆ vmaCheckCorruption()

      + +

      ◆ vmaCheckCorruption()

      VMA_CALL_PRE void VMA_CALL_POST vmaCalculateStats void vmaCalculateStats ( VmaAllocator  allocator,
      - + @@ -1717,14 +1691,14 @@ Functions - -

      ◆ vmaCheckPoolCorruption()

      + +

      ◆ vmaCheckPoolCorruption()

      VMA_CALL_PRE VkResult VMA_CALL_POST vmaCheckCorruption VkResult vmaCheckCorruption ( VmaAllocator  allocator,
      - + @@ -1755,14 +1729,14 @@ Functions - -

      ◆ vmaCreateAllocator()

      + +

      ◆ vmaCreateAllocator()

      VMA_CALL_PRE VkResult VMA_CALL_POST vmaCheckPoolCorruption VkResult vmaCheckPoolCorruption ( VmaAllocator  allocator,
      - + @@ -1785,14 +1759,14 @@ Functions - -

      ◆ vmaCreateBuffer()

      + +

      ◆ vmaCreateBuffer()

      VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateAllocator VkResult vmaCreateAllocator ( const VmaAllocatorCreateInfo *  pCreateInfo,
      - + @@ -1838,7 +1812,7 @@ Functions
      VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateBuffer VkResult vmaCreateBuffer ( VmaAllocator  allocator,
      - +
      [out]pBufferBuffer that was created.
      [out]pAllocationAllocation that was created.
      [out]pAllocationInfoOptional. Information about allocated memory. It can be later fetched using function vmaGetAllocationInfo().
      [out]pAllocationInfoOptional. Information about allocated memory. It can be later fetched using function vmaGetAllocationInfo().
      @@ -1849,19 +1823,19 @@ Functions
    • Binds the buffer with the memory.

      • If any of these operations fail, buffer and allocation are not created, returned value is negative error code, *pBuffer and *pAllocation are null.

      -

      If the function succeeded, you must destroy both buffer and allocation when you no longer need them using either convenience function vmaDestroyBuffer() or separately, using vkDestroyBuffer() and vmaFreeMemory().

      +

      If the function succeeded, you must destroy both buffer and allocation when you no longer need them using either convenience function vmaDestroyBuffer() or separately, using vkDestroyBuffer() and vmaFreeMemory().

      If VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT flag was used, VK_KHR_dedicated_allocation extension is used internally to query driver whether it requires or prefers the new buffer to have dedicated allocation. If yes, and if dedicated allocation is possible (VmaAllocationCreateInfo::pool is null and VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT is not used), it creates dedicated allocation for this buffer, just like when using VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT.

      - -

      ◆ vmaCreateImage()

      + +

      ◆ vmaCreateImage()

      - + @@ -1904,18 +1878,18 @@ Functions
      VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateImage VkResult vmaCreateImage ( VmaAllocator  allocator,
      -

      Function similar to vmaCreateBuffer().

      +

      Function similar to vmaCreateBuffer().

      - -

      ◆ vmaCreateLostAllocation()

      + +

      ◆ vmaCreateLostAllocation()

      - + @@ -1936,19 +1910,19 @@ Functions

      Creates new allocation that is in lost state from the beginning.

      It can be useful if you need a dummy, non-null allocation.

      -

      You still need to destroy created object using vmaFreeMemory().

      +

      You still need to destroy created object using vmaFreeMemory().

      Returned allocation is not tied to any specific memory pool or memory type and not bound to any image or buffer. It has size = 0. It cannot be turned into a real, non-empty allocation.

      - -

      ◆ vmaCreatePool()

      + +

      ◆ vmaCreatePool()

      VMA_CALL_PRE void VMA_CALL_POST vmaCreateLostAllocation void vmaCreateLostAllocation ( VmaAllocator  allocator,
      - + @@ -1985,14 +1959,14 @@ Functions - -

      ◆ vmaDefragment()

      + +

      ◆ vmaDefragment()

      VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreatePool VkResult vmaCreatePool ( VmaAllocator  allocator,
      - + @@ -2047,7 +2021,7 @@ Functions
      Returns
      VK_SUCCESS if completed, negative error code in case of error.
      -
      Deprecated:
      This is a part of the old interface. It is recommended to use structure VmaDefragmentationInfo2 and function vmaDefragmentationBegin() instead.
      +
      Deprecated:
      This is a part of the old interface. It is recommended to use structure VmaDefragmentationInfo2 and function vmaDefragmentationBegin() instead.

      This function works by moving allocations to different places (different VkDeviceMemory objects and/or different offsets) in order to optimize memory usage. Only allocations that are in pAllocations array can be moved. All other allocations are considered nonmovable in this call. Basic rules:

      • Only allocations made in memory types that have VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT and VK_MEMORY_PROPERTY_HOST_COHERENT_BIT flags can be compacted. You may pass other allocations but it makes no sense - these will never be moved.
        • @@ -2062,14 +2036,14 @@ Functions - -

        ◆ vmaDefragmentationBegin()

        + +

        ◆ vmaDefragmentationBegin()

      VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragment VkResult vmaDefragment ( VmaAllocator  allocator,
      - + @@ -2106,31 +2080,31 @@ Functions - +
      VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragmentationBegin VkResult vmaDefragmentationBegin ( VmaAllocator  allocator,
      allocatorAllocator object.
      pInfoStructure filled with parameters of defragmentation.
      [out]pStatsOptional. Statistics of defragmentation. You can pass null if you are not interested in this information.
      [out]pContextContext object that must be passed to vmaDefragmentationEnd() to finish defragmentation.
      [out]pContextContext object that must be passed to vmaDefragmentationEnd() to finish defragmentation.
      -
      Returns
      VK_SUCCESS and *pContext == null if defragmentation finished within this function call. VK_NOT_READY and *pContext != null if defragmentation has been started and you need to call vmaDefragmentationEnd() to finish it. Negative value in case of error.
      -

      Use this function instead of old, deprecated vmaDefragment().

      -

      Warning! Between the call to vmaDefragmentationBegin() and vmaDefragmentationEnd():

      +
      Returns
      VK_SUCCESS and *pContext == null if defragmentation finished within this function call. VK_NOT_READY and *pContext != null if defragmentation has been started and you need to call vmaDefragmentationEnd() to finish it. Negative value in case of error.
      +

      Use this function instead of old, deprecated vmaDefragment().

      +

      Warning! Between the call to vmaDefragmentationBegin() and vmaDefragmentationEnd():

        -
      • You should not use any of allocations passed as pInfo->pAllocations or any allocations that belong to pools passed as pInfo->pPools, including calling vmaGetAllocationInfo(), vmaTouchAllocation(), or access their data.
        • +
      • You should not use any of allocations passed as pInfo->pAllocations or any allocations that belong to pools passed as pInfo->pPools, including calling vmaGetAllocationInfo(), vmaTouchAllocation(), or access their data.
      • Some mutexes protecting internal data structures may be locked, so trying to make or free any allocations, bind buffers or images, map memory, or launch another simultaneous defragmentation in between may cause stall (when done on another thread) or deadlock (when done on the same thread), unless you are 100% sure that defragmented allocations are in different pools.
        • -
      • Information returned via pStats and pInfo->pAllocationsChanged are undefined. They become valid after call to vmaDefragmentationEnd().
        • -
      • If pInfo->commandBuffer is not null, you must submit that command buffer and make sure it finished execution before calling vmaDefragmentationEnd().
        • +
      • Information returned via pStats and pInfo->pAllocationsChanged are undefined. They become valid after call to vmaDefragmentationEnd().
        • +
      • If pInfo->commandBuffer is not null, you must submit that command buffer and make sure it finished execution before calling vmaDefragmentationEnd().

      For more information and important limitations regarding defragmentation, see documentation chapter: Defragmentation.

      - -

      ◆ vmaDefragmentationEnd()

      + +

      ◆ vmaDefragmentationEnd()

      - + @@ -2150,18 +2124,18 @@ Functions

      Ends defragmentation process.

      -

      Use this function to finish defragmentation started by vmaDefragmentationBegin(). It is safe to pass context == null. The function then does nothing.

      +

      Use this function to finish defragmentation started by vmaDefragmentationBegin(). It is safe to pass context == null. The function then does nothing.

      - -

      ◆ vmaDestroyAllocator()

      + +

      ◆ vmaDestroyAllocator()

      VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragmentationEnd VkResult vmaDefragmentationEnd ( VmaAllocator  allocator,
      - + @@ -2174,14 +2148,14 @@ Functions - -

      ◆ vmaDestroyBuffer()

      + +

      ◆ vmaDestroyBuffer()

      VMA_CALL_PRE void VMA_CALL_POST vmaDestroyAllocator void vmaDestroyAllocator ( VmaAllocator  allocator)
      - + @@ -2209,19 +2183,19 @@ Functions

      Destroys Vulkan buffer and frees allocated memory.

      This is just a convenience function equivalent to:

      vkDestroyBuffer(device, buffer, allocationCallbacks);
      -
      vmaFreeMemory(allocator, allocation);
      +
      vmaFreeMemory(allocator, allocation);

      It it safe to pass null as buffer and/or allocation.

      - -

      ◆ vmaDestroyImage()

      + +

      ◆ vmaDestroyImage()

      VMA_CALL_PRE void VMA_CALL_POST vmaDestroyBuffer void vmaDestroyBuffer ( VmaAllocator  allocator,
      - + @@ -2249,19 +2223,19 @@ Functions

      Destroys Vulkan image and frees allocated memory.

      This is just a convenience function equivalent to:

      vkDestroyImage(device, image, allocationCallbacks);
      -
      vmaFreeMemory(allocator, allocation);
      +
      vmaFreeMemory(allocator, allocation);

      It it safe to pass null as image and/or allocation.

      - -

      ◆ vmaDestroyPool()

      + +

      ◆ vmaDestroyPool()

      VMA_CALL_PRE void VMA_CALL_POST vmaDestroyImage void vmaDestroyImage ( VmaAllocator  allocator,
      - + @@ -2284,14 +2258,14 @@ Functions - -

      ◆ vmaFindMemoryTypeIndex()

      + +

      ◆ vmaFindMemoryTypeIndex()

      VMA_CALL_PRE void VMA_CALL_POST vmaDestroyPool void vmaDestroyPool ( VmaAllocator  allocator,
      - + @@ -2334,14 +2308,14 @@ Functions - -

      ◆ vmaFindMemoryTypeIndexForBufferInfo()

      + +

      ◆ vmaFindMemoryTypeIndexForBufferInfo()

      VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndex VkResult vmaFindMemoryTypeIndex ( VmaAllocator  allocator,
      - + @@ -2383,14 +2357,14 @@ Functions - -

      ◆ vmaFindMemoryTypeIndexForImageInfo()

      + +

      ◆ vmaFindMemoryTypeIndexForImageInfo()

      VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForBufferInfo VkResult vmaFindMemoryTypeIndexForBufferInfo ( VmaAllocator  allocator,
      - + @@ -2432,14 +2406,14 @@ Functions - -

      ◆ vmaFlushAllocation()

      + +

      ◆ vmaFlushAllocation()

      VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForImageInfo VkResult vmaFindMemoryTypeIndexForImageInfo ( VmaAllocator  allocator,
      - + @@ -2483,14 +2457,14 @@ Functions - -

      ◆ vmaFreeMemory()

      + +

      ◆ vmaFreeMemory()

      VMA_CALL_PRE void VMA_CALL_POST vmaFlushAllocation void vmaFlushAllocation ( VmaAllocator  allocator,
      - + @@ -2509,19 +2483,19 @@ Functions
      VMA_CALL_PRE void VMA_CALL_POST vmaFreeMemory void vmaFreeMemory ( VmaAllocator  allocator,
      -

      Frees memory previously allocated using vmaAllocateMemory(), vmaAllocateMemoryForBuffer(), or vmaAllocateMemoryForImage().

      +

      Frees memory previously allocated using vmaAllocateMemory(), vmaAllocateMemoryForBuffer(), or vmaAllocateMemoryForImage().

      Passing VK_NULL_HANDLE as allocation is valid. Such function call is just skipped.

      - -

      ◆ vmaFreeMemoryPages()

      + +

      ◆ vmaFreeMemoryPages()

      - + @@ -2547,19 +2521,19 @@ Functions

      Frees memory and destroys multiple allocations.

      -

      Word "pages" is just a suggestion to use this function to free pieces of memory used for sparse binding. It is just a general purpose function to free memory and destroy allocations made using e.g. vmaAllocateMemory(), vmaAllocateMemoryPages() and other functions. It may be internally optimized to be more efficient than calling vmaFreeMemory() allocationCount times.

      +

      Word "pages" is just a suggestion to use this function to free pieces of memory used for sparse binding. It is just a general purpose function to free memory and destroy allocations made using e.g. vmaAllocateMemory(), vmaAllocateMemoryPages() and other functions. It may be internally optimized to be more efficient than calling vmaFreeMemory() allocationCount times.

      Allocations in pAllocations array can come from any memory pools and types. Passing VK_NULL_HANDLE as elements of pAllocations array is valid. Such entries are just skipped.

      - -

      ◆ vmaFreeStatsString()

      + +

      ◆ vmaFreeStatsString()

      VMA_CALL_PRE void VMA_CALL_POST vmaFreeMemoryPages void vmaFreeMemoryPages ( VmaAllocator  allocator,
      - + @@ -2580,14 +2554,14 @@ Functions - -

      ◆ vmaGetAllocationInfo()

      + +

      ◆ vmaGetAllocationInfo()

      VMA_CALL_PRE void VMA_CALL_POST vmaFreeStatsString void vmaFreeStatsString ( VmaAllocator  allocator,
      - + @@ -2614,23 +2588,23 @@ Functions

      Returns current information about specified allocation and atomically marks it as used in current frame.

      Current paramters of given allocation are returned in pAllocationInfo.

      -

      This function also atomically "touches" allocation - marks it as used in current frame, just like vmaTouchAllocation(). If the allocation is in lost state, pAllocationInfo->deviceMemory == VK_NULL_HANDLE.

      +

      This function also atomically "touches" allocation - marks it as used in current frame, just like vmaTouchAllocation(). If the allocation is in lost state, pAllocationInfo->deviceMemory == VK_NULL_HANDLE.

      Although this function uses atomics and doesn't lock any mutex, so it should be quite efficient, you can avoid calling it too often.

      - -

      ◆ vmaGetBudget()

      + +

      ◆ vmaGetBudget()

      VMA_CALL_PRE void VMA_CALL_POST vmaGetAllocationInfo void vmaGetAllocationInfo ( VmaAllocator  allocator,
      - + @@ -2656,19 +2630,19 @@ Functions
      VMA_CALL_PRE void VMA_CALL_POST vmaGetBudget void vmaGetBudget ( VmaAllocator  allocator,
      -

      This function is called "get" not "calculate" because it is very fast, suitable to be called every frame or every allocation. For more detailed statistics use vmaCalculateStats().

      +

      This function is called "get" not "calculate" because it is very fast, suitable to be called every frame or every allocation. For more detailed statistics use vmaCalculateStats().

      Note that when using allocator from multiple threads, returned information may immediately become outdated.

      - -

      ◆ vmaGetMemoryProperties()

      + +

      ◆ vmaGetMemoryProperties()

      - + @@ -2690,14 +2664,14 @@ Functions - -

      ◆ vmaGetMemoryTypeProperties()

      + +

      ◆ vmaGetMemoryTypeProperties()

      VMA_CALL_PRE void VMA_CALL_POST vmaGetMemoryProperties void vmaGetMemoryProperties ( VmaAllocator  allocator,
      - + @@ -2723,18 +2697,18 @@ Functions

      Given Memory Type Index, returns Property Flags of this memory type.

      -

      This is just a convenience function. Same information can be obtained using vmaGetMemoryProperties().

      +

      This is just a convenience function. Same information can be obtained using vmaGetMemoryProperties().

      - -

      ◆ vmaGetPhysicalDeviceProperties()

      + +

      ◆ vmaGetPhysicalDeviceProperties()

      VMA_CALL_PRE void VMA_CALL_POST vmaGetMemoryTypeProperties void vmaGetMemoryTypeProperties ( VmaAllocator  allocator,
      - + @@ -2756,14 +2730,51 @@ Functions - -

      ◆ vmaGetPoolStats()

      + +

      ◆ vmaGetPoolName()

      VMA_CALL_PRE void VMA_CALL_POST vmaGetPhysicalDeviceProperties void vmaGetPhysicalDeviceProperties ( VmaAllocator  allocator,
      - + + + + + + + + + + + + + + + + + + + + + + +
      VMA_CALL_PRE void VMA_CALL_POST vmaGetPoolStats void vmaGetPoolName (VmaAllocator allocator,
      VmaPool pool,
      const char ** ppName 
      )
      +
      + +

      Retrieves name of a custom pool.

      +

      After the call ppName is either null or points to an internally-owned null-terminated string containing name of the pool that was previously set. The pointer becomes invalid when the pool is destroyed or its name is changed using vmaSetPoolName().

      + +
      +
      + +

      ◆ vmaGetPoolStats()

      + +
      +
      + + + @@ -2800,14 +2811,14 @@ Functions - -

      ◆ vmaInvalidateAllocation()

      + +

      ◆ vmaInvalidateAllocation()

      void vmaGetPoolStats ( VmaAllocator  allocator,
      - + @@ -2851,14 +2862,14 @@ Functions - -

      ◆ vmaMakePoolAllocationsLost()

      + +

      ◆ vmaMakePoolAllocationsLost()

      VMA_CALL_PRE void VMA_CALL_POST vmaInvalidateAllocation void vmaInvalidateAllocation ( VmaAllocator  allocator,
      - + @@ -2895,14 +2906,14 @@ Functions - -

      ◆ vmaMapMemory()

      + +

      ◆ vmaMapMemory()

      VMA_CALL_PRE void VMA_CALL_POST vmaMakePoolAllocationsLost void vmaMakePoolAllocationsLost ( VmaAllocator  allocator,
      - + @@ -2930,22 +2941,22 @@ Functions

      Maps memory represented by given allocation and returns pointer to it.

      Maps memory represented by given allocation to make it accessible to CPU code. When succeeded, *ppData contains pointer to first byte of this memory. If the allocation is part of bigger VkDeviceMemory block, the pointer is correctly offseted to the beginning of region assigned to this particular allocation.

      Mapping is internally reference-counted and synchronized, so despite raw Vulkan function vkMapMemory() cannot be used to map same block of VkDeviceMemory multiple times simultaneously, it is safe to call this function on allocations assigned to the same memory block. Actual Vulkan memory will be mapped on first mapping and unmapped on last unmapping.

      -

      If the function succeeded, you must call vmaUnmapMemory() to unmap the allocation when mapping is no longer needed or before freeing the allocation, at the latest.

      -

      It also safe to call this function multiple times on the same allocation. You must call vmaUnmapMemory() same number of times as you called vmaMapMemory().

      -

      It is also safe to call this function on allocation created with VMA_ALLOCATION_CREATE_MAPPED_BIT flag. Its memory stays mapped all the time. You must still call vmaUnmapMemory() same number of times as you called vmaMapMemory(). You must not call vmaUnmapMemory() additional time to free the "0-th" mapping made automatically due to VMA_ALLOCATION_CREATE_MAPPED_BIT flag.

      +

      If the function succeeded, you must call vmaUnmapMemory() to unmap the allocation when mapping is no longer needed or before freeing the allocation, at the latest.

      +

      It also safe to call this function multiple times on the same allocation. You must call vmaUnmapMemory() same number of times as you called vmaMapMemory().

      +

      It is also safe to call this function on allocation created with VMA_ALLOCATION_CREATE_MAPPED_BIT flag. Its memory stays mapped all the time. You must still call vmaUnmapMemory() same number of times as you called vmaMapMemory(). You must not call vmaUnmapMemory() additional time to free the "0-th" mapping made automatically due to VMA_ALLOCATION_CREATE_MAPPED_BIT flag.

      This function fails when used on allocation made in memory type that is not HOST_VISIBLE.

      This function always fails when called for allocation that was created with VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT flag. Such allocations cannot be mapped.

      - -

      ◆ vmaResizeAllocation()

      + +

      ◆ vmaResizeAllocation()

      VMA_CALL_PRE VkResult VMA_CALL_POST vmaMapMemory VkResult vmaMapMemory ( VmaAllocator  allocator,
      - + @@ -2975,14 +2986,14 @@ Functions - -

      ◆ vmaSetAllocationUserData()

      + +

      ◆ vmaSetAllocationUserData()

      VMA_CALL_PRE VkResult VMA_CALL_POST vmaResizeAllocation VkResult vmaResizeAllocation ( VmaAllocator  allocator,
      - + @@ -3013,14 +3024,14 @@ Functions - -

      ◆ vmaSetCurrentFrameIndex()

      + +

      ◆ vmaSetCurrentFrameIndex()

      VMA_CALL_PRE void VMA_CALL_POST vmaSetAllocationUserData void vmaSetAllocationUserData ( VmaAllocator  allocator,
      - + @@ -3040,18 +3051,55 @@ Functions

      Sets index of the current frame.

      -

      This function must be used if you make allocations with VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT and VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT flags to inform the allocator when a new frame begins. Allocations queried using vmaGetAllocationInfo() cannot become lost in the current frame.

      +

      This function must be used if you make allocations with VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT and VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT flags to inform the allocator when a new frame begins. Allocations queried using vmaGetAllocationInfo() cannot become lost in the current frame.

      - -

      ◆ vmaTouchAllocation()

      + +

      ◆ vmaSetPoolName()

      VMA_CALL_PRE void VMA_CALL_POST vmaSetCurrentFrameIndex void vmaSetCurrentFrameIndex ( VmaAllocator  allocator,
      - + + + + + + + + + + + + + + + + + + + + + + +
      VMA_CALL_PRE VkBool32 VMA_CALL_POST vmaTouchAllocation void vmaSetPoolName (VmaAllocator allocator,
      VmaPool pool,
      const char * pName 
      )
      +
      + +

      Sets name of a custom pool.

      +

      pName can be either null or pointer to a null-terminated string with new name for the pool. Function makes internal copy of the string, so it can be changed or freed immediately after this call.

      + +
      +
      + +

      ◆ vmaTouchAllocation()

      + +
      +
      + + + @@ -3077,14 +3125,14 @@ Functions - -

      ◆ vmaUnmapMemory()

      + +

      ◆ vmaUnmapMemory()

      VkBool32 vmaTouchAllocation ( VmaAllocator  allocator,
      - + @@ -3103,13 +3151,13 @@ Functions
      VMA_CALL_PRE void VMA_CALL_POST vmaUnmapMemory void vmaUnmapMemory ( VmaAllocator  allocator,
      -

      Unmaps memory represented by given allocation, mapped previously using vmaMapMemory().

      -

      For details, see description of vmaMapMemory().

      +

      Unmaps memory represented by given allocation, mapped previously using vmaMapMemory().

      +

      For details, see description of vmaMapMemory().

      -
      vmaFreeMemory
      VMA_CALL_PRE void VMA_CALL_POST vmaFreeMemory(VmaAllocator allocator, VmaAllocation allocation)
      Frees memory previously allocated using vmaAllocateMemory(), vmaAllocateMemoryForBuffer(),...
      +
      vmaFreeMemory
      void vmaFreeMemory(VmaAllocator allocator, VmaAllocation allocation)
      Frees memory previously allocated using vmaAllocateMemory(), vmaAllocateMemoryForBuffer(),...
      Generated by   diff --git a/docs/html/vk__mem__alloc_8h_source.html b/docs/html/vk__mem__alloc_8h_source.html index b62f0f6..69a3a92 100644 --- a/docs/html/vk__mem__alloc_8h_source.html +++ b/docs/html/vk__mem__alloc_8h_source.html @@ -144,10 +144,10 @@ $(function() {
      1807 // #define VMA_CALL_PRE __declspec(dllexport)
      1808 // #define VMA_CALL_POST __cdecl
      1809 #ifndef VMA_CALL_PRE
      -
      1810  #define VMA_CALL_PRE
      +
      1810  #define VMA_CALL_PRE
      1811 #endif
      1812 #ifndef VMA_CALL_POST
      -
      1813  #define VMA_CALL_POST
      +
      1813  #define VMA_CALL_POST
      1814 #endif
      1815 
      1825 VK_DEFINE_HANDLE(VmaAllocator)
      @@ -242,27 +242,27 @@ $(function() {
      2057  VkInstance instance;
      2058 } VmaAllocatorCreateInfo;
      2059 
      -
      2061 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateAllocator(
      +
      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(
      +
      2066 VMA_CALL_PRE void VMA_CALL_POST vmaDestroyAllocator(
      2067  VmaAllocator allocator);
      2068 
      -
      2073 VMA_CALL_PRE void VMA_CALL_POST vmaGetPhysicalDeviceProperties(
      +
      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(
      +
      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(
      +
      2091 VMA_CALL_PRE void VMA_CALL_POST vmaGetMemoryTypeProperties(
      2092  VmaAllocator allocator,
      2093  uint32_t memoryTypeIndex,
      2094  VkMemoryPropertyFlags* pFlags);
      2095 
      -
      2104 VMA_CALL_PRE void VMA_CALL_POST vmaSetCurrentFrameIndex(
      +
      2104 VMA_CALL_PRE void VMA_CALL_POST vmaSetCurrentFrameIndex(
      2105  VmaAllocator allocator,
      2106  uint32_t frameIndex);
      2107 
      @@ -284,7 +284,7 @@ $(function() {
      2131  VmaStatInfo total;
      2132 } VmaStats;
      2133 
      -
      2143 VMA_CALL_PRE void VMA_CALL_POST vmaCalculateStats(
      +
      2143 VMA_CALL_PRE void VMA_CALL_POST vmaCalculateStats(
      2144  VmaAllocator allocator,
      2145  VmaStats* pStats);
      2146 
      @@ -292,10910 +292,10896 @@ $(function() {
      2150 {
      2153  VkDeviceSize blockBytes;
      2154 
      -
      2161  VkDeviceSize allocationBytes;
      -
      2162 
      -
      2171  VkDeviceSize usage;
      -
      2172 
      -
      2182  VkDeviceSize budget;
      -
      2183 } VmaBudget;
      -
      2184 
      -
      2195 VMA_CALL_PRE void VMA_CALL_POST vmaGetBudget(
      -
      2196  VmaAllocator allocator,
      -
      2197  VmaBudget* pBudget);
      -
      2198 
      -
      2199 #ifndef VMA_STATS_STRING_ENABLED
      -
      2200 #define VMA_STATS_STRING_ENABLED 1
      -
      2201 #endif
      -
      2202 
      -
      2203 #if VMA_STATS_STRING_ENABLED
      -
      2204 
      -
      2206 
      -
      2208 VMA_CALL_PRE void VMA_CALL_POST vmaBuildStatsString(
      -
      2209  VmaAllocator allocator,
      -
      2210  char** ppStatsString,
      -
      2211  VkBool32 detailedMap);
      -
      2212 
      -
      2213 VMA_CALL_PRE void VMA_CALL_POST vmaFreeStatsString(
      -
      2214  VmaAllocator allocator,
      -
      2215  char* pStatsString);
      -
      2216 
      -
      2217 #endif // #if VMA_STATS_STRING_ENABLED
      -
      2218 
      -
      2227 VK_DEFINE_HANDLE(VmaPool)
      -
      2228 
      -
      2229 typedef enum VmaMemoryUsage
      -
      2230 {
      -
      2234  VMA_MEMORY_USAGE_UNKNOWN = 0,
      -
      2251  VMA_MEMORY_USAGE_GPU_ONLY = 1,
      -
      2261  VMA_MEMORY_USAGE_CPU_ONLY = 2,
      -
      2268  VMA_MEMORY_USAGE_CPU_TO_GPU = 3,
      -
      2277  VMA_MEMORY_USAGE_GPU_TO_CPU = 4,
      -
      2278  VMA_MEMORY_USAGE_MAX_ENUM = 0x7FFFFFFF
      -
      2279 } VmaMemoryUsage;
      -
      2280 
      -
      2282 typedef enum VmaAllocationCreateFlagBits {
      -
      2289  VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT = 0x00000001,
      -
      2290 
      -
      2300  VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT = 0x00000002,
      -
      2313  VMA_ALLOCATION_CREATE_MAPPED_BIT = 0x00000004,
      -
      2326  VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT = 0x00000008,
      -
      2333  VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT = 0x00000010,
      -
      2339  VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT = 0x00000020,
      -
      2344  VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT = 0x00000040,
      -
      2350  VMA_ALLOCATION_CREATE_DONT_BIND_BIT = 0x00000080,
      -
      2354  VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT = 0x00000100,
      -
      2355 
      -
      2359  VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT = 0x00010000,
      -
      2363  VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT = 0x00020000,
      -
      2370  VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT = 0x00040000,
      -
      2371 
      -
      2374  VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT = VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT,
      -
      2377  VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT = VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT,
      -
      2380  VMA_ALLOCATION_CREATE_STRATEGY_MIN_FRAGMENTATION_BIT = VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT,
      -
      2381 
      -
      2384  VMA_ALLOCATION_CREATE_STRATEGY_MASK =
      -
      2385  VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT |
      -
      2386  VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT |
      -
      2387  VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT,
      -
      2388 
      -
      2389  VMA_ALLOCATION_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
      -
      2390 } VmaAllocationCreateFlagBits;
      -
      2391 typedef VkFlags VmaAllocationCreateFlags;
      -
      2392 
      -
      2393 typedef struct VmaAllocationCreateInfo
      -
      2394 {
      -
      2396  VmaAllocationCreateFlags flags;
      -
      2402  VmaMemoryUsage usage;
      -
      2407  VkMemoryPropertyFlags requiredFlags;
      -
      2412  VkMemoryPropertyFlags preferredFlags;
      -
      2420  uint32_t memoryTypeBits;
      -
      2426  VmaPool pool;
      -
      2433  void* pUserData;
      -
      2434 } VmaAllocationCreateInfo;
      -
      2435 
      -
      2452 VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndex(
      -
      2453  VmaAllocator allocator,
      -
      2454  uint32_t memoryTypeBits,
      -
      2455  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      -
      2456  uint32_t* pMemoryTypeIndex);
      -
      2457 
      -
      2470 VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForBufferInfo(
      -
      2471  VmaAllocator allocator,
      -
      2472  const VkBufferCreateInfo* pBufferCreateInfo,
      -
      2473  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      -
      2474  uint32_t* pMemoryTypeIndex);
      -
      2475 
      -
      2488 VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForImageInfo(
      -
      2489  VmaAllocator allocator,
      -
      2490  const VkImageCreateInfo* pImageCreateInfo,
      -
      2491  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      -
      2492  uint32_t* pMemoryTypeIndex);
      -
      2493 
      -
      2495 typedef enum VmaPoolCreateFlagBits {
      -
      2513  VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT = 0x00000002,
      -
      2514 
      -
      2530  VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT = 0x00000004,
      -
      2531 
      -
      2541  VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT = 0x00000008,
      -
      2542 
      -
      2545  VMA_POOL_CREATE_ALGORITHM_MASK =
      -
      2546  VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT |
      -
      2547  VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT,
      -
      2548 
      -
      2549  VMA_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
      -
      2550 } VmaPoolCreateFlagBits;
      -
      2551 typedef VkFlags VmaPoolCreateFlags;
      -
      2552 
      -
      2555 typedef struct VmaPoolCreateInfo {
      -
      2558  uint32_t memoryTypeIndex;
      -
      2561  VmaPoolCreateFlags flags;
      -
      2570  VkDeviceSize blockSize;
      -
      2575  size_t minBlockCount;
      -
      2583  size_t maxBlockCount;
      -
      2597  uint32_t frameInUseCount;
      -
      2598 } VmaPoolCreateInfo;
      -
      2599 
      -
      2602 typedef struct VmaPoolStats {
      -
      2605  VkDeviceSize size;
      -
      2608  VkDeviceSize unusedSize;
      -
      2611  size_t allocationCount;
      -
      2614  size_t unusedRangeCount;
      -
      2621  VkDeviceSize unusedRangeSizeMax;
      -
      2624  size_t blockCount;
      -
      2625 } VmaPoolStats;
      -
      2626 
      -
      2633 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreatePool(
      -
      2634  VmaAllocator allocator,
      -
      2635  const VmaPoolCreateInfo* pCreateInfo,
      -
      2636  VmaPool* pPool);
      -
      2637 
      -
      2640 VMA_CALL_PRE void VMA_CALL_POST vmaDestroyPool(
      -
      2641  VmaAllocator allocator,
      -
      2642  VmaPool pool);
      -
      2643 
      -
      2650 VMA_CALL_PRE void VMA_CALL_POST vmaGetPoolStats(
      -
      2651  VmaAllocator allocator,
      -
      2652  VmaPool pool,
      -
      2653  VmaPoolStats* pPoolStats);
      -
      2654 
      -
      2661 VMA_CALL_PRE void VMA_CALL_POST vmaMakePoolAllocationsLost(
      -
      2662  VmaAllocator allocator,
      -
      2663  VmaPool pool,
      -
      2664  size_t* pLostAllocationCount);
      -
      2665 
      -
      2680 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCheckPoolCorruption(VmaAllocator allocator, VmaPool pool);
      -
      2681 
      -
      2706 VK_DEFINE_HANDLE(VmaAllocation)
      -
      2707 
      -
      2708 
      -
      2710 typedef struct VmaAllocationInfo {
      -
      2715  uint32_t memoryType;
      -
      2724  VkDeviceMemory deviceMemory;
      -
      2729  VkDeviceSize offset;
      -
      2734  VkDeviceSize size;
      -
      2743  void* pMappedData;
      -
      2748  void* pUserData;
      -
      2749 } VmaAllocationInfo;
      -
      2750 
      -
      2761 VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemory(
      -
      2762  VmaAllocator allocator,
      -
      2763  const VkMemoryRequirements* pVkMemoryRequirements,
      -
      2764  const VmaAllocationCreateInfo* pCreateInfo,
      -
      2765  VmaAllocation* pAllocation,
      -
      2766  VmaAllocationInfo* pAllocationInfo);
      -
      2767 
      -
      2787 VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryPages(
      -
      2788  VmaAllocator allocator,
      -
      2789  const VkMemoryRequirements* pVkMemoryRequirements,
      -
      2790  const VmaAllocationCreateInfo* pCreateInfo,
      -
      2791  size_t allocationCount,
      -
      2792  VmaAllocation* pAllocations,
      -
      2793  VmaAllocationInfo* pAllocationInfo);
      -
      2794 
      -
      2801 VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryForBuffer(
      -
      2802  VmaAllocator allocator,
      -
      2803  VkBuffer buffer,
      -
      2804  const VmaAllocationCreateInfo* pCreateInfo,
      -
      2805  VmaAllocation* pAllocation,
      -
      2806  VmaAllocationInfo* pAllocationInfo);
      -
      2807 
      -
      2809 VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryForImage(
      -
      2810  VmaAllocator allocator,
      -
      2811  VkImage image,
      -
      2812  const VmaAllocationCreateInfo* pCreateInfo,
      -
      2813  VmaAllocation* pAllocation,
      -
      2814  VmaAllocationInfo* pAllocationInfo);
      -
      2815 
      -
      2820 VMA_CALL_PRE void VMA_CALL_POST vmaFreeMemory(
      -
      2821  VmaAllocator allocator,
      -
      2822  VmaAllocation allocation);
      -
      2823 
      -
      2834 VMA_CALL_PRE void VMA_CALL_POST vmaFreeMemoryPages(
      -
      2835  VmaAllocator allocator,
      -
      2836  size_t allocationCount,
      -
      2837  VmaAllocation* pAllocations);
      -
      2838 
      -
      2845 VMA_CALL_PRE VkResult VMA_CALL_POST vmaResizeAllocation(
      -
      2846  VmaAllocator allocator,
      -
      2847  VmaAllocation allocation,
      -
      2848  VkDeviceSize newSize);
      -
      2849 
      -
      2866 VMA_CALL_PRE void VMA_CALL_POST vmaGetAllocationInfo(
      -
      2867  VmaAllocator allocator,
      -
      2868  VmaAllocation allocation,
      -
      2869  VmaAllocationInfo* pAllocationInfo);
      -
      2870 
      -
      2885 VMA_CALL_PRE VkBool32 VMA_CALL_POST vmaTouchAllocation(
      -
      2886  VmaAllocator allocator,
      -
      2887  VmaAllocation allocation);
      -
      2888 
      -
      2902 VMA_CALL_PRE void VMA_CALL_POST vmaSetAllocationUserData(
      -
      2903  VmaAllocator allocator,
      -
      2904  VmaAllocation allocation,
      -
      2905  void* pUserData);
      -
      2906 
      -
      2917 VMA_CALL_PRE void VMA_CALL_POST vmaCreateLostAllocation(
      -
      2918  VmaAllocator allocator,
      -
      2919  VmaAllocation* pAllocation);
      -
      2920 
      -
      2955 VMA_CALL_PRE VkResult VMA_CALL_POST vmaMapMemory(
      -
      2956  VmaAllocator allocator,
      -
      2957  VmaAllocation allocation,
      -
      2958  void** ppData);
      -
      2959 
      -
      2964 VMA_CALL_PRE void VMA_CALL_POST vmaUnmapMemory(
      -
      2965  VmaAllocator allocator,
      -
      2966  VmaAllocation allocation);
      -
      2967 
      -
      2984 VMA_CALL_PRE void VMA_CALL_POST vmaFlushAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size);
      -
      2985 
      -
      3002 VMA_CALL_PRE void VMA_CALL_POST vmaInvalidateAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size);
      -
      3003 
      -
      3020 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCheckCorruption(VmaAllocator allocator, uint32_t memoryTypeBits);
      -
      3021 
      -
      3028 VK_DEFINE_HANDLE(VmaDefragmentationContext)
      -
      3029 
      -
      3030 typedef enum VmaDefragmentationFlagBits {
      -
      3032  VMA_DEFRAGMENTATION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
      -
      3033 } VmaDefragmentationFlagBits;
      -
      3034 typedef VkFlags VmaDefragmentationFlags;
      -
      3035 
      -
      3040 typedef struct VmaDefragmentationInfo2 {
      -
      3043  VmaDefragmentationFlags flags;
      -
      3046  uint32_t allocationCount;
      -
      3055  VmaAllocation* pAllocations;
      -
      3061  VkBool32* pAllocationsChanged;
      -
      3064  uint32_t poolCount;
      -
      3080  VmaPool* pPools;
      -
      3085  VkDeviceSize maxCpuBytesToMove;
      -
      3090  uint32_t maxCpuAllocationsToMove;
      -
      3095  VkDeviceSize maxGpuBytesToMove;
      -
      3100  uint32_t maxGpuAllocationsToMove;
      -
      3109  VkCommandBuffer commandBuffer;
      -
      3110 } VmaDefragmentationInfo2;
      -
      3111 
      -
      3116 typedef struct VmaDefragmentationInfo {
      -
      3121  VkDeviceSize maxBytesToMove;
      -
      3126  uint32_t maxAllocationsToMove;
      -
      3127 } VmaDefragmentationInfo;
      -
      3128 
      -
      3130 typedef struct VmaDefragmentationStats {
      -
      3132  VkDeviceSize bytesMoved;
      -
      3134  VkDeviceSize bytesFreed;
      -
      3136  uint32_t allocationsMoved;
      -
      3138  uint32_t deviceMemoryBlocksFreed;
      -
      3139 } VmaDefragmentationStats;
      -
      3140 
      -
      3170 VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragmentationBegin(
      -
      3171  VmaAllocator allocator,
      -
      3172  const VmaDefragmentationInfo2* pInfo,
      -
      3173  VmaDefragmentationStats* pStats,
      -
      3174  VmaDefragmentationContext *pContext);
      -
      3175 
      -
      3181 VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragmentationEnd(
      -
      3182  VmaAllocator allocator,
      -
      3183  VmaDefragmentationContext context);
      -
      3184 
      -
      3225 VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragment(
      -
      3226  VmaAllocator allocator,
      -
      3227  VmaAllocation* pAllocations,
      -
      3228  size_t allocationCount,
      -
      3229  VkBool32* pAllocationsChanged,
      -
      3230  const VmaDefragmentationInfo *pDefragmentationInfo,
      -
      3231  VmaDefragmentationStats* pDefragmentationStats);
      -
      3232 
      -
      3245 VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindBufferMemory(
      -
      3246  VmaAllocator allocator,
      -
      3247  VmaAllocation allocation,
      -
      3248  VkBuffer buffer);
      -
      3249 
      -
      3260 VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindBufferMemory2(
      -
      3261  VmaAllocator allocator,
      -
      3262  VmaAllocation allocation,
      -
      3263  VkDeviceSize allocationLocalOffset,
      -
      3264  VkBuffer buffer,
      -
      3265  const void* pNext);
      -
      3266 
      -
      3279 VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindImageMemory(
      -
      3280  VmaAllocator allocator,
      -
      3281  VmaAllocation allocation,
      -
      3282  VkImage image);
      -
      3283 
      -
      3294 VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindImageMemory2(
      -
      3295  VmaAllocator allocator,
      -
      3296  VmaAllocation allocation,
      -
      3297  VkDeviceSize allocationLocalOffset,
      -
      3298  VkImage image,
      -
      3299  const void* pNext);
      -
      3300 
      -
      3327 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateBuffer(
      -
      3328  VmaAllocator allocator,
      -
      3329  const VkBufferCreateInfo* pBufferCreateInfo,
      -
      3330  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      -
      3331  VkBuffer* pBuffer,
      -
      3332  VmaAllocation* pAllocation,
      -
      3333  VmaAllocationInfo* pAllocationInfo);
      -
      3334 
      -
      3346 VMA_CALL_PRE void VMA_CALL_POST vmaDestroyBuffer(
      -
      3347  VmaAllocator allocator,
      -
      3348  VkBuffer buffer,
      -
      3349  VmaAllocation allocation);
      -
      3350 
      -
      3352 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateImage(
      -
      3353  VmaAllocator allocator,
      -
      3354  const VkImageCreateInfo* pImageCreateInfo,
      -
      3355  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      -
      3356  VkImage* pImage,
      -
      3357  VmaAllocation* pAllocation,
      -
      3358  VmaAllocationInfo* pAllocationInfo);
      -
      3359 
      -
      3371 VMA_CALL_PRE void VMA_CALL_POST vmaDestroyImage(
      -
      3372  VmaAllocator allocator,
      -
      3373  VkImage image,
      -
      3374  VmaAllocation allocation);
      -
      3375 
      -
      3376 #ifdef __cplusplus
      -
      3377 }
      -
      3378 #endif
      -
      3379 
      -
      3380 #endif // AMD_VULKAN_MEMORY_ALLOCATOR_H
      -
      3381 
      -
      3382 // For Visual Studio IntelliSense.
      -
      3383 #if defined(__cplusplus) && defined(__INTELLISENSE__)
      -
      3384 #define VMA_IMPLEMENTATION
      -
      3385 #endif
      -
      3386 
      -
      3387 #ifdef VMA_IMPLEMENTATION
      -
      3388 #undef VMA_IMPLEMENTATION
      -
      3389 
      -
      3390 #include <cstdint>
      -
      3391 #include <cstdlib>
      -
      3392 #include <cstring>
      -
      3393 
      -
      3394 /*******************************************************************************
      -
      3395 CONFIGURATION SECTION
      -
      3396 
      -
      3397 Define some of these macros before each #include of this header or change them
      -
      3398 here if you need other then default behavior depending on your environment.
      -
      3399 */
      -
      3400 
      -
      3401 /*
      -
      3402 Define this macro to 1 to make the library fetch pointers to Vulkan functions
      -
      3403 internally, like:
      -
      3404 
      -
      3405  vulkanFunctions.vkAllocateMemory = &vkAllocateMemory;
      -
      3406 
      -
      3407 Define to 0 if you are going to provide you own pointers to Vulkan functions via
      -
      3408 VmaAllocatorCreateInfo::pVulkanFunctions.
      -
      3409 */
      -
      3410 #if !defined(VMA_STATIC_VULKAN_FUNCTIONS) && !defined(VK_NO_PROTOTYPES)
      -
      3411 #define VMA_STATIC_VULKAN_FUNCTIONS 1
      -
      3412 #endif
      +
      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,
      +
      2281  VMA_MEMORY_USAGE_MAX_ENUM = 0x7FFFFFFF
      +
      2282 } VmaMemoryUsage;
      +
      2283 
      +
      2285 typedef enum VmaAllocationCreateFlagBits {
      +
      2292  VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT = 0x00000001,
      +
      2293 
      +
      2303  VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT = 0x00000002,
      +
      2316  VMA_ALLOCATION_CREATE_MAPPED_BIT = 0x00000004,
      +
      2329  VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT = 0x00000008,
      +
      2336  VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT = 0x00000010,
      +
      2342  VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT = 0x00000020,
      +
      2347  VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT = 0x00000040,
      +
      2353  VMA_ALLOCATION_CREATE_DONT_BIND_BIT = 0x00000080,
      +
      2357  VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT = 0x00000100,
      +
      2358 
      +
      2362  VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT = 0x00010000,
      +
      2366  VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT = 0x00020000,
      +
      2373  VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT = 0x00040000,
      +
      2374 
      +
      2377  VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT = VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT,
      +
      2380  VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT = VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT,
      +
      2383  VMA_ALLOCATION_CREATE_STRATEGY_MIN_FRAGMENTATION_BIT = VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT,
      +
      2384 
      +
      2387  VMA_ALLOCATION_CREATE_STRATEGY_MASK =
      +
      2388  VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT |
      +
      2389  VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT |
      +
      2390  VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT,
      +
      2391 
      +
      2392  VMA_ALLOCATION_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
      +
      2393 } VmaAllocationCreateFlagBits;
      +
      2394 typedef VkFlags VmaAllocationCreateFlags;
      +
      2395 
      +
      2396 typedef struct VmaAllocationCreateInfo
      +
      2397 {
      +
      2399  VmaAllocationCreateFlags flags;
      +
      2405  VmaMemoryUsage usage;
      +
      2410  VkMemoryPropertyFlags requiredFlags;
      +
      2415  VkMemoryPropertyFlags preferredFlags;
      +
      2423  uint32_t memoryTypeBits;
      +
      2429  VmaPool pool;
      +
      2436  void* pUserData;
      +
      2437 } VmaAllocationCreateInfo;
      +
      2438 
      +
      2455 VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndex(
      +
      2456  VmaAllocator allocator,
      +
      2457  uint32_t memoryTypeBits,
      +
      2458  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      +
      2459  uint32_t* pMemoryTypeIndex);
      +
      2460 
      +
      2473 VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForBufferInfo(
      +
      2474  VmaAllocator allocator,
      +
      2475  const VkBufferCreateInfo* pBufferCreateInfo,
      +
      2476  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      +
      2477  uint32_t* pMemoryTypeIndex);
      +
      2478 
      +
      2491 VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForImageInfo(
      +
      2492  VmaAllocator allocator,
      +
      2493  const VkImageCreateInfo* pImageCreateInfo,
      +
      2494  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      +
      2495  uint32_t* pMemoryTypeIndex);
      +
      2496 
      +
      2498 typedef enum VmaPoolCreateFlagBits {
      +
      2516  VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT = 0x00000002,
      +
      2517 
      +
      2533  VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT = 0x00000004,
      +
      2534 
      +
      2544  VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT = 0x00000008,
      +
      2545 
      +
      2548  VMA_POOL_CREATE_ALGORITHM_MASK =
      +
      2549  VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT |
      +
      2550  VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT,
      +
      2551 
      +
      2552  VMA_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
      +
      2553 } VmaPoolCreateFlagBits;
      +
      2554 typedef VkFlags VmaPoolCreateFlags;
      +
      2555 
      +
      2558 typedef struct VmaPoolCreateInfo {
      +
      2561  uint32_t memoryTypeIndex;
      +
      2564  VmaPoolCreateFlags flags;
      +
      2573  VkDeviceSize blockSize;
      +
      2578  size_t minBlockCount;
      +
      2586  size_t maxBlockCount;
      +
      2600  uint32_t frameInUseCount;
      +
      2601 } VmaPoolCreateInfo;
      +
      2602 
      +
      2605 typedef struct VmaPoolStats {
      +
      2608  VkDeviceSize size;
      +
      2611  VkDeviceSize unusedSize;
      +
      2614  size_t allocationCount;
      +
      2617  size_t unusedRangeCount;
      +
      2624  VkDeviceSize unusedRangeSizeMax;
      +
      2627  size_t blockCount;
      +
      2628 } VmaPoolStats;
      +
      2629 
      +
      2636 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreatePool(
      +
      2637  VmaAllocator allocator,
      +
      2638  const VmaPoolCreateInfo* pCreateInfo,
      +
      2639  VmaPool* pPool);
      +
      2640 
      +
      2643 VMA_CALL_PRE void VMA_CALL_POST vmaDestroyPool(
      +
      2644  VmaAllocator allocator,
      +
      2645  VmaPool pool);
      +
      2646 
      +
      2653 VMA_CALL_PRE void VMA_CALL_POST vmaGetPoolStats(
      +
      2654  VmaAllocator allocator,
      +
      2655  VmaPool pool,
      +
      2656  VmaPoolStats* pPoolStats);
      +
      2657 
      +
      2664 VMA_CALL_PRE void VMA_CALL_POST vmaMakePoolAllocationsLost(
      +
      2665  VmaAllocator allocator,
      +
      2666  VmaPool pool,
      +
      2667  size_t* pLostAllocationCount);
      +
      2668 
      +
      2683 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCheckPoolCorruption(VmaAllocator allocator, VmaPool pool);
      +
      2684 
      +
      2691 VMA_CALL_PRE void VMA_CALL_POST vmaGetPoolName(
      +
      2692  VmaAllocator allocator,
      +
      2693  VmaPool pool,
      +
      2694  const char** ppName);
      +
      2695 
      +
      2701 VMA_CALL_PRE void VMA_CALL_POST vmaSetPoolName(
      +
      2702  VmaAllocator allocator,
      +
      2703  VmaPool pool,
      +
      2704  const char* pName);
      +
      2705 
      +
      2730 VK_DEFINE_HANDLE(VmaAllocation)
      +
      2731 
      +
      2732 
      +
      2734 typedef struct VmaAllocationInfo {
      +
      2739  uint32_t memoryType;
      +
      2748  VkDeviceMemory deviceMemory;
      +
      2753  VkDeviceSize offset;
      +
      2758  VkDeviceSize size;
      +
      2767  void* pMappedData;
      +
      2772  void* pUserData;
      +
      2773 } VmaAllocationInfo;
      +
      2774 
      +
      2785 VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemory(
      +
      2786  VmaAllocator allocator,
      +
      2787  const VkMemoryRequirements* pVkMemoryRequirements,
      +
      2788  const VmaAllocationCreateInfo* pCreateInfo,
      +
      2789  VmaAllocation* pAllocation,
      +
      2790  VmaAllocationInfo* pAllocationInfo);
      +
      2791 
      +
      2811 VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryPages(
      +
      2812  VmaAllocator allocator,
      +
      2813  const VkMemoryRequirements* pVkMemoryRequirements,
      +
      2814  const VmaAllocationCreateInfo* pCreateInfo,
      +
      2815  size_t allocationCount,
      +
      2816  VmaAllocation* pAllocations,
      +
      2817  VmaAllocationInfo* pAllocationInfo);
      +
      2818 
      +
      2825 VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryForBuffer(
      +
      2826  VmaAllocator allocator,
      +
      2827  VkBuffer buffer,
      +
      2828  const VmaAllocationCreateInfo* pCreateInfo,
      +
      2829  VmaAllocation* pAllocation,
      +
      2830  VmaAllocationInfo* pAllocationInfo);
      +
      2831 
      +
      2833 VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryForImage(
      +
      2834  VmaAllocator allocator,
      +
      2835  VkImage image,
      +
      2836  const VmaAllocationCreateInfo* pCreateInfo,
      +
      2837  VmaAllocation* pAllocation,
      +
      2838  VmaAllocationInfo* pAllocationInfo);
      +
      2839 
      +
      2844 VMA_CALL_PRE void VMA_CALL_POST vmaFreeMemory(
      +
      2845  VmaAllocator allocator,
      +
      2846  VmaAllocation allocation);
      +
      2847 
      +
      2858 VMA_CALL_PRE void VMA_CALL_POST vmaFreeMemoryPages(
      +
      2859  VmaAllocator allocator,
      +
      2860  size_t allocationCount,
      +
      2861  VmaAllocation* pAllocations);
      +
      2862 
      +
      2869 VMA_CALL_PRE VkResult VMA_CALL_POST vmaResizeAllocation(
      +
      2870  VmaAllocator allocator,
      +
      2871  VmaAllocation allocation,
      +
      2872  VkDeviceSize newSize);
      +
      2873 
      +
      2890 VMA_CALL_PRE void VMA_CALL_POST vmaGetAllocationInfo(
      +
      2891  VmaAllocator allocator,
      +
      2892  VmaAllocation allocation,
      +
      2893  VmaAllocationInfo* pAllocationInfo);
      +
      2894 
      +
      2909 VMA_CALL_PRE VkBool32 VMA_CALL_POST vmaTouchAllocation(
      +
      2910  VmaAllocator allocator,
      +
      2911  VmaAllocation allocation);
      +
      2912 
      +
      2926 VMA_CALL_PRE void VMA_CALL_POST vmaSetAllocationUserData(
      +
      2927  VmaAllocator allocator,
      +
      2928  VmaAllocation allocation,
      +
      2929  void* pUserData);
      +
      2930 
      +
      2941 VMA_CALL_PRE void VMA_CALL_POST vmaCreateLostAllocation(
      +
      2942  VmaAllocator allocator,
      +
      2943  VmaAllocation* pAllocation);
      +
      2944 
      +
      2979 VMA_CALL_PRE VkResult VMA_CALL_POST vmaMapMemory(
      +
      2980  VmaAllocator allocator,
      +
      2981  VmaAllocation allocation,
      +
      2982  void** ppData);
      +
      2983 
      +
      2988 VMA_CALL_PRE void VMA_CALL_POST vmaUnmapMemory(
      +
      2989  VmaAllocator allocator,
      +
      2990  VmaAllocation allocation);
      +
      2991 
      +
      3008 VMA_CALL_PRE void VMA_CALL_POST vmaFlushAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size);
      +
      3009 
      +
      3026 VMA_CALL_PRE void VMA_CALL_POST vmaInvalidateAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size);
      +
      3027 
      +
      3044 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCheckCorruption(VmaAllocator allocator, uint32_t memoryTypeBits);
      +
      3045 
      +
      3052 VK_DEFINE_HANDLE(VmaDefragmentationContext)
      +
      3053 
      +
      3054 typedef enum VmaDefragmentationFlagBits {
      +
      3056  VMA_DEFRAGMENTATION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
      +
      3057 } VmaDefragmentationFlagBits;
      +
      3058 typedef VkFlags VmaDefragmentationFlags;
      +
      3059 
      +
      3064 typedef struct VmaDefragmentationInfo2 {
      +
      3067  VmaDefragmentationFlags flags;
      +
      3070  uint32_t allocationCount;
      +
      3079  VmaAllocation* pAllocations;
      +
      3085  VkBool32* pAllocationsChanged;
      +
      3088  uint32_t poolCount;
      +
      3104  VmaPool* pPools;
      +
      3109  VkDeviceSize maxCpuBytesToMove;
      +
      3114  uint32_t maxCpuAllocationsToMove;
      +
      3119  VkDeviceSize maxGpuBytesToMove;
      +
      3124  uint32_t maxGpuAllocationsToMove;
      +
      3133  VkCommandBuffer commandBuffer;
      +
      3134 } VmaDefragmentationInfo2;
      +
      3135 
      +
      3140 typedef struct VmaDefragmentationInfo {
      +
      3145  VkDeviceSize maxBytesToMove;
      +
      3150  uint32_t maxAllocationsToMove;
      +
      3151 } VmaDefragmentationInfo;
      +
      3152 
      +
      3154 typedef struct VmaDefragmentationStats {
      +
      3156  VkDeviceSize bytesMoved;
      +
      3158  VkDeviceSize bytesFreed;
      +
      3160  uint32_t allocationsMoved;
      +
      3162  uint32_t deviceMemoryBlocksFreed;
      +
      3163 } VmaDefragmentationStats;
      +
      3164 
      +
      3194 VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragmentationBegin(
      +
      3195  VmaAllocator allocator,
      +
      3196  const VmaDefragmentationInfo2* pInfo,
      +
      3197  VmaDefragmentationStats* pStats,
      +
      3198  VmaDefragmentationContext *pContext);
      +
      3199 
      +
      3205 VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragmentationEnd(
      +
      3206  VmaAllocator allocator,
      +
      3207  VmaDefragmentationContext context);
      +
      3208 
      +
      3249 VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragment(
      +
      3250  VmaAllocator allocator,
      +
      3251  VmaAllocation* pAllocations,
      +
      3252  size_t allocationCount,
      +
      3253  VkBool32* pAllocationsChanged,
      +
      3254  const VmaDefragmentationInfo *pDefragmentationInfo,
      +
      3255  VmaDefragmentationStats* pDefragmentationStats);
      +
      3256 
      +
      3269 VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindBufferMemory(
      +
      3270  VmaAllocator allocator,
      +
      3271  VmaAllocation allocation,
      +
      3272  VkBuffer buffer);
      +
      3273 
      +
      3284 VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindBufferMemory2(
      +
      3285  VmaAllocator allocator,
      +
      3286  VmaAllocation allocation,
      +
      3287  VkDeviceSize allocationLocalOffset,
      +
      3288  VkBuffer buffer,
      +
      3289  const void* pNext);
      +
      3290 
      +
      3303 VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindImageMemory(
      +
      3304  VmaAllocator allocator,
      +
      3305  VmaAllocation allocation,
      +
      3306  VkImage image);
      +
      3307 
      +
      3318 VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindImageMemory2(
      +
      3319  VmaAllocator allocator,
      +
      3320  VmaAllocation allocation,
      +
      3321  VkDeviceSize allocationLocalOffset,
      +
      3322  VkImage image,
      +
      3323  const void* pNext);
      +
      3324 
      +
      3351 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateBuffer(
      +
      3352  VmaAllocator allocator,
      +
      3353  const VkBufferCreateInfo* pBufferCreateInfo,
      +
      3354  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      +
      3355  VkBuffer* pBuffer,
      +
      3356  VmaAllocation* pAllocation,
      +
      3357  VmaAllocationInfo* pAllocationInfo);
      +
      3358 
      +
      3370 VMA_CALL_PRE void VMA_CALL_POST vmaDestroyBuffer(
      +
      3371  VmaAllocator allocator,
      +
      3372  VkBuffer buffer,
      +
      3373  VmaAllocation allocation);
      +
      3374 
      +
      3376 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateImage(
      +
      3377  VmaAllocator allocator,
      +
      3378  const VkImageCreateInfo* pImageCreateInfo,
      +
      3379  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      +
      3380  VkImage* pImage,
      +
      3381  VmaAllocation* pAllocation,
      +
      3382  VmaAllocationInfo* pAllocationInfo);
      +
      3383 
      +
      3395 VMA_CALL_PRE void VMA_CALL_POST vmaDestroyImage(
      +
      3396  VmaAllocator allocator,
      +
      3397  VkImage image,
      +
      3398  VmaAllocation allocation);
      +
      3399 
      +
      3400 #ifdef __cplusplus
      +
      3401 }
      +
      3402 #endif
      +
      3403 
      +
      3404 #endif // AMD_VULKAN_MEMORY_ALLOCATOR_H
      +
      3405 
      +
      3406 // For Visual Studio IntelliSense.
      +
      3407 #if defined(__cplusplus) && defined(__INTELLISENSE__)
      +
      3408 #define VMA_IMPLEMENTATION
      +
      3409 #endif
      +
      3410 
      +
      3411 #ifdef VMA_IMPLEMENTATION
      +
      3412 #undef VMA_IMPLEMENTATION
      3413 
      -
      3414 // Define this macro to 1 to make the library use STL containers instead of its own implementation.
      -
      3415 //#define VMA_USE_STL_CONTAINERS 1
      -
      3416 
      -
      3417 /* Set this macro to 1 to make the library including and using STL containers:
      -
      3418 std::pair, std::vector, std::list, std::unordered_map.
      -
      3419 
      -
      3420 Set it to 0 or undefined to make the library using its own implementation of
      -
      3421 the containers.
      -
      3422 */
      -
      3423 #if VMA_USE_STL_CONTAINERS
      -
      3424  #define VMA_USE_STL_VECTOR 1
      -
      3425  #define VMA_USE_STL_UNORDERED_MAP 1
      -
      3426  #define VMA_USE_STL_LIST 1
      -
      3427 #endif
      -
      3428 
      -
      3429 #ifndef VMA_USE_STL_SHARED_MUTEX
      -
      3430  // Compiler conforms to C++17.
      -
      3431  #if __cplusplus >= 201703L
      -
      3432  #define VMA_USE_STL_SHARED_MUTEX 1
      -
      3433  // Visual studio defines __cplusplus properly only when passed additional parameter: /Zc:__cplusplus
      -
      3434  // Otherwise it's always 199711L, despite shared_mutex works since Visual Studio 2015 Update 2.
      -
      3435  // See: https://blogs.msdn.microsoft.com/vcblog/2018/04/09/msvc-now-correctly-reports-__cplusplus/
      -
      3436  #elif defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023918 && __cplusplus == 199711L && _MSVC_LANG >= 201703L
      -
      3437  #define VMA_USE_STL_SHARED_MUTEX 1
      -
      3438  #else
      -
      3439  #define VMA_USE_STL_SHARED_MUTEX 0
      -
      3440  #endif
      -
      3441 #endif
      -
      3442 
      -
      3443 /*
      -
      3444 THESE INCLUDES ARE NOT ENABLED BY DEFAULT.
      -
      3445 Library has its own container implementation.
      +
      3414 #include <cstdint>
      +
      3415 #include <cstdlib>
      +
      3416 #include <cstring>
      +
      3417 
      +
      3418 /*******************************************************************************
      +
      3419 CONFIGURATION SECTION
      +
      3420 
      +
      3421 Define some of these macros before each #include of this header or change them
      +
      3422 here if you need other then default behavior depending on your environment.
      +
      3423 */
      +
      3424 
      +
      3425 /*
      +
      3426 Define this macro to 1 to make the library fetch pointers to Vulkan functions
      +
      3427 internally, like:
      +
      3428 
      +
      3429  vulkanFunctions.vkAllocateMemory = &vkAllocateMemory;
      +
      3430 
      +
      3431 Define to 0 if you are going to provide you own pointers to Vulkan functions via
      +
      3432 VmaAllocatorCreateInfo::pVulkanFunctions.
      +
      3433 */
      +
      3434 #if !defined(VMA_STATIC_VULKAN_FUNCTIONS) && !defined(VK_NO_PROTOTYPES)
      +
      3435 #define VMA_STATIC_VULKAN_FUNCTIONS 1
      +
      3436 #endif
      +
      3437 
      +
      3438 // Define this macro to 1 to make the library use STL containers instead of its own implementation.
      +
      3439 //#define VMA_USE_STL_CONTAINERS 1
      +
      3440 
      +
      3441 /* Set this macro to 1 to make the library including and using STL containers:
      +
      3442 std::pair, std::vector, std::list, std::unordered_map.
      +
      3443 
      +
      3444 Set it to 0 or undefined to make the library using its own implementation of
      +
      3445 the containers.
      3446 */
      -
      3447 #if VMA_USE_STL_VECTOR
      -
      3448  #include <vector>
      -
      3449 #endif
      -
      3450 
      -
      3451 #if VMA_USE_STL_UNORDERED_MAP
      -
      3452  #include <unordered_map>
      -
      3453 #endif
      -
      3454 
      -
      3455 #if VMA_USE_STL_LIST
      -
      3456  #include <list>
      -
      3457 #endif
      -
      3458 
      -
      3459 /*
      -
      3460 Following headers are used in this CONFIGURATION section only, so feel free to
      -
      3461 remove them if not needed.
      -
      3462 */
      -
      3463 #include <cassert> // for assert
      -
      3464 #include <algorithm> // for min, max
      -
      3465 #include <mutex>
      +
      3447 #if VMA_USE_STL_CONTAINERS
      +
      3448  #define VMA_USE_STL_VECTOR 1
      +
      3449  #define VMA_USE_STL_UNORDERED_MAP 1
      +
      3450  #define VMA_USE_STL_LIST 1
      +
      3451 #endif
      +
      3452 
      +
      3453 #ifndef VMA_USE_STL_SHARED_MUTEX
      +
      3454  // Compiler conforms to C++17.
      +
      3455  #if __cplusplus >= 201703L
      +
      3456  #define VMA_USE_STL_SHARED_MUTEX 1
      +
      3457  // Visual studio defines __cplusplus properly only when passed additional parameter: /Zc:__cplusplus
      +
      3458  // Otherwise it's always 199711L, despite shared_mutex works since Visual Studio 2015 Update 2.
      +
      3459  // See: https://blogs.msdn.microsoft.com/vcblog/2018/04/09/msvc-now-correctly-reports-__cplusplus/
      +
      3460  #elif defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023918 && __cplusplus == 199711L && _MSVC_LANG >= 201703L
      +
      3461  #define VMA_USE_STL_SHARED_MUTEX 1
      +
      3462  #else
      +
      3463  #define VMA_USE_STL_SHARED_MUTEX 0
      +
      3464  #endif
      +
      3465 #endif
      3466 
      -
      3467 #ifndef VMA_NULL
      -
      3468  // Value used as null pointer. Define it to e.g.: nullptr, NULL, 0, (void*)0.
      -
      3469  #define VMA_NULL nullptr
      -
      3470 #endif
      -
      3471 
      -
      3472 #if defined(__ANDROID_API__) && (__ANDROID_API__ < 16)
      -
      3473 #include <cstdlib>
      -
      3474 void *aligned_alloc(size_t alignment, size_t size)
      -
      3475 {
      -
      3476  // alignment must be >= sizeof(void*)
      -
      3477  if(alignment < sizeof(void*))
      -
      3478  {
      -
      3479  alignment = sizeof(void*);
      -
      3480  }
      -
      3481 
      -
      3482  return memalign(alignment, size);
      -
      3483 }
      -
      3484 #elif defined(__APPLE__) || defined(__ANDROID__) || (defined(__linux__) && defined(__GLIBCXX__) && !defined(_GLIBCXX_HAVE_ALIGNED_ALLOC))
      -
      3485 #include <cstdlib>
      -
      3486 void *aligned_alloc(size_t alignment, size_t size)
      -
      3487 {
      -
      3488  // alignment must be >= sizeof(void*)
      -
      3489  if(alignment < sizeof(void*))
      -
      3490  {
      -
      3491  alignment = sizeof(void*);
      -
      3492  }
      -
      3493 
      -
      3494  void *pointer;
      -
      3495  if(posix_memalign(&pointer, alignment, size) == 0)
      -
      3496  return pointer;
      -
      3497  return VMA_NULL;
      -
      3498 }
      -
      3499 #endif
      -
      3500 
      -
      3501 // If your compiler is not compatible with C++11 and definition of
      -
      3502 // aligned_alloc() function is missing, uncommeting following line may help:
      -
      3503 
      -
      3504 //#include <malloc.h>
      +
      3467 /*
      +
      3468 THESE INCLUDES ARE NOT ENABLED BY DEFAULT.
      +
      3469 Library has its own container implementation.
      +
      3470 */
      +
      3471 #if VMA_USE_STL_VECTOR
      +
      3472  #include <vector>
      +
      3473 #endif
      +
      3474 
      +
      3475 #if VMA_USE_STL_UNORDERED_MAP
      +
      3476  #include <unordered_map>
      +
      3477 #endif
      +
      3478 
      +
      3479 #if VMA_USE_STL_LIST
      +
      3480  #include <list>
      +
      3481 #endif
      +
      3482 
      +
      3483 /*
      +
      3484 Following headers are used in this CONFIGURATION section only, so feel free to
      +
      3485 remove them if not needed.
      +
      3486 */
      +
      3487 #include <cassert> // for assert
      +
      3488 #include <algorithm> // for min, max
      +
      3489 #include <mutex>
      +
      3490 
      +
      3491 #ifndef VMA_NULL
      +
      3492  // Value used as null pointer. Define it to e.g.: nullptr, NULL, 0, (void*)0.
      +
      3493  #define VMA_NULL nullptr
      +
      3494 #endif
      +
      3495 
      +
      3496 #if defined(__ANDROID_API__) && (__ANDROID_API__ < 16)
      +
      3497 #include <cstdlib>
      +
      3498 void *aligned_alloc(size_t alignment, size_t size)
      +
      3499 {
      +
      3500  // alignment must be >= sizeof(void*)
      +
      3501  if(alignment < sizeof(void*))
      +
      3502  {
      +
      3503  alignment = sizeof(void*);
      +
      3504  }
      3505 
      -
      3506 // Normal assert to check for programmer's errors, especially in Debug configuration.
      -
      3507 #ifndef VMA_ASSERT
      -
      3508  #ifdef _DEBUG
      -
      3509  #define VMA_ASSERT(expr) assert(expr)
      -
      3510  #else
      -
      3511  #define VMA_ASSERT(expr)
      -
      3512  #endif
      -
      3513 #endif
      -
      3514 
      -
      3515 // Assert that will be called very often, like inside data structures e.g. operator[].
      -
      3516 // Making it non-empty can make program slow.
      -
      3517 #ifndef VMA_HEAVY_ASSERT
      -
      3518  #ifdef _DEBUG
      -
      3519  #define VMA_HEAVY_ASSERT(expr) //VMA_ASSERT(expr)
      -
      3520  #else
      -
      3521  #define VMA_HEAVY_ASSERT(expr)
      -
      3522  #endif
      +
      3506  return memalign(alignment, size);
      +
      3507 }
      +
      3508 #elif defined(__APPLE__) || defined(__ANDROID__) || (defined(__linux__) && defined(__GLIBCXX__) && !defined(_GLIBCXX_HAVE_ALIGNED_ALLOC))
      +
      3509 #include <cstdlib>
      +
      3510 void *aligned_alloc(size_t alignment, size_t size)
      +
      3511 {
      +
      3512  // alignment must be >= sizeof(void*)
      +
      3513  if(alignment < sizeof(void*))
      +
      3514  {
      +
      3515  alignment = sizeof(void*);
      +
      3516  }
      +
      3517 
      +
      3518  void *pointer;
      +
      3519  if(posix_memalign(&pointer, alignment, size) == 0)
      +
      3520  return pointer;
      +
      3521  return VMA_NULL;
      +
      3522 }
      3523 #endif
      3524 
      -
      3525 #ifndef VMA_ALIGN_OF
      -
      3526  #define VMA_ALIGN_OF(type) (__alignof(type))
      -
      3527 #endif
      -
      3528 
      -
      3529 #ifndef VMA_SYSTEM_ALIGNED_MALLOC
      -
      3530  #if defined(_WIN32)
      -
      3531  #define VMA_SYSTEM_ALIGNED_MALLOC(size, alignment) (_aligned_malloc((size), (alignment)))
      -
      3532  #else
      -
      3533  #define VMA_SYSTEM_ALIGNED_MALLOC(size, alignment) (aligned_alloc((alignment), (size) ))
      -
      3534  #endif
      -
      3535 #endif
      -
      3536 
      -
      3537 #ifndef VMA_SYSTEM_FREE
      -
      3538  #if defined(_WIN32)
      -
      3539  #define VMA_SYSTEM_FREE(ptr) _aligned_free(ptr)
      -
      3540  #else
      -
      3541  #define VMA_SYSTEM_FREE(ptr) free(ptr)
      -
      3542  #endif
      -
      3543 #endif
      -
      3544 
      -
      3545 #ifndef VMA_MIN
      -
      3546  #define VMA_MIN(v1, v2) (std::min((v1), (v2)))
      +
      3525 // If your compiler is not compatible with C++11 and definition of
      +
      3526 // aligned_alloc() function is missing, uncommeting following line may help:
      +
      3527 
      +
      3528 //#include <malloc.h>
      +
      3529 
      +
      3530 // Normal assert to check for programmer's errors, especially in Debug configuration.
      +
      3531 #ifndef VMA_ASSERT
      +
      3532  #ifdef _DEBUG
      +
      3533  #define VMA_ASSERT(expr) assert(expr)
      +
      3534  #else
      +
      3535  #define VMA_ASSERT(expr)
      +
      3536  #endif
      +
      3537 #endif
      +
      3538 
      +
      3539 // Assert that will be called very often, like inside data structures e.g. operator[].
      +
      3540 // Making it non-empty can make program slow.
      +
      3541 #ifndef VMA_HEAVY_ASSERT
      +
      3542  #ifdef _DEBUG
      +
      3543  #define VMA_HEAVY_ASSERT(expr) //VMA_ASSERT(expr)
      +
      3544  #else
      +
      3545  #define VMA_HEAVY_ASSERT(expr)
      +
      3546  #endif
      3547 #endif
      3548 
      -
      3549 #ifndef VMA_MAX
      -
      3550  #define VMA_MAX(v1, v2) (std::max((v1), (v2)))
      +
      3549 #ifndef VMA_ALIGN_OF
      +
      3550  #define VMA_ALIGN_OF(type) (__alignof(type))
      3551 #endif
      3552 
      -
      3553 #ifndef VMA_SWAP
      -
      3554  #define VMA_SWAP(v1, v2) std::swap((v1), (v2))
      -
      3555 #endif
      -
      3556 
      -
      3557 #ifndef VMA_SORT
      -
      3558  #define VMA_SORT(beg, end, cmp) std::sort(beg, end, cmp)
      +
      3553 #ifndef VMA_SYSTEM_ALIGNED_MALLOC
      +
      3554  #if defined(_WIN32)
      +
      3555  #define VMA_SYSTEM_ALIGNED_MALLOC(size, alignment) (_aligned_malloc((size), (alignment)))
      +
      3556  #else
      +
      3557  #define VMA_SYSTEM_ALIGNED_MALLOC(size, alignment) (aligned_alloc((alignment), (size) ))
      +
      3558  #endif
      3559 #endif
      3560 
      -
      3561 #ifndef VMA_DEBUG_LOG
      -
      3562  #define VMA_DEBUG_LOG(format, ...)
      -
      3563  /*
      -
      3564  #define VMA_DEBUG_LOG(format, ...) do { \
      -
      3565  printf(format, __VA_ARGS__); \
      -
      3566  printf("\n"); \
      -
      3567  } while(false)
      -
      3568  */
      -
      3569 #endif
      -
      3570 
      -
      3571 // Define this macro to 1 to enable functions: vmaBuildStatsString, vmaFreeStatsString.
      -
      3572 #if VMA_STATS_STRING_ENABLED
      -
      3573  static inline void VmaUint32ToStr(char* outStr, size_t strLen, uint32_t num)
      -
      3574  {
      -
      3575  snprintf(outStr, strLen, "%u", static_cast<unsigned int>(num));
      -
      3576  }
      -
      3577  static inline void VmaUint64ToStr(char* outStr, size_t strLen, uint64_t num)
      -
      3578  {
      -
      3579  snprintf(outStr, strLen, "%llu", static_cast<unsigned long long>(num));
      -
      3580  }
      -
      3581  static inline void VmaPtrToStr(char* outStr, size_t strLen, const void* ptr)
      -
      3582  {
      -
      3583  snprintf(outStr, strLen, "%p", ptr);
      -
      3584  }
      -
      3585 #endif
      -
      3586 
      -
      3587 #ifndef VMA_MUTEX
      -
      3588  class VmaMutex
      -
      3589  {
      -
      3590  public:
      -
      3591  void Lock() { m_Mutex.lock(); }
      -
      3592  void Unlock() { m_Mutex.unlock(); }
      -
      3593  private:
      -
      3594  std::mutex m_Mutex;
      -
      3595  };
      -
      3596  #define VMA_MUTEX VmaMutex
      -
      3597 #endif
      -
      3598 
      -
      3599 // Read-write mutex, where "read" is shared access, "write" is exclusive access.
      -
      3600 #ifndef VMA_RW_MUTEX
      -
      3601  #if VMA_USE_STL_SHARED_MUTEX
      -
      3602  // Use std::shared_mutex from C++17.
      -
      3603  #include <shared_mutex>
      -
      3604  class VmaRWMutex
      -
      3605  {
      -
      3606  public:
      -
      3607  void LockRead() { m_Mutex.lock_shared(); }
      -
      3608  void UnlockRead() { m_Mutex.unlock_shared(); }
      -
      3609  void LockWrite() { m_Mutex.lock(); }
      -
      3610  void UnlockWrite() { m_Mutex.unlock(); }
      -
      3611  private:
      -
      3612  std::shared_mutex m_Mutex;
      -
      3613  };
      -
      3614  #define VMA_RW_MUTEX VmaRWMutex
      -
      3615  #elif defined(_WIN32) && defined(WINVER) && WINVER >= 0x0600
      -
      3616  // Use SRWLOCK from WinAPI.
      -
      3617  // Minimum supported client = Windows Vista, server = Windows Server 2008.
      -
      3618  class VmaRWMutex
      -
      3619  {
      -
      3620  public:
      -
      3621  VmaRWMutex() { InitializeSRWLock(&m_Lock); }
      -
      3622  void LockRead() { AcquireSRWLockShared(&m_Lock); }
      -
      3623  void UnlockRead() { ReleaseSRWLockShared(&m_Lock); }
      -
      3624  void LockWrite() { AcquireSRWLockExclusive(&m_Lock); }
      -
      3625  void UnlockWrite() { ReleaseSRWLockExclusive(&m_Lock); }
      -
      3626  private:
      -
      3627  SRWLOCK m_Lock;
      -
      3628  };
      -
      3629  #define VMA_RW_MUTEX VmaRWMutex
      -
      3630  #else
      -
      3631  // Less efficient fallback: Use normal mutex.
      -
      3632  class VmaRWMutex
      -
      3633  {
      -
      3634  public:
      -
      3635  void LockRead() { m_Mutex.Lock(); }
      -
      3636  void UnlockRead() { m_Mutex.Unlock(); }
      -
      3637  void LockWrite() { m_Mutex.Lock(); }
      -
      3638  void UnlockWrite() { m_Mutex.Unlock(); }
      -
      3639  private:
      -
      3640  VMA_MUTEX m_Mutex;
      -
      3641  };
      -
      3642  #define VMA_RW_MUTEX VmaRWMutex
      -
      3643  #endif // #if VMA_USE_STL_SHARED_MUTEX
      -
      3644 #endif // #ifndef VMA_RW_MUTEX
      -
      3645 
      -
      3646 /*
      -
      3647 If providing your own implementation, you need to implement a subset of std::atomic.
      -
      3648 */
      -
      3649 #ifndef VMA_ATOMIC_UINT32
      -
      3650  #include <atomic>
      -
      3651  #define VMA_ATOMIC_UINT32 std::atomic<uint32_t>
      -
      3652 #endif
      -
      3653 
      -
      3654 #ifndef VMA_ATOMIC_UINT64
      -
      3655  #include <atomic>
      -
      3656  #define VMA_ATOMIC_UINT64 std::atomic<uint64_t>
      -
      3657 #endif
      -
      3658 
      -
      3659 #ifndef VMA_DEBUG_ALWAYS_DEDICATED_MEMORY
      -
      3660 
      -
      3664  #define VMA_DEBUG_ALWAYS_DEDICATED_MEMORY (0)
      -
      3665 #endif
      -
      3666 
      -
      3667 #ifndef VMA_DEBUG_ALIGNMENT
      -
      3668 
      -
      3672  #define VMA_DEBUG_ALIGNMENT (1)
      -
      3673 #endif
      -
      3674 
      -
      3675 #ifndef VMA_DEBUG_MARGIN
      -
      3676 
      -
      3680  #define VMA_DEBUG_MARGIN (0)
      +
      3561 #ifndef VMA_SYSTEM_FREE
      +
      3562  #if defined(_WIN32)
      +
      3563  #define VMA_SYSTEM_FREE(ptr) _aligned_free(ptr)
      +
      3564  #else
      +
      3565  #define VMA_SYSTEM_FREE(ptr) free(ptr)
      +
      3566  #endif
      +
      3567 #endif
      +
      3568 
      +
      3569 #ifndef VMA_MIN
      +
      3570  #define VMA_MIN(v1, v2) (std::min((v1), (v2)))
      +
      3571 #endif
      +
      3572 
      +
      3573 #ifndef VMA_MAX
      +
      3574  #define VMA_MAX(v1, v2) (std::max((v1), (v2)))
      +
      3575 #endif
      +
      3576 
      +
      3577 #ifndef VMA_SWAP
      +
      3578  #define VMA_SWAP(v1, v2) std::swap((v1), (v2))
      +
      3579 #endif
      +
      3580 
      +
      3581 #ifndef VMA_SORT
      +
      3582  #define VMA_SORT(beg, end, cmp) std::sort(beg, end, cmp)
      +
      3583 #endif
      +
      3584 
      +
      3585 #ifndef VMA_DEBUG_LOG
      +
      3586  #define VMA_DEBUG_LOG(format, ...)
      +
      3587  /*
      +
      3588  #define VMA_DEBUG_LOG(format, ...) do { \
      +
      3589  printf(format, __VA_ARGS__); \
      +
      3590  printf("\n"); \
      +
      3591  } while(false)
      +
      3592  */
      +
      3593 #endif
      +
      3594 
      +
      3595 // Define this macro to 1 to enable functions: vmaBuildStatsString, vmaFreeStatsString.
      +
      3596 #if VMA_STATS_STRING_ENABLED
      +
      3597  static inline void VmaUint32ToStr(char* outStr, size_t strLen, uint32_t num)
      +
      3598  {
      +
      3599  snprintf(outStr, strLen, "%u", static_cast<unsigned int>(num));
      +
      3600  }
      +
      3601  static inline void VmaUint64ToStr(char* outStr, size_t strLen, uint64_t num)
      +
      3602  {
      +
      3603  snprintf(outStr, strLen, "%llu", static_cast<unsigned long long>(num));
      +
      3604  }
      +
      3605  static inline void VmaPtrToStr(char* outStr, size_t strLen, const void* ptr)
      +
      3606  {
      +
      3607  snprintf(outStr, strLen, "%p", ptr);
      +
      3608  }
      +
      3609 #endif
      +
      3610 
      +
      3611 #ifndef VMA_MUTEX
      +
      3612  class VmaMutex
      +
      3613  {
      +
      3614  public:
      +
      3615  void Lock() { m_Mutex.lock(); }
      +
      3616  void Unlock() { m_Mutex.unlock(); }
      +
      3617  private:
      +
      3618  std::mutex m_Mutex;
      +
      3619  };
      +
      3620  #define VMA_MUTEX VmaMutex
      +
      3621 #endif
      +
      3622 
      +
      3623 // Read-write mutex, where "read" is shared access, "write" is exclusive access.
      +
      3624 #ifndef VMA_RW_MUTEX
      +
      3625  #if VMA_USE_STL_SHARED_MUTEX
      +
      3626  // Use std::shared_mutex from C++17.
      +
      3627  #include <shared_mutex>
      +
      3628  class VmaRWMutex
      +
      3629  {
      +
      3630  public:
      +
      3631  void LockRead() { m_Mutex.lock_shared(); }
      +
      3632  void UnlockRead() { m_Mutex.unlock_shared(); }
      +
      3633  void LockWrite() { m_Mutex.lock(); }
      +
      3634  void UnlockWrite() { m_Mutex.unlock(); }
      +
      3635  private:
      +
      3636  std::shared_mutex m_Mutex;
      +
      3637  };
      +
      3638  #define VMA_RW_MUTEX VmaRWMutex
      +
      3639  #elif defined(_WIN32) && defined(WINVER) && WINVER >= 0x0600
      +
      3640  // Use SRWLOCK from WinAPI.
      +
      3641  // Minimum supported client = Windows Vista, server = Windows Server 2008.
      +
      3642  class VmaRWMutex
      +
      3643  {
      +
      3644  public:
      +
      3645  VmaRWMutex() { InitializeSRWLock(&m_Lock); }
      +
      3646  void LockRead() { AcquireSRWLockShared(&m_Lock); }
      +
      3647  void UnlockRead() { ReleaseSRWLockShared(&m_Lock); }
      +
      3648  void LockWrite() { AcquireSRWLockExclusive(&m_Lock); }
      +
      3649  void UnlockWrite() { ReleaseSRWLockExclusive(&m_Lock); }
      +
      3650  private:
      +
      3651  SRWLOCK m_Lock;
      +
      3652  };
      +
      3653  #define VMA_RW_MUTEX VmaRWMutex
      +
      3654  #else
      +
      3655  // Less efficient fallback: Use normal mutex.
      +
      3656  class VmaRWMutex
      +
      3657  {
      +
      3658  public:
      +
      3659  void LockRead() { m_Mutex.Lock(); }
      +
      3660  void UnlockRead() { m_Mutex.Unlock(); }
      +
      3661  void LockWrite() { m_Mutex.Lock(); }
      +
      3662  void UnlockWrite() { m_Mutex.Unlock(); }
      +
      3663  private:
      +
      3664  VMA_MUTEX m_Mutex;
      +
      3665  };
      +
      3666  #define VMA_RW_MUTEX VmaRWMutex
      +
      3667  #endif // #if VMA_USE_STL_SHARED_MUTEX
      +
      3668 #endif // #ifndef VMA_RW_MUTEX
      +
      3669 
      +
      3670 /*
      +
      3671 If providing your own implementation, you need to implement a subset of std::atomic.
      +
      3672 */
      +
      3673 #ifndef VMA_ATOMIC_UINT32
      +
      3674  #include <atomic>
      +
      3675  #define VMA_ATOMIC_UINT32 std::atomic<uint32_t>
      +
      3676 #endif
      +
      3677 
      +
      3678 #ifndef VMA_ATOMIC_UINT64
      +
      3679  #include <atomic>
      +
      3680  #define VMA_ATOMIC_UINT64 std::atomic<uint64_t>
      3681 #endif
      3682 
      -
      3683 #ifndef VMA_DEBUG_INITIALIZE_ALLOCATIONS
      +
      3683 #ifndef VMA_DEBUG_ALWAYS_DEDICATED_MEMORY
      3684 
      -
      3688  #define VMA_DEBUG_INITIALIZE_ALLOCATIONS (0)
      +
      3688  #define VMA_DEBUG_ALWAYS_DEDICATED_MEMORY (0)
      3689 #endif
      3690 
      -
      3691 #ifndef VMA_DEBUG_DETECT_CORRUPTION
      +
      3691 #ifndef VMA_DEBUG_ALIGNMENT
      3692 
      -
      3697  #define VMA_DEBUG_DETECT_CORRUPTION (0)
      -
      3698 #endif
      -
      3699 
      -
      3700 #ifndef VMA_DEBUG_GLOBAL_MUTEX
      -
      3701 
      -
      3705  #define VMA_DEBUG_GLOBAL_MUTEX (0)
      -
      3706 #endif
      -
      3707 
      -
      3708 #ifndef VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY
      -
      3709 
      -
      3713  #define VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY (1)
      -
      3714 #endif
      -
      3715 
      -
      3716 #ifndef VMA_SMALL_HEAP_MAX_SIZE
      -
      3717  #define VMA_SMALL_HEAP_MAX_SIZE (1024ull * 1024 * 1024)
      -
      3719 #endif
      -
      3720 
      -
      3721 #ifndef VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE
      -
      3722  #define VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE (256ull * 1024 * 1024)
      -
      3724 #endif
      +
      3696  #define VMA_DEBUG_ALIGNMENT (1)
      +
      3697 #endif
      +
      3698 
      +
      3699 #ifndef VMA_DEBUG_MARGIN
      +
      3700 
      +
      3704  #define VMA_DEBUG_MARGIN (0)
      +
      3705 #endif
      +
      3706 
      +
      3707 #ifndef VMA_DEBUG_INITIALIZE_ALLOCATIONS
      +
      3708 
      +
      3712  #define VMA_DEBUG_INITIALIZE_ALLOCATIONS (0)
      +
      3713 #endif
      +
      3714 
      +
      3715 #ifndef VMA_DEBUG_DETECT_CORRUPTION
      +
      3716 
      +
      3721  #define VMA_DEBUG_DETECT_CORRUPTION (0)
      +
      3722 #endif
      +
      3723 
      +
      3724 #ifndef VMA_DEBUG_GLOBAL_MUTEX
      3725 
      -
      3726 #ifndef VMA_CLASS_NO_COPY
      -
      3727  #define VMA_CLASS_NO_COPY(className) \
      -
      3728  private: \
      -
      3729  className(const className&) = delete; \
      -
      3730  className& operator=(const className&) = delete;
      -
      3731 #endif
      -
      3732 
      -
      3733 static const uint32_t VMA_FRAME_INDEX_LOST = UINT32_MAX;
      -
      3734 
      -
      3735 // Decimal 2139416166, float NaN, little-endian binary 66 E6 84 7F.
      -
      3736 static const uint32_t VMA_CORRUPTION_DETECTION_MAGIC_VALUE = 0x7F84E666;
      -
      3737 
      -
      3738 static const uint8_t VMA_ALLOCATION_FILL_PATTERN_CREATED = 0xDC;
      -
      3739 static const uint8_t VMA_ALLOCATION_FILL_PATTERN_DESTROYED = 0xEF;
      -
      3740 
      -
      3741 /*******************************************************************************
      -
      3742 END OF CONFIGURATION
      -
      3743 */
      +
      3729  #define VMA_DEBUG_GLOBAL_MUTEX (0)
      +
      3730 #endif
      +
      3731 
      +
      3732 #ifndef VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY
      +
      3733 
      +
      3737  #define VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY (1)
      +
      3738 #endif
      +
      3739 
      +
      3740 #ifndef VMA_SMALL_HEAP_MAX_SIZE
      +
      3741  #define VMA_SMALL_HEAP_MAX_SIZE (1024ull * 1024 * 1024)
      +
      3743 #endif
      3744 
      -
      3745 static const uint32_t VMA_ALLOCATION_INTERNAL_STRATEGY_MIN_OFFSET = 0x10000000u;
      -
      3746 
      -
      3747 static VkAllocationCallbacks VmaEmptyAllocationCallbacks = {
      -
      3748  VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL };
      +
      3745 #ifndef VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE
      +
      3746  #define VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE (256ull * 1024 * 1024)
      +
      3748 #endif
      3749 
      -
      3750 // Returns number of bits set to 1 in (v).
      -
      3751 static inline uint32_t VmaCountBitsSet(uint32_t v)
      -
      3752 {
      -
      3753  uint32_t c = v - ((v >> 1) & 0x55555555);
      -
      3754  c = ((c >> 2) & 0x33333333) + (c & 0x33333333);
      -
      3755  c = ((c >> 4) + c) & 0x0F0F0F0F;
      -
      3756  c = ((c >> 8) + c) & 0x00FF00FF;
      -
      3757  c = ((c >> 16) + c) & 0x0000FFFF;
      -
      3758  return c;
      -
      3759 }
      -
      3760 
      -
      3761 // Aligns given value up to nearest multiply of align value. For example: VmaAlignUp(11, 8) = 16.
      -
      3762 // Use types like uint32_t, uint64_t as T.
      -
      3763 template <typename T>
      -
      3764 static inline T VmaAlignUp(T val, T align)
      -
      3765 {
      -
      3766  return (val + align - 1) / align * align;
      -
      3767 }
      -
      3768 // Aligns given value down to nearest multiply of align value. For example: VmaAlignUp(11, 8) = 8.
      -
      3769 // Use types like uint32_t, uint64_t as T.
      -
      3770 template <typename T>
      -
      3771 static inline T VmaAlignDown(T val, T align)
      -
      3772 {
      -
      3773  return val / align * align;
      -
      3774 }
      -
      3775 
      -
      3776 // Division with mathematical rounding to nearest number.
      -
      3777 template <typename T>
      -
      3778 static inline T VmaRoundDiv(T x, T y)
      -
      3779 {
      -
      3780  return (x + (y / (T)2)) / y;
      -
      3781 }
      -
      3782 
      -
      3783 /*
      -
      3784 Returns true if given number is a power of two.
      -
      3785 T must be unsigned integer number or signed integer but always nonnegative.
      -
      3786 For 0 returns true.
      -
      3787 */
      -
      3788 template <typename T>
      -
      3789 inline bool VmaIsPow2(T x)
      -
      3790 {
      -
      3791  return (x & (x-1)) == 0;
      -
      3792 }
      -
      3793 
      -
      3794 // Returns smallest power of 2 greater or equal to v.
      -
      3795 static inline uint32_t VmaNextPow2(uint32_t v)
      +
      3750 #ifndef VMA_CLASS_NO_COPY
      +
      3751  #define VMA_CLASS_NO_COPY(className) \
      +
      3752  private: \
      +
      3753  className(const className&) = delete; \
      +
      3754  className& operator=(const className&) = delete;
      +
      3755 #endif
      +
      3756 
      +
      3757 static const uint32_t VMA_FRAME_INDEX_LOST = UINT32_MAX;
      +
      3758 
      +
      3759 // Decimal 2139416166, float NaN, little-endian binary 66 E6 84 7F.
      +
      3760 static const uint32_t VMA_CORRUPTION_DETECTION_MAGIC_VALUE = 0x7F84E666;
      +
      3761 
      +
      3762 static const uint8_t VMA_ALLOCATION_FILL_PATTERN_CREATED = 0xDC;
      +
      3763 static const uint8_t VMA_ALLOCATION_FILL_PATTERN_DESTROYED = 0xEF;
      +
      3764 
      +
      3765 /*******************************************************************************
      +
      3766 END OF CONFIGURATION
      +
      3767 */
      +
      3768 
      +
      3769 static const uint32_t VMA_ALLOCATION_INTERNAL_STRATEGY_MIN_OFFSET = 0x10000000u;
      +
      3770 
      +
      3771 static VkAllocationCallbacks VmaEmptyAllocationCallbacks = {
      +
      3772  VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL };
      +
      3773 
      +
      3774 // Returns number of bits set to 1 in (v).
      +
      3775 static inline uint32_t VmaCountBitsSet(uint32_t v)
      +
      3776 {
      +
      3777  uint32_t c = v - ((v >> 1) & 0x55555555);
      +
      3778  c = ((c >> 2) & 0x33333333) + (c & 0x33333333);
      +
      3779  c = ((c >> 4) + c) & 0x0F0F0F0F;
      +
      3780  c = ((c >> 8) + c) & 0x00FF00FF;
      +
      3781  c = ((c >> 16) + c) & 0x0000FFFF;
      +
      3782  return c;
      +
      3783 }
      +
      3784 
      +
      3785 // Aligns given value up to nearest multiply of align value. For example: VmaAlignUp(11, 8) = 16.
      +
      3786 // Use types like uint32_t, uint64_t as T.
      +
      3787 template <typename T>
      +
      3788 static inline T VmaAlignUp(T val, T align)
      +
      3789 {
      +
      3790  return (val + align - 1) / align * align;
      +
      3791 }
      +
      3792 // Aligns given value down to nearest multiply of align value. For example: VmaAlignUp(11, 8) = 8.
      +
      3793 // Use types like uint32_t, uint64_t as T.
      +
      3794 template <typename T>
      +
      3795 static inline T VmaAlignDown(T val, T align)
      3796 {
      -
      3797  v--;
      -
      3798  v |= v >> 1;
      -
      3799  v |= v >> 2;
      -
      3800  v |= v >> 4;
      -
      3801  v |= v >> 8;
      -
      3802  v |= v >> 16;
      -
      3803  v++;
      -
      3804  return v;
      +
      3797  return val / align * align;
      +
      3798 }
      +
      3799 
      +
      3800 // Division with mathematical rounding to nearest number.
      +
      3801 template <typename T>
      +
      3802 static inline T VmaRoundDiv(T x, T y)
      +
      3803 {
      +
      3804  return (x + (y / (T)2)) / y;
      3805 }
      -
      3806 static inline uint64_t VmaNextPow2(uint64_t v)
      -
      3807 {
      -
      3808  v--;
      -
      3809  v |= v >> 1;
      -
      3810  v |= v >> 2;
      -
      3811  v |= v >> 4;
      -
      3812  v |= v >> 8;
      -
      3813  v |= v >> 16;
      -
      3814  v |= v >> 32;
      -
      3815  v++;
      -
      3816  return v;
      -
      3817 }
      -
      3818 
      -
      3819 // Returns largest power of 2 less or equal to v.
      -
      3820 static inline uint32_t VmaPrevPow2(uint32_t v)
      -
      3821 {
      +
      3806 
      +
      3807 /*
      +
      3808 Returns true if given number is a power of two.
      +
      3809 T must be unsigned integer number or signed integer but always nonnegative.
      +
      3810 For 0 returns true.
      +
      3811 */
      +
      3812 template <typename T>
      +
      3813 inline bool VmaIsPow2(T x)
      +
      3814 {
      +
      3815  return (x & (x-1)) == 0;
      +
      3816 }
      +
      3817 
      +
      3818 // Returns smallest power of 2 greater or equal to v.
      +
      3819 static inline uint32_t VmaNextPow2(uint32_t v)
      +
      3820 {
      +
      3821  v--;
      3822  v |= v >> 1;
      3823  v |= v >> 2;
      3824  v |= v >> 4;
      3825  v |= v >> 8;
      3826  v |= v >> 16;
      -
      3827  v = v ^ (v >> 1);
      +
      3827  v++;
      3828  return v;
      3829 }
      -
      3830 static inline uint64_t VmaPrevPow2(uint64_t v)
      +
      3830 static inline uint64_t VmaNextPow2(uint64_t v)
      3831 {
      -
      3832  v |= v >> 1;
      -
      3833  v |= v >> 2;
      -
      3834  v |= v >> 4;
      -
      3835  v |= v >> 8;
      -
      3836  v |= v >> 16;
      -
      3837  v |= v >> 32;
      -
      3838  v = v ^ (v >> 1);
      -
      3839  return v;
      -
      3840 }
      -
      3841 
      -
      3842 static inline bool VmaStrIsEmpty(const char* pStr)
      -
      3843 {
      -
      3844  return pStr == VMA_NULL || *pStr == '\0';
      -
      3845 }
      -
      3846 
      -
      3847 #if VMA_STATS_STRING_ENABLED
      -
      3848 
      -
      3849 static const char* VmaAlgorithmToStr(uint32_t algorithm)
      -
      3850 {
      -
      3851  switch(algorithm)
      -
      3852  {
      -
      3853  case VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT:
      -
      3854  return "Linear";
      -
      3855  case VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT:
      -
      3856  return "Buddy";
      -
      3857  case 0:
      -
      3858  return "Default";
      -
      3859  default:
      -
      3860  VMA_ASSERT(0);
      -
      3861  return "";
      -
      3862  }
      -
      3863 }
      -
      3864 
      -
      3865 #endif // #if VMA_STATS_STRING_ENABLED
      -
      3866 
      -
      3867 #ifndef VMA_SORT
      -
      3868 
      -
      3869 template<typename Iterator, typename Compare>
      -
      3870 Iterator VmaQuickSortPartition(Iterator beg, Iterator end, Compare cmp)
      -
      3871 {
      -
      3872  Iterator centerValue = end; --centerValue;
      -
      3873  Iterator insertIndex = beg;
      -
      3874  for(Iterator memTypeIndex = beg; memTypeIndex < centerValue; ++memTypeIndex)
      -
      3875  {
      -
      3876  if(cmp(*memTypeIndex, *centerValue))
      -
      3877  {
      -
      3878  if(insertIndex != memTypeIndex)
      -
      3879  {
      -
      3880  VMA_SWAP(*memTypeIndex, *insertIndex);
      -
      3881  }
      -
      3882  ++insertIndex;
      -
      3883  }
      -
      3884  }
      -
      3885  if(insertIndex != centerValue)
      -
      3886  {
      -
      3887  VMA_SWAP(*insertIndex, *centerValue);
      -
      3888  }
      -
      3889  return insertIndex;
      -
      3890 }
      -
      3891 
      -
      3892 template<typename Iterator, typename Compare>
      -
      3893 void VmaQuickSort(Iterator beg, Iterator end, Compare cmp)
      -
      3894 {
      -
      3895  if(beg < end)
      -
      3896  {
      -
      3897  Iterator it = VmaQuickSortPartition<Iterator, Compare>(beg, end, cmp);
      -
      3898  VmaQuickSort<Iterator, Compare>(beg, it, cmp);
      -
      3899  VmaQuickSort<Iterator, Compare>(it + 1, end, cmp);
      -
      3900  }
      -
      3901 }
      -
      3902 
      -
      3903 #define VMA_SORT(beg, end, cmp) VmaQuickSort(beg, end, cmp)
      -
      3904 
      -
      3905 #endif // #ifndef VMA_SORT
      -
      3906 
      -
      3907 /*
      -
      3908 Returns true if two memory blocks occupy overlapping pages.
      -
      3909 ResourceA must be in less memory offset than ResourceB.
      -
      3910 
      -
      3911 Algorithm is based on "Vulkan 1.0.39 - A Specification (with all registered Vulkan extensions)"
      -
      3912 chapter 11.6 "Resource Memory Association", paragraph "Buffer-Image Granularity".
      -
      3913 */
      -
      3914 static inline bool VmaBlocksOnSamePage(
      -
      3915  VkDeviceSize resourceAOffset,
      -
      3916  VkDeviceSize resourceASize,
      -
      3917  VkDeviceSize resourceBOffset,
      -
      3918  VkDeviceSize pageSize)
      -
      3919 {
      -
      3920  VMA_ASSERT(resourceAOffset + resourceASize <= resourceBOffset && resourceASize > 0 && pageSize > 0);
      -
      3921  VkDeviceSize resourceAEnd = resourceAOffset + resourceASize - 1;
      -
      3922  VkDeviceSize resourceAEndPage = resourceAEnd & ~(pageSize - 1);
      -
      3923  VkDeviceSize resourceBStart = resourceBOffset;
      -
      3924  VkDeviceSize resourceBStartPage = resourceBStart & ~(pageSize - 1);
      -
      3925  return resourceAEndPage == resourceBStartPage;
      -
      3926 }
      -
      3927 
      -
      3928 enum VmaSuballocationType
      -
      3929 {
      -
      3930  VMA_SUBALLOCATION_TYPE_FREE = 0,
      -
      3931  VMA_SUBALLOCATION_TYPE_UNKNOWN = 1,
      -
      3932  VMA_SUBALLOCATION_TYPE_BUFFER = 2,
      -
      3933  VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN = 3,
      -
      3934  VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR = 4,
      -
      3935  VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL = 5,
      -
      3936  VMA_SUBALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
      -
      3937 };
      -
      3938 
      -
      3939 /*
      -
      3940 Returns true if given suballocation types could conflict and must respect
      -
      3941 VkPhysicalDeviceLimits::bufferImageGranularity. They conflict if one is buffer
      -
      3942 or linear image and another one is optimal image. If type is unknown, behave
      -
      3943 conservatively.
      -
      3944 */
      -
      3945 static inline bool VmaIsBufferImageGranularityConflict(
      -
      3946  VmaSuballocationType suballocType1,
      -
      3947  VmaSuballocationType suballocType2)
      -
      3948 {
      -
      3949  if(suballocType1 > suballocType2)
      -
      3950  {
      -
      3951  VMA_SWAP(suballocType1, suballocType2);
      -
      3952  }
      -
      3953 
      -
      3954  switch(suballocType1)
      -
      3955  {
      -
      3956  case VMA_SUBALLOCATION_TYPE_FREE:
      -
      3957  return false;
      -
      3958  case VMA_SUBALLOCATION_TYPE_UNKNOWN:
      -
      3959  return true;
      -
      3960  case VMA_SUBALLOCATION_TYPE_BUFFER:
      -
      3961  return
      -
      3962  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
      -
      3963  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
      -
      3964  case VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN:
      -
      3965  return
      -
      3966  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
      -
      3967  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR ||
      -
      3968  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
      -
      3969  case VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR:
      -
      3970  return
      -
      3971  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
      -
      3972  case VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL:
      -
      3973  return false;
      -
      3974  default:
      -
      3975  VMA_ASSERT(0);
      -
      3976  return true;
      -
      3977  }
      -
      3978 }
      -
      3979 
      -
      3980 static void VmaWriteMagicValue(void* pData, VkDeviceSize offset)
      -
      3981 {
      -
      3982 #if VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_DETECT_CORRUPTION
      -
      3983  uint32_t* pDst = (uint32_t*)((char*)pData + offset);
      -
      3984  const size_t numberCount = VMA_DEBUG_MARGIN / sizeof(uint32_t);
      -
      3985  for(size_t i = 0; i < numberCount; ++i, ++pDst)
      -
      3986  {
      -
      3987  *pDst = VMA_CORRUPTION_DETECTION_MAGIC_VALUE;
      -
      3988  }
      -
      3989 #else
      -
      3990  // no-op
      -
      3991 #endif
      -
      3992 }
      -
      3993 
      -
      3994 static bool VmaValidateMagicValue(const void* pData, VkDeviceSize offset)
      -
      3995 {
      -
      3996 #if VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_DETECT_CORRUPTION
      -
      3997  const uint32_t* pSrc = (const uint32_t*)((const char*)pData + offset);
      -
      3998  const size_t numberCount = VMA_DEBUG_MARGIN / sizeof(uint32_t);
      -
      3999  for(size_t i = 0; i < numberCount; ++i, ++pSrc)
      -
      4000  {
      -
      4001  if(*pSrc != VMA_CORRUPTION_DETECTION_MAGIC_VALUE)
      -
      4002  {
      -
      4003  return false;
      -
      4004  }
      -
      4005  }
      -
      4006 #endif
      -
      4007  return true;
      -
      4008 }
      -
      4009 
      -
      4010 /*
      -
      4011 Fills structure with parameters of an example buffer to be used for transfers
      -
      4012 during GPU memory defragmentation.
      -
      4013 */
      -
      4014 static void VmaFillGpuDefragmentationBufferCreateInfo(VkBufferCreateInfo& outBufCreateInfo)
      -
      4015 {
      -
      4016  memset(&outBufCreateInfo, 0, sizeof(outBufCreateInfo));
      -
      4017  outBufCreateInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
      -
      4018  outBufCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
      -
      4019  outBufCreateInfo.size = (VkDeviceSize)VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE; // Example size.
      -
      4020 }
      -
      4021 
      -
      4022 // Helper RAII class to lock a mutex in constructor and unlock it in destructor (at the end of scope).
      -
      4023 struct VmaMutexLock
      -
      4024 {
      -
      4025  VMA_CLASS_NO_COPY(VmaMutexLock)
      -
      4026 public:
      -
      4027  VmaMutexLock(VMA_MUTEX& mutex, bool useMutex = true) :
      -
      4028  m_pMutex(useMutex ? &mutex : VMA_NULL)
      -
      4029  { if(m_pMutex) { m_pMutex->Lock(); } }
      -
      4030  ~VmaMutexLock()
      -
      4031  { if(m_pMutex) { m_pMutex->Unlock(); } }
      -
      4032 private:
      -
      4033  VMA_MUTEX* m_pMutex;
      -
      4034 };
      -
      4035 
      -
      4036 // Helper RAII class to lock a RW mutex in constructor and unlock it in destructor (at the end of scope), for reading.
      -
      4037 struct VmaMutexLockRead
      -
      4038 {
      -
      4039  VMA_CLASS_NO_COPY(VmaMutexLockRead)
      -
      4040 public:
      -
      4041  VmaMutexLockRead(VMA_RW_MUTEX& mutex, bool useMutex) :
      -
      4042  m_pMutex(useMutex ? &mutex : VMA_NULL)
      -
      4043  { if(m_pMutex) { m_pMutex->LockRead(); } }
      -
      4044  ~VmaMutexLockRead() { if(m_pMutex) { m_pMutex->UnlockRead(); } }
      -
      4045 private:
      -
      4046  VMA_RW_MUTEX* m_pMutex;
      -
      4047 };
      -
      4048 
      -
      4049 // Helper RAII class to lock a RW mutex in constructor and unlock it in destructor (at the end of scope), for writing.
      -
      4050 struct VmaMutexLockWrite
      -
      4051 {
      -
      4052  VMA_CLASS_NO_COPY(VmaMutexLockWrite)
      -
      4053 public:
      -
      4054  VmaMutexLockWrite(VMA_RW_MUTEX& mutex, bool useMutex) :
      -
      4055  m_pMutex(useMutex ? &mutex : VMA_NULL)
      -
      4056  { if(m_pMutex) { m_pMutex->LockWrite(); } }
      -
      4057  ~VmaMutexLockWrite() { if(m_pMutex) { m_pMutex->UnlockWrite(); } }
      -
      4058 private:
      -
      4059  VMA_RW_MUTEX* m_pMutex;
      -
      4060 };
      -
      4061 
      -
      4062 #if VMA_DEBUG_GLOBAL_MUTEX
      -
      4063  static VMA_MUTEX gDebugGlobalMutex;
      -
      4064  #define VMA_DEBUG_GLOBAL_MUTEX_LOCK VmaMutexLock debugGlobalMutexLock(gDebugGlobalMutex, true);
      -
      4065 #else
      -
      4066  #define VMA_DEBUG_GLOBAL_MUTEX_LOCK
      -
      4067 #endif
      -
      4068 
      -
      4069 // Minimum size of a free suballocation to register it in the free suballocation collection.
      -
      4070 static const VkDeviceSize VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER = 16;
      -
      4071 
      -
      4072 /*
      -
      4073 Performs binary search and returns iterator to first element that is greater or
      -
      4074 equal to (key), according to comparison (cmp).
      -
      4075 
      -
      4076 Cmp should return true if first argument is less than second argument.
      -
      4077 
      -
      4078 Returned value is the found element, if present in the collection or place where
      -
      4079 new element with value (key) should be inserted.
      -
      4080 */
      -
      4081 template <typename CmpLess, typename IterT, typename KeyT>
      -
      4082 static IterT VmaBinaryFindFirstNotLess(IterT beg, IterT end, const KeyT &key, const CmpLess& cmp)
      -
      4083 {
      -
      4084  size_t down = 0, up = (end - beg);
      -
      4085  while(down < up)
      -
      4086  {
      -
      4087  const size_t mid = (down + up) / 2;
      -
      4088  if(cmp(*(beg+mid), key))
      -
      4089  {
      -
      4090  down = mid + 1;
      -
      4091  }
      -
      4092  else
      -
      4093  {
      -
      4094  up = mid;
      -
      4095  }
      -
      4096  }
      -
      4097  return beg + down;
      -
      4098 }
      -
      4099 
      -
      4100 template<typename CmpLess, typename IterT, typename KeyT>
      -
      4101 IterT VmaBinaryFindSorted(const IterT& beg, const IterT& end, const KeyT& value, const CmpLess& cmp)
      -
      4102 {
      -
      4103  IterT it = VmaBinaryFindFirstNotLess<CmpLess, IterT, KeyT>(
      -
      4104  beg, end, value, cmp);
      -
      4105  if(it == end ||
      -
      4106  (!cmp(*it, value) && !cmp(value, *it)))
      -
      4107  {
      -
      4108  return it;
      -
      4109  }
      -
      4110  return end;
      -
      4111 }
      -
      4112 
      -
      4113 /*
      -
      4114 Returns true if all pointers in the array are not-null and unique.
      -
      4115 Warning! O(n^2) complexity. Use only inside VMA_HEAVY_ASSERT.
      -
      4116 T must be pointer type, e.g. VmaAllocation, VmaPool.
      -
      4117 */
      -
      4118 template<typename T>
      -
      4119 static bool VmaValidatePointerArray(uint32_t count, const T* arr)
      -
      4120 {
      -
      4121  for(uint32_t i = 0; i < count; ++i)
      -
      4122  {
      -
      4123  const T iPtr = arr[i];
      -
      4124  if(iPtr == VMA_NULL)
      -
      4125  {
      -
      4126  return false;
      -
      4127  }
      -
      4128  for(uint32_t j = i + 1; j < count; ++j)
      -
      4129  {
      -
      4130  if(iPtr == arr[j])
      -
      4131  {
      -
      4132  return false;
      -
      4133  }
      -
      4134  }
      -
      4135  }
      -
      4136  return true;
      -
      4137 }
      -
      4138 
      -
      4140 // Memory allocation
      -
      4141 
      -
      4142 static void* VmaMalloc(const VkAllocationCallbacks* pAllocationCallbacks, size_t size, size_t alignment)
      -
      4143 {
      -
      4144  if((pAllocationCallbacks != VMA_NULL) &&
      -
      4145  (pAllocationCallbacks->pfnAllocation != VMA_NULL))
      +
      3832  v--;
      +
      3833  v |= v >> 1;
      +
      3834  v |= v >> 2;
      +
      3835  v |= v >> 4;
      +
      3836  v |= v >> 8;
      +
      3837  v |= v >> 16;
      +
      3838  v |= v >> 32;
      +
      3839  v++;
      +
      3840  return v;
      +
      3841 }
      +
      3842 
      +
      3843 // Returns largest power of 2 less or equal to v.
      +
      3844 static inline uint32_t VmaPrevPow2(uint32_t v)
      +
      3845 {
      +
      3846  v |= v >> 1;
      +
      3847  v |= v >> 2;
      +
      3848  v |= v >> 4;
      +
      3849  v |= v >> 8;
      +
      3850  v |= v >> 16;
      +
      3851  v = v ^ (v >> 1);
      +
      3852  return v;
      +
      3853 }
      +
      3854 static inline uint64_t VmaPrevPow2(uint64_t v)
      +
      3855 {
      +
      3856  v |= v >> 1;
      +
      3857  v |= v >> 2;
      +
      3858  v |= v >> 4;
      +
      3859  v |= v >> 8;
      +
      3860  v |= v >> 16;
      +
      3861  v |= v >> 32;
      +
      3862  v = v ^ (v >> 1);
      +
      3863  return v;
      +
      3864 }
      +
      3865 
      +
      3866 static inline bool VmaStrIsEmpty(const char* pStr)
      +
      3867 {
      +
      3868  return pStr == VMA_NULL || *pStr == '\0';
      +
      3869 }
      +
      3870 
      +
      3871 #if VMA_STATS_STRING_ENABLED
      +
      3872 
      +
      3873 static const char* VmaAlgorithmToStr(uint32_t algorithm)
      +
      3874 {
      +
      3875  switch(algorithm)
      +
      3876  {
      +
      3877  case VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT:
      +
      3878  return "Linear";
      +
      3879  case VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT:
      +
      3880  return "Buddy";
      +
      3881  case 0:
      +
      3882  return "Default";
      +
      3883  default:
      +
      3884  VMA_ASSERT(0);
      +
      3885  return "";
      +
      3886  }
      +
      3887 }
      +
      3888 
      +
      3889 #endif // #if VMA_STATS_STRING_ENABLED
      +
      3890 
      +
      3891 #ifndef VMA_SORT
      +
      3892 
      +
      3893 template<typename Iterator, typename Compare>
      +
      3894 Iterator VmaQuickSortPartition(Iterator beg, Iterator end, Compare cmp)
      +
      3895 {
      +
      3896  Iterator centerValue = end; --centerValue;
      +
      3897  Iterator insertIndex = beg;
      +
      3898  for(Iterator memTypeIndex = beg; memTypeIndex < centerValue; ++memTypeIndex)
      +
      3899  {
      +
      3900  if(cmp(*memTypeIndex, *centerValue))
      +
      3901  {
      +
      3902  if(insertIndex != memTypeIndex)
      +
      3903  {
      +
      3904  VMA_SWAP(*memTypeIndex, *insertIndex);
      +
      3905  }
      +
      3906  ++insertIndex;
      +
      3907  }
      +
      3908  }
      +
      3909  if(insertIndex != centerValue)
      +
      3910  {
      +
      3911  VMA_SWAP(*insertIndex, *centerValue);
      +
      3912  }
      +
      3913  return insertIndex;
      +
      3914 }
      +
      3915 
      +
      3916 template<typename Iterator, typename Compare>
      +
      3917 void VmaQuickSort(Iterator beg, Iterator end, Compare cmp)
      +
      3918 {
      +
      3919  if(beg < end)
      +
      3920  {
      +
      3921  Iterator it = VmaQuickSortPartition<Iterator, Compare>(beg, end, cmp);
      +
      3922  VmaQuickSort<Iterator, Compare>(beg, it, cmp);
      +
      3923  VmaQuickSort<Iterator, Compare>(it + 1, end, cmp);
      +
      3924  }
      +
      3925 }
      +
      3926 
      +
      3927 #define VMA_SORT(beg, end, cmp) VmaQuickSort(beg, end, cmp)
      +
      3928 
      +
      3929 #endif // #ifndef VMA_SORT
      +
      3930 
      +
      3931 /*
      +
      3932 Returns true if two memory blocks occupy overlapping pages.
      +
      3933 ResourceA must be in less memory offset than ResourceB.
      +
      3934 
      +
      3935 Algorithm is based on "Vulkan 1.0.39 - A Specification (with all registered Vulkan extensions)"
      +
      3936 chapter 11.6 "Resource Memory Association", paragraph "Buffer-Image Granularity".
      +
      3937 */
      +
      3938 static inline bool VmaBlocksOnSamePage(
      +
      3939  VkDeviceSize resourceAOffset,
      +
      3940  VkDeviceSize resourceASize,
      +
      3941  VkDeviceSize resourceBOffset,
      +
      3942  VkDeviceSize pageSize)
      +
      3943 {
      +
      3944  VMA_ASSERT(resourceAOffset + resourceASize <= resourceBOffset && resourceASize > 0 && pageSize > 0);
      +
      3945  VkDeviceSize resourceAEnd = resourceAOffset + resourceASize - 1;
      +
      3946  VkDeviceSize resourceAEndPage = resourceAEnd & ~(pageSize - 1);
      +
      3947  VkDeviceSize resourceBStart = resourceBOffset;
      +
      3948  VkDeviceSize resourceBStartPage = resourceBStart & ~(pageSize - 1);
      +
      3949  return resourceAEndPage == resourceBStartPage;
      +
      3950 }
      +
      3951 
      +
      3952 enum VmaSuballocationType
      +
      3953 {
      +
      3954  VMA_SUBALLOCATION_TYPE_FREE = 0,
      +
      3955  VMA_SUBALLOCATION_TYPE_UNKNOWN = 1,
      +
      3956  VMA_SUBALLOCATION_TYPE_BUFFER = 2,
      +
      3957  VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN = 3,
      +
      3958  VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR = 4,
      +
      3959  VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL = 5,
      +
      3960  VMA_SUBALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
      +
      3961 };
      +
      3962 
      +
      3963 /*
      +
      3964 Returns true if given suballocation types could conflict and must respect
      +
      3965 VkPhysicalDeviceLimits::bufferImageGranularity. They conflict if one is buffer
      +
      3966 or linear image and another one is optimal image. If type is unknown, behave
      +
      3967 conservatively.
      +
      3968 */
      +
      3969 static inline bool VmaIsBufferImageGranularityConflict(
      +
      3970  VmaSuballocationType suballocType1,
      +
      3971  VmaSuballocationType suballocType2)
      +
      3972 {
      +
      3973  if(suballocType1 > suballocType2)
      +
      3974  {
      +
      3975  VMA_SWAP(suballocType1, suballocType2);
      +
      3976  }
      +
      3977 
      +
      3978  switch(suballocType1)
      +
      3979  {
      +
      3980  case VMA_SUBALLOCATION_TYPE_FREE:
      +
      3981  return false;
      +
      3982  case VMA_SUBALLOCATION_TYPE_UNKNOWN:
      +
      3983  return true;
      +
      3984  case VMA_SUBALLOCATION_TYPE_BUFFER:
      +
      3985  return
      +
      3986  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
      +
      3987  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
      +
      3988  case VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN:
      +
      3989  return
      +
      3990  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
      +
      3991  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR ||
      +
      3992  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
      +
      3993  case VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR:
      +
      3994  return
      +
      3995  suballocType2 == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL;
      +
      3996  case VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL:
      +
      3997  return false;
      +
      3998  default:
      +
      3999  VMA_ASSERT(0);
      +
      4000  return true;
      +
      4001  }
      +
      4002 }
      +
      4003 
      +
      4004 static void VmaWriteMagicValue(void* pData, VkDeviceSize offset)
      +
      4005 {
      +
      4006 #if VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_DETECT_CORRUPTION
      +
      4007  uint32_t* pDst = (uint32_t*)((char*)pData + offset);
      +
      4008  const size_t numberCount = VMA_DEBUG_MARGIN / sizeof(uint32_t);
      +
      4009  for(size_t i = 0; i < numberCount; ++i, ++pDst)
      +
      4010  {
      +
      4011  *pDst = VMA_CORRUPTION_DETECTION_MAGIC_VALUE;
      +
      4012  }
      +
      4013 #else
      +
      4014  // no-op
      +
      4015 #endif
      +
      4016 }
      +
      4017 
      +
      4018 static bool VmaValidateMagicValue(const void* pData, VkDeviceSize offset)
      +
      4019 {
      +
      4020 #if VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_DETECT_CORRUPTION
      +
      4021  const uint32_t* pSrc = (const uint32_t*)((const char*)pData + offset);
      +
      4022  const size_t numberCount = VMA_DEBUG_MARGIN / sizeof(uint32_t);
      +
      4023  for(size_t i = 0; i < numberCount; ++i, ++pSrc)
      +
      4024  {
      +
      4025  if(*pSrc != VMA_CORRUPTION_DETECTION_MAGIC_VALUE)
      +
      4026  {
      +
      4027  return false;
      +
      4028  }
      +
      4029  }
      +
      4030 #endif
      +
      4031  return true;
      +
      4032 }
      +
      4033 
      +
      4034 /*
      +
      4035 Fills structure with parameters of an example buffer to be used for transfers
      +
      4036 during GPU memory defragmentation.
      +
      4037 */
      +
      4038 static void VmaFillGpuDefragmentationBufferCreateInfo(VkBufferCreateInfo& outBufCreateInfo)
      +
      4039 {
      +
      4040  memset(&outBufCreateInfo, 0, sizeof(outBufCreateInfo));
      +
      4041  outBufCreateInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
      +
      4042  outBufCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
      +
      4043  outBufCreateInfo.size = (VkDeviceSize)VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE; // Example size.
      +
      4044 }
      +
      4045 
      +
      4046 // Helper RAII class to lock a mutex in constructor and unlock it in destructor (at the end of scope).
      +
      4047 struct VmaMutexLock
      +
      4048 {
      +
      4049  VMA_CLASS_NO_COPY(VmaMutexLock)
      +
      4050 public:
      +
      4051  VmaMutexLock(VMA_MUTEX& mutex, bool useMutex = true) :
      +
      4052  m_pMutex(useMutex ? &mutex : VMA_NULL)
      +
      4053  { if(m_pMutex) { m_pMutex->Lock(); } }
      +
      4054  ~VmaMutexLock()
      +
      4055  { if(m_pMutex) { m_pMutex->Unlock(); } }
      +
      4056 private:
      +
      4057  VMA_MUTEX* m_pMutex;
      +
      4058 };
      +
      4059 
      +
      4060 // Helper RAII class to lock a RW mutex in constructor and unlock it in destructor (at the end of scope), for reading.
      +
      4061 struct VmaMutexLockRead
      +
      4062 {
      +
      4063  VMA_CLASS_NO_COPY(VmaMutexLockRead)
      +
      4064 public:
      +
      4065  VmaMutexLockRead(VMA_RW_MUTEX& mutex, bool useMutex) :
      +
      4066  m_pMutex(useMutex ? &mutex : VMA_NULL)
      +
      4067  { if(m_pMutex) { m_pMutex->LockRead(); } }
      +
      4068  ~VmaMutexLockRead() { if(m_pMutex) { m_pMutex->UnlockRead(); } }
      +
      4069 private:
      +
      4070  VMA_RW_MUTEX* m_pMutex;
      +
      4071 };
      +
      4072 
      +
      4073 // Helper RAII class to lock a RW mutex in constructor and unlock it in destructor (at the end of scope), for writing.
      +
      4074 struct VmaMutexLockWrite
      +
      4075 {
      +
      4076  VMA_CLASS_NO_COPY(VmaMutexLockWrite)
      +
      4077 public:
      +
      4078  VmaMutexLockWrite(VMA_RW_MUTEX& mutex, bool useMutex) :
      +
      4079  m_pMutex(useMutex ? &mutex : VMA_NULL)
      +
      4080  { if(m_pMutex) { m_pMutex->LockWrite(); } }
      +
      4081  ~VmaMutexLockWrite() { if(m_pMutex) { m_pMutex->UnlockWrite(); } }
      +
      4082 private:
      +
      4083  VMA_RW_MUTEX* m_pMutex;
      +
      4084 };
      +
      4085 
      +
      4086 #if VMA_DEBUG_GLOBAL_MUTEX
      +
      4087  static VMA_MUTEX gDebugGlobalMutex;
      +
      4088  #define VMA_DEBUG_GLOBAL_MUTEX_LOCK VmaMutexLock debugGlobalMutexLock(gDebugGlobalMutex, true);
      +
      4089 #else
      +
      4090  #define VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      4091 #endif
      +
      4092 
      +
      4093 // Minimum size of a free suballocation to register it in the free suballocation collection.
      +
      4094 static const VkDeviceSize VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER = 16;
      +
      4095 
      +
      4096 /*
      +
      4097 Performs binary search and returns iterator to first element that is greater or
      +
      4098 equal to (key), according to comparison (cmp).
      +
      4099 
      +
      4100 Cmp should return true if first argument is less than second argument.
      +
      4101 
      +
      4102 Returned value is the found element, if present in the collection or place where
      +
      4103 new element with value (key) should be inserted.
      +
      4104 */
      +
      4105 template <typename CmpLess, typename IterT, typename KeyT>
      +
      4106 static IterT VmaBinaryFindFirstNotLess(IterT beg, IterT end, const KeyT &key, const CmpLess& cmp)
      +
      4107 {
      +
      4108  size_t down = 0, up = (end - beg);
      +
      4109  while(down < up)
      +
      4110  {
      +
      4111  const size_t mid = (down + up) / 2;
      +
      4112  if(cmp(*(beg+mid), key))
      +
      4113  {
      +
      4114  down = mid + 1;
      +
      4115  }
      +
      4116  else
      +
      4117  {
      +
      4118  up = mid;
      +
      4119  }
      +
      4120  }
      +
      4121  return beg + down;
      +
      4122 }
      +
      4123 
      +
      4124 template<typename CmpLess, typename IterT, typename KeyT>
      +
      4125 IterT VmaBinaryFindSorted(const IterT& beg, const IterT& end, const KeyT& value, const CmpLess& cmp)
      +
      4126 {
      +
      4127  IterT it = VmaBinaryFindFirstNotLess<CmpLess, IterT, KeyT>(
      +
      4128  beg, end, value, cmp);
      +
      4129  if(it == end ||
      +
      4130  (!cmp(*it, value) && !cmp(value, *it)))
      +
      4131  {
      +
      4132  return it;
      +
      4133  }
      +
      4134  return end;
      +
      4135 }
      +
      4136 
      +
      4137 /*
      +
      4138 Returns true if all pointers in the array are not-null and unique.
      +
      4139 Warning! O(n^2) complexity. Use only inside VMA_HEAVY_ASSERT.
      +
      4140 T must be pointer type, e.g. VmaAllocation, VmaPool.
      +
      4141 */
      +
      4142 template<typename T>
      +
      4143 static bool VmaValidatePointerArray(uint32_t count, const T* arr)
      +
      4144 {
      +
      4145  for(uint32_t i = 0; i < count; ++i)
      4146  {
      -
      4147  return (*pAllocationCallbacks->pfnAllocation)(
      -
      4148  pAllocationCallbacks->pUserData,
      -
      4149  size,
      -
      4150  alignment,
      -
      4151  VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
      -
      4152  }
      -
      4153  else
      -
      4154  {
      -
      4155  return VMA_SYSTEM_ALIGNED_MALLOC(size, alignment);
      -
      4156  }
      -
      4157 }
      -
      4158 
      -
      4159 static void VmaFree(const VkAllocationCallbacks* pAllocationCallbacks, void* ptr)
      -
      4160 {
      -
      4161  if((pAllocationCallbacks != VMA_NULL) &&
      -
      4162  (pAllocationCallbacks->pfnFree != VMA_NULL))
      -
      4163  {
      -
      4164  (*pAllocationCallbacks->pfnFree)(pAllocationCallbacks->pUserData, ptr);
      -
      4165  }
      -
      4166  else
      -
      4167  {
      -
      4168  VMA_SYSTEM_FREE(ptr);
      -
      4169  }
      -
      4170 }
      -
      4171 
      -
      4172 template<typename T>
      -
      4173 static T* VmaAllocate(const VkAllocationCallbacks* pAllocationCallbacks)
      -
      4174 {
      -
      4175  return (T*)VmaMalloc(pAllocationCallbacks, sizeof(T), VMA_ALIGN_OF(T));
      -
      4176 }
      -
      4177 
      -
      4178 template<typename T>
      -
      4179 static T* VmaAllocateArray(const VkAllocationCallbacks* pAllocationCallbacks, size_t count)
      -
      4180 {
      -
      4181  return (T*)VmaMalloc(pAllocationCallbacks, sizeof(T) * count, VMA_ALIGN_OF(T));
      -
      4182 }
      -
      4183 
      -
      4184 #define vma_new(allocator, type) new(VmaAllocate<type>(allocator))(type)
      -
      4185 
      -
      4186 #define vma_new_array(allocator, type, count) new(VmaAllocateArray<type>((allocator), (count)))(type)
      -
      4187 
      -
      4188 template<typename T>
      -
      4189 static void vma_delete(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr)
      -
      4190 {
      -
      4191  ptr->~T();
      -
      4192  VmaFree(pAllocationCallbacks, ptr);
      -
      4193 }
      -
      4194 
      -
      4195 template<typename T>
      -
      4196 static void vma_delete_array(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr, size_t count)
      -
      4197 {
      -
      4198  if(ptr != VMA_NULL)
      -
      4199  {
      -
      4200  for(size_t i = count; i--; )
      -
      4201  {
      -
      4202  ptr[i].~T();
      -
      4203  }
      -
      4204  VmaFree(pAllocationCallbacks, ptr);
      -
      4205  }
      +
      4147  const T iPtr = arr[i];
      +
      4148  if(iPtr == VMA_NULL)
      +
      4149  {
      +
      4150  return false;
      +
      4151  }
      +
      4152  for(uint32_t j = i + 1; j < count; ++j)
      +
      4153  {
      +
      4154  if(iPtr == arr[j])
      +
      4155  {
      +
      4156  return false;
      +
      4157  }
      +
      4158  }
      +
      4159  }
      +
      4160  return true;
      +
      4161 }
      +
      4162 
      +
      4164 // Memory allocation
      +
      4165 
      +
      4166 static void* VmaMalloc(const VkAllocationCallbacks* pAllocationCallbacks, size_t size, size_t alignment)
      +
      4167 {
      +
      4168  if((pAllocationCallbacks != VMA_NULL) &&
      +
      4169  (pAllocationCallbacks->pfnAllocation != VMA_NULL))
      +
      4170  {
      +
      4171  return (*pAllocationCallbacks->pfnAllocation)(
      +
      4172  pAllocationCallbacks->pUserData,
      +
      4173  size,
      +
      4174  alignment,
      +
      4175  VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
      +
      4176  }
      +
      4177  else
      +
      4178  {
      +
      4179  return VMA_SYSTEM_ALIGNED_MALLOC(size, alignment);
      +
      4180  }
      +
      4181 }
      +
      4182 
      +
      4183 static void VmaFree(const VkAllocationCallbacks* pAllocationCallbacks, void* ptr)
      +
      4184 {
      +
      4185  if((pAllocationCallbacks != VMA_NULL) &&
      +
      4186  (pAllocationCallbacks->pfnFree != VMA_NULL))
      +
      4187  {
      +
      4188  (*pAllocationCallbacks->pfnFree)(pAllocationCallbacks->pUserData, ptr);
      +
      4189  }
      +
      4190  else
      +
      4191  {
      +
      4192  VMA_SYSTEM_FREE(ptr);
      +
      4193  }
      +
      4194 }
      +
      4195 
      +
      4196 template<typename T>
      +
      4197 static T* VmaAllocate(const VkAllocationCallbacks* pAllocationCallbacks)
      +
      4198 {
      +
      4199  return (T*)VmaMalloc(pAllocationCallbacks, sizeof(T), VMA_ALIGN_OF(T));
      +
      4200 }
      +
      4201 
      +
      4202 template<typename T>
      +
      4203 static T* VmaAllocateArray(const VkAllocationCallbacks* pAllocationCallbacks, size_t count)
      +
      4204 {
      +
      4205  return (T*)VmaMalloc(pAllocationCallbacks, sizeof(T) * count, VMA_ALIGN_OF(T));
      4206 }
      4207 
      -
      4208 // STL-compatible allocator.
      -
      4209 template<typename T>
      -
      4210 class VmaStlAllocator
      -
      4211 {
      -
      4212 public:
      -
      4213  const VkAllocationCallbacks* const m_pCallbacks;
      -
      4214  typedef T value_type;
      -
      4215 
      -
      4216  VmaStlAllocator(const VkAllocationCallbacks* pCallbacks) : m_pCallbacks(pCallbacks) { }
      -
      4217  template<typename U> VmaStlAllocator(const VmaStlAllocator<U>& src) : m_pCallbacks(src.m_pCallbacks) { }
      +
      4208 #define vma_new(allocator, type) new(VmaAllocate<type>(allocator))(type)
      +
      4209 
      +
      4210 #define vma_new_array(allocator, type, count) new(VmaAllocateArray<type>((allocator), (count)))(type)
      +
      4211 
      +
      4212 template<typename T>
      +
      4213 static void vma_delete(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr)
      +
      4214 {
      +
      4215  ptr->~T();
      +
      4216  VmaFree(pAllocationCallbacks, ptr);
      +
      4217 }
      4218 
      -
      4219  T* allocate(size_t n) { return VmaAllocateArray<T>(m_pCallbacks, n); }
      -
      4220  void deallocate(T* p, size_t n) { VmaFree(m_pCallbacks, p); }
      -
      4221 
      -
      4222  template<typename U>
      -
      4223  bool operator==(const VmaStlAllocator<U>& rhs) const
      -
      4224  {
      -
      4225  return m_pCallbacks == rhs.m_pCallbacks;
      -
      4226  }
      -
      4227  template<typename U>
      -
      4228  bool operator!=(const VmaStlAllocator<U>& rhs) const
      -
      4229  {
      -
      4230  return m_pCallbacks != rhs.m_pCallbacks;
      -
      4231  }
      -
      4232 
      -
      4233  VmaStlAllocator& operator=(const VmaStlAllocator& x) = delete;
      -
      4234 };
      -
      4235 
      -
      4236 #if VMA_USE_STL_VECTOR
      -
      4237 
      -
      4238 #define VmaVector std::vector
      -
      4239 
      -
      4240 template<typename T, typename allocatorT>
      -
      4241 static void VmaVectorInsert(std::vector<T, allocatorT>& vec, size_t index, const T& item)
      -
      4242 {
      -
      4243  vec.insert(vec.begin() + index, item);
      -
      4244 }
      -
      4245 
      -
      4246 template<typename T, typename allocatorT>
      -
      4247 static void VmaVectorRemove(std::vector<T, allocatorT>& vec, size_t index)
      +
      4219 template<typename T>
      +
      4220 static void vma_delete_array(const VkAllocationCallbacks* pAllocationCallbacks, T* ptr, size_t count)
      +
      4221 {
      +
      4222  if(ptr != VMA_NULL)
      +
      4223  {
      +
      4224  for(size_t i = count; i--; )
      +
      4225  {
      +
      4226  ptr[i].~T();
      +
      4227  }
      +
      4228  VmaFree(pAllocationCallbacks, ptr);
      +
      4229  }
      +
      4230 }
      +
      4231 
      +
      4232 static char* VmaCreateStringCopy(const VkAllocationCallbacks* allocs, const char* srcStr)
      +
      4233 {
      +
      4234  if(srcStr != VMA_NULL)
      +
      4235  {
      +
      4236  const size_t len = strlen(srcStr);
      +
      4237  char* const result = vma_new_array(allocs, char, len + 1);
      +
      4238  memcpy(result, srcStr, len + 1);
      +
      4239  return result;
      +
      4240  }
      +
      4241  else
      +
      4242  {
      +
      4243  return VMA_NULL;
      +
      4244  }
      +
      4245 }
      +
      4246 
      +
      4247 static void VmaFreeString(const VkAllocationCallbacks* allocs, char* str)
      4248 {
      -
      4249  vec.erase(vec.begin() + index);
      -
      4250 }
      -
      4251 
      -
      4252 #else // #if VMA_USE_STL_VECTOR
      -
      4253 
      -
      4254 /* Class with interface compatible with subset of std::vector.
      -
      4255 T must be POD because constructors and destructors are not called and memcpy is
      -
      4256 used for these objects. */
      -
      4257 template<typename T, typename AllocatorT>
      -
      4258 class VmaVector
      +
      4249  if(str != VMA_NULL)
      +
      4250  {
      +
      4251  const size_t len = strlen(str);
      +
      4252  vma_delete_array(allocs, str, len + 1);
      +
      4253  }
      +
      4254 }
      +
      4255 
      +
      4256 // STL-compatible allocator.
      +
      4257 template<typename T>
      +
      4258 class VmaStlAllocator
      4259 {
      4260 public:
      -
      4261  typedef T value_type;
      -
      4262 
      -
      4263  VmaVector(const AllocatorT& allocator) :
      -
      4264  m_Allocator(allocator),
      -
      4265  m_pArray(VMA_NULL),
      -
      4266  m_Count(0),
      -
      4267  m_Capacity(0)
      -
      4268  {
      -
      4269  }
      -
      4270 
      -
      4271  VmaVector(size_t count, const AllocatorT& allocator) :
      -
      4272  m_Allocator(allocator),
      -
      4273  m_pArray(count ? (T*)VmaAllocateArray<T>(allocator.m_pCallbacks, count) : VMA_NULL),
      -
      4274  m_Count(count),
      -
      4275  m_Capacity(count)
      -
      4276  {
      -
      4277  }
      -
      4278 
      -
      4279  // This version of the constructor is here for compatibility with pre-C++14 std::vector.
      -
      4280  // value is unused.
      -
      4281  VmaVector(size_t count, const T& value, const AllocatorT& allocator)
      -
      4282  : VmaVector(count, allocator) {}
      -
      4283 
      -
      4284  VmaVector(const VmaVector<T, AllocatorT>& src) :
      -
      4285  m_Allocator(src.m_Allocator),
      -
      4286  m_pArray(src.m_Count ? (T*)VmaAllocateArray<T>(src.m_Allocator.m_pCallbacks, src.m_Count) : VMA_NULL),
      -
      4287  m_Count(src.m_Count),
      -
      4288  m_Capacity(src.m_Count)
      -
      4289  {
      -
      4290  if(m_Count != 0)
      -
      4291  {
      -
      4292  memcpy(m_pArray, src.m_pArray, m_Count * sizeof(T));
      -
      4293  }
      -
      4294  }
      -
      4295 
      -
      4296  ~VmaVector()
      -
      4297  {
      -
      4298  VmaFree(m_Allocator.m_pCallbacks, m_pArray);
      -
      4299  }
      -
      4300 
      -
      4301  VmaVector& operator=(const VmaVector<T, AllocatorT>& rhs)
      -
      4302  {
      -
      4303  if(&rhs != this)
      -
      4304  {
      -
      4305  resize(rhs.m_Count);
      -
      4306  if(m_Count != 0)
      -
      4307  {
      -
      4308  memcpy(m_pArray, rhs.m_pArray, m_Count * sizeof(T));
      -
      4309  }
      -
      4310  }
      -
      4311  return *this;
      -
      4312  }
      -
      4313 
      -
      4314  bool empty() const { return m_Count == 0; }
      -
      4315  size_t size() const { return m_Count; }
      -
      4316  T* data() { return m_pArray; }
      -
      4317  const T* data() const { return m_pArray; }
      -
      4318 
      -
      4319  T& operator[](size_t index)
      -
      4320  {
      -
      4321  VMA_HEAVY_ASSERT(index < m_Count);
      -
      4322  return m_pArray[index];
      -
      4323  }
      -
      4324  const T& operator[](size_t index) const
      -
      4325  {
      -
      4326  VMA_HEAVY_ASSERT(index < m_Count);
      -
      4327  return m_pArray[index];
      -
      4328  }
      -
      4329 
      -
      4330  T& front()
      -
      4331  {
      -
      4332  VMA_HEAVY_ASSERT(m_Count > 0);
      -
      4333  return m_pArray[0];
      -
      4334  }
      -
      4335  const T& front() const
      -
      4336  {
      -
      4337  VMA_HEAVY_ASSERT(m_Count > 0);
      -
      4338  return m_pArray[0];
      -
      4339  }
      -
      4340  T& back()
      -
      4341  {
      -
      4342  VMA_HEAVY_ASSERT(m_Count > 0);
      -
      4343  return m_pArray[m_Count - 1];
      -
      4344  }
      -
      4345  const T& back() const
      -
      4346  {
      -
      4347  VMA_HEAVY_ASSERT(m_Count > 0);
      -
      4348  return m_pArray[m_Count - 1];
      -
      4349  }
      -
      4350 
      -
      4351  void reserve(size_t newCapacity, bool freeMemory = false)
      -
      4352  {
      -
      4353  newCapacity = VMA_MAX(newCapacity, m_Count);
      -
      4354 
      -
      4355  if((newCapacity < m_Capacity) && !freeMemory)
      -
      4356  {
      -
      4357  newCapacity = m_Capacity;
      +
      4261  const VkAllocationCallbacks* const m_pCallbacks;
      +
      4262  typedef T value_type;
      +
      4263 
      +
      4264  VmaStlAllocator(const VkAllocationCallbacks* pCallbacks) : m_pCallbacks(pCallbacks) { }
      +
      4265  template<typename U> VmaStlAllocator(const VmaStlAllocator<U>& src) : m_pCallbacks(src.m_pCallbacks) { }
      +
      4266 
      +
      4267  T* allocate(size_t n) { return VmaAllocateArray<T>(m_pCallbacks, n); }
      +
      4268  void deallocate(T* p, size_t n) { VmaFree(m_pCallbacks, p); }
      +
      4269 
      +
      4270  template<typename U>
      +
      4271  bool operator==(const VmaStlAllocator<U>& rhs) const
      +
      4272  {
      +
      4273  return m_pCallbacks == rhs.m_pCallbacks;
      +
      4274  }
      +
      4275  template<typename U>
      +
      4276  bool operator!=(const VmaStlAllocator<U>& rhs) const
      +
      4277  {
      +
      4278  return m_pCallbacks != rhs.m_pCallbacks;
      +
      4279  }
      +
      4280 
      +
      4281  VmaStlAllocator& operator=(const VmaStlAllocator& x) = delete;
      +
      4282 };
      +
      4283 
      +
      4284 #if VMA_USE_STL_VECTOR
      +
      4285 
      +
      4286 #define VmaVector std::vector
      +
      4287 
      +
      4288 template<typename T, typename allocatorT>
      +
      4289 static void VmaVectorInsert(std::vector<T, allocatorT>& vec, size_t index, const T& item)
      +
      4290 {
      +
      4291  vec.insert(vec.begin() + index, item);
      +
      4292 }
      +
      4293 
      +
      4294 template<typename T, typename allocatorT>
      +
      4295 static void VmaVectorRemove(std::vector<T, allocatorT>& vec, size_t index)
      +
      4296 {
      +
      4297  vec.erase(vec.begin() + index);
      +
      4298 }
      +
      4299 
      +
      4300 #else // #if VMA_USE_STL_VECTOR
      +
      4301 
      +
      4302 /* Class with interface compatible with subset of std::vector.
      +
      4303 T must be POD because constructors and destructors are not called and memcpy is
      +
      4304 used for these objects. */
      +
      4305 template<typename T, typename AllocatorT>
      +
      4306 class VmaVector
      +
      4307 {
      +
      4308 public:
      +
      4309  typedef T value_type;
      +
      4310 
      +
      4311  VmaVector(const AllocatorT& allocator) :
      +
      4312  m_Allocator(allocator),
      +
      4313  m_pArray(VMA_NULL),
      +
      4314  m_Count(0),
      +
      4315  m_Capacity(0)
      +
      4316  {
      +
      4317  }
      +
      4318 
      +
      4319  VmaVector(size_t count, const AllocatorT& allocator) :
      +
      4320  m_Allocator(allocator),
      +
      4321  m_pArray(count ? (T*)VmaAllocateArray<T>(allocator.m_pCallbacks, count) : VMA_NULL),
      +
      4322  m_Count(count),
      +
      4323  m_Capacity(count)
      +
      4324  {
      +
      4325  }
      +
      4326 
      +
      4327  // This version of the constructor is here for compatibility with pre-C++14 std::vector.
      +
      4328  // value is unused.
      +
      4329  VmaVector(size_t count, const T& value, const AllocatorT& allocator)
      +
      4330  : VmaVector(count, allocator) {}
      +
      4331 
      +
      4332  VmaVector(const VmaVector<T, AllocatorT>& src) :
      +
      4333  m_Allocator(src.m_Allocator),
      +
      4334  m_pArray(src.m_Count ? (T*)VmaAllocateArray<T>(src.m_Allocator.m_pCallbacks, src.m_Count) : VMA_NULL),
      +
      4335  m_Count(src.m_Count),
      +
      4336  m_Capacity(src.m_Count)
      +
      4337  {
      +
      4338  if(m_Count != 0)
      +
      4339  {
      +
      4340  memcpy(m_pArray, src.m_pArray, m_Count * sizeof(T));
      +
      4341  }
      +
      4342  }
      +
      4343 
      +
      4344  ~VmaVector()
      +
      4345  {
      +
      4346  VmaFree(m_Allocator.m_pCallbacks, m_pArray);
      +
      4347  }
      +
      4348 
      +
      4349  VmaVector& operator=(const VmaVector<T, AllocatorT>& rhs)
      +
      4350  {
      +
      4351  if(&rhs != this)
      +
      4352  {
      +
      4353  resize(rhs.m_Count);
      +
      4354  if(m_Count != 0)
      +
      4355  {
      +
      4356  memcpy(m_pArray, rhs.m_pArray, m_Count * sizeof(T));
      +
      4357  }
      4358  }
      -
      4359 
      -
      4360  if(newCapacity != m_Capacity)
      -
      4361  {
      -
      4362  T* const newArray = newCapacity ? VmaAllocateArray<T>(m_Allocator, newCapacity) : VMA_NULL;
      -
      4363  if(m_Count != 0)
      -
      4364  {
      -
      4365  memcpy(newArray, m_pArray, m_Count * sizeof(T));
      -
      4366  }
      -
      4367  VmaFree(m_Allocator.m_pCallbacks, m_pArray);
      -
      4368  m_Capacity = newCapacity;
      -
      4369  m_pArray = newArray;
      -
      4370  }
      +
      4359  return *this;
      +
      4360  }
      +
      4361 
      +
      4362  bool empty() const { return m_Count == 0; }
      +
      4363  size_t size() const { return m_Count; }
      +
      4364  T* data() { return m_pArray; }
      +
      4365  const T* data() const { return m_pArray; }
      +
      4366 
      +
      4367  T& operator[](size_t index)
      +
      4368  {
      +
      4369  VMA_HEAVY_ASSERT(index < m_Count);
      +
      4370  return m_pArray[index];
      4371  }
      -
      4372 
      -
      4373  void resize(size_t newCount, bool freeMemory = false)
      -
      4374  {
      -
      4375  size_t newCapacity = m_Capacity;
      -
      4376  if(newCount > m_Capacity)
      -
      4377  {
      -
      4378  newCapacity = VMA_MAX(newCount, VMA_MAX(m_Capacity * 3 / 2, (size_t)8));
      -
      4379  }
      -
      4380  else if(freeMemory)
      -
      4381  {
      -
      4382  newCapacity = newCount;
      -
      4383  }
      -
      4384 
      -
      4385  if(newCapacity != m_Capacity)
      -
      4386  {
      -
      4387  T* const newArray = newCapacity ? VmaAllocateArray<T>(m_Allocator.m_pCallbacks, newCapacity) : VMA_NULL;
      -
      4388  const size_t elementsToCopy = VMA_MIN(m_Count, newCount);
      -
      4389  if(elementsToCopy != 0)
      -
      4390  {
      -
      4391  memcpy(newArray, m_pArray, elementsToCopy * sizeof(T));
      -
      4392  }
      -
      4393  VmaFree(m_Allocator.m_pCallbacks, m_pArray);
      -
      4394  m_Capacity = newCapacity;
      -
      4395  m_pArray = newArray;
      -
      4396  }
      -
      4397 
      -
      4398  m_Count = newCount;
      -
      4399  }
      -
      4400 
      -
      4401  void clear(bool freeMemory = false)
      -
      4402  {
      -
      4403  resize(0, freeMemory);
      -
      4404  }
      -
      4405 
      -
      4406  void insert(size_t index, const T& src)
      -
      4407  {
      -
      4408  VMA_HEAVY_ASSERT(index <= m_Count);
      -
      4409  const size_t oldCount = size();
      -
      4410  resize(oldCount + 1);
      -
      4411  if(index < oldCount)
      -
      4412  {
      -
      4413  memmove(m_pArray + (index + 1), m_pArray + index, (oldCount - index) * sizeof(T));
      -
      4414  }
      -
      4415  m_pArray[index] = src;
      -
      4416  }
      -
      4417 
      -
      4418  void remove(size_t index)
      -
      4419  {
      -
      4420  VMA_HEAVY_ASSERT(index < m_Count);
      -
      4421  const size_t oldCount = size();
      -
      4422  if(index < oldCount - 1)
      -
      4423  {
      -
      4424  memmove(m_pArray + index, m_pArray + (index + 1), (oldCount - index - 1) * sizeof(T));
      -
      4425  }
      -
      4426  resize(oldCount - 1);
      -
      4427  }
      -
      4428 
      -
      4429  void push_back(const T& src)
      -
      4430  {
      -
      4431  const size_t newIndex = size();
      -
      4432  resize(newIndex + 1);
      -
      4433  m_pArray[newIndex] = src;
      -
      4434  }
      -
      4435 
      -
      4436  void pop_back()
      -
      4437  {
      -
      4438  VMA_HEAVY_ASSERT(m_Count > 0);
      -
      4439  resize(size() - 1);
      -
      4440  }
      -
      4441 
      -
      4442  void push_front(const T& src)
      -
      4443  {
      -
      4444  insert(0, src);
      -
      4445  }
      -
      4446 
      -
      4447  void pop_front()
      -
      4448  {
      -
      4449  VMA_HEAVY_ASSERT(m_Count > 0);
      -
      4450  remove(0);
      -
      4451  }
      -
      4452 
      -
      4453  typedef T* iterator;
      -
      4454 
      -
      4455  iterator begin() { return m_pArray; }
      -
      4456  iterator end() { return m_pArray + m_Count; }
      -
      4457 
      -
      4458 private:
      -
      4459  AllocatorT m_Allocator;
      -
      4460  T* m_pArray;
      -
      4461  size_t m_Count;
      -
      4462  size_t m_Capacity;
      -
      4463 };
      -
      4464 
      -
      4465 template<typename T, typename allocatorT>
      -
      4466 static void VmaVectorInsert(VmaVector<T, allocatorT>& vec, size_t index, const T& item)
      -
      4467 {
      -
      4468  vec.insert(index, item);
      -
      4469 }
      -
      4470 
      -
      4471 template<typename T, typename allocatorT>
      -
      4472 static void VmaVectorRemove(VmaVector<T, allocatorT>& vec, size_t index)
      -
      4473 {
      -
      4474  vec.remove(index);
      -
      4475 }
      +
      4372  const T& operator[](size_t index) const
      +
      4373  {
      +
      4374  VMA_HEAVY_ASSERT(index < m_Count);
      +
      4375  return m_pArray[index];
      +
      4376  }
      +
      4377 
      +
      4378  T& front()
      +
      4379  {
      +
      4380  VMA_HEAVY_ASSERT(m_Count > 0);
      +
      4381  return m_pArray[0];
      +
      4382  }
      +
      4383  const T& front() const
      +
      4384  {
      +
      4385  VMA_HEAVY_ASSERT(m_Count > 0);
      +
      4386  return m_pArray[0];
      +
      4387  }
      +
      4388  T& back()
      +
      4389  {
      +
      4390  VMA_HEAVY_ASSERT(m_Count > 0);
      +
      4391  return m_pArray[m_Count - 1];
      +
      4392  }
      +
      4393  const T& back() const
      +
      4394  {
      +
      4395  VMA_HEAVY_ASSERT(m_Count > 0);
      +
      4396  return m_pArray[m_Count - 1];
      +
      4397  }
      +
      4398 
      +
      4399  void reserve(size_t newCapacity, bool freeMemory = false)
      +
      4400  {
      +
      4401  newCapacity = VMA_MAX(newCapacity, m_Count);
      +
      4402 
      +
      4403  if((newCapacity < m_Capacity) && !freeMemory)
      +
      4404  {
      +
      4405  newCapacity = m_Capacity;
      +
      4406  }
      +
      4407 
      +
      4408  if(newCapacity != m_Capacity)
      +
      4409  {
      +
      4410  T* const newArray = newCapacity ? VmaAllocateArray<T>(m_Allocator, newCapacity) : VMA_NULL;
      +
      4411  if(m_Count != 0)
      +
      4412  {
      +
      4413  memcpy(newArray, m_pArray, m_Count * sizeof(T));
      +
      4414  }
      +
      4415  VmaFree(m_Allocator.m_pCallbacks, m_pArray);
      +
      4416  m_Capacity = newCapacity;
      +
      4417  m_pArray = newArray;
      +
      4418  }
      +
      4419  }
      +
      4420 
      +
      4421  void resize(size_t newCount, bool freeMemory = false)
      +
      4422  {
      +
      4423  size_t newCapacity = m_Capacity;
      +
      4424  if(newCount > m_Capacity)
      +
      4425  {
      +
      4426  newCapacity = VMA_MAX(newCount, VMA_MAX(m_Capacity * 3 / 2, (size_t)8));
      +
      4427  }
      +
      4428  else if(freeMemory)
      +
      4429  {
      +
      4430  newCapacity = newCount;
      +
      4431  }
      +
      4432 
      +
      4433  if(newCapacity != m_Capacity)
      +
      4434  {
      +
      4435  T* const newArray = newCapacity ? VmaAllocateArray<T>(m_Allocator.m_pCallbacks, newCapacity) : VMA_NULL;
      +
      4436  const size_t elementsToCopy = VMA_MIN(m_Count, newCount);
      +
      4437  if(elementsToCopy != 0)
      +
      4438  {
      +
      4439  memcpy(newArray, m_pArray, elementsToCopy * sizeof(T));
      +
      4440  }
      +
      4441  VmaFree(m_Allocator.m_pCallbacks, m_pArray);
      +
      4442  m_Capacity = newCapacity;
      +
      4443  m_pArray = newArray;
      +
      4444  }
      +
      4445 
      +
      4446  m_Count = newCount;
      +
      4447  }
      +
      4448 
      +
      4449  void clear(bool freeMemory = false)
      +
      4450  {
      +
      4451  resize(0, freeMemory);
      +
      4452  }
      +
      4453 
      +
      4454  void insert(size_t index, const T& src)
      +
      4455  {
      +
      4456  VMA_HEAVY_ASSERT(index <= m_Count);
      +
      4457  const size_t oldCount = size();
      +
      4458  resize(oldCount + 1);
      +
      4459  if(index < oldCount)
      +
      4460  {
      +
      4461  memmove(m_pArray + (index + 1), m_pArray + index, (oldCount - index) * sizeof(T));
      +
      4462  }
      +
      4463  m_pArray[index] = src;
      +
      4464  }
      +
      4465 
      +
      4466  void remove(size_t index)
      +
      4467  {
      +
      4468  VMA_HEAVY_ASSERT(index < m_Count);
      +
      4469  const size_t oldCount = size();
      +
      4470  if(index < oldCount - 1)
      +
      4471  {
      +
      4472  memmove(m_pArray + index, m_pArray + (index + 1), (oldCount - index - 1) * sizeof(T));
      +
      4473  }
      +
      4474  resize(oldCount - 1);
      +
      4475  }
      4476 
      -
      4477 #endif // #if VMA_USE_STL_VECTOR
      -
      4478 
      -
      4479 template<typename CmpLess, typename VectorT>
      -
      4480 size_t VmaVectorInsertSorted(VectorT& vector, const typename VectorT::value_type& value)
      -
      4481 {
      -
      4482  const size_t indexToInsert = VmaBinaryFindFirstNotLess(
      -
      4483  vector.data(),
      -
      4484  vector.data() + vector.size(),
      -
      4485  value,
      -
      4486  CmpLess()) - vector.data();
      -
      4487  VmaVectorInsert(vector, indexToInsert, value);
      -
      4488  return indexToInsert;
      -
      4489 }
      -
      4490 
      -
      4491 template<typename CmpLess, typename VectorT>
      -
      4492 bool VmaVectorRemoveSorted(VectorT& vector, const typename VectorT::value_type& value)
      -
      4493 {
      -
      4494  CmpLess comparator;
      -
      4495  typename VectorT::iterator it = VmaBinaryFindFirstNotLess(
      -
      4496  vector.begin(),
      -
      4497  vector.end(),
      -
      4498  value,
      -
      4499  comparator);
      -
      4500  if((it != vector.end()) && !comparator(*it, value) && !comparator(value, *it))
      -
      4501  {
      -
      4502  size_t indexToRemove = it - vector.begin();
      -
      4503  VmaVectorRemove(vector, indexToRemove);
      -
      4504  return true;
      -
      4505  }
      -
      4506  return false;
      -
      4507 }
      -
      4508 
      -
      4510 // class VmaPoolAllocator
      -
      4511 
      -
      4512 /*
      -
      4513 Allocator for objects of type T using a list of arrays (pools) to speed up
      -
      4514 allocation. Number of elements that can be allocated is not bounded because
      -
      4515 allocator can create multiple blocks.
      -
      4516 */
      -
      4517 template<typename T>
      -
      4518 class VmaPoolAllocator
      -
      4519 {
      -
      4520  VMA_CLASS_NO_COPY(VmaPoolAllocator)
      -
      4521 public:
      -
      4522  VmaPoolAllocator(const VkAllocationCallbacks* pAllocationCallbacks, uint32_t firstBlockCapacity);
      -
      4523  ~VmaPoolAllocator();
      -
      4524  T* Alloc();
      -
      4525  void Free(T* ptr);
      +
      4477  void push_back(const T& src)
      +
      4478  {
      +
      4479  const size_t newIndex = size();
      +
      4480  resize(newIndex + 1);
      +
      4481  m_pArray[newIndex] = src;
      +
      4482  }
      +
      4483 
      +
      4484  void pop_back()
      +
      4485  {
      +
      4486  VMA_HEAVY_ASSERT(m_Count > 0);
      +
      4487  resize(size() - 1);
      +
      4488  }
      +
      4489 
      +
      4490  void push_front(const T& src)
      +
      4491  {
      +
      4492  insert(0, src);
      +
      4493  }
      +
      4494 
      +
      4495  void pop_front()
      +
      4496  {
      +
      4497  VMA_HEAVY_ASSERT(m_Count > 0);
      +
      4498  remove(0);
      +
      4499  }
      +
      4500 
      +
      4501  typedef T* iterator;
      +
      4502 
      +
      4503  iterator begin() { return m_pArray; }
      +
      4504  iterator end() { return m_pArray + m_Count; }
      +
      4505 
      +
      4506 private:
      +
      4507  AllocatorT m_Allocator;
      +
      4508  T* m_pArray;
      +
      4509  size_t m_Count;
      +
      4510  size_t m_Capacity;
      +
      4511 };
      +
      4512 
      +
      4513 template<typename T, typename allocatorT>
      +
      4514 static void VmaVectorInsert(VmaVector<T, allocatorT>& vec, size_t index, const T& item)
      +
      4515 {
      +
      4516  vec.insert(index, item);
      +
      4517 }
      +
      4518 
      +
      4519 template<typename T, typename allocatorT>
      +
      4520 static void VmaVectorRemove(VmaVector<T, allocatorT>& vec, size_t index)
      +
      4521 {
      +
      4522  vec.remove(index);
      +
      4523 }
      +
      4524 
      +
      4525 #endif // #if VMA_USE_STL_VECTOR
      4526 
      -
      4527 private:
      -
      4528  union Item
      -
      4529  {
      -
      4530  uint32_t NextFreeIndex;
      -
      4531  alignas(T) char Value[sizeof(T)];
      -
      4532  };
      -
      4533 
      -
      4534  struct ItemBlock
      -
      4535  {
      -
      4536  Item* pItems;
      -
      4537  uint32_t Capacity;
      -
      4538  uint32_t FirstFreeIndex;
      -
      4539  };
      -
      4540 
      -
      4541  const VkAllocationCallbacks* m_pAllocationCallbacks;
      -
      4542  const uint32_t m_FirstBlockCapacity;
      -
      4543  VmaVector< ItemBlock, VmaStlAllocator<ItemBlock> > m_ItemBlocks;
      -
      4544 
      -
      4545  ItemBlock& CreateNewBlock();
      -
      4546 };
      -
      4547 
      -
      4548 template<typename T>
      -
      4549 VmaPoolAllocator<T>::VmaPoolAllocator(const VkAllocationCallbacks* pAllocationCallbacks, uint32_t firstBlockCapacity) :
      -
      4550  m_pAllocationCallbacks(pAllocationCallbacks),
      -
      4551  m_FirstBlockCapacity(firstBlockCapacity),
      -
      4552  m_ItemBlocks(VmaStlAllocator<ItemBlock>(pAllocationCallbacks))
      -
      4553 {
      -
      4554  VMA_ASSERT(m_FirstBlockCapacity > 1);
      +
      4527 template<typename CmpLess, typename VectorT>
      +
      4528 size_t VmaVectorInsertSorted(VectorT& vector, const typename VectorT::value_type& value)
      +
      4529 {
      +
      4530  const size_t indexToInsert = VmaBinaryFindFirstNotLess(
      +
      4531  vector.data(),
      +
      4532  vector.data() + vector.size(),
      +
      4533  value,
      +
      4534  CmpLess()) - vector.data();
      +
      4535  VmaVectorInsert(vector, indexToInsert, value);
      +
      4536  return indexToInsert;
      +
      4537 }
      +
      4538 
      +
      4539 template<typename CmpLess, typename VectorT>
      +
      4540 bool VmaVectorRemoveSorted(VectorT& vector, const typename VectorT::value_type& value)
      +
      4541 {
      +
      4542  CmpLess comparator;
      +
      4543  typename VectorT::iterator it = VmaBinaryFindFirstNotLess(
      +
      4544  vector.begin(),
      +
      4545  vector.end(),
      +
      4546  value,
      +
      4547  comparator);
      +
      4548  if((it != vector.end()) && !comparator(*it, value) && !comparator(value, *it))
      +
      4549  {
      +
      4550  size_t indexToRemove = it - vector.begin();
      +
      4551  VmaVectorRemove(vector, indexToRemove);
      +
      4552  return true;
      +
      4553  }
      +
      4554  return false;
      4555 }
      4556 
      -
      4557 template<typename T>
      -
      4558 VmaPoolAllocator<T>::~VmaPoolAllocator()
      -
      4559 {
      -
      4560  for(size_t i = m_ItemBlocks.size(); i--; )
      -
      4561  vma_delete_array(m_pAllocationCallbacks, m_ItemBlocks[i].pItems, m_ItemBlocks[i].Capacity);
      -
      4562  m_ItemBlocks.clear();
      -
      4563 }
      -
      4564 
      +
      4558 // class VmaPoolAllocator
      +
      4559 
      +
      4560 /*
      +
      4561 Allocator for objects of type T using a list of arrays (pools) to speed up
      +
      4562 allocation. Number of elements that can be allocated is not bounded because
      +
      4563 allocator can create multiple blocks.
      +
      4564 */
      4565 template<typename T>
      -
      4566 T* VmaPoolAllocator<T>::Alloc()
      +
      4566 class VmaPoolAllocator
      4567 {
      -
      4568  for(size_t i = m_ItemBlocks.size(); i--; )
      -
      4569  {
      -
      4570  ItemBlock& block = m_ItemBlocks[i];
      -
      4571  // This block has some free items: Use first one.
      -
      4572  if(block.FirstFreeIndex != UINT32_MAX)
      -
      4573  {
      -
      4574  Item* const pItem = &block.pItems[block.FirstFreeIndex];
      -
      4575  block.FirstFreeIndex = pItem->NextFreeIndex;
      -
      4576  T* result = (T*)&pItem->Value;
      -
      4577  new(result)T(); // Explicit constructor call.
      -
      4578  return result;
      -
      4579  }
      -
      4580  }
      +
      4568  VMA_CLASS_NO_COPY(VmaPoolAllocator)
      +
      4569 public:
      +
      4570  VmaPoolAllocator(const VkAllocationCallbacks* pAllocationCallbacks, uint32_t firstBlockCapacity);
      +
      4571  ~VmaPoolAllocator();
      +
      4572  T* Alloc();
      +
      4573  void Free(T* ptr);
      +
      4574 
      +
      4575 private:
      +
      4576  union Item
      +
      4577  {
      +
      4578  uint32_t NextFreeIndex;
      +
      4579  alignas(T) char Value[sizeof(T)];
      +
      4580  };
      4581 
      -
      4582  // No block has free item: Create new one and use it.
      -
      4583  ItemBlock& newBlock = CreateNewBlock();
      -
      4584  Item* const pItem = &newBlock.pItems[0];
      -
      4585  newBlock.FirstFreeIndex = pItem->NextFreeIndex;
      -
      4586  T* result = (T*)&pItem->Value;
      -
      4587  new(result)T(); // Explicit constructor call.
      -
      4588  return result;
      -
      4589 }
      -
      4590 
      -
      4591 template<typename T>
      -
      4592 void VmaPoolAllocator<T>::Free(T* ptr)
      -
      4593 {
      -
      4594  // Search all memory blocks to find ptr.
      -
      4595  for(size_t i = m_ItemBlocks.size(); i--; )
      -
      4596  {
      -
      4597  ItemBlock& block = m_ItemBlocks[i];
      -
      4598 
      -
      4599  // Casting to union.
      -
      4600  Item* pItemPtr;
      -
      4601  memcpy(&pItemPtr, &ptr, sizeof(pItemPtr));
      -
      4602 
      -
      4603  // Check if pItemPtr is in address range of this block.
      -
      4604  if((pItemPtr >= block.pItems) && (pItemPtr < block.pItems + block.Capacity))
      -
      4605  {
      -
      4606  ptr->~T(); // Explicit destructor call.
      -
      4607  const uint32_t index = static_cast<uint32_t>(pItemPtr - block.pItems);
      -
      4608  pItemPtr->NextFreeIndex = block.FirstFreeIndex;
      -
      4609  block.FirstFreeIndex = index;
      -
      4610  return;
      -
      4611  }
      -
      4612  }
      -
      4613  VMA_ASSERT(0 && "Pointer doesn't belong to this memory pool.");
      -
      4614 }
      -
      4615 
      -
      4616 template<typename T>
      -
      4617 typename VmaPoolAllocator<T>::ItemBlock& VmaPoolAllocator<T>::CreateNewBlock()
      -
      4618 {
      -
      4619  const uint32_t newBlockCapacity = m_ItemBlocks.empty() ?
      -
      4620  m_FirstBlockCapacity : m_ItemBlocks.back().Capacity * 3 / 2;
      -
      4621 
      -
      4622  const ItemBlock newBlock = {
      -
      4623  vma_new_array(m_pAllocationCallbacks, Item, newBlockCapacity),
      -
      4624  newBlockCapacity,
      -
      4625  0 };
      -
      4626 
      -
      4627  m_ItemBlocks.push_back(newBlock);
      -
      4628 
      -
      4629  // Setup singly-linked list of all free items in this block.
      -
      4630  for(uint32_t i = 0; i < newBlockCapacity - 1; ++i)
      -
      4631  newBlock.pItems[i].NextFreeIndex = i + 1;
      -
      4632  newBlock.pItems[newBlockCapacity - 1].NextFreeIndex = UINT32_MAX;
      -
      4633  return m_ItemBlocks.back();
      -
      4634 }
      -
      4635 
      -
      4637 // class VmaRawList, VmaList
      +
      4582  struct ItemBlock
      +
      4583  {
      +
      4584  Item* pItems;
      +
      4585  uint32_t Capacity;
      +
      4586  uint32_t FirstFreeIndex;
      +
      4587  };
      +
      4588 
      +
      4589  const VkAllocationCallbacks* m_pAllocationCallbacks;
      +
      4590  const uint32_t m_FirstBlockCapacity;
      +
      4591  VmaVector< ItemBlock, VmaStlAllocator<ItemBlock> > m_ItemBlocks;
      +
      4592 
      +
      4593  ItemBlock& CreateNewBlock();
      +
      4594 };
      +
      4595 
      +
      4596 template<typename T>
      +
      4597 VmaPoolAllocator<T>::VmaPoolAllocator(const VkAllocationCallbacks* pAllocationCallbacks, uint32_t firstBlockCapacity) :
      +
      4598  m_pAllocationCallbacks(pAllocationCallbacks),
      +
      4599  m_FirstBlockCapacity(firstBlockCapacity),
      +
      4600  m_ItemBlocks(VmaStlAllocator<ItemBlock>(pAllocationCallbacks))
      +
      4601 {
      +
      4602  VMA_ASSERT(m_FirstBlockCapacity > 1);
      +
      4603 }
      +
      4604 
      +
      4605 template<typename T>
      +
      4606 VmaPoolAllocator<T>::~VmaPoolAllocator()
      +
      4607 {
      +
      4608  for(size_t i = m_ItemBlocks.size(); i--; )
      +
      4609  vma_delete_array(m_pAllocationCallbacks, m_ItemBlocks[i].pItems, m_ItemBlocks[i].Capacity);
      +
      4610  m_ItemBlocks.clear();
      +
      4611 }
      +
      4612 
      +
      4613 template<typename T>
      +
      4614 T* VmaPoolAllocator<T>::Alloc()
      +
      4615 {
      +
      4616  for(size_t i = m_ItemBlocks.size(); i--; )
      +
      4617  {
      +
      4618  ItemBlock& block = m_ItemBlocks[i];
      +
      4619  // This block has some free items: Use first one.
      +
      4620  if(block.FirstFreeIndex != UINT32_MAX)
      +
      4621  {
      +
      4622  Item* const pItem = &block.pItems[block.FirstFreeIndex];
      +
      4623  block.FirstFreeIndex = pItem->NextFreeIndex;
      +
      4624  T* result = (T*)&pItem->Value;
      +
      4625  new(result)T(); // Explicit constructor call.
      +
      4626  return result;
      +
      4627  }
      +
      4628  }
      +
      4629 
      +
      4630  // No block has free item: Create new one and use it.
      +
      4631  ItemBlock& newBlock = CreateNewBlock();
      +
      4632  Item* const pItem = &newBlock.pItems[0];
      +
      4633  newBlock.FirstFreeIndex = pItem->NextFreeIndex;
      +
      4634  T* result = (T*)&pItem->Value;
      +
      4635  new(result)T(); // Explicit constructor call.
      +
      4636  return result;
      +
      4637 }
      4638 
      -
      4639 #if VMA_USE_STL_LIST
      -
      4640 
      -
      4641 #define VmaList std::list
      -
      4642 
      -
      4643 #else // #if VMA_USE_STL_LIST
      -
      4644 
      -
      4645 template<typename T>
      -
      4646 struct VmaListItem
      -
      4647 {
      -
      4648  VmaListItem* pPrev;
      -
      4649  VmaListItem* pNext;
      -
      4650  T Value;
      -
      4651 };
      -
      4652 
      -
      4653 // Doubly linked list.
      -
      4654 template<typename T>
      -
      4655 class VmaRawList
      -
      4656 {
      -
      4657  VMA_CLASS_NO_COPY(VmaRawList)
      -
      4658 public:
      -
      4659  typedef VmaListItem<T> ItemType;
      -
      4660 
      -
      4661  VmaRawList(const VkAllocationCallbacks* pAllocationCallbacks);
      -
      4662  ~VmaRawList();
      -
      4663  void Clear();
      -
      4664 
      -
      4665  size_t GetCount() const { return m_Count; }
      -
      4666  bool IsEmpty() const { return m_Count == 0; }
      -
      4667 
      -
      4668  ItemType* Front() { return m_pFront; }
      -
      4669  const ItemType* Front() const { return m_pFront; }
      -
      4670  ItemType* Back() { return m_pBack; }
      -
      4671  const ItemType* Back() const { return m_pBack; }
      -
      4672 
      -
      4673  ItemType* PushBack();
      -
      4674  ItemType* PushFront();
      -
      4675  ItemType* PushBack(const T& value);
      -
      4676  ItemType* PushFront(const T& value);
      -
      4677  void PopBack();
      -
      4678  void PopFront();
      -
      4679 
      -
      4680  // Item can be null - it means PushBack.
      -
      4681  ItemType* InsertBefore(ItemType* pItem);
      -
      4682  // Item can be null - it means PushFront.
      -
      4683  ItemType* InsertAfter(ItemType* pItem);
      -
      4684 
      -
      4685  ItemType* InsertBefore(ItemType* pItem, const T& value);
      -
      4686  ItemType* InsertAfter(ItemType* pItem, const T& value);
      -
      4687 
      -
      4688  void Remove(ItemType* pItem);
      -
      4689 
      -
      4690 private:
      -
      4691  const VkAllocationCallbacks* const m_pAllocationCallbacks;
      -
      4692  VmaPoolAllocator<ItemType> m_ItemAllocator;
      -
      4693  ItemType* m_pFront;
      -
      4694  ItemType* m_pBack;
      -
      4695  size_t m_Count;
      -
      4696 };
      -
      4697 
      -
      4698 template<typename T>
      -
      4699 VmaRawList<T>::VmaRawList(const VkAllocationCallbacks* pAllocationCallbacks) :
      -
      4700  m_pAllocationCallbacks(pAllocationCallbacks),
      -
      4701  m_ItemAllocator(pAllocationCallbacks, 128),
      -
      4702  m_pFront(VMA_NULL),
      -
      4703  m_pBack(VMA_NULL),
      -
      4704  m_Count(0)
      -
      4705 {
      -
      4706 }
      -
      4707 
      -
      4708 template<typename T>
      -
      4709 VmaRawList<T>::~VmaRawList()
      -
      4710 {
      -
      4711  // Intentionally not calling Clear, because that would be unnecessary
      -
      4712  // computations to return all items to m_ItemAllocator as free.
      -
      4713 }
      -
      4714 
      -
      4715 template<typename T>
      -
      4716 void VmaRawList<T>::Clear()
      -
      4717 {
      -
      4718  if(IsEmpty() == false)
      -
      4719  {
      -
      4720  ItemType* pItem = m_pBack;
      -
      4721  while(pItem != VMA_NULL)
      -
      4722  {
      -
      4723  ItemType* const pPrevItem = pItem->pPrev;
      -
      4724  m_ItemAllocator.Free(pItem);
      -
      4725  pItem = pPrevItem;
      -
      4726  }
      -
      4727  m_pFront = VMA_NULL;
      -
      4728  m_pBack = VMA_NULL;
      -
      4729  m_Count = 0;
      -
      4730  }
      -
      4731 }
      +
      4639 template<typename T>
      +
      4640 void VmaPoolAllocator<T>::Free(T* ptr)
      +
      4641 {
      +
      4642  // Search all memory blocks to find ptr.
      +
      4643  for(size_t i = m_ItemBlocks.size(); i--; )
      +
      4644  {
      +
      4645  ItemBlock& block = m_ItemBlocks[i];
      +
      4646 
      +
      4647  // Casting to union.
      +
      4648  Item* pItemPtr;
      +
      4649  memcpy(&pItemPtr, &ptr, sizeof(pItemPtr));
      +
      4650 
      +
      4651  // Check if pItemPtr is in address range of this block.
      +
      4652  if((pItemPtr >= block.pItems) && (pItemPtr < block.pItems + block.Capacity))
      +
      4653  {
      +
      4654  ptr->~T(); // Explicit destructor call.
      +
      4655  const uint32_t index = static_cast<uint32_t>(pItemPtr - block.pItems);
      +
      4656  pItemPtr->NextFreeIndex = block.FirstFreeIndex;
      +
      4657  block.FirstFreeIndex = index;
      +
      4658  return;
      +
      4659  }
      +
      4660  }
      +
      4661  VMA_ASSERT(0 && "Pointer doesn't belong to this memory pool.");
      +
      4662 }
      +
      4663 
      +
      4664 template<typename T>
      +
      4665 typename VmaPoolAllocator<T>::ItemBlock& VmaPoolAllocator<T>::CreateNewBlock()
      +
      4666 {
      +
      4667  const uint32_t newBlockCapacity = m_ItemBlocks.empty() ?
      +
      4668  m_FirstBlockCapacity : m_ItemBlocks.back().Capacity * 3 / 2;
      +
      4669 
      +
      4670  const ItemBlock newBlock = {
      +
      4671  vma_new_array(m_pAllocationCallbacks, Item, newBlockCapacity),
      +
      4672  newBlockCapacity,
      +
      4673  0 };
      +
      4674 
      +
      4675  m_ItemBlocks.push_back(newBlock);
      +
      4676 
      +
      4677  // Setup singly-linked list of all free items in this block.
      +
      4678  for(uint32_t i = 0; i < newBlockCapacity - 1; ++i)
      +
      4679  newBlock.pItems[i].NextFreeIndex = i + 1;
      +
      4680  newBlock.pItems[newBlockCapacity - 1].NextFreeIndex = UINT32_MAX;
      +
      4681  return m_ItemBlocks.back();
      +
      4682 }
      +
      4683 
      +
      4685 // class VmaRawList, VmaList
      +
      4686 
      +
      4687 #if VMA_USE_STL_LIST
      +
      4688 
      +
      4689 #define VmaList std::list
      +
      4690 
      +
      4691 #else // #if VMA_USE_STL_LIST
      +
      4692 
      +
      4693 template<typename T>
      +
      4694 struct VmaListItem
      +
      4695 {
      +
      4696  VmaListItem* pPrev;
      +
      4697  VmaListItem* pNext;
      +
      4698  T Value;
      +
      4699 };
      +
      4700 
      +
      4701 // Doubly linked list.
      +
      4702 template<typename T>
      +
      4703 class VmaRawList
      +
      4704 {
      +
      4705  VMA_CLASS_NO_COPY(VmaRawList)
      +
      4706 public:
      +
      4707  typedef VmaListItem<T> ItemType;
      +
      4708 
      +
      4709  VmaRawList(const VkAllocationCallbacks* pAllocationCallbacks);
      +
      4710  ~VmaRawList();
      +
      4711  void Clear();
      +
      4712 
      +
      4713  size_t GetCount() const { return m_Count; }
      +
      4714  bool IsEmpty() const { return m_Count == 0; }
      +
      4715 
      +
      4716  ItemType* Front() { return m_pFront; }
      +
      4717  const ItemType* Front() const { return m_pFront; }
      +
      4718  ItemType* Back() { return m_pBack; }
      +
      4719  const ItemType* Back() const { return m_pBack; }
      +
      4720 
      +
      4721  ItemType* PushBack();
      +
      4722  ItemType* PushFront();
      +
      4723  ItemType* PushBack(const T& value);
      +
      4724  ItemType* PushFront(const T& value);
      +
      4725  void PopBack();
      +
      4726  void PopFront();
      +
      4727 
      +
      4728  // Item can be null - it means PushBack.
      +
      4729  ItemType* InsertBefore(ItemType* pItem);
      +
      4730  // Item can be null - it means PushFront.
      +
      4731  ItemType* InsertAfter(ItemType* pItem);
      4732 
      -
      4733 template<typename T>
      -
      4734 VmaListItem<T>* VmaRawList<T>::PushBack()
      -
      4735 {
      -
      4736  ItemType* const pNewItem = m_ItemAllocator.Alloc();
      -
      4737  pNewItem->pNext = VMA_NULL;
      -
      4738  if(IsEmpty())
      -
      4739  {
      -
      4740  pNewItem->pPrev = VMA_NULL;
      -
      4741  m_pFront = pNewItem;
      -
      4742  m_pBack = pNewItem;
      -
      4743  m_Count = 1;
      -
      4744  }
      -
      4745  else
      -
      4746  {
      -
      4747  pNewItem->pPrev = m_pBack;
      -
      4748  m_pBack->pNext = pNewItem;
      -
      4749  m_pBack = pNewItem;
      -
      4750  ++m_Count;
      -
      4751  }
      -
      4752  return pNewItem;
      -
      4753 }
      -
      4754 
      -
      4755 template<typename T>
      -
      4756 VmaListItem<T>* VmaRawList<T>::PushFront()
      -
      4757 {
      -
      4758  ItemType* const pNewItem = m_ItemAllocator.Alloc();
      -
      4759  pNewItem->pPrev = VMA_NULL;
      -
      4760  if(IsEmpty())
      -
      4761  {
      -
      4762  pNewItem->pNext = VMA_NULL;
      -
      4763  m_pFront = pNewItem;
      -
      4764  m_pBack = pNewItem;
      -
      4765  m_Count = 1;
      -
      4766  }
      -
      4767  else
      -
      4768  {
      -
      4769  pNewItem->pNext = m_pFront;
      -
      4770  m_pFront->pPrev = pNewItem;
      -
      4771  m_pFront = pNewItem;
      -
      4772  ++m_Count;
      -
      4773  }
      -
      4774  return pNewItem;
      -
      4775 }
      -
      4776 
      -
      4777 template<typename T>
      -
      4778 VmaListItem<T>* VmaRawList<T>::PushBack(const T& value)
      -
      4779 {
      -
      4780  ItemType* const pNewItem = PushBack();
      -
      4781  pNewItem->Value = value;
      -
      4782  return pNewItem;
      -
      4783 }
      -
      4784 
      -
      4785 template<typename T>
      -
      4786 VmaListItem<T>* VmaRawList<T>::PushFront(const T& value)
      -
      4787 {
      -
      4788  ItemType* const pNewItem = PushFront();
      -
      4789  pNewItem->Value = value;
      -
      4790  return pNewItem;
      -
      4791 }
      -
      4792 
      -
      4793 template<typename T>
      -
      4794 void VmaRawList<T>::PopBack()
      -
      4795 {
      -
      4796  VMA_HEAVY_ASSERT(m_Count > 0);
      -
      4797  ItemType* const pBackItem = m_pBack;
      -
      4798  ItemType* const pPrevItem = pBackItem->pPrev;
      -
      4799  if(pPrevItem != VMA_NULL)
      -
      4800  {
      -
      4801  pPrevItem->pNext = VMA_NULL;
      -
      4802  }
      -
      4803  m_pBack = pPrevItem;
      -
      4804  m_ItemAllocator.Free(pBackItem);
      -
      4805  --m_Count;
      -
      4806 }
      -
      4807 
      -
      4808 template<typename T>
      -
      4809 void VmaRawList<T>::PopFront()
      -
      4810 {
      -
      4811  VMA_HEAVY_ASSERT(m_Count > 0);
      -
      4812  ItemType* const pFrontItem = m_pFront;
      -
      4813  ItemType* const pNextItem = pFrontItem->pNext;
      -
      4814  if(pNextItem != VMA_NULL)
      -
      4815  {
      -
      4816  pNextItem->pPrev = VMA_NULL;
      -
      4817  }
      -
      4818  m_pFront = pNextItem;
      -
      4819  m_ItemAllocator.Free(pFrontItem);
      -
      4820  --m_Count;
      -
      4821 }
      -
      4822 
      -
      4823 template<typename T>
      -
      4824 void VmaRawList<T>::Remove(ItemType* pItem)
      -
      4825 {
      -
      4826  VMA_HEAVY_ASSERT(pItem != VMA_NULL);
      -
      4827  VMA_HEAVY_ASSERT(m_Count > 0);
      -
      4828 
      -
      4829  if(pItem->pPrev != VMA_NULL)
      -
      4830  {
      -
      4831  pItem->pPrev->pNext = pItem->pNext;
      -
      4832  }
      -
      4833  else
      -
      4834  {
      -
      4835  VMA_HEAVY_ASSERT(m_pFront == pItem);
      -
      4836  m_pFront = pItem->pNext;
      -
      4837  }
      -
      4838 
      -
      4839  if(pItem->pNext != VMA_NULL)
      -
      4840  {
      -
      4841  pItem->pNext->pPrev = pItem->pPrev;
      -
      4842  }
      -
      4843  else
      -
      4844  {
      -
      4845  VMA_HEAVY_ASSERT(m_pBack == pItem);
      -
      4846  m_pBack = pItem->pPrev;
      -
      4847  }
      -
      4848 
      -
      4849  m_ItemAllocator.Free(pItem);
      -
      4850  --m_Count;
      -
      4851 }
      -
      4852 
      -
      4853 template<typename T>
      -
      4854 VmaListItem<T>* VmaRawList<T>::InsertBefore(ItemType* pItem)
      -
      4855 {
      -
      4856  if(pItem != VMA_NULL)
      -
      4857  {
      -
      4858  ItemType* const prevItem = pItem->pPrev;
      -
      4859  ItemType* const newItem = m_ItemAllocator.Alloc();
      -
      4860  newItem->pPrev = prevItem;
      -
      4861  newItem->pNext = pItem;
      -
      4862  pItem->pPrev = newItem;
      -
      4863  if(prevItem != VMA_NULL)
      -
      4864  {
      -
      4865  prevItem->pNext = newItem;
      -
      4866  }
      -
      4867  else
      -
      4868  {
      -
      4869  VMA_HEAVY_ASSERT(m_pFront == pItem);
      -
      4870  m_pFront = newItem;
      -
      4871  }
      -
      4872  ++m_Count;
      -
      4873  return newItem;
      -
      4874  }
      -
      4875  else
      -
      4876  return PushBack();
      -
      4877 }
      -
      4878 
      -
      4879 template<typename T>
      -
      4880 VmaListItem<T>* VmaRawList<T>::InsertAfter(ItemType* pItem)
      -
      4881 {
      -
      4882  if(pItem != VMA_NULL)
      -
      4883  {
      -
      4884  ItemType* const nextItem = pItem->pNext;
      -
      4885  ItemType* const newItem = m_ItemAllocator.Alloc();
      -
      4886  newItem->pNext = nextItem;
      -
      4887  newItem->pPrev = pItem;
      -
      4888  pItem->pNext = newItem;
      -
      4889  if(nextItem != VMA_NULL)
      -
      4890  {
      -
      4891  nextItem->pPrev = newItem;
      -
      4892  }
      -
      4893  else
      -
      4894  {
      -
      4895  VMA_HEAVY_ASSERT(m_pBack == pItem);
      -
      4896  m_pBack = newItem;
      -
      4897  }
      -
      4898  ++m_Count;
      -
      4899  return newItem;
      -
      4900  }
      -
      4901  else
      -
      4902  return PushFront();
      -
      4903 }
      -
      4904 
      -
      4905 template<typename T>
      -
      4906 VmaListItem<T>* VmaRawList<T>::InsertBefore(ItemType* pItem, const T& value)
      -
      4907 {
      -
      4908  ItemType* const newItem = InsertBefore(pItem);
      -
      4909  newItem->Value = value;
      -
      4910  return newItem;
      -
      4911 }
      -
      4912 
      -
      4913 template<typename T>
      -
      4914 VmaListItem<T>* VmaRawList<T>::InsertAfter(ItemType* pItem, const T& value)
      -
      4915 {
      -
      4916  ItemType* const newItem = InsertAfter(pItem);
      -
      4917  newItem->Value = value;
      -
      4918  return newItem;
      -
      4919 }
      -
      4920 
      -
      4921 template<typename T, typename AllocatorT>
      -
      4922 class VmaList
      -
      4923 {
      -
      4924  VMA_CLASS_NO_COPY(VmaList)
      -
      4925 public:
      -
      4926  class iterator
      -
      4927  {
      -
      4928  public:
      -
      4929  iterator() :
      -
      4930  m_pList(VMA_NULL),
      -
      4931  m_pItem(VMA_NULL)
      -
      4932  {
      -
      4933  }
      -
      4934 
      -
      4935  T& operator*() const
      -
      4936  {
      -
      4937  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
      -
      4938  return m_pItem->Value;
      -
      4939  }
      -
      4940  T* operator->() const
      -
      4941  {
      -
      4942  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
      -
      4943  return &m_pItem->Value;
      -
      4944  }
      -
      4945 
      -
      4946  iterator& operator++()
      -
      4947  {
      -
      4948  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
      -
      4949  m_pItem = m_pItem->pNext;
      -
      4950  return *this;
      -
      4951  }
      -
      4952  iterator& operator--()
      -
      4953  {
      -
      4954  if(m_pItem != VMA_NULL)
      -
      4955  {
      -
      4956  m_pItem = m_pItem->pPrev;
      -
      4957  }
      -
      4958  else
      -
      4959  {
      -
      4960  VMA_HEAVY_ASSERT(!m_pList->IsEmpty());
      -
      4961  m_pItem = m_pList->Back();
      -
      4962  }
      -
      4963  return *this;
      -
      4964  }
      -
      4965 
      -
      4966  iterator operator++(int)
      -
      4967  {
      -
      4968  iterator result = *this;
      -
      4969  ++*this;
      -
      4970  return result;
      -
      4971  }
      -
      4972  iterator operator--(int)
      -
      4973  {
      -
      4974  iterator result = *this;
      -
      4975  --*this;
      -
      4976  return result;
      -
      4977  }
      -
      4978 
      -
      4979  bool operator==(const iterator& rhs) const
      -
      4980  {
      -
      4981  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
      -
      4982  return m_pItem == rhs.m_pItem;
      -
      4983  }
      -
      4984  bool operator!=(const iterator& rhs) const
      -
      4985  {
      -
      4986  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
      -
      4987  return m_pItem != rhs.m_pItem;
      -
      4988  }
      -
      4989 
      -
      4990  private:
      -
      4991  VmaRawList<T>* m_pList;
      -
      4992  VmaListItem<T>* m_pItem;
      +
      4733  ItemType* InsertBefore(ItemType* pItem, const T& value);
      +
      4734  ItemType* InsertAfter(ItemType* pItem, const T& value);
      +
      4735 
      +
      4736  void Remove(ItemType* pItem);
      +
      4737 
      +
      4738 private:
      +
      4739  const VkAllocationCallbacks* const m_pAllocationCallbacks;
      +
      4740  VmaPoolAllocator<ItemType> m_ItemAllocator;
      +
      4741  ItemType* m_pFront;
      +
      4742  ItemType* m_pBack;
      +
      4743  size_t m_Count;
      +
      4744 };
      +
      4745 
      +
      4746 template<typename T>
      +
      4747 VmaRawList<T>::VmaRawList(const VkAllocationCallbacks* pAllocationCallbacks) :
      +
      4748  m_pAllocationCallbacks(pAllocationCallbacks),
      +
      4749  m_ItemAllocator(pAllocationCallbacks, 128),
      +
      4750  m_pFront(VMA_NULL),
      +
      4751  m_pBack(VMA_NULL),
      +
      4752  m_Count(0)
      +
      4753 {
      +
      4754 }
      +
      4755 
      +
      4756 template<typename T>
      +
      4757 VmaRawList<T>::~VmaRawList()
      +
      4758 {
      +
      4759  // Intentionally not calling Clear, because that would be unnecessary
      +
      4760  // computations to return all items to m_ItemAllocator as free.
      +
      4761 }
      +
      4762 
      +
      4763 template<typename T>
      +
      4764 void VmaRawList<T>::Clear()
      +
      4765 {
      +
      4766  if(IsEmpty() == false)
      +
      4767  {
      +
      4768  ItemType* pItem = m_pBack;
      +
      4769  while(pItem != VMA_NULL)
      +
      4770  {
      +
      4771  ItemType* const pPrevItem = pItem->pPrev;
      +
      4772  m_ItemAllocator.Free(pItem);
      +
      4773  pItem = pPrevItem;
      +
      4774  }
      +
      4775  m_pFront = VMA_NULL;
      +
      4776  m_pBack = VMA_NULL;
      +
      4777  m_Count = 0;
      +
      4778  }
      +
      4779 }
      +
      4780 
      +
      4781 template<typename T>
      +
      4782 VmaListItem<T>* VmaRawList<T>::PushBack()
      +
      4783 {
      +
      4784  ItemType* const pNewItem = m_ItemAllocator.Alloc();
      +
      4785  pNewItem->pNext = VMA_NULL;
      +
      4786  if(IsEmpty())
      +
      4787  {
      +
      4788  pNewItem->pPrev = VMA_NULL;
      +
      4789  m_pFront = pNewItem;
      +
      4790  m_pBack = pNewItem;
      +
      4791  m_Count = 1;
      +
      4792  }
      +
      4793  else
      +
      4794  {
      +
      4795  pNewItem->pPrev = m_pBack;
      +
      4796  m_pBack->pNext = pNewItem;
      +
      4797  m_pBack = pNewItem;
      +
      4798  ++m_Count;
      +
      4799  }
      +
      4800  return pNewItem;
      +
      4801 }
      +
      4802 
      +
      4803 template<typename T>
      +
      4804 VmaListItem<T>* VmaRawList<T>::PushFront()
      +
      4805 {
      +
      4806  ItemType* const pNewItem = m_ItemAllocator.Alloc();
      +
      4807  pNewItem->pPrev = VMA_NULL;
      +
      4808  if(IsEmpty())
      +
      4809  {
      +
      4810  pNewItem->pNext = VMA_NULL;
      +
      4811  m_pFront = pNewItem;
      +
      4812  m_pBack = pNewItem;
      +
      4813  m_Count = 1;
      +
      4814  }
      +
      4815  else
      +
      4816  {
      +
      4817  pNewItem->pNext = m_pFront;
      +
      4818  m_pFront->pPrev = pNewItem;
      +
      4819  m_pFront = pNewItem;
      +
      4820  ++m_Count;
      +
      4821  }
      +
      4822  return pNewItem;
      +
      4823 }
      +
      4824 
      +
      4825 template<typename T>
      +
      4826 VmaListItem<T>* VmaRawList<T>::PushBack(const T& value)
      +
      4827 {
      +
      4828  ItemType* const pNewItem = PushBack();
      +
      4829  pNewItem->Value = value;
      +
      4830  return pNewItem;
      +
      4831 }
      +
      4832 
      +
      4833 template<typename T>
      +
      4834 VmaListItem<T>* VmaRawList<T>::PushFront(const T& value)
      +
      4835 {
      +
      4836  ItemType* const pNewItem = PushFront();
      +
      4837  pNewItem->Value = value;
      +
      4838  return pNewItem;
      +
      4839 }
      +
      4840 
      +
      4841 template<typename T>
      +
      4842 void VmaRawList<T>::PopBack()
      +
      4843 {
      +
      4844  VMA_HEAVY_ASSERT(m_Count > 0);
      +
      4845  ItemType* const pBackItem = m_pBack;
      +
      4846  ItemType* const pPrevItem = pBackItem->pPrev;
      +
      4847  if(pPrevItem != VMA_NULL)
      +
      4848  {
      +
      4849  pPrevItem->pNext = VMA_NULL;
      +
      4850  }
      +
      4851  m_pBack = pPrevItem;
      +
      4852  m_ItemAllocator.Free(pBackItem);
      +
      4853  --m_Count;
      +
      4854 }
      +
      4855 
      +
      4856 template<typename T>
      +
      4857 void VmaRawList<T>::PopFront()
      +
      4858 {
      +
      4859  VMA_HEAVY_ASSERT(m_Count > 0);
      +
      4860  ItemType* const pFrontItem = m_pFront;
      +
      4861  ItemType* const pNextItem = pFrontItem->pNext;
      +
      4862  if(pNextItem != VMA_NULL)
      +
      4863  {
      +
      4864  pNextItem->pPrev = VMA_NULL;
      +
      4865  }
      +
      4866  m_pFront = pNextItem;
      +
      4867  m_ItemAllocator.Free(pFrontItem);
      +
      4868  --m_Count;
      +
      4869 }
      +
      4870 
      +
      4871 template<typename T>
      +
      4872 void VmaRawList<T>::Remove(ItemType* pItem)
      +
      4873 {
      +
      4874  VMA_HEAVY_ASSERT(pItem != VMA_NULL);
      +
      4875  VMA_HEAVY_ASSERT(m_Count > 0);
      +
      4876 
      +
      4877  if(pItem->pPrev != VMA_NULL)
      +
      4878  {
      +
      4879  pItem->pPrev->pNext = pItem->pNext;
      +
      4880  }
      +
      4881  else
      +
      4882  {
      +
      4883  VMA_HEAVY_ASSERT(m_pFront == pItem);
      +
      4884  m_pFront = pItem->pNext;
      +
      4885  }
      +
      4886 
      +
      4887  if(pItem->pNext != VMA_NULL)
      +
      4888  {
      +
      4889  pItem->pNext->pPrev = pItem->pPrev;
      +
      4890  }
      +
      4891  else
      +
      4892  {
      +
      4893  VMA_HEAVY_ASSERT(m_pBack == pItem);
      +
      4894  m_pBack = pItem->pPrev;
      +
      4895  }
      +
      4896 
      +
      4897  m_ItemAllocator.Free(pItem);
      +
      4898  --m_Count;
      +
      4899 }
      +
      4900 
      +
      4901 template<typename T>
      +
      4902 VmaListItem<T>* VmaRawList<T>::InsertBefore(ItemType* pItem)
      +
      4903 {
      +
      4904  if(pItem != VMA_NULL)
      +
      4905  {
      +
      4906  ItemType* const prevItem = pItem->pPrev;
      +
      4907  ItemType* const newItem = m_ItemAllocator.Alloc();
      +
      4908  newItem->pPrev = prevItem;
      +
      4909  newItem->pNext = pItem;
      +
      4910  pItem->pPrev = newItem;
      +
      4911  if(prevItem != VMA_NULL)
      +
      4912  {
      +
      4913  prevItem->pNext = newItem;
      +
      4914  }
      +
      4915  else
      +
      4916  {
      +
      4917  VMA_HEAVY_ASSERT(m_pFront == pItem);
      +
      4918  m_pFront = newItem;
      +
      4919  }
      +
      4920  ++m_Count;
      +
      4921  return newItem;
      +
      4922  }
      +
      4923  else
      +
      4924  return PushBack();
      +
      4925 }
      +
      4926 
      +
      4927 template<typename T>
      +
      4928 VmaListItem<T>* VmaRawList<T>::InsertAfter(ItemType* pItem)
      +
      4929 {
      +
      4930  if(pItem != VMA_NULL)
      +
      4931  {
      +
      4932  ItemType* const nextItem = pItem->pNext;
      +
      4933  ItemType* const newItem = m_ItemAllocator.Alloc();
      +
      4934  newItem->pNext = nextItem;
      +
      4935  newItem->pPrev = pItem;
      +
      4936  pItem->pNext = newItem;
      +
      4937  if(nextItem != VMA_NULL)
      +
      4938  {
      +
      4939  nextItem->pPrev = newItem;
      +
      4940  }
      +
      4941  else
      +
      4942  {
      +
      4943  VMA_HEAVY_ASSERT(m_pBack == pItem);
      +
      4944  m_pBack = newItem;
      +
      4945  }
      +
      4946  ++m_Count;
      +
      4947  return newItem;
      +
      4948  }
      +
      4949  else
      +
      4950  return PushFront();
      +
      4951 }
      +
      4952 
      +
      4953 template<typename T>
      +
      4954 VmaListItem<T>* VmaRawList<T>::InsertBefore(ItemType* pItem, const T& value)
      +
      4955 {
      +
      4956  ItemType* const newItem = InsertBefore(pItem);
      +
      4957  newItem->Value = value;
      +
      4958  return newItem;
      +
      4959 }
      +
      4960 
      +
      4961 template<typename T>
      +
      4962 VmaListItem<T>* VmaRawList<T>::InsertAfter(ItemType* pItem, const T& value)
      +
      4963 {
      +
      4964  ItemType* const newItem = InsertAfter(pItem);
      +
      4965  newItem->Value = value;
      +
      4966  return newItem;
      +
      4967 }
      +
      4968 
      +
      4969 template<typename T, typename AllocatorT>
      +
      4970 class VmaList
      +
      4971 {
      +
      4972  VMA_CLASS_NO_COPY(VmaList)
      +
      4973 public:
      +
      4974  class iterator
      +
      4975  {
      +
      4976  public:
      +
      4977  iterator() :
      +
      4978  m_pList(VMA_NULL),
      +
      4979  m_pItem(VMA_NULL)
      +
      4980  {
      +
      4981  }
      +
      4982 
      +
      4983  T& operator*() const
      +
      4984  {
      +
      4985  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
      +
      4986  return m_pItem->Value;
      +
      4987  }
      +
      4988  T* operator->() const
      +
      4989  {
      +
      4990  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
      +
      4991  return &m_pItem->Value;
      +
      4992  }
      4993 
      -
      4994  iterator(VmaRawList<T>* pList, VmaListItem<T>* pItem) :
      -
      4995  m_pList(pList),
      -
      4996  m_pItem(pItem)
      -
      4997  {
      -
      4998  }
      -
      4999 
      -
      5000  friend class VmaList<T, AllocatorT>;
      -
      5001  };
      -
      5002 
      -
      5003  class const_iterator
      -
      5004  {
      -
      5005  public:
      -
      5006  const_iterator() :
      -
      5007  m_pList(VMA_NULL),
      -
      5008  m_pItem(VMA_NULL)
      -
      5009  {
      -
      5010  }
      -
      5011 
      -
      5012  const_iterator(const iterator& src) :
      -
      5013  m_pList(src.m_pList),
      -
      5014  m_pItem(src.m_pItem)
      +
      4994  iterator& operator++()
      +
      4995  {
      +
      4996  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
      +
      4997  m_pItem = m_pItem->pNext;
      +
      4998  return *this;
      +
      4999  }
      +
      5000  iterator& operator--()
      +
      5001  {
      +
      5002  if(m_pItem != VMA_NULL)
      +
      5003  {
      +
      5004  m_pItem = m_pItem->pPrev;
      +
      5005  }
      +
      5006  else
      +
      5007  {
      +
      5008  VMA_HEAVY_ASSERT(!m_pList->IsEmpty());
      +
      5009  m_pItem = m_pList->Back();
      +
      5010  }
      +
      5011  return *this;
      +
      5012  }
      +
      5013 
      +
      5014  iterator operator++(int)
      5015  {
      -
      5016  }
      -
      5017 
      -
      5018  const T& operator*() const
      -
      5019  {
      -
      5020  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
      -
      5021  return m_pItem->Value;
      -
      5022  }
      -
      5023  const T* operator->() const
      -
      5024  {
      -
      5025  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
      -
      5026  return &m_pItem->Value;
      -
      5027  }
      -
      5028 
      -
      5029  const_iterator& operator++()
      -
      5030  {
      -
      5031  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
      -
      5032  m_pItem = m_pItem->pNext;
      -
      5033  return *this;
      -
      5034  }
      -
      5035  const_iterator& operator--()
      -
      5036  {
      -
      5037  if(m_pItem != VMA_NULL)
      -
      5038  {
      -
      5039  m_pItem = m_pItem->pPrev;
      -
      5040  }
      -
      5041  else
      -
      5042  {
      -
      5043  VMA_HEAVY_ASSERT(!m_pList->IsEmpty());
      -
      5044  m_pItem = m_pList->Back();
      -
      5045  }
      -
      5046  return *this;
      -
      5047  }
      -
      5048 
      -
      5049  const_iterator operator++(int)
      -
      5050  {
      -
      5051  const_iterator result = *this;
      -
      5052  ++*this;
      -
      5053  return result;
      -
      5054  }
      -
      5055  const_iterator operator--(int)
      -
      5056  {
      -
      5057  const_iterator result = *this;
      -
      5058  --*this;
      -
      5059  return result;
      -
      5060  }
      -
      5061 
      -
      5062  bool operator==(const const_iterator& rhs) const
      -
      5063  {
      -
      5064  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
      -
      5065  return m_pItem == rhs.m_pItem;
      -
      5066  }
      -
      5067  bool operator!=(const const_iterator& rhs) const
      -
      5068  {
      -
      5069  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
      -
      5070  return m_pItem != rhs.m_pItem;
      -
      5071  }
      -
      5072 
      -
      5073  private:
      -
      5074  const_iterator(const VmaRawList<T>* pList, const VmaListItem<T>* pItem) :
      -
      5075  m_pList(pList),
      -
      5076  m_pItem(pItem)
      -
      5077  {
      -
      5078  }
      -
      5079 
      -
      5080  const VmaRawList<T>* m_pList;
      -
      5081  const VmaListItem<T>* m_pItem;
      -
      5082 
      -
      5083  friend class VmaList<T, AllocatorT>;
      -
      5084  };
      -
      5085 
      -
      5086  VmaList(const AllocatorT& allocator) : m_RawList(allocator.m_pCallbacks) { }
      -
      5087 
      -
      5088  bool empty() const { return m_RawList.IsEmpty(); }
      -
      5089  size_t size() const { return m_RawList.GetCount(); }
      -
      5090 
      -
      5091  iterator begin() { return iterator(&m_RawList, m_RawList.Front()); }
      -
      5092  iterator end() { return iterator(&m_RawList, VMA_NULL); }
      -
      5093 
      -
      5094  const_iterator cbegin() const { return const_iterator(&m_RawList, m_RawList.Front()); }
      -
      5095  const_iterator cend() const { return const_iterator(&m_RawList, VMA_NULL); }
      +
      5016  iterator result = *this;
      +
      5017  ++*this;
      +
      5018  return result;
      +
      5019  }
      +
      5020  iterator operator--(int)
      +
      5021  {
      +
      5022  iterator result = *this;
      +
      5023  --*this;
      +
      5024  return result;
      +
      5025  }
      +
      5026 
      +
      5027  bool operator==(const iterator& rhs) const
      +
      5028  {
      +
      5029  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
      +
      5030  return m_pItem == rhs.m_pItem;
      +
      5031  }
      +
      5032  bool operator!=(const iterator& rhs) const
      +
      5033  {
      +
      5034  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
      +
      5035  return m_pItem != rhs.m_pItem;
      +
      5036  }
      +
      5037 
      +
      5038  private:
      +
      5039  VmaRawList<T>* m_pList;
      +
      5040  VmaListItem<T>* m_pItem;
      +
      5041 
      +
      5042  iterator(VmaRawList<T>* pList, VmaListItem<T>* pItem) :
      +
      5043  m_pList(pList),
      +
      5044  m_pItem(pItem)
      +
      5045  {
      +
      5046  }
      +
      5047 
      +
      5048  friend class VmaList<T, AllocatorT>;
      +
      5049  };
      +
      5050 
      +
      5051  class const_iterator
      +
      5052  {
      +
      5053  public:
      +
      5054  const_iterator() :
      +
      5055  m_pList(VMA_NULL),
      +
      5056  m_pItem(VMA_NULL)
      +
      5057  {
      +
      5058  }
      +
      5059 
      +
      5060  const_iterator(const iterator& src) :
      +
      5061  m_pList(src.m_pList),
      +
      5062  m_pItem(src.m_pItem)
      +
      5063  {
      +
      5064  }
      +
      5065 
      +
      5066  const T& operator*() const
      +
      5067  {
      +
      5068  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
      +
      5069  return m_pItem->Value;
      +
      5070  }
      +
      5071  const T* operator->() const
      +
      5072  {
      +
      5073  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
      +
      5074  return &m_pItem->Value;
      +
      5075  }
      +
      5076 
      +
      5077  const_iterator& operator++()
      +
      5078  {
      +
      5079  VMA_HEAVY_ASSERT(m_pItem != VMA_NULL);
      +
      5080  m_pItem = m_pItem->pNext;
      +
      5081  return *this;
      +
      5082  }
      +
      5083  const_iterator& operator--()
      +
      5084  {
      +
      5085  if(m_pItem != VMA_NULL)
      +
      5086  {
      +
      5087  m_pItem = m_pItem->pPrev;
      +
      5088  }
      +
      5089  else
      +
      5090  {
      +
      5091  VMA_HEAVY_ASSERT(!m_pList->IsEmpty());
      +
      5092  m_pItem = m_pList->Back();
      +
      5093  }
      +
      5094  return *this;
      +
      5095  }
      5096 
      -
      5097  void clear() { m_RawList.Clear(); }
      -
      5098  void push_back(const T& value) { m_RawList.PushBack(value); }
      -
      5099  void erase(iterator it) { m_RawList.Remove(it.m_pItem); }
      -
      5100  iterator insert(iterator it, const T& value) { return iterator(&m_RawList, m_RawList.InsertBefore(it.m_pItem, value)); }
      -
      5101 
      -
      5102 private:
      -
      5103  VmaRawList<T> m_RawList;
      -
      5104 };
      -
      5105 
      -
      5106 #endif // #if VMA_USE_STL_LIST
      -
      5107 
      -
      5109 // class VmaMap
      -
      5110 
      -
      5111 // Unused in this version.
      -
      5112 #if 0
      -
      5113 
      -
      5114 #if VMA_USE_STL_UNORDERED_MAP
      -
      5115 
      -
      5116 #define VmaPair std::pair
      -
      5117 
      -
      5118 #define VMA_MAP_TYPE(KeyT, ValueT) \
      -
      5119  std::unordered_map< KeyT, ValueT, std::hash<KeyT>, std::equal_to<KeyT>, VmaStlAllocator< std::pair<KeyT, ValueT> > >
      -
      5120 
      -
      5121 #else // #if VMA_USE_STL_UNORDERED_MAP
      -
      5122 
      -
      5123 template<typename T1, typename T2>
      -
      5124 struct VmaPair
      -
      5125 {
      -
      5126  T1 first;
      -
      5127  T2 second;
      -
      5128 
      -
      5129  VmaPair() : first(), second() { }
      -
      5130  VmaPair(const T1& firstSrc, const T2& secondSrc) : first(firstSrc), second(secondSrc) { }
      -
      5131 };
      -
      5132 
      -
      5133 /* Class compatible with subset of interface of std::unordered_map.
      -
      5134 KeyT, ValueT must be POD because they will be stored in VmaVector.
      -
      5135 */
      -
      5136 template<typename KeyT, typename ValueT>
      -
      5137 class VmaMap
      -
      5138 {
      -
      5139 public:
      -
      5140  typedef VmaPair<KeyT, ValueT> PairType;
      -
      5141  typedef PairType* iterator;
      -
      5142 
      -
      5143  VmaMap(const VmaStlAllocator<PairType>& allocator) : m_Vector(allocator) { }
      +
      5097  const_iterator operator++(int)
      +
      5098  {
      +
      5099  const_iterator result = *this;
      +
      5100  ++*this;
      +
      5101  return result;
      +
      5102  }
      +
      5103  const_iterator operator--(int)
      +
      5104  {
      +
      5105  const_iterator result = *this;
      +
      5106  --*this;
      +
      5107  return result;
      +
      5108  }
      +
      5109 
      +
      5110  bool operator==(const const_iterator& rhs) const
      +
      5111  {
      +
      5112  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
      +
      5113  return m_pItem == rhs.m_pItem;
      +
      5114  }
      +
      5115  bool operator!=(const const_iterator& rhs) const
      +
      5116  {
      +
      5117  VMA_HEAVY_ASSERT(m_pList == rhs.m_pList);
      +
      5118  return m_pItem != rhs.m_pItem;
      +
      5119  }
      +
      5120 
      +
      5121  private:
      +
      5122  const_iterator(const VmaRawList<T>* pList, const VmaListItem<T>* pItem) :
      +
      5123  m_pList(pList),
      +
      5124  m_pItem(pItem)
      +
      5125  {
      +
      5126  }
      +
      5127 
      +
      5128  const VmaRawList<T>* m_pList;
      +
      5129  const VmaListItem<T>* m_pItem;
      +
      5130 
      +
      5131  friend class VmaList<T, AllocatorT>;
      +
      5132  };
      +
      5133 
      +
      5134  VmaList(const AllocatorT& allocator) : m_RawList(allocator.m_pCallbacks) { }
      +
      5135 
      +
      5136  bool empty() const { return m_RawList.IsEmpty(); }
      +
      5137  size_t size() const { return m_RawList.GetCount(); }
      +
      5138 
      +
      5139  iterator begin() { return iterator(&m_RawList, m_RawList.Front()); }
      +
      5140  iterator end() { return iterator(&m_RawList, VMA_NULL); }
      +
      5141 
      +
      5142  const_iterator cbegin() const { return const_iterator(&m_RawList, m_RawList.Front()); }
      +
      5143  const_iterator cend() const { return const_iterator(&m_RawList, VMA_NULL); }
      5144 
      -
      5145  iterator begin() { return m_Vector.begin(); }
      -
      5146  iterator end() { return m_Vector.end(); }
      -
      5147 
      -
      5148  void insert(const PairType& pair);
      -
      5149  iterator find(const KeyT& key);
      -
      5150  void erase(iterator it);
      -
      5151 
      -
      5152 private:
      -
      5153  VmaVector< PairType, VmaStlAllocator<PairType> > m_Vector;
      -
      5154 };
      +
      5145  void clear() { m_RawList.Clear(); }
      +
      5146  void push_back(const T& value) { m_RawList.PushBack(value); }
      +
      5147  void erase(iterator it) { m_RawList.Remove(it.m_pItem); }
      +
      5148  iterator insert(iterator it, const T& value) { return iterator(&m_RawList, m_RawList.InsertBefore(it.m_pItem, value)); }
      +
      5149 
      +
      5150 private:
      +
      5151  VmaRawList<T> m_RawList;
      +
      5152 };
      +
      5153 
      +
      5154 #endif // #if VMA_USE_STL_LIST
      5155 
      -
      5156 #define VMA_MAP_TYPE(KeyT, ValueT) VmaMap<KeyT, ValueT>
      -
      5157 
      -
      5158 template<typename FirstT, typename SecondT>
      -
      5159 struct VmaPairFirstLess
      -
      5160 {
      -
      5161  bool operator()(const VmaPair<FirstT, SecondT>& lhs, const VmaPair<FirstT, SecondT>& rhs) const
      -
      5162  {
      -
      5163  return lhs.first < rhs.first;
      -
      5164  }
      -
      5165  bool operator()(const VmaPair<FirstT, SecondT>& lhs, const FirstT& rhsFirst) const
      -
      5166  {
      -
      5167  return lhs.first < rhsFirst;
      -
      5168  }
      -
      5169 };
      +
      5157 // class VmaMap
      +
      5158 
      +
      5159 // Unused in this version.
      +
      5160 #if 0
      +
      5161 
      +
      5162 #if VMA_USE_STL_UNORDERED_MAP
      +
      5163 
      +
      5164 #define VmaPair std::pair
      +
      5165 
      +
      5166 #define VMA_MAP_TYPE(KeyT, ValueT) \
      +
      5167  std::unordered_map< KeyT, ValueT, std::hash<KeyT>, std::equal_to<KeyT>, VmaStlAllocator< std::pair<KeyT, ValueT> > >
      +
      5168 
      +
      5169 #else // #if VMA_USE_STL_UNORDERED_MAP
      5170 
      -
      5171 template<typename KeyT, typename ValueT>
      -
      5172 void VmaMap<KeyT, ValueT>::insert(const PairType& pair)
      +
      5171 template<typename T1, typename T2>
      +
      5172 struct VmaPair
      5173 {
      -
      5174  const size_t indexToInsert = VmaBinaryFindFirstNotLess(
      -
      5175  m_Vector.data(),
      -
      5176  m_Vector.data() + m_Vector.size(),
      -
      5177  pair,
      -
      5178  VmaPairFirstLess<KeyT, ValueT>()) - m_Vector.data();
      -
      5179  VmaVectorInsert(m_Vector, indexToInsert, pair);
      -
      5180 }
      -
      5181 
      -
      5182 template<typename KeyT, typename ValueT>
      -
      5183 VmaPair<KeyT, ValueT>* VmaMap<KeyT, ValueT>::find(const KeyT& key)
      -
      5184 {
      -
      5185  PairType* it = VmaBinaryFindFirstNotLess(
      -
      5186  m_Vector.data(),
      -
      5187  m_Vector.data() + m_Vector.size(),
      -
      5188  key,
      -
      5189  VmaPairFirstLess<KeyT, ValueT>());
      -
      5190  if((it != m_Vector.end()) && (it->first == key))
      -
      5191  {
      -
      5192  return it;
      -
      5193  }
      -
      5194  else
      -
      5195  {
      -
      5196  return m_Vector.end();
      -
      5197  }
      -
      5198 }
      -
      5199 
      -
      5200 template<typename KeyT, typename ValueT>
      -
      5201 void VmaMap<KeyT, ValueT>::erase(iterator it)
      -
      5202 {
      -
      5203  VmaVectorRemove(m_Vector, it - m_Vector.begin());
      -
      5204 }
      +
      5174  T1 first;
      +
      5175  T2 second;
      +
      5176 
      +
      5177  VmaPair() : first(), second() { }
      +
      5178  VmaPair(const T1& firstSrc, const T2& secondSrc) : first(firstSrc), second(secondSrc) { }
      +
      5179 };
      +
      5180 
      +
      5181 /* Class compatible with subset of interface of std::unordered_map.
      +
      5182 KeyT, ValueT must be POD because they will be stored in VmaVector.
      +
      5183 */
      +
      5184 template<typename KeyT, typename ValueT>
      +
      5185 class VmaMap
      +
      5186 {
      +
      5187 public:
      +
      5188  typedef VmaPair<KeyT, ValueT> PairType;
      +
      5189  typedef PairType* iterator;
      +
      5190 
      +
      5191  VmaMap(const VmaStlAllocator<PairType>& allocator) : m_Vector(allocator) { }
      +
      5192 
      +
      5193  iterator begin() { return m_Vector.begin(); }
      +
      5194  iterator end() { return m_Vector.end(); }
      +
      5195 
      +
      5196  void insert(const PairType& pair);
      +
      5197  iterator find(const KeyT& key);
      +
      5198  void erase(iterator it);
      +
      5199 
      +
      5200 private:
      +
      5201  VmaVector< PairType, VmaStlAllocator<PairType> > m_Vector;
      +
      5202 };
      +
      5203 
      +
      5204 #define VMA_MAP_TYPE(KeyT, ValueT) VmaMap<KeyT, ValueT>
      5205 
      -
      5206 #endif // #if VMA_USE_STL_UNORDERED_MAP
      -
      5207 
      -
      5208 #endif // #if 0
      -
      5209 
      -
      5211 
      -
      5212 class VmaDeviceMemoryBlock;
      -
      5213 
      -
      5214 enum VMA_CACHE_OPERATION { VMA_CACHE_FLUSH, VMA_CACHE_INVALIDATE };
      -
      5215 
      -
      5216 struct VmaAllocation_T
      -
      5217 {
      -
      5218 private:
      -
      5219  static const uint8_t MAP_COUNT_FLAG_PERSISTENT_MAP = 0x80;
      -
      5220 
      -
      5221  enum FLAGS
      -
      5222  {
      -
      5223  FLAG_USER_DATA_STRING = 0x01,
      -
      5224  };
      -
      5225 
      -
      5226 public:
      -
      5227  enum ALLOCATION_TYPE
      -
      5228  {
      -
      5229  ALLOCATION_TYPE_NONE,
      -
      5230  ALLOCATION_TYPE_BLOCK,
      -
      5231  ALLOCATION_TYPE_DEDICATED,
      -
      5232  };
      -
      5233 
      -
      5234  /*
      -
      5235  This struct is allocated using VmaPoolAllocator.
      -
      5236  */
      -
      5237 
      -
      5238  void Ctor(uint32_t currentFrameIndex, bool userDataString)
      +
      5206 template<typename FirstT, typename SecondT>
      +
      5207 struct VmaPairFirstLess
      +
      5208 {
      +
      5209  bool operator()(const VmaPair<FirstT, SecondT>& lhs, const VmaPair<FirstT, SecondT>& rhs) const
      +
      5210  {
      +
      5211  return lhs.first < rhs.first;
      +
      5212  }
      +
      5213  bool operator()(const VmaPair<FirstT, SecondT>& lhs, const FirstT& rhsFirst) const
      +
      5214  {
      +
      5215  return lhs.first < rhsFirst;
      +
      5216  }
      +
      5217 };
      +
      5218 
      +
      5219 template<typename KeyT, typename ValueT>
      +
      5220 void VmaMap<KeyT, ValueT>::insert(const PairType& pair)
      +
      5221 {
      +
      5222  const size_t indexToInsert = VmaBinaryFindFirstNotLess(
      +
      5223  m_Vector.data(),
      +
      5224  m_Vector.data() + m_Vector.size(),
      +
      5225  pair,
      +
      5226  VmaPairFirstLess<KeyT, ValueT>()) - m_Vector.data();
      +
      5227  VmaVectorInsert(m_Vector, indexToInsert, pair);
      +
      5228 }
      +
      5229 
      +
      5230 template<typename KeyT, typename ValueT>
      +
      5231 VmaPair<KeyT, ValueT>* VmaMap<KeyT, ValueT>::find(const KeyT& key)
      +
      5232 {
      +
      5233  PairType* it = VmaBinaryFindFirstNotLess(
      +
      5234  m_Vector.data(),
      +
      5235  m_Vector.data() + m_Vector.size(),
      +
      5236  key,
      +
      5237  VmaPairFirstLess<KeyT, ValueT>());
      +
      5238  if((it != m_Vector.end()) && (it->first == key))
      5239  {
      -
      5240  m_Alignment = 1;
      -
      5241  m_Size = 0;
      -
      5242  m_pUserData = VMA_NULL;
      -
      5243  m_LastUseFrameIndex = currentFrameIndex;
      -
      5244  m_Type = (uint8_t)ALLOCATION_TYPE_NONE;
      -
      5245  m_SuballocationType = (uint8_t)VMA_SUBALLOCATION_TYPE_UNKNOWN;
      -
      5246  m_MapCount = 0;
      -
      5247  m_Flags = userDataString ? (uint8_t)FLAG_USER_DATA_STRING : 0;
      -
      5248 
      -
      5249 #if VMA_STATS_STRING_ENABLED
      -
      5250  m_CreationFrameIndex = currentFrameIndex;
      -
      5251  m_BufferImageUsage = 0;
      -
      5252 #endif
      -
      5253  }
      -
      5254 
      -
      5255  void Dtor()
      -
      5256  {
      -
      5257  VMA_ASSERT((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) == 0 && "Allocation was not unmapped before destruction.");
      -
      5258 
      -
      5259  // Check if owned string was freed.
      -
      5260  VMA_ASSERT(m_pUserData == VMA_NULL);
      -
      5261  }
      -
      5262 
      -
      5263  void InitBlockAllocation(
      -
      5264  VmaDeviceMemoryBlock* block,
      -
      5265  VkDeviceSize offset,
      -
      5266  VkDeviceSize alignment,
      -
      5267  VkDeviceSize size,
      -
      5268  VmaSuballocationType suballocationType,
      -
      5269  bool mapped,
      -
      5270  bool canBecomeLost)
      -
      5271  {
      -
      5272  VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
      -
      5273  VMA_ASSERT(block != VMA_NULL);
      -
      5274  m_Type = (uint8_t)ALLOCATION_TYPE_BLOCK;
      -
      5275  m_Alignment = alignment;
      -
      5276  m_Size = size;
      -
      5277  m_MapCount = mapped ? MAP_COUNT_FLAG_PERSISTENT_MAP : 0;
      -
      5278  m_SuballocationType = (uint8_t)suballocationType;
      -
      5279  m_BlockAllocation.m_Block = block;
      -
      5280  m_BlockAllocation.m_Offset = offset;
      -
      5281  m_BlockAllocation.m_CanBecomeLost = canBecomeLost;
      -
      5282  }
      -
      5283 
      -
      5284  void InitLost()
      -
      5285  {
      -
      5286  VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
      -
      5287  VMA_ASSERT(m_LastUseFrameIndex.load() == VMA_FRAME_INDEX_LOST);
      -
      5288  m_Type = (uint8_t)ALLOCATION_TYPE_BLOCK;
      -
      5289  m_BlockAllocation.m_Block = VMA_NULL;
      -
      5290  m_BlockAllocation.m_Offset = 0;
      -
      5291  m_BlockAllocation.m_CanBecomeLost = true;
      -
      5292  }
      -
      5293 
      -
      5294  void ChangeBlockAllocation(
      -
      5295  VmaAllocator hAllocator,
      -
      5296  VmaDeviceMemoryBlock* block,
      -
      5297  VkDeviceSize offset);
      -
      5298 
      -
      5299  void ChangeOffset(VkDeviceSize newOffset);
      -
      5300 
      -
      5301  // pMappedData not null means allocation is created with MAPPED flag.
      -
      5302  void InitDedicatedAllocation(
      -
      5303  uint32_t memoryTypeIndex,
      -
      5304  VkDeviceMemory hMemory,
      -
      5305  VmaSuballocationType suballocationType,
      -
      5306  void* pMappedData,
      -
      5307  VkDeviceSize size)
      -
      5308  {
      -
      5309  VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
      -
      5310  VMA_ASSERT(hMemory != VK_NULL_HANDLE);
      -
      5311  m_Type = (uint8_t)ALLOCATION_TYPE_DEDICATED;
      -
      5312  m_Alignment = 0;
      -
      5313  m_Size = size;
      -
      5314  m_SuballocationType = (uint8_t)suballocationType;
      -
      5315  m_MapCount = (pMappedData != VMA_NULL) ? MAP_COUNT_FLAG_PERSISTENT_MAP : 0;
      -
      5316  m_DedicatedAllocation.m_MemoryTypeIndex = memoryTypeIndex;
      -
      5317  m_DedicatedAllocation.m_hMemory = hMemory;
      -
      5318  m_DedicatedAllocation.m_pMappedData = pMappedData;
      -
      5319  }
      -
      5320 
      -
      5321  ALLOCATION_TYPE GetType() const { return (ALLOCATION_TYPE)m_Type; }
      -
      5322  VkDeviceSize GetAlignment() const { return m_Alignment; }
      -
      5323  VkDeviceSize GetSize() const { return m_Size; }
      -
      5324  bool IsUserDataString() const { return (m_Flags & FLAG_USER_DATA_STRING) != 0; }
      -
      5325  void* GetUserData() const { return m_pUserData; }
      -
      5326  void SetUserData(VmaAllocator hAllocator, void* pUserData);
      -
      5327  VmaSuballocationType GetSuballocationType() const { return (VmaSuballocationType)m_SuballocationType; }
      -
      5328 
      -
      5329  VmaDeviceMemoryBlock* GetBlock() const
      -
      5330  {
      -
      5331  VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
      -
      5332  return m_BlockAllocation.m_Block;
      +
      5240  return it;
      +
      5241  }
      +
      5242  else
      +
      5243  {
      +
      5244  return m_Vector.end();
      +
      5245  }
      +
      5246 }
      +
      5247 
      +
      5248 template<typename KeyT, typename ValueT>
      +
      5249 void VmaMap<KeyT, ValueT>::erase(iterator it)
      +
      5250 {
      +
      5251  VmaVectorRemove(m_Vector, it - m_Vector.begin());
      +
      5252 }
      +
      5253 
      +
      5254 #endif // #if VMA_USE_STL_UNORDERED_MAP
      +
      5255 
      +
      5256 #endif // #if 0
      +
      5257 
      +
      5259 
      +
      5260 class VmaDeviceMemoryBlock;
      +
      5261 
      +
      5262 enum VMA_CACHE_OPERATION { VMA_CACHE_FLUSH, VMA_CACHE_INVALIDATE };
      +
      5263 
      +
      5264 struct VmaAllocation_T
      +
      5265 {
      +
      5266 private:
      +
      5267  static const uint8_t MAP_COUNT_FLAG_PERSISTENT_MAP = 0x80;
      +
      5268 
      +
      5269  enum FLAGS
      +
      5270  {
      +
      5271  FLAG_USER_DATA_STRING = 0x01,
      +
      5272  };
      +
      5273 
      +
      5274 public:
      +
      5275  enum ALLOCATION_TYPE
      +
      5276  {
      +
      5277  ALLOCATION_TYPE_NONE,
      +
      5278  ALLOCATION_TYPE_BLOCK,
      +
      5279  ALLOCATION_TYPE_DEDICATED,
      +
      5280  };
      +
      5281 
      +
      5282  /*
      +
      5283  This struct is allocated using VmaPoolAllocator.
      +
      5284  */
      +
      5285 
      +
      5286  void Ctor(uint32_t currentFrameIndex, bool userDataString)
      +
      5287  {
      +
      5288  m_Alignment = 1;
      +
      5289  m_Size = 0;
      +
      5290  m_MemoryTypeIndex = 0;
      +
      5291  m_pUserData = VMA_NULL;
      +
      5292  m_LastUseFrameIndex = currentFrameIndex;
      +
      5293  m_Type = (uint8_t)ALLOCATION_TYPE_NONE;
      +
      5294  m_SuballocationType = (uint8_t)VMA_SUBALLOCATION_TYPE_UNKNOWN;
      +
      5295  m_MapCount = 0;
      +
      5296  m_Flags = userDataString ? (uint8_t)FLAG_USER_DATA_STRING : 0;
      +
      5297 
      +
      5298 #if VMA_STATS_STRING_ENABLED
      +
      5299  m_CreationFrameIndex = currentFrameIndex;
      +
      5300  m_BufferImageUsage = 0;
      +
      5301 #endif
      +
      5302  }
      +
      5303 
      +
      5304  void Dtor()
      +
      5305  {
      +
      5306  VMA_ASSERT((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) == 0 && "Allocation was not unmapped before destruction.");
      +
      5307 
      +
      5308  // Check if owned string was freed.
      +
      5309  VMA_ASSERT(m_pUserData == VMA_NULL);
      +
      5310  }
      +
      5311 
      +
      5312  void InitBlockAllocation(
      +
      5313  VmaDeviceMemoryBlock* block,
      +
      5314  VkDeviceSize offset,
      +
      5315  VkDeviceSize alignment,
      +
      5316  VkDeviceSize size,
      +
      5317  uint32_t memoryTypeIndex,
      +
      5318  VmaSuballocationType suballocationType,
      +
      5319  bool mapped,
      +
      5320  bool canBecomeLost)
      +
      5321  {
      +
      5322  VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
      +
      5323  VMA_ASSERT(block != VMA_NULL);
      +
      5324  m_Type = (uint8_t)ALLOCATION_TYPE_BLOCK;
      +
      5325  m_Alignment = alignment;
      +
      5326  m_Size = size;
      +
      5327  m_MemoryTypeIndex = memoryTypeIndex;
      +
      5328  m_MapCount = mapped ? MAP_COUNT_FLAG_PERSISTENT_MAP : 0;
      +
      5329  m_SuballocationType = (uint8_t)suballocationType;
      +
      5330  m_BlockAllocation.m_Block = block;
      +
      5331  m_BlockAllocation.m_Offset = offset;
      +
      5332  m_BlockAllocation.m_CanBecomeLost = canBecomeLost;
      5333  }
      -
      5334  VkDeviceSize GetOffset() const;
      -
      5335  VkDeviceMemory GetMemory() const;
      -
      5336  uint32_t GetMemoryTypeIndex() const;
      -
      5337  bool IsPersistentMap() const { return (m_MapCount & MAP_COUNT_FLAG_PERSISTENT_MAP) != 0; }
      -
      5338  void* GetMappedData() const;
      -
      5339  bool CanBecomeLost() const;
      -
      5340 
      -
      5341  uint32_t GetLastUseFrameIndex() const
      -
      5342  {
      -
      5343  return m_LastUseFrameIndex.load();
      +
      5334 
      +
      5335  void InitLost()
      +
      5336  {
      +
      5337  VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
      +
      5338  VMA_ASSERT(m_LastUseFrameIndex.load() == VMA_FRAME_INDEX_LOST);
      +
      5339  m_Type = (uint8_t)ALLOCATION_TYPE_BLOCK;
      +
      5340  m_MemoryTypeIndex = 0;
      +
      5341  m_BlockAllocation.m_Block = VMA_NULL;
      +
      5342  m_BlockAllocation.m_Offset = 0;
      +
      5343  m_BlockAllocation.m_CanBecomeLost = true;
      5344  }
      -
      5345  bool CompareExchangeLastUseFrameIndex(uint32_t& expected, uint32_t desired)
      -
      5346  {
      -
      5347  return m_LastUseFrameIndex.compare_exchange_weak(expected, desired);
      -
      5348  }
      -
      5349  /*
      -
      5350  - If hAllocation.LastUseFrameIndex + frameInUseCount < allocator.CurrentFrameIndex,
      -
      5351  makes it lost by setting LastUseFrameIndex = VMA_FRAME_INDEX_LOST and returns true.
      -
      5352  - Else, returns false.
      -
      5353 
      -
      5354  If hAllocation is already lost, assert - you should not call it then.
      -
      5355  If hAllocation was not created with CAN_BECOME_LOST_BIT, assert.
      -
      5356  */
      -
      5357  bool MakeLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
      -
      5358 
      -
      5359  void DedicatedAllocCalcStatsInfo(VmaStatInfo& outInfo)
      +
      5345 
      +
      5346  void ChangeBlockAllocation(
      +
      5347  VmaAllocator hAllocator,
      +
      5348  VmaDeviceMemoryBlock* block,
      +
      5349  VkDeviceSize offset);
      +
      5350 
      +
      5351  void ChangeOffset(VkDeviceSize newOffset);
      +
      5352 
      +
      5353  // pMappedData not null means allocation is created with MAPPED flag.
      +
      5354  void InitDedicatedAllocation(
      +
      5355  uint32_t memoryTypeIndex,
      +
      5356  VkDeviceMemory hMemory,
      +
      5357  VmaSuballocationType suballocationType,
      +
      5358  void* pMappedData,
      +
      5359  VkDeviceSize size)
      5360  {
      -
      5361  VMA_ASSERT(m_Type == ALLOCATION_TYPE_DEDICATED);
      -
      5362  outInfo.blockCount = 1;
      -
      5363  outInfo.allocationCount = 1;
      -
      5364  outInfo.unusedRangeCount = 0;
      -
      5365  outInfo.usedBytes = m_Size;
      -
      5366  outInfo.unusedBytes = 0;
      -
      5367  outInfo.allocationSizeMin = outInfo.allocationSizeMax = m_Size;
      -
      5368  outInfo.unusedRangeSizeMin = UINT64_MAX;
      -
      5369  outInfo.unusedRangeSizeMax = 0;
      -
      5370  }
      -
      5371 
      -
      5372  void BlockAllocMap();
      -
      5373  void BlockAllocUnmap();
      -
      5374  VkResult DedicatedAllocMap(VmaAllocator hAllocator, void** ppData);
      -
      5375  void DedicatedAllocUnmap(VmaAllocator hAllocator);
      -
      5376 
      -
      5377 #if VMA_STATS_STRING_ENABLED
      -
      5378  uint32_t GetCreationFrameIndex() const { return m_CreationFrameIndex; }
      -
      5379  uint32_t GetBufferImageUsage() const { return m_BufferImageUsage; }
      +
      5361  VMA_ASSERT(m_Type == ALLOCATION_TYPE_NONE);
      +
      5362  VMA_ASSERT(hMemory != VK_NULL_HANDLE);
      +
      5363  m_Type = (uint8_t)ALLOCATION_TYPE_DEDICATED;
      +
      5364  m_Alignment = 0;
      +
      5365  m_Size = size;
      +
      5366  m_MemoryTypeIndex = memoryTypeIndex;
      +
      5367  m_SuballocationType = (uint8_t)suballocationType;
      +
      5368  m_MapCount = (pMappedData != VMA_NULL) ? MAP_COUNT_FLAG_PERSISTENT_MAP : 0;
      +
      5369  m_DedicatedAllocation.m_hMemory = hMemory;
      +
      5370  m_DedicatedAllocation.m_pMappedData = pMappedData;
      +
      5371  }
      +
      5372 
      +
      5373  ALLOCATION_TYPE GetType() const { return (ALLOCATION_TYPE)m_Type; }
      +
      5374  VkDeviceSize GetAlignment() const { return m_Alignment; }
      +
      5375  VkDeviceSize GetSize() const { return m_Size; }
      +
      5376  bool IsUserDataString() const { return (m_Flags & FLAG_USER_DATA_STRING) != 0; }
      +
      5377  void* GetUserData() const { return m_pUserData; }
      +
      5378  void SetUserData(VmaAllocator hAllocator, void* pUserData);
      +
      5379  VmaSuballocationType GetSuballocationType() const { return (VmaSuballocationType)m_SuballocationType; }
      5380 
      -
      5381  void InitBufferImageUsage(uint32_t bufferImageUsage)
      -
      5382  {
      -
      5383  VMA_ASSERT(m_BufferImageUsage == 0);
      -
      5384  m_BufferImageUsage = bufferImageUsage;
      +
      5381  VmaDeviceMemoryBlock* GetBlock() const
      +
      5382  {
      +
      5383  VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
      +
      5384  return m_BlockAllocation.m_Block;
      5385  }
      -
      5386 
      -
      5387  void PrintParameters(class VmaJsonWriter& json) const;
      -
      5388 #endif
      -
      5389 
      -
      5390 private:
      -
      5391  VkDeviceSize m_Alignment;
      -
      5392  VkDeviceSize m_Size;
      -
      5393  void* m_pUserData;
      -
      5394  VMA_ATOMIC_UINT32 m_LastUseFrameIndex;
      -
      5395  uint8_t m_Type; // ALLOCATION_TYPE
      -
      5396  uint8_t m_SuballocationType; // VmaSuballocationType
      -
      5397  // Bit 0x80 is set when allocation was created with VMA_ALLOCATION_CREATE_MAPPED_BIT.
      -
      5398  // Bits with mask 0x7F are reference counter for vmaMapMemory()/vmaUnmapMemory().
      -
      5399  uint8_t m_MapCount;
      -
      5400  uint8_t m_Flags; // enum FLAGS
      -
      5401 
      -
      5402  // Allocation out of VmaDeviceMemoryBlock.
      -
      5403  struct BlockAllocation
      -
      5404  {
      -
      5405  VmaDeviceMemoryBlock* m_Block;
      -
      5406  VkDeviceSize m_Offset;
      -
      5407  bool m_CanBecomeLost;
      -
      5408  };
      -
      5409 
      -
      5410  // Allocation for an object that has its own private VkDeviceMemory.
      -
      5411  struct DedicatedAllocation
      +
      5386  VkDeviceSize GetOffset() const;
      +
      5387  VkDeviceMemory GetMemory() const;
      +
      5388  uint32_t GetMemoryTypeIndex() const { return m_MemoryTypeIndex; }
      +
      5389  bool IsPersistentMap() const { return (m_MapCount & MAP_COUNT_FLAG_PERSISTENT_MAP) != 0; }
      +
      5390  void* GetMappedData() const;
      +
      5391  bool CanBecomeLost() const;
      +
      5392 
      +
      5393  uint32_t GetLastUseFrameIndex() const
      +
      5394  {
      +
      5395  return m_LastUseFrameIndex.load();
      +
      5396  }
      +
      5397  bool CompareExchangeLastUseFrameIndex(uint32_t& expected, uint32_t desired)
      +
      5398  {
      +
      5399  return m_LastUseFrameIndex.compare_exchange_weak(expected, desired);
      +
      5400  }
      +
      5401  /*
      +
      5402  - If hAllocation.LastUseFrameIndex + frameInUseCount < allocator.CurrentFrameIndex,
      +
      5403  makes it lost by setting LastUseFrameIndex = VMA_FRAME_INDEX_LOST and returns true.
      +
      5404  - Else, returns false.
      +
      5405 
      +
      5406  If hAllocation is already lost, assert - you should not call it then.
      +
      5407  If hAllocation was not created with CAN_BECOME_LOST_BIT, assert.
      +
      5408  */
      +
      5409  bool MakeLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
      +
      5410 
      +
      5411  void DedicatedAllocCalcStatsInfo(VmaStatInfo& outInfo)
      5412  {
      -
      5413  uint32_t m_MemoryTypeIndex;
      -
      5414  VkDeviceMemory m_hMemory;
      -
      5415  void* m_pMappedData; // Not null means memory is mapped.
      -
      5416  };
      -
      5417 
      -
      5418  union
      -
      5419  {
      -
      5420  // Allocation out of VmaDeviceMemoryBlock.
      -
      5421  BlockAllocation m_BlockAllocation;
      -
      5422  // Allocation for an object that has its own private VkDeviceMemory.
      -
      5423  DedicatedAllocation m_DedicatedAllocation;
      -
      5424  };
      -
      5425 
      -
      5426 #if VMA_STATS_STRING_ENABLED
      -
      5427  uint32_t m_CreationFrameIndex;
      -
      5428  uint32_t m_BufferImageUsage; // 0 if unknown.
      -
      5429 #endif
      -
      5430 
      -
      5431  void FreeUserDataString(VmaAllocator hAllocator);
      -
      5432 };
      -
      5433 
      -
      5434 /*
      -
      5435 Represents a region of VmaDeviceMemoryBlock that is either assigned and returned as
      -
      5436 allocated memory block or free.
      -
      5437 */
      -
      5438 struct VmaSuballocation
      -
      5439 {
      -
      5440  VkDeviceSize offset;
      -
      5441  VkDeviceSize size;
      -
      5442  VmaAllocation hAllocation;
      -
      5443  VmaSuballocationType type;
      -
      5444 };
      -
      5445 
      -
      5446 // Comparator for offsets.
      -
      5447 struct VmaSuballocationOffsetLess
      -
      5448 {
      -
      5449  bool operator()(const VmaSuballocation& lhs, const VmaSuballocation& rhs) const
      -
      5450  {
      -
      5451  return lhs.offset < rhs.offset;
      -
      5452  }
      -
      5453 };
      -
      5454 struct VmaSuballocationOffsetGreater
      -
      5455 {
      -
      5456  bool operator()(const VmaSuballocation& lhs, const VmaSuballocation& rhs) const
      -
      5457  {
      -
      5458  return lhs.offset > rhs.offset;
      -
      5459  }
      -
      5460 };
      -
      5461 
      -
      5462 typedef VmaList< VmaSuballocation, VmaStlAllocator<VmaSuballocation> > VmaSuballocationList;
      -
      5463 
      -
      5464 // Cost of one additional allocation lost, as equivalent in bytes.
      -
      5465 static const VkDeviceSize VMA_LOST_ALLOCATION_COST = 1048576;
      -
      5466 
      -
      5467 enum class VmaAllocationRequestType
      -
      5468 {
      -
      5469  Normal,
      -
      5470  // Used by "Linear" algorithm.
      -
      5471  UpperAddress,
      -
      5472  EndOf1st,
      -
      5473  EndOf2nd,
      -
      5474 };
      -
      5475 
      -
      5476 /*
      -
      5477 Parameters of planned allocation inside a VmaDeviceMemoryBlock.
      -
      5478 
      -
      5479 If canMakeOtherLost was false:
      -
      5480 - item points to a FREE suballocation.
      -
      5481 - itemsToMakeLostCount is 0.
      -
      5482 
      -
      5483 If canMakeOtherLost was true:
      -
      5484 - item points to first of sequence of suballocations, which are either FREE,
      -
      5485  or point to VmaAllocations that can become lost.
      -
      5486 - itemsToMakeLostCount is the number of VmaAllocations that need to be made lost for
      -
      5487  the requested allocation to succeed.
      -
      5488 */
      -
      5489 struct VmaAllocationRequest
      -
      5490 {
      -
      5491  VkDeviceSize offset;
      -
      5492  VkDeviceSize sumFreeSize; // Sum size of free items that overlap with proposed allocation.
      -
      5493  VkDeviceSize sumItemSize; // Sum size of items to make lost that overlap with proposed allocation.
      -
      5494  VmaSuballocationList::iterator item;
      -
      5495  size_t itemsToMakeLostCount;
      -
      5496  void* customData;
      -
      5497  VmaAllocationRequestType type;
      -
      5498 
      -
      5499  VkDeviceSize CalcCost() const
      -
      5500  {
      -
      5501  return sumItemSize + itemsToMakeLostCount * VMA_LOST_ALLOCATION_COST;
      -
      5502  }
      -
      5503 };
      -
      5504 
      -
      5505 /*
      -
      5506 Data structure used for bookkeeping of allocations and unused ranges of memory
      -
      5507 in a single VkDeviceMemory block.
      -
      5508 */
      -
      5509 class VmaBlockMetadata
      -
      5510 {
      -
      5511 public:
      -
      5512  VmaBlockMetadata(VmaAllocator hAllocator);
      -
      5513  virtual ~VmaBlockMetadata() { }
      -
      5514  virtual void Init(VkDeviceSize size) { m_Size = size; }
      +
      5413  VMA_ASSERT(m_Type == ALLOCATION_TYPE_DEDICATED);
      +
      5414  outInfo.blockCount = 1;
      +
      5415  outInfo.allocationCount = 1;
      +
      5416  outInfo.unusedRangeCount = 0;
      +
      5417  outInfo.usedBytes = m_Size;
      +
      5418  outInfo.unusedBytes = 0;
      +
      5419  outInfo.allocationSizeMin = outInfo.allocationSizeMax = m_Size;
      +
      5420  outInfo.unusedRangeSizeMin = UINT64_MAX;
      +
      5421  outInfo.unusedRangeSizeMax = 0;
      +
      5422  }
      +
      5423 
      +
      5424  void BlockAllocMap();
      +
      5425  void BlockAllocUnmap();
      +
      5426  VkResult DedicatedAllocMap(VmaAllocator hAllocator, void** ppData);
      +
      5427  void DedicatedAllocUnmap(VmaAllocator hAllocator);
      +
      5428 
      +
      5429 #if VMA_STATS_STRING_ENABLED
      +
      5430  uint32_t GetCreationFrameIndex() const { return m_CreationFrameIndex; }
      +
      5431  uint32_t GetBufferImageUsage() const { return m_BufferImageUsage; }
      +
      5432 
      +
      5433  void InitBufferImageUsage(uint32_t bufferImageUsage)
      +
      5434  {
      +
      5435  VMA_ASSERT(m_BufferImageUsage == 0);
      +
      5436  m_BufferImageUsage = bufferImageUsage;
      +
      5437  }
      +
      5438 
      +
      5439  void PrintParameters(class VmaJsonWriter& json) const;
      +
      5440 #endif
      +
      5441 
      +
      5442 private:
      +
      5443  VkDeviceSize m_Alignment;
      +
      5444  VkDeviceSize m_Size;
      +
      5445  void* m_pUserData;
      +
      5446  VMA_ATOMIC_UINT32 m_LastUseFrameIndex;
      +
      5447  uint32_t m_MemoryTypeIndex;
      +
      5448  uint8_t m_Type; // ALLOCATION_TYPE
      +
      5449  uint8_t m_SuballocationType; // VmaSuballocationType
      +
      5450  // Bit 0x80 is set when allocation was created with VMA_ALLOCATION_CREATE_MAPPED_BIT.
      +
      5451  // Bits with mask 0x7F are reference counter for vmaMapMemory()/vmaUnmapMemory().
      +
      5452  uint8_t m_MapCount;
      +
      5453  uint8_t m_Flags; // enum FLAGS
      +
      5454 
      +
      5455  // Allocation out of VmaDeviceMemoryBlock.
      +
      5456  struct BlockAllocation
      +
      5457  {
      +
      5458  VmaDeviceMemoryBlock* m_Block;
      +
      5459  VkDeviceSize m_Offset;
      +
      5460  bool m_CanBecomeLost;
      +
      5461  };
      +
      5462 
      +
      5463  // Allocation for an object that has its own private VkDeviceMemory.
      +
      5464  struct DedicatedAllocation
      +
      5465  {
      +
      5466  VkDeviceMemory m_hMemory;
      +
      5467  void* m_pMappedData; // Not null means memory is mapped.
      +
      5468  };
      +
      5469 
      +
      5470  union
      +
      5471  {
      +
      5472  // Allocation out of VmaDeviceMemoryBlock.
      +
      5473  BlockAllocation m_BlockAllocation;
      +
      5474  // Allocation for an object that has its own private VkDeviceMemory.
      +
      5475  DedicatedAllocation m_DedicatedAllocation;
      +
      5476  };
      +
      5477 
      +
      5478 #if VMA_STATS_STRING_ENABLED
      +
      5479  uint32_t m_CreationFrameIndex;
      +
      5480  uint32_t m_BufferImageUsage; // 0 if unknown.
      +
      5481 #endif
      +
      5482 
      +
      5483  void FreeUserDataString(VmaAllocator hAllocator);
      +
      5484 };
      +
      5485 
      +
      5486 /*
      +
      5487 Represents a region of VmaDeviceMemoryBlock that is either assigned and returned as
      +
      5488 allocated memory block or free.
      +
      5489 */
      +
      5490 struct VmaSuballocation
      +
      5491 {
      +
      5492  VkDeviceSize offset;
      +
      5493  VkDeviceSize size;
      +
      5494  VmaAllocation hAllocation;
      +
      5495  VmaSuballocationType type;
      +
      5496 };
      +
      5497 
      +
      5498 // Comparator for offsets.
      +
      5499 struct VmaSuballocationOffsetLess
      +
      5500 {
      +
      5501  bool operator()(const VmaSuballocation& lhs, const VmaSuballocation& rhs) const
      +
      5502  {
      +
      5503  return lhs.offset < rhs.offset;
      +
      5504  }
      +
      5505 };
      +
      5506 struct VmaSuballocationOffsetGreater
      +
      5507 {
      +
      5508  bool operator()(const VmaSuballocation& lhs, const VmaSuballocation& rhs) const
      +
      5509  {
      +
      5510  return lhs.offset > rhs.offset;
      +
      5511  }
      +
      5512 };
      +
      5513 
      +
      5514 typedef VmaList< VmaSuballocation, VmaStlAllocator<VmaSuballocation> > VmaSuballocationList;
      5515 
      -
      5516  // Validates all data structures inside this object. If not valid, returns false.
      -
      5517  virtual bool Validate() const = 0;
      -
      5518  VkDeviceSize GetSize() const { return m_Size; }
      -
      5519  virtual size_t GetAllocationCount() const = 0;
      -
      5520  virtual VkDeviceSize GetSumFreeSize() const = 0;
      -
      5521  virtual VkDeviceSize GetUnusedRangeSizeMax() const = 0;
      -
      5522  // Returns true if this block is empty - contains only single free suballocation.
      -
      5523  virtual bool IsEmpty() const = 0;
      -
      5524 
      -
      5525  virtual void CalcAllocationStatInfo(VmaStatInfo& outInfo) const = 0;
      -
      5526  // Shouldn't modify blockCount.
      -
      5527  virtual void AddPoolStats(VmaPoolStats& inoutStats) const = 0;
      -
      5528 
      -
      5529 #if VMA_STATS_STRING_ENABLED
      -
      5530  virtual void PrintDetailedMap(class VmaJsonWriter& json) const = 0;
      -
      5531 #endif
      -
      5532 
      -
      5533  // Tries to find a place for suballocation with given parameters inside this block.
      -
      5534  // If succeeded, fills pAllocationRequest and returns true.
      -
      5535  // If failed, returns false.
      -
      5536  virtual bool CreateAllocationRequest(
      -
      5537  uint32_t currentFrameIndex,
      -
      5538  uint32_t frameInUseCount,
      -
      5539  VkDeviceSize bufferImageGranularity,
      -
      5540  VkDeviceSize allocSize,
      -
      5541  VkDeviceSize allocAlignment,
      -
      5542  bool upperAddress,
      -
      5543  VmaSuballocationType allocType,
      -
      5544  bool canMakeOtherLost,
      -
      5545  // Always one of VMA_ALLOCATION_CREATE_STRATEGY_* or VMA_ALLOCATION_INTERNAL_STRATEGY_* flags.
      -
      5546  uint32_t strategy,
      -
      5547  VmaAllocationRequest* pAllocationRequest) = 0;
      -
      5548 
      -
      5549  virtual bool MakeRequestedAllocationsLost(
      -
      5550  uint32_t currentFrameIndex,
      -
      5551  uint32_t frameInUseCount,
      -
      5552  VmaAllocationRequest* pAllocationRequest) = 0;
      -
      5553 
      -
      5554  virtual uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount) = 0;
      -
      5555 
      -
      5556  virtual VkResult CheckCorruption(const void* pBlockData) = 0;
      -
      5557 
      -
      5558  // Makes actual allocation based on request. Request must already be checked and valid.
      -
      5559  virtual void Alloc(
      -
      5560  const VmaAllocationRequest& request,
      -
      5561  VmaSuballocationType type,
      -
      5562  VkDeviceSize allocSize,
      -
      5563  VmaAllocation hAllocation) = 0;
      -
      5564 
      -
      5565  // Frees suballocation assigned to given memory region.
      -
      5566  virtual void Free(const VmaAllocation allocation) = 0;
      -
      5567  virtual void FreeAtOffset(VkDeviceSize offset) = 0;
      -
      5568 
      -
      5569 protected:
      -
      5570  const VkAllocationCallbacks* GetAllocationCallbacks() const { return m_pAllocationCallbacks; }
      -
      5571 
      -
      5572 #if VMA_STATS_STRING_ENABLED
      -
      5573  void PrintDetailedMap_Begin(class VmaJsonWriter& json,
      -
      5574  VkDeviceSize unusedBytes,
      -
      5575  size_t allocationCount,
      -
      5576  size_t unusedRangeCount) const;
      -
      5577  void PrintDetailedMap_Allocation(class VmaJsonWriter& json,
      -
      5578  VkDeviceSize offset,
      -
      5579  VmaAllocation hAllocation) const;
      -
      5580  void PrintDetailedMap_UnusedRange(class VmaJsonWriter& json,
      -
      5581  VkDeviceSize offset,
      -
      5582  VkDeviceSize size) const;
      -
      5583  void PrintDetailedMap_End(class VmaJsonWriter& json) const;
      -
      5584 #endif
      -
      5585 
      -
      5586 private:
      -
      5587  VkDeviceSize m_Size;
      -
      5588  const VkAllocationCallbacks* m_pAllocationCallbacks;
      -
      5589 };
      -
      5590 
      -
      5591 #define VMA_VALIDATE(cond) do { if(!(cond)) { \
      -
      5592  VMA_ASSERT(0 && "Validation failed: " #cond); \
      -
      5593  return false; \
      -
      5594  } } while(false)
      -
      5595 
      -
      5596 class VmaBlockMetadata_Generic : public VmaBlockMetadata
      -
      5597 {
      -
      5598  VMA_CLASS_NO_COPY(VmaBlockMetadata_Generic)
      -
      5599 public:
      -
      5600  VmaBlockMetadata_Generic(VmaAllocator hAllocator);
      -
      5601  virtual ~VmaBlockMetadata_Generic();
      -
      5602  virtual void Init(VkDeviceSize size);
      -
      5603 
      -
      5604  virtual bool Validate() const;
      -
      5605  virtual size_t GetAllocationCount() const { return m_Suballocations.size() - m_FreeCount; }
      -
      5606  virtual VkDeviceSize GetSumFreeSize() const { return m_SumFreeSize; }
      -
      5607  virtual VkDeviceSize GetUnusedRangeSizeMax() const;
      -
      5608  virtual bool IsEmpty() const;
      +
      5516 // Cost of one additional allocation lost, as equivalent in bytes.
      +
      5517 static const VkDeviceSize VMA_LOST_ALLOCATION_COST = 1048576;
      +
      5518 
      +
      5519 enum class VmaAllocationRequestType
      +
      5520 {
      +
      5521  Normal,
      +
      5522  // Used by "Linear" algorithm.
      +
      5523  UpperAddress,
      +
      5524  EndOf1st,
      +
      5525  EndOf2nd,
      +
      5526 };
      +
      5527 
      +
      5528 /*
      +
      5529 Parameters of planned allocation inside a VmaDeviceMemoryBlock.
      +
      5530 
      +
      5531 If canMakeOtherLost was false:
      +
      5532 - item points to a FREE suballocation.
      +
      5533 - itemsToMakeLostCount is 0.
      +
      5534 
      +
      5535 If canMakeOtherLost was true:
      +
      5536 - item points to first of sequence of suballocations, which are either FREE,
      +
      5537  or point to VmaAllocations that can become lost.
      +
      5538 - itemsToMakeLostCount is the number of VmaAllocations that need to be made lost for
      +
      5539  the requested allocation to succeed.
      +
      5540 */
      +
      5541 struct VmaAllocationRequest
      +
      5542 {
      +
      5543  VkDeviceSize offset;
      +
      5544  VkDeviceSize sumFreeSize; // Sum size of free items that overlap with proposed allocation.
      +
      5545  VkDeviceSize sumItemSize; // Sum size of items to make lost that overlap with proposed allocation.
      +
      5546  VmaSuballocationList::iterator item;
      +
      5547  size_t itemsToMakeLostCount;
      +
      5548  void* customData;
      +
      5549  VmaAllocationRequestType type;
      +
      5550 
      +
      5551  VkDeviceSize CalcCost() const
      +
      5552  {
      +
      5553  return sumItemSize + itemsToMakeLostCount * VMA_LOST_ALLOCATION_COST;
      +
      5554  }
      +
      5555 };
      +
      5556 
      +
      5557 /*
      +
      5558 Data structure used for bookkeeping of allocations and unused ranges of memory
      +
      5559 in a single VkDeviceMemory block.
      +
      5560 */
      +
      5561 class VmaBlockMetadata
      +
      5562 {
      +
      5563 public:
      +
      5564  VmaBlockMetadata(VmaAllocator hAllocator);
      +
      5565  virtual ~VmaBlockMetadata() { }
      +
      5566  virtual void Init(VkDeviceSize size) { m_Size = size; }
      +
      5567 
      +
      5568  // Validates all data structures inside this object. If not valid, returns false.
      +
      5569  virtual bool Validate() const = 0;
      +
      5570  VkDeviceSize GetSize() const { return m_Size; }
      +
      5571  virtual size_t GetAllocationCount() const = 0;
      +
      5572  virtual VkDeviceSize GetSumFreeSize() const = 0;
      +
      5573  virtual VkDeviceSize GetUnusedRangeSizeMax() const = 0;
      +
      5574  // Returns true if this block is empty - contains only single free suballocation.
      +
      5575  virtual bool IsEmpty() const = 0;
      +
      5576 
      +
      5577  virtual void CalcAllocationStatInfo(VmaStatInfo& outInfo) const = 0;
      +
      5578  // Shouldn't modify blockCount.
      +
      5579  virtual void AddPoolStats(VmaPoolStats& inoutStats) const = 0;
      +
      5580 
      +
      5581 #if VMA_STATS_STRING_ENABLED
      +
      5582  virtual void PrintDetailedMap(class VmaJsonWriter& json) const = 0;
      +
      5583 #endif
      +
      5584 
      +
      5585  // Tries to find a place for suballocation with given parameters inside this block.
      +
      5586  // If succeeded, fills pAllocationRequest and returns true.
      +
      5587  // If failed, returns false.
      +
      5588  virtual bool CreateAllocationRequest(
      +
      5589  uint32_t currentFrameIndex,
      +
      5590  uint32_t frameInUseCount,
      +
      5591  VkDeviceSize bufferImageGranularity,
      +
      5592  VkDeviceSize allocSize,
      +
      5593  VkDeviceSize allocAlignment,
      +
      5594  bool upperAddress,
      +
      5595  VmaSuballocationType allocType,
      +
      5596  bool canMakeOtherLost,
      +
      5597  // Always one of VMA_ALLOCATION_CREATE_STRATEGY_* or VMA_ALLOCATION_INTERNAL_STRATEGY_* flags.
      +
      5598  uint32_t strategy,
      +
      5599  VmaAllocationRequest* pAllocationRequest) = 0;
      +
      5600 
      +
      5601  virtual bool MakeRequestedAllocationsLost(
      +
      5602  uint32_t currentFrameIndex,
      +
      5603  uint32_t frameInUseCount,
      +
      5604  VmaAllocationRequest* pAllocationRequest) = 0;
      +
      5605 
      +
      5606  virtual uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount) = 0;
      +
      5607 
      +
      5608  virtual VkResult CheckCorruption(const void* pBlockData) = 0;
      5609 
      -
      5610  virtual void CalcAllocationStatInfo(VmaStatInfo& outInfo) const;
      -
      5611  virtual void AddPoolStats(VmaPoolStats& inoutStats) const;
      -
      5612 
      -
      5613 #if VMA_STATS_STRING_ENABLED
      -
      5614  virtual void PrintDetailedMap(class VmaJsonWriter& json) const;
      -
      5615 #endif
      +
      5610  // Makes actual allocation based on request. Request must already be checked and valid.
      +
      5611  virtual void Alloc(
      +
      5612  const VmaAllocationRequest& request,
      +
      5613  VmaSuballocationType type,
      +
      5614  VkDeviceSize allocSize,
      +
      5615  VmaAllocation hAllocation) = 0;
      5616 
      -
      5617  virtual bool CreateAllocationRequest(
      -
      5618  uint32_t currentFrameIndex,
      -
      5619  uint32_t frameInUseCount,
      -
      5620  VkDeviceSize bufferImageGranularity,
      -
      5621  VkDeviceSize allocSize,
      -
      5622  VkDeviceSize allocAlignment,
      -
      5623  bool upperAddress,
      -
      5624  VmaSuballocationType allocType,
      -
      5625  bool canMakeOtherLost,
      -
      5626  uint32_t strategy,
      -
      5627  VmaAllocationRequest* pAllocationRequest);
      -
      5628 
      -
      5629  virtual bool MakeRequestedAllocationsLost(
      -
      5630  uint32_t currentFrameIndex,
      -
      5631  uint32_t frameInUseCount,
      -
      5632  VmaAllocationRequest* pAllocationRequest);
      -
      5633 
      -
      5634  virtual uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
      -
      5635 
      -
      5636  virtual VkResult CheckCorruption(const void* pBlockData);
      +
      5617  // Frees suballocation assigned to given memory region.
      +
      5618  virtual void Free(const VmaAllocation allocation) = 0;
      +
      5619  virtual void FreeAtOffset(VkDeviceSize offset) = 0;
      +
      5620 
      +
      5621 protected:
      +
      5622  const VkAllocationCallbacks* GetAllocationCallbacks() const { return m_pAllocationCallbacks; }
      +
      5623 
      +
      5624 #if VMA_STATS_STRING_ENABLED
      +
      5625  void PrintDetailedMap_Begin(class VmaJsonWriter& json,
      +
      5626  VkDeviceSize unusedBytes,
      +
      5627  size_t allocationCount,
      +
      5628  size_t unusedRangeCount) const;
      +
      5629  void PrintDetailedMap_Allocation(class VmaJsonWriter& json,
      +
      5630  VkDeviceSize offset,
      +
      5631  VmaAllocation hAllocation) const;
      +
      5632  void PrintDetailedMap_UnusedRange(class VmaJsonWriter& json,
      +
      5633  VkDeviceSize offset,
      +
      5634  VkDeviceSize size) const;
      +
      5635  void PrintDetailedMap_End(class VmaJsonWriter& json) const;
      +
      5636 #endif
      5637 
      -
      5638  virtual void Alloc(
      -
      5639  const VmaAllocationRequest& request,
      -
      5640  VmaSuballocationType type,
      -
      5641  VkDeviceSize allocSize,
      -
      5642  VmaAllocation hAllocation);
      -
      5643 
      -
      5644  virtual void Free(const VmaAllocation allocation);
      -
      5645  virtual void FreeAtOffset(VkDeviceSize offset);
      -
      5646 
      -
      5648  // For defragmentation
      -
      5649 
      -
      5650  bool IsBufferImageGranularityConflictPossible(
      -
      5651  VkDeviceSize bufferImageGranularity,
      -
      5652  VmaSuballocationType& inOutPrevSuballocType) const;
      -
      5653 
      -
      5654 private:
      -
      5655  friend class VmaDefragmentationAlgorithm_Generic;
      -
      5656  friend class VmaDefragmentationAlgorithm_Fast;
      -
      5657 
      -
      5658  uint32_t m_FreeCount;
      -
      5659  VkDeviceSize m_SumFreeSize;
      -
      5660  VmaSuballocationList m_Suballocations;
      -
      5661  // Suballocations that are free and have size greater than certain threshold.
      -
      5662  // Sorted by size, ascending.
      -
      5663  VmaVector< VmaSuballocationList::iterator, VmaStlAllocator< VmaSuballocationList::iterator > > m_FreeSuballocationsBySize;
      +
      5638 private:
      +
      5639  VkDeviceSize m_Size;
      +
      5640  const VkAllocationCallbacks* m_pAllocationCallbacks;
      +
      5641 };
      +
      5642 
      +
      5643 #define VMA_VALIDATE(cond) do { if(!(cond)) { \
      +
      5644  VMA_ASSERT(0 && "Validation failed: " #cond); \
      +
      5645  return false; \
      +
      5646  } } while(false)
      +
      5647 
      +
      5648 class VmaBlockMetadata_Generic : public VmaBlockMetadata
      +
      5649 {
      +
      5650  VMA_CLASS_NO_COPY(VmaBlockMetadata_Generic)
      +
      5651 public:
      +
      5652  VmaBlockMetadata_Generic(VmaAllocator hAllocator);
      +
      5653  virtual ~VmaBlockMetadata_Generic();
      +
      5654  virtual void Init(VkDeviceSize size);
      +
      5655 
      +
      5656  virtual bool Validate() const;
      +
      5657  virtual size_t GetAllocationCount() const { return m_Suballocations.size() - m_FreeCount; }
      +
      5658  virtual VkDeviceSize GetSumFreeSize() const { return m_SumFreeSize; }
      +
      5659  virtual VkDeviceSize GetUnusedRangeSizeMax() const;
      +
      5660  virtual bool IsEmpty() const;
      +
      5661 
      +
      5662  virtual void CalcAllocationStatInfo(VmaStatInfo& outInfo) const;
      +
      5663  virtual void AddPoolStats(VmaPoolStats& inoutStats) const;
      5664 
      -
      5665  bool ValidateFreeSuballocationList() const;
      -
      5666 
      -
      5667  // Checks if requested suballocation with given parameters can be placed in given pFreeSuballocItem.
      -
      5668  // If yes, fills pOffset and returns true. If no, returns false.
      -
      5669  bool CheckAllocation(
      +
      5665 #if VMA_STATS_STRING_ENABLED
      +
      5666  virtual void PrintDetailedMap(class VmaJsonWriter& json) const;
      +
      5667 #endif
      +
      5668 
      +
      5669  virtual bool CreateAllocationRequest(
      5670  uint32_t currentFrameIndex,
      5671  uint32_t frameInUseCount,
      5672  VkDeviceSize bufferImageGranularity,
      5673  VkDeviceSize allocSize,
      5674  VkDeviceSize allocAlignment,
      -
      5675  VmaSuballocationType allocType,
      -
      5676  VmaSuballocationList::const_iterator suballocItem,
      +
      5675  bool upperAddress,
      +
      5676  VmaSuballocationType allocType,
      5677  bool canMakeOtherLost,
      -
      5678  VkDeviceSize* pOffset,
      -
      5679  size_t* itemsToMakeLostCount,
      -
      5680  VkDeviceSize* pSumFreeSize,
      -
      5681  VkDeviceSize* pSumItemSize) const;
      -
      5682  // Given free suballocation, it merges it with following one, which must also be free.
      -
      5683  void MergeFreeWithNext(VmaSuballocationList::iterator item);
      -
      5684  // Releases given suballocation, making it free.
      -
      5685  // Merges it with adjacent free suballocations if applicable.
      -
      5686  // Returns iterator to new free suballocation at this place.
      -
      5687  VmaSuballocationList::iterator FreeSuballocation(VmaSuballocationList::iterator suballocItem);
      -
      5688  // Given free suballocation, it inserts it into sorted list of
      -
      5689  // m_FreeSuballocationsBySize if it's suitable.
      -
      5690  void RegisterFreeSuballocation(VmaSuballocationList::iterator item);
      -
      5691  // Given free suballocation, it removes it from sorted list of
      -
      5692  // m_FreeSuballocationsBySize if it's suitable.
      -
      5693  void UnregisterFreeSuballocation(VmaSuballocationList::iterator item);
      -
      5694 };
      +
      5678  uint32_t strategy,
      +
      5679  VmaAllocationRequest* pAllocationRequest);
      +
      5680 
      +
      5681  virtual bool MakeRequestedAllocationsLost(
      +
      5682  uint32_t currentFrameIndex,
      +
      5683  uint32_t frameInUseCount,
      +
      5684  VmaAllocationRequest* pAllocationRequest);
      +
      5685 
      +
      5686  virtual uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
      +
      5687 
      +
      5688  virtual VkResult CheckCorruption(const void* pBlockData);
      +
      5689 
      +
      5690  virtual void Alloc(
      +
      5691  const VmaAllocationRequest& request,
      +
      5692  VmaSuballocationType type,
      +
      5693  VkDeviceSize allocSize,
      +
      5694  VmaAllocation hAllocation);
      5695 
      -
      5696 /*
      -
      5697 Allocations and their references in internal data structure look like this:
      -
      5698 
      -
      5699 if(m_2ndVectorMode == SECOND_VECTOR_EMPTY):
      -
      5700 
      -
      5701  0 +-------+
      -
      5702  | |
      -
      5703  | |
      -
      5704  | |
      -
      5705  +-------+
      -
      5706  | Alloc | 1st[m_1stNullItemsBeginCount]
      -
      5707  +-------+
      -
      5708  | Alloc | 1st[m_1stNullItemsBeginCount + 1]
      -
      5709  +-------+
      -
      5710  | ... |
      -
      5711  +-------+
      -
      5712  | Alloc | 1st[1st.size() - 1]
      -
      5713  +-------+
      -
      5714  | |
      -
      5715  | |
      -
      5716  | |
      -
      5717 GetSize() +-------+
      -
      5718 
      -
      5719 if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER):
      -
      5720 
      -
      5721  0 +-------+
      -
      5722  | Alloc | 2nd[0]
      -
      5723  +-------+
      -
      5724  | Alloc | 2nd[1]
      -
      5725  +-------+
      -
      5726  | ... |
      -
      5727  +-------+
      -
      5728  | Alloc | 2nd[2nd.size() - 1]
      -
      5729  +-------+
      -
      5730  | |
      -
      5731  | |
      -
      5732  | |
      -
      5733  +-------+
      -
      5734  | Alloc | 1st[m_1stNullItemsBeginCount]
      -
      5735  +-------+
      -
      5736  | Alloc | 1st[m_1stNullItemsBeginCount + 1]
      -
      5737  +-------+
      -
      5738  | ... |
      -
      5739  +-------+
      -
      5740  | Alloc | 1st[1st.size() - 1]
      -
      5741  +-------+
      -
      5742  | |
      -
      5743 GetSize() +-------+
      -
      5744 
      -
      5745 if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK):
      -
      5746 
      -
      5747  0 +-------+
      -
      5748  | |
      -
      5749  | |
      -
      5750  | |
      -
      5751  +-------+
      -
      5752  | Alloc | 1st[m_1stNullItemsBeginCount]
      -
      5753  +-------+
      -
      5754  | Alloc | 1st[m_1stNullItemsBeginCount + 1]
      -
      5755  +-------+
      -
      5756  | ... |
      +
      5696  virtual void Free(const VmaAllocation allocation);
      +
      5697  virtual void FreeAtOffset(VkDeviceSize offset);
      +
      5698 
      +
      5700  // For defragmentation
      +
      5701 
      +
      5702  bool IsBufferImageGranularityConflictPossible(
      +
      5703  VkDeviceSize bufferImageGranularity,
      +
      5704  VmaSuballocationType& inOutPrevSuballocType) const;
      +
      5705 
      +
      5706 private:
      +
      5707  friend class VmaDefragmentationAlgorithm_Generic;
      +
      5708  friend class VmaDefragmentationAlgorithm_Fast;
      +
      5709 
      +
      5710  uint32_t m_FreeCount;
      +
      5711  VkDeviceSize m_SumFreeSize;
      +
      5712  VmaSuballocationList m_Suballocations;
      +
      5713  // Suballocations that are free and have size greater than certain threshold.
      +
      5714  // Sorted by size, ascending.
      +
      5715  VmaVector< VmaSuballocationList::iterator, VmaStlAllocator< VmaSuballocationList::iterator > > m_FreeSuballocationsBySize;
      +
      5716 
      +
      5717  bool ValidateFreeSuballocationList() const;
      +
      5718 
      +
      5719  // Checks if requested suballocation with given parameters can be placed in given pFreeSuballocItem.
      +
      5720  // If yes, fills pOffset and returns true. If no, returns false.
      +
      5721  bool CheckAllocation(
      +
      5722  uint32_t currentFrameIndex,
      +
      5723  uint32_t frameInUseCount,
      +
      5724  VkDeviceSize bufferImageGranularity,
      +
      5725  VkDeviceSize allocSize,
      +
      5726  VkDeviceSize allocAlignment,
      +
      5727  VmaSuballocationType allocType,
      +
      5728  VmaSuballocationList::const_iterator suballocItem,
      +
      5729  bool canMakeOtherLost,
      +
      5730  VkDeviceSize* pOffset,
      +
      5731  size_t* itemsToMakeLostCount,
      +
      5732  VkDeviceSize* pSumFreeSize,
      +
      5733  VkDeviceSize* pSumItemSize) const;
      +
      5734  // Given free suballocation, it merges it with following one, which must also be free.
      +
      5735  void MergeFreeWithNext(VmaSuballocationList::iterator item);
      +
      5736  // Releases given suballocation, making it free.
      +
      5737  // Merges it with adjacent free suballocations if applicable.
      +
      5738  // Returns iterator to new free suballocation at this place.
      +
      5739  VmaSuballocationList::iterator FreeSuballocation(VmaSuballocationList::iterator suballocItem);
      +
      5740  // Given free suballocation, it inserts it into sorted list of
      +
      5741  // m_FreeSuballocationsBySize if it's suitable.
      +
      5742  void RegisterFreeSuballocation(VmaSuballocationList::iterator item);
      +
      5743  // Given free suballocation, it removes it from sorted list of
      +
      5744  // m_FreeSuballocationsBySize if it's suitable.
      +
      5745  void UnregisterFreeSuballocation(VmaSuballocationList::iterator item);
      +
      5746 };
      +
      5747 
      +
      5748 /*
      +
      5749 Allocations and their references in internal data structure look like this:
      +
      5750 
      +
      5751 if(m_2ndVectorMode == SECOND_VECTOR_EMPTY):
      +
      5752 
      +
      5753  0 +-------+
      +
      5754  | |
      +
      5755  | |
      +
      5756  | |
      5757  +-------+
      -
      5758  | Alloc | 1st[1st.size() - 1]
      +
      5758  | Alloc | 1st[m_1stNullItemsBeginCount]
      5759  +-------+
      -
      5760  | |
      -
      5761  | |
      -
      5762  | |
      +
      5760  | Alloc | 1st[m_1stNullItemsBeginCount + 1]
      +
      5761  +-------+
      +
      5762  | ... |
      5763  +-------+
      -
      5764  | Alloc | 2nd[2nd.size() - 1]
      +
      5764  | Alloc | 1st[1st.size() - 1]
      5765  +-------+
      -
      5766  | ... |
      -
      5767  +-------+
      -
      5768  | Alloc | 2nd[1]
      -
      5769  +-------+
      -
      5770  | Alloc | 2nd[0]
      -
      5771 GetSize() +-------+
      +
      5766  | |
      +
      5767  | |
      +
      5768  | |
      +
      5769 GetSize() +-------+
      +
      5770 
      +
      5771 if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER):
      5772 
      -
      5773 */
      -
      5774 class VmaBlockMetadata_Linear : public VmaBlockMetadata
      -
      5775 {
      -
      5776  VMA_CLASS_NO_COPY(VmaBlockMetadata_Linear)
      -
      5777 public:
      -
      5778  VmaBlockMetadata_Linear(VmaAllocator hAllocator);
      -
      5779  virtual ~VmaBlockMetadata_Linear();
      -
      5780  virtual void Init(VkDeviceSize size);
      -
      5781 
      -
      5782  virtual bool Validate() const;
      -
      5783  virtual size_t GetAllocationCount() const;
      -
      5784  virtual VkDeviceSize GetSumFreeSize() const { return m_SumFreeSize; }
      -
      5785  virtual VkDeviceSize GetUnusedRangeSizeMax() const;
      -
      5786  virtual bool IsEmpty() const { return GetAllocationCount() == 0; }
      -
      5787 
      -
      5788  virtual void CalcAllocationStatInfo(VmaStatInfo& outInfo) const;
      -
      5789  virtual void AddPoolStats(VmaPoolStats& inoutStats) const;
      -
      5790 
      -
      5791 #if VMA_STATS_STRING_ENABLED
      -
      5792  virtual void PrintDetailedMap(class VmaJsonWriter& json) const;
      -
      5793 #endif
      -
      5794 
      -
      5795  virtual bool CreateAllocationRequest(
      -
      5796  uint32_t currentFrameIndex,
      -
      5797  uint32_t frameInUseCount,
      -
      5798  VkDeviceSize bufferImageGranularity,
      -
      5799  VkDeviceSize allocSize,
      -
      5800  VkDeviceSize allocAlignment,
      -
      5801  bool upperAddress,
      -
      5802  VmaSuballocationType allocType,
      -
      5803  bool canMakeOtherLost,
      -
      5804  uint32_t strategy,
      -
      5805  VmaAllocationRequest* pAllocationRequest);
      -
      5806 
      -
      5807  virtual bool MakeRequestedAllocationsLost(
      -
      5808  uint32_t currentFrameIndex,
      -
      5809  uint32_t frameInUseCount,
      -
      5810  VmaAllocationRequest* pAllocationRequest);
      -
      5811 
      -
      5812  virtual uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
      -
      5813 
      -
      5814  virtual VkResult CheckCorruption(const void* pBlockData);
      -
      5815 
      -
      5816  virtual void Alloc(
      -
      5817  const VmaAllocationRequest& request,
      -
      5818  VmaSuballocationType type,
      -
      5819  VkDeviceSize allocSize,
      -
      5820  VmaAllocation hAllocation);
      -
      5821 
      -
      5822  virtual void Free(const VmaAllocation allocation);
      -
      5823  virtual void FreeAtOffset(VkDeviceSize offset);
      -
      5824 
      -
      5825 private:
      -
      5826  /*
      -
      5827  There are two suballocation vectors, used in ping-pong way.
      -
      5828  The one with index m_1stVectorIndex is called 1st.
      -
      5829  The one with index (m_1stVectorIndex ^ 1) is called 2nd.
      -
      5830  2nd can be non-empty only when 1st is not empty.
      -
      5831  When 2nd is not empty, m_2ndVectorMode indicates its mode of operation.
      -
      5832  */
      -
      5833  typedef VmaVector< VmaSuballocation, VmaStlAllocator<VmaSuballocation> > SuballocationVectorType;
      -
      5834 
      -
      5835  enum SECOND_VECTOR_MODE
      -
      5836  {
      -
      5837  SECOND_VECTOR_EMPTY,
      -
      5838  /*
      -
      5839  Suballocations in 2nd vector are created later than the ones in 1st, but they
      -
      5840  all have smaller offset.
      -
      5841  */
      -
      5842  SECOND_VECTOR_RING_BUFFER,
      -
      5843  /*
      -
      5844  Suballocations in 2nd vector are upper side of double stack.
      -
      5845  They all have offsets higher than those in 1st vector.
      -
      5846  Top of this stack means smaller offsets, but higher indices in this vector.
      -
      5847  */
      -
      5848  SECOND_VECTOR_DOUBLE_STACK,
      -
      5849  };
      -
      5850 
      -
      5851  VkDeviceSize m_SumFreeSize;
      -
      5852  SuballocationVectorType m_Suballocations0, m_Suballocations1;
      -
      5853  uint32_t m_1stVectorIndex;
      -
      5854  SECOND_VECTOR_MODE m_2ndVectorMode;
      -
      5855 
      -
      5856  SuballocationVectorType& AccessSuballocations1st() { return m_1stVectorIndex ? m_Suballocations1 : m_Suballocations0; }
      -
      5857  SuballocationVectorType& AccessSuballocations2nd() { return m_1stVectorIndex ? m_Suballocations0 : m_Suballocations1; }
      -
      5858  const SuballocationVectorType& AccessSuballocations1st() const { return m_1stVectorIndex ? m_Suballocations1 : m_Suballocations0; }
      -
      5859  const SuballocationVectorType& AccessSuballocations2nd() const { return m_1stVectorIndex ? m_Suballocations0 : m_Suballocations1; }
      -
      5860 
      -
      5861  // Number of items in 1st vector with hAllocation = null at the beginning.
      -
      5862  size_t m_1stNullItemsBeginCount;
      -
      5863  // Number of other items in 1st vector with hAllocation = null somewhere in the middle.
      -
      5864  size_t m_1stNullItemsMiddleCount;
      -
      5865  // Number of items in 2nd vector with hAllocation = null.
      -
      5866  size_t m_2ndNullItemsCount;
      +
      5773  0 +-------+
      +
      5774  | Alloc | 2nd[0]
      +
      5775  +-------+
      +
      5776  | Alloc | 2nd[1]
      +
      5777  +-------+
      +
      5778  | ... |
      +
      5779  +-------+
      +
      5780  | Alloc | 2nd[2nd.size() - 1]
      +
      5781  +-------+
      +
      5782  | |
      +
      5783  | |
      +
      5784  | |
      +
      5785  +-------+
      +
      5786  | Alloc | 1st[m_1stNullItemsBeginCount]
      +
      5787  +-------+
      +
      5788  | Alloc | 1st[m_1stNullItemsBeginCount + 1]
      +
      5789  +-------+
      +
      5790  | ... |
      +
      5791  +-------+
      +
      5792  | Alloc | 1st[1st.size() - 1]
      +
      5793  +-------+
      +
      5794  | |
      +
      5795 GetSize() +-------+
      +
      5796 
      +
      5797 if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK):
      +
      5798 
      +
      5799  0 +-------+
      +
      5800  | |
      +
      5801  | |
      +
      5802  | |
      +
      5803  +-------+
      +
      5804  | Alloc | 1st[m_1stNullItemsBeginCount]
      +
      5805  +-------+
      +
      5806  | Alloc | 1st[m_1stNullItemsBeginCount + 1]
      +
      5807  +-------+
      +
      5808  | ... |
      +
      5809  +-------+
      +
      5810  | Alloc | 1st[1st.size() - 1]
      +
      5811  +-------+
      +
      5812  | |
      +
      5813  | |
      +
      5814  | |
      +
      5815  +-------+
      +
      5816  | Alloc | 2nd[2nd.size() - 1]
      +
      5817  +-------+
      +
      5818  | ... |
      +
      5819  +-------+
      +
      5820  | Alloc | 2nd[1]
      +
      5821  +-------+
      +
      5822  | Alloc | 2nd[0]
      +
      5823 GetSize() +-------+
      +
      5824 
      +
      5825 */
      +
      5826 class VmaBlockMetadata_Linear : public VmaBlockMetadata
      +
      5827 {
      +
      5828  VMA_CLASS_NO_COPY(VmaBlockMetadata_Linear)
      +
      5829 public:
      +
      5830  VmaBlockMetadata_Linear(VmaAllocator hAllocator);
      +
      5831  virtual ~VmaBlockMetadata_Linear();
      +
      5832  virtual void Init(VkDeviceSize size);
      +
      5833 
      +
      5834  virtual bool Validate() const;
      +
      5835  virtual size_t GetAllocationCount() const;
      +
      5836  virtual VkDeviceSize GetSumFreeSize() const { return m_SumFreeSize; }
      +
      5837  virtual VkDeviceSize GetUnusedRangeSizeMax() const;
      +
      5838  virtual bool IsEmpty() const { return GetAllocationCount() == 0; }
      +
      5839 
      +
      5840  virtual void CalcAllocationStatInfo(VmaStatInfo& outInfo) const;
      +
      5841  virtual void AddPoolStats(VmaPoolStats& inoutStats) const;
      +
      5842 
      +
      5843 #if VMA_STATS_STRING_ENABLED
      +
      5844  virtual void PrintDetailedMap(class VmaJsonWriter& json) const;
      +
      5845 #endif
      +
      5846 
      +
      5847  virtual bool CreateAllocationRequest(
      +
      5848  uint32_t currentFrameIndex,
      +
      5849  uint32_t frameInUseCount,
      +
      5850  VkDeviceSize bufferImageGranularity,
      +
      5851  VkDeviceSize allocSize,
      +
      5852  VkDeviceSize allocAlignment,
      +
      5853  bool upperAddress,
      +
      5854  VmaSuballocationType allocType,
      +
      5855  bool canMakeOtherLost,
      +
      5856  uint32_t strategy,
      +
      5857  VmaAllocationRequest* pAllocationRequest);
      +
      5858 
      +
      5859  virtual bool MakeRequestedAllocationsLost(
      +
      5860  uint32_t currentFrameIndex,
      +
      5861  uint32_t frameInUseCount,
      +
      5862  VmaAllocationRequest* pAllocationRequest);
      +
      5863 
      +
      5864  virtual uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
      +
      5865 
      +
      5866  virtual VkResult CheckCorruption(const void* pBlockData);
      5867 
      -
      5868  bool ShouldCompact1st() const;
      -
      5869  void CleanupAfterFree();
      -
      5870 
      -
      5871  bool CreateAllocationRequest_LowerAddress(
      -
      5872  uint32_t currentFrameIndex,
      -
      5873  uint32_t frameInUseCount,
      -
      5874  VkDeviceSize bufferImageGranularity,
      -
      5875  VkDeviceSize allocSize,
      -
      5876  VkDeviceSize allocAlignment,
      -
      5877  VmaSuballocationType allocType,
      -
      5878  bool canMakeOtherLost,
      -
      5879  uint32_t strategy,
      -
      5880  VmaAllocationRequest* pAllocationRequest);
      -
      5881  bool CreateAllocationRequest_UpperAddress(
      -
      5882  uint32_t currentFrameIndex,
      -
      5883  uint32_t frameInUseCount,
      -
      5884  VkDeviceSize bufferImageGranularity,
      -
      5885  VkDeviceSize allocSize,
      -
      5886  VkDeviceSize allocAlignment,
      -
      5887  VmaSuballocationType allocType,
      -
      5888  bool canMakeOtherLost,
      -
      5889  uint32_t strategy,
      -
      5890  VmaAllocationRequest* pAllocationRequest);
      -
      5891 };
      -
      5892 
      -
      5893 /*
      -
      5894 - GetSize() is the original size of allocated memory block.
      -
      5895 - m_UsableSize is this size aligned down to a power of two.
      -
      5896  All allocations and calculations happen relative to m_UsableSize.
      -
      5897 - GetUnusableSize() is the difference between them.
      -
      5898  It is repoted as separate, unused range, not available for allocations.
      -
      5899 
      -
      5900 Node at level 0 has size = m_UsableSize.
      -
      5901 Each next level contains nodes with size 2 times smaller than current level.
      -
      5902 m_LevelCount is the maximum number of levels to use in the current object.
      -
      5903 */
      -
      5904 class VmaBlockMetadata_Buddy : public VmaBlockMetadata
      -
      5905 {
      -
      5906  VMA_CLASS_NO_COPY(VmaBlockMetadata_Buddy)
      -
      5907 public:
      -
      5908  VmaBlockMetadata_Buddy(VmaAllocator hAllocator);
      -
      5909  virtual ~VmaBlockMetadata_Buddy();
      -
      5910  virtual void Init(VkDeviceSize size);
      -
      5911 
      -
      5912  virtual bool Validate() const;
      -
      5913  virtual size_t GetAllocationCount() const { return m_AllocationCount; }
      -
      5914  virtual VkDeviceSize GetSumFreeSize() const { return m_SumFreeSize + GetUnusableSize(); }
      -
      5915  virtual VkDeviceSize GetUnusedRangeSizeMax() const;
      -
      5916  virtual bool IsEmpty() const { return m_Root->type == Node::TYPE_FREE; }
      -
      5917 
      -
      5918  virtual void CalcAllocationStatInfo(VmaStatInfo& outInfo) const;
      -
      5919  virtual void AddPoolStats(VmaPoolStats& inoutStats) const;
      -
      5920 
      -
      5921 #if VMA_STATS_STRING_ENABLED
      -
      5922  virtual void PrintDetailedMap(class VmaJsonWriter& json) const;
      -
      5923 #endif
      -
      5924 
      -
      5925  virtual bool CreateAllocationRequest(
      -
      5926  uint32_t currentFrameIndex,
      -
      5927  uint32_t frameInUseCount,
      -
      5928  VkDeviceSize bufferImageGranularity,
      -
      5929  VkDeviceSize allocSize,
      -
      5930  VkDeviceSize allocAlignment,
      -
      5931  bool upperAddress,
      -
      5932  VmaSuballocationType allocType,
      -
      5933  bool canMakeOtherLost,
      -
      5934  uint32_t strategy,
      -
      5935  VmaAllocationRequest* pAllocationRequest);
      -
      5936 
      -
      5937  virtual bool MakeRequestedAllocationsLost(
      -
      5938  uint32_t currentFrameIndex,
      -
      5939  uint32_t frameInUseCount,
      -
      5940  VmaAllocationRequest* pAllocationRequest);
      -
      5941 
      -
      5942  virtual uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
      -
      5943 
      -
      5944  virtual VkResult CheckCorruption(const void* pBlockData) { return VK_ERROR_FEATURE_NOT_PRESENT; }
      -
      5945 
      -
      5946  virtual void Alloc(
      -
      5947  const VmaAllocationRequest& request,
      -
      5948  VmaSuballocationType type,
      -
      5949  VkDeviceSize allocSize,
      -
      5950  VmaAllocation hAllocation);
      -
      5951 
      -
      5952  virtual void Free(const VmaAllocation allocation) { FreeAtOffset(allocation, allocation->GetOffset()); }
      -
      5953  virtual void FreeAtOffset(VkDeviceSize offset) { FreeAtOffset(VMA_NULL, offset); }
      -
      5954 
      -
      5955 private:
      -
      5956  static const VkDeviceSize MIN_NODE_SIZE = 32;
      -
      5957  static const size_t MAX_LEVELS = 30;
      -
      5958 
      -
      5959  struct ValidationContext
      -
      5960  {
      -
      5961  size_t calculatedAllocationCount;
      -
      5962  size_t calculatedFreeCount;
      -
      5963  VkDeviceSize calculatedSumFreeSize;
      -
      5964 
      -
      5965  ValidationContext() :
      -
      5966  calculatedAllocationCount(0),
      -
      5967  calculatedFreeCount(0),
      -
      5968  calculatedSumFreeSize(0) { }
      -
      5969  };
      -
      5970 
      -
      5971  struct Node
      -
      5972  {
      -
      5973  VkDeviceSize offset;
      -
      5974  enum TYPE
      -
      5975  {
      -
      5976  TYPE_FREE,
      -
      5977  TYPE_ALLOCATION,
      -
      5978  TYPE_SPLIT,
      -
      5979  TYPE_COUNT
      -
      5980  } type;
      -
      5981  Node* parent;
      -
      5982  Node* buddy;
      -
      5983 
      -
      5984  union
      -
      5985  {
      -
      5986  struct
      -
      5987  {
      -
      5988  Node* prev;
      -
      5989  Node* next;
      -
      5990  } free;
      -
      5991  struct
      -
      5992  {
      -
      5993  VmaAllocation alloc;
      -
      5994  } allocation;
      -
      5995  struct
      -
      5996  {
      -
      5997  Node* leftChild;
      -
      5998  } split;
      -
      5999  };
      -
      6000  };
      -
      6001 
      -
      6002  // Size of the memory block aligned down to a power of two.
      -
      6003  VkDeviceSize m_UsableSize;
      -
      6004  uint32_t m_LevelCount;
      -
      6005 
      -
      6006  Node* m_Root;
      -
      6007  struct {
      -
      6008  Node* front;
      -
      6009  Node* back;
      -
      6010  } m_FreeList[MAX_LEVELS];
      -
      6011  // Number of nodes in the tree with type == TYPE_ALLOCATION.
      -
      6012  size_t m_AllocationCount;
      -
      6013  // Number of nodes in the tree with type == TYPE_FREE.
      -
      6014  size_t m_FreeCount;
      -
      6015  // This includes space wasted due to internal fragmentation. Doesn't include unusable size.
      -
      6016  VkDeviceSize m_SumFreeSize;
      -
      6017 
      -
      6018  VkDeviceSize GetUnusableSize() const { return GetSize() - m_UsableSize; }
      -
      6019  void DeleteNode(Node* node);
      -
      6020  bool ValidateNode(ValidationContext& ctx, const Node* parent, const Node* curr, uint32_t level, VkDeviceSize levelNodeSize) const;
      -
      6021  uint32_t AllocSizeToLevel(VkDeviceSize allocSize) const;
      -
      6022  inline VkDeviceSize LevelToNodeSize(uint32_t level) const { return m_UsableSize >> level; }
      -
      6023  // Alloc passed just for validation. Can be null.
      -
      6024  void FreeAtOffset(VmaAllocation alloc, VkDeviceSize offset);
      -
      6025  void CalcAllocationStatInfoNode(VmaStatInfo& outInfo, const Node* node, VkDeviceSize levelNodeSize) const;
      -
      6026  // Adds node to the front of FreeList at given level.
      -
      6027  // node->type must be FREE.
      -
      6028  // node->free.prev, next can be undefined.
      -
      6029  void AddToFreeListFront(uint32_t level, Node* node);
      -
      6030  // Removes node from FreeList at given level.
      -
      6031  // node->type must be FREE.
      -
      6032  // node->free.prev, next stay untouched.
      -
      6033  void RemoveFromFreeList(uint32_t level, Node* node);
      -
      6034 
      -
      6035 #if VMA_STATS_STRING_ENABLED
      -
      6036  void PrintDetailedMapNode(class VmaJsonWriter& json, const Node* node, VkDeviceSize levelNodeSize) const;
      -
      6037 #endif
      -
      6038 };
      -
      6039 
      -
      6040 /*
      -
      6041 Represents a single block of device memory (`VkDeviceMemory`) with all the
      -
      6042 data about its regions (aka suballocations, #VmaAllocation), assigned and free.
      -
      6043 
      -
      6044 Thread-safety: This class must be externally synchronized.
      -
      6045 */
      -
      6046 class VmaDeviceMemoryBlock
      -
      6047 {
      -
      6048  VMA_CLASS_NO_COPY(VmaDeviceMemoryBlock)
      -
      6049 public:
      -
      6050  VmaBlockMetadata* m_pMetadata;
      -
      6051 
      -
      6052  VmaDeviceMemoryBlock(VmaAllocator hAllocator);
      +
      5868  virtual void Alloc(
      +
      5869  const VmaAllocationRequest& request,
      +
      5870  VmaSuballocationType type,
      +
      5871  VkDeviceSize allocSize,
      +
      5872  VmaAllocation hAllocation);
      +
      5873 
      +
      5874  virtual void Free(const VmaAllocation allocation);
      +
      5875  virtual void FreeAtOffset(VkDeviceSize offset);
      +
      5876 
      +
      5877 private:
      +
      5878  /*
      +
      5879  There are two suballocation vectors, used in ping-pong way.
      +
      5880  The one with index m_1stVectorIndex is called 1st.
      +
      5881  The one with index (m_1stVectorIndex ^ 1) is called 2nd.
      +
      5882  2nd can be non-empty only when 1st is not empty.
      +
      5883  When 2nd is not empty, m_2ndVectorMode indicates its mode of operation.
      +
      5884  */
      +
      5885  typedef VmaVector< VmaSuballocation, VmaStlAllocator<VmaSuballocation> > SuballocationVectorType;
      +
      5886 
      +
      5887  enum SECOND_VECTOR_MODE
      +
      5888  {
      +
      5889  SECOND_VECTOR_EMPTY,
      +
      5890  /*
      +
      5891  Suballocations in 2nd vector are created later than the ones in 1st, but they
      +
      5892  all have smaller offset.
      +
      5893  */
      +
      5894  SECOND_VECTOR_RING_BUFFER,
      +
      5895  /*
      +
      5896  Suballocations in 2nd vector are upper side of double stack.
      +
      5897  They all have offsets higher than those in 1st vector.
      +
      5898  Top of this stack means smaller offsets, but higher indices in this vector.
      +
      5899  */
      +
      5900  SECOND_VECTOR_DOUBLE_STACK,
      +
      5901  };
      +
      5902 
      +
      5903  VkDeviceSize m_SumFreeSize;
      +
      5904  SuballocationVectorType m_Suballocations0, m_Suballocations1;
      +
      5905  uint32_t m_1stVectorIndex;
      +
      5906  SECOND_VECTOR_MODE m_2ndVectorMode;
      +
      5907 
      +
      5908  SuballocationVectorType& AccessSuballocations1st() { return m_1stVectorIndex ? m_Suballocations1 : m_Suballocations0; }
      +
      5909  SuballocationVectorType& AccessSuballocations2nd() { return m_1stVectorIndex ? m_Suballocations0 : m_Suballocations1; }
      +
      5910  const SuballocationVectorType& AccessSuballocations1st() const { return m_1stVectorIndex ? m_Suballocations1 : m_Suballocations0; }
      +
      5911  const SuballocationVectorType& AccessSuballocations2nd() const { return m_1stVectorIndex ? m_Suballocations0 : m_Suballocations1; }
      +
      5912 
      +
      5913  // Number of items in 1st vector with hAllocation = null at the beginning.
      +
      5914  size_t m_1stNullItemsBeginCount;
      +
      5915  // Number of other items in 1st vector with hAllocation = null somewhere in the middle.
      +
      5916  size_t m_1stNullItemsMiddleCount;
      +
      5917  // Number of items in 2nd vector with hAllocation = null.
      +
      5918  size_t m_2ndNullItemsCount;
      +
      5919 
      +
      5920  bool ShouldCompact1st() const;
      +
      5921  void CleanupAfterFree();
      +
      5922 
      +
      5923  bool CreateAllocationRequest_LowerAddress(
      +
      5924  uint32_t currentFrameIndex,
      +
      5925  uint32_t frameInUseCount,
      +
      5926  VkDeviceSize bufferImageGranularity,
      +
      5927  VkDeviceSize allocSize,
      +
      5928  VkDeviceSize allocAlignment,
      +
      5929  VmaSuballocationType allocType,
      +
      5930  bool canMakeOtherLost,
      +
      5931  uint32_t strategy,
      +
      5932  VmaAllocationRequest* pAllocationRequest);
      +
      5933  bool CreateAllocationRequest_UpperAddress(
      +
      5934  uint32_t currentFrameIndex,
      +
      5935  uint32_t frameInUseCount,
      +
      5936  VkDeviceSize bufferImageGranularity,
      +
      5937  VkDeviceSize allocSize,
      +
      5938  VkDeviceSize allocAlignment,
      +
      5939  VmaSuballocationType allocType,
      +
      5940  bool canMakeOtherLost,
      +
      5941  uint32_t strategy,
      +
      5942  VmaAllocationRequest* pAllocationRequest);
      +
      5943 };
      +
      5944 
      +
      5945 /*
      +
      5946 - GetSize() is the original size of allocated memory block.
      +
      5947 - m_UsableSize is this size aligned down to a power of two.
      +
      5948  All allocations and calculations happen relative to m_UsableSize.
      +
      5949 - GetUnusableSize() is the difference between them.
      +
      5950  It is repoted as separate, unused range, not available for allocations.
      +
      5951 
      +
      5952 Node at level 0 has size = m_UsableSize.
      +
      5953 Each next level contains nodes with size 2 times smaller than current level.
      +
      5954 m_LevelCount is the maximum number of levels to use in the current object.
      +
      5955 */
      +
      5956 class VmaBlockMetadata_Buddy : public VmaBlockMetadata
      +
      5957 {
      +
      5958  VMA_CLASS_NO_COPY(VmaBlockMetadata_Buddy)
      +
      5959 public:
      +
      5960  VmaBlockMetadata_Buddy(VmaAllocator hAllocator);
      +
      5961  virtual ~VmaBlockMetadata_Buddy();
      +
      5962  virtual void Init(VkDeviceSize size);
      +
      5963 
      +
      5964  virtual bool Validate() const;
      +
      5965  virtual size_t GetAllocationCount() const { return m_AllocationCount; }
      +
      5966  virtual VkDeviceSize GetSumFreeSize() const { return m_SumFreeSize + GetUnusableSize(); }
      +
      5967  virtual VkDeviceSize GetUnusedRangeSizeMax() const;
      +
      5968  virtual bool IsEmpty() const { return m_Root->type == Node::TYPE_FREE; }
      +
      5969 
      +
      5970  virtual void CalcAllocationStatInfo(VmaStatInfo& outInfo) const;
      +
      5971  virtual void AddPoolStats(VmaPoolStats& inoutStats) const;
      +
      5972 
      +
      5973 #if VMA_STATS_STRING_ENABLED
      +
      5974  virtual void PrintDetailedMap(class VmaJsonWriter& json) const;
      +
      5975 #endif
      +
      5976 
      +
      5977  virtual bool CreateAllocationRequest(
      +
      5978  uint32_t currentFrameIndex,
      +
      5979  uint32_t frameInUseCount,
      +
      5980  VkDeviceSize bufferImageGranularity,
      +
      5981  VkDeviceSize allocSize,
      +
      5982  VkDeviceSize allocAlignment,
      +
      5983  bool upperAddress,
      +
      5984  VmaSuballocationType allocType,
      +
      5985  bool canMakeOtherLost,
      +
      5986  uint32_t strategy,
      +
      5987  VmaAllocationRequest* pAllocationRequest);
      +
      5988 
      +
      5989  virtual bool MakeRequestedAllocationsLost(
      +
      5990  uint32_t currentFrameIndex,
      +
      5991  uint32_t frameInUseCount,
      +
      5992  VmaAllocationRequest* pAllocationRequest);
      +
      5993 
      +
      5994  virtual uint32_t MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount);
      +
      5995 
      +
      5996  virtual VkResult CheckCorruption(const void* pBlockData) { return VK_ERROR_FEATURE_NOT_PRESENT; }
      +
      5997 
      +
      5998  virtual void Alloc(
      +
      5999  const VmaAllocationRequest& request,
      +
      6000  VmaSuballocationType type,
      +
      6001  VkDeviceSize allocSize,
      +
      6002  VmaAllocation hAllocation);
      +
      6003 
      +
      6004  virtual void Free(const VmaAllocation allocation) { FreeAtOffset(allocation, allocation->GetOffset()); }
      +
      6005  virtual void FreeAtOffset(VkDeviceSize offset) { FreeAtOffset(VMA_NULL, offset); }
      +
      6006 
      +
      6007 private:
      +
      6008  static const VkDeviceSize MIN_NODE_SIZE = 32;
      +
      6009  static const size_t MAX_LEVELS = 30;
      +
      6010 
      +
      6011  struct ValidationContext
      +
      6012  {
      +
      6013  size_t calculatedAllocationCount;
      +
      6014  size_t calculatedFreeCount;
      +
      6015  VkDeviceSize calculatedSumFreeSize;
      +
      6016 
      +
      6017  ValidationContext() :
      +
      6018  calculatedAllocationCount(0),
      +
      6019  calculatedFreeCount(0),
      +
      6020  calculatedSumFreeSize(0) { }
      +
      6021  };
      +
      6022 
      +
      6023  struct Node
      +
      6024  {
      +
      6025  VkDeviceSize offset;
      +
      6026  enum TYPE
      +
      6027  {
      +
      6028  TYPE_FREE,
      +
      6029  TYPE_ALLOCATION,
      +
      6030  TYPE_SPLIT,
      +
      6031  TYPE_COUNT
      +
      6032  } type;
      +
      6033  Node* parent;
      +
      6034  Node* buddy;
      +
      6035 
      +
      6036  union
      +
      6037  {
      +
      6038  struct
      +
      6039  {
      +
      6040  Node* prev;
      +
      6041  Node* next;
      +
      6042  } free;
      +
      6043  struct
      +
      6044  {
      +
      6045  VmaAllocation alloc;
      +
      6046  } allocation;
      +
      6047  struct
      +
      6048  {
      +
      6049  Node* leftChild;
      +
      6050  } split;
      +
      6051  };
      +
      6052  };
      6053 
      -
      6054  ~VmaDeviceMemoryBlock()
      -
      6055  {
      -
      6056  VMA_ASSERT(m_MapCount == 0 && "VkDeviceMemory block is being destroyed while it is still mapped.");
      -
      6057  VMA_ASSERT(m_hMemory == VK_NULL_HANDLE);
      -
      6058  }
      -
      6059 
      -
      6060  // Always call after construction.
      -
      6061  void Init(
      -
      6062  VmaAllocator hAllocator,
      -
      6063  VmaPool hParentPool,
      -
      6064  uint32_t newMemoryTypeIndex,
      -
      6065  VkDeviceMemory newMemory,
      -
      6066  VkDeviceSize newSize,
      -
      6067  uint32_t id,
      -
      6068  uint32_t algorithm);
      -
      6069  // Always call before destruction.
      -
      6070  void Destroy(VmaAllocator allocator);
      -
      6071 
      -
      6072  VmaPool GetParentPool() const { return m_hParentPool; }
      -
      6073  VkDeviceMemory GetDeviceMemory() const { return m_hMemory; }
      -
      6074  uint32_t GetMemoryTypeIndex() const { return m_MemoryTypeIndex; }
      -
      6075  uint32_t GetId() const { return m_Id; }
      -
      6076  void* GetMappedData() const { return m_pMappedData; }
      -
      6077 
      -
      6078  // Validates all data structures inside this object. If not valid, returns false.
      -
      6079  bool Validate() const;
      -
      6080 
      -
      6081  VkResult CheckCorruption(VmaAllocator hAllocator);
      -
      6082 
      -
      6083  // ppData can be null.
      -
      6084  VkResult Map(VmaAllocator hAllocator, uint32_t count, void** ppData);
      -
      6085  void Unmap(VmaAllocator hAllocator, uint32_t count);
      +
      6054  // Size of the memory block aligned down to a power of two.
      +
      6055  VkDeviceSize m_UsableSize;
      +
      6056  uint32_t m_LevelCount;
      +
      6057 
      +
      6058  Node* m_Root;
      +
      6059  struct {
      +
      6060  Node* front;
      +
      6061  Node* back;
      +
      6062  } m_FreeList[MAX_LEVELS];
      +
      6063  // Number of nodes in the tree with type == TYPE_ALLOCATION.
      +
      6064  size_t m_AllocationCount;
      +
      6065  // Number of nodes in the tree with type == TYPE_FREE.
      +
      6066  size_t m_FreeCount;
      +
      6067  // This includes space wasted due to internal fragmentation. Doesn't include unusable size.
      +
      6068  VkDeviceSize m_SumFreeSize;
      +
      6069 
      +
      6070  VkDeviceSize GetUnusableSize() const { return GetSize() - m_UsableSize; }
      +
      6071  void DeleteNode(Node* node);
      +
      6072  bool ValidateNode(ValidationContext& ctx, const Node* parent, const Node* curr, uint32_t level, VkDeviceSize levelNodeSize) const;
      +
      6073  uint32_t AllocSizeToLevel(VkDeviceSize allocSize) const;
      +
      6074  inline VkDeviceSize LevelToNodeSize(uint32_t level) const { return m_UsableSize >> level; }
      +
      6075  // Alloc passed just for validation. Can be null.
      +
      6076  void FreeAtOffset(VmaAllocation alloc, VkDeviceSize offset);
      +
      6077  void CalcAllocationStatInfoNode(VmaStatInfo& outInfo, const Node* node, VkDeviceSize levelNodeSize) const;
      +
      6078  // Adds node to the front of FreeList at given level.
      +
      6079  // node->type must be FREE.
      +
      6080  // node->free.prev, next can be undefined.
      +
      6081  void AddToFreeListFront(uint32_t level, Node* node);
      +
      6082  // Removes node from FreeList at given level.
      +
      6083  // node->type must be FREE.
      +
      6084  // node->free.prev, next stay untouched.
      +
      6085  void RemoveFromFreeList(uint32_t level, Node* node);
      6086 
      -
      6087  VkResult WriteMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize);
      -
      6088  VkResult ValidateMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize);
      -
      6089 
      -
      6090  VkResult BindBufferMemory(
      -
      6091  const VmaAllocator hAllocator,
      -
      6092  const VmaAllocation hAllocation,
      -
      6093  VkDeviceSize allocationLocalOffset,
      -
      6094  VkBuffer hBuffer,
      -
      6095  const void* pNext);
      -
      6096  VkResult BindImageMemory(
      -
      6097  const VmaAllocator hAllocator,
      -
      6098  const VmaAllocation hAllocation,
      -
      6099  VkDeviceSize allocationLocalOffset,
      -
      6100  VkImage hImage,
      -
      6101  const void* pNext);
      -
      6102 
      -
      6103 private:
      -
      6104  VmaPool m_hParentPool; // VK_NULL_HANDLE if not belongs to custom pool.
      -
      6105  uint32_t m_MemoryTypeIndex;
      -
      6106  uint32_t m_Id;
      -
      6107  VkDeviceMemory m_hMemory;
      -
      6108 
      -
      6109  /*
      -
      6110  Protects access to m_hMemory so it's not used by multiple threads simultaneously, e.g. vkMapMemory, vkBindBufferMemory.
      -
      6111  Also protects m_MapCount, m_pMappedData.
      -
      6112  Allocations, deallocations, any change in m_pMetadata is protected by parent's VmaBlockVector::m_Mutex.
      -
      6113  */
      -
      6114  VMA_MUTEX m_Mutex;
      -
      6115  uint32_t m_MapCount;
      -
      6116  void* m_pMappedData;
      -
      6117 };
      -
      6118 
      -
      6119 struct VmaPointerLess
      -
      6120 {
      -
      6121  bool operator()(const void* lhs, const void* rhs) const
      -
      6122  {
      -
      6123  return lhs < rhs;
      -
      6124  }
      -
      6125 };
      -
      6126 
      -
      6127 struct VmaDefragmentationMove
      -
      6128 {
      -
      6129  size_t srcBlockIndex;
      -
      6130  size_t dstBlockIndex;
      -
      6131  VkDeviceSize srcOffset;
      -
      6132  VkDeviceSize dstOffset;
      -
      6133  VkDeviceSize size;
      -
      6134 };
      -
      6135 
      -
      6136 class VmaDefragmentationAlgorithm;
      -
      6137 
      -
      6138 /*
      -
      6139 Sequence of VmaDeviceMemoryBlock. Represents memory blocks allocated for a specific
      -
      6140 Vulkan memory type.
      -
      6141 
      -
      6142 Synchronized internally with a mutex.
      -
      6143 */
      -
      6144 struct VmaBlockVector
      -
      6145 {
      -
      6146  VMA_CLASS_NO_COPY(VmaBlockVector)
      -
      6147 public:
      -
      6148  VmaBlockVector(
      -
      6149  VmaAllocator hAllocator,
      -
      6150  VmaPool hParentPool,
      -
      6151  uint32_t memoryTypeIndex,
      -
      6152  VkDeviceSize preferredBlockSize,
      -
      6153  size_t minBlockCount,
      -
      6154  size_t maxBlockCount,
      -
      6155  VkDeviceSize bufferImageGranularity,
      -
      6156  uint32_t frameInUseCount,
      -
      6157  bool isCustomPool,
      -
      6158  bool explicitBlockSize,
      -
      6159  uint32_t algorithm);
      -
      6160  ~VmaBlockVector();
      -
      6161 
      -
      6162  VkResult CreateMinBlocks();
      -
      6163 
      -
      6164  VmaPool GetParentPool() const { return m_hParentPool; }
      -
      6165  uint32_t GetMemoryTypeIndex() const { return m_MemoryTypeIndex; }
      -
      6166  VkDeviceSize GetPreferredBlockSize() const { return m_PreferredBlockSize; }
      -
      6167  VkDeviceSize GetBufferImageGranularity() const { return m_BufferImageGranularity; }
      -
      6168  uint32_t GetFrameInUseCount() const { return m_FrameInUseCount; }
      -
      6169  uint32_t GetAlgorithm() const { return m_Algorithm; }
      +
      6087 #if VMA_STATS_STRING_ENABLED
      +
      6088  void PrintDetailedMapNode(class VmaJsonWriter& json, const Node* node, VkDeviceSize levelNodeSize) const;
      +
      6089 #endif
      +
      6090 };
      +
      6091 
      +
      6092 /*
      +
      6093 Represents a single block of device memory (`VkDeviceMemory`) with all the
      +
      6094 data about its regions (aka suballocations, #VmaAllocation), assigned and free.
      +
      6095 
      +
      6096 Thread-safety: This class must be externally synchronized.
      +
      6097 */
      +
      6098 class VmaDeviceMemoryBlock
      +
      6099 {
      +
      6100  VMA_CLASS_NO_COPY(VmaDeviceMemoryBlock)
      +
      6101 public:
      +
      6102  VmaBlockMetadata* m_pMetadata;
      +
      6103 
      +
      6104  VmaDeviceMemoryBlock(VmaAllocator hAllocator);
      +
      6105 
      +
      6106  ~VmaDeviceMemoryBlock()
      +
      6107  {
      +
      6108  VMA_ASSERT(m_MapCount == 0 && "VkDeviceMemory block is being destroyed while it is still mapped.");
      +
      6109  VMA_ASSERT(m_hMemory == VK_NULL_HANDLE);
      +
      6110  }
      +
      6111 
      +
      6112  // Always call after construction.
      +
      6113  void Init(
      +
      6114  VmaAllocator hAllocator,
      +
      6115  VmaPool hParentPool,
      +
      6116  uint32_t newMemoryTypeIndex,
      +
      6117  VkDeviceMemory newMemory,
      +
      6118  VkDeviceSize newSize,
      +
      6119  uint32_t id,
      +
      6120  uint32_t algorithm);
      +
      6121  // Always call before destruction.
      +
      6122  void Destroy(VmaAllocator allocator);
      +
      6123 
      +
      6124  VmaPool GetParentPool() const { return m_hParentPool; }
      +
      6125  VkDeviceMemory GetDeviceMemory() const { return m_hMemory; }
      +
      6126  uint32_t GetMemoryTypeIndex() const { return m_MemoryTypeIndex; }
      +
      6127  uint32_t GetId() const { return m_Id; }
      +
      6128  void* GetMappedData() const { return m_pMappedData; }
      +
      6129 
      +
      6130  // Validates all data structures inside this object. If not valid, returns false.
      +
      6131  bool Validate() const;
      +
      6132 
      +
      6133  VkResult CheckCorruption(VmaAllocator hAllocator);
      +
      6134 
      +
      6135  // ppData can be null.
      +
      6136  VkResult Map(VmaAllocator hAllocator, uint32_t count, void** ppData);
      +
      6137  void Unmap(VmaAllocator hAllocator, uint32_t count);
      +
      6138 
      +
      6139  VkResult WriteMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize);
      +
      6140  VkResult ValidateMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize);
      +
      6141 
      +
      6142  VkResult BindBufferMemory(
      +
      6143  const VmaAllocator hAllocator,
      +
      6144  const VmaAllocation hAllocation,
      +
      6145  VkDeviceSize allocationLocalOffset,
      +
      6146  VkBuffer hBuffer,
      +
      6147  const void* pNext);
      +
      6148  VkResult BindImageMemory(
      +
      6149  const VmaAllocator hAllocator,
      +
      6150  const VmaAllocation hAllocation,
      +
      6151  VkDeviceSize allocationLocalOffset,
      +
      6152  VkImage hImage,
      +
      6153  const void* pNext);
      +
      6154 
      +
      6155 private:
      +
      6156  VmaPool m_hParentPool; // VK_NULL_HANDLE if not belongs to custom pool.
      +
      6157  uint32_t m_MemoryTypeIndex;
      +
      6158  uint32_t m_Id;
      +
      6159  VkDeviceMemory m_hMemory;
      +
      6160 
      +
      6161  /*
      +
      6162  Protects access to m_hMemory so it's not used by multiple threads simultaneously, e.g. vkMapMemory, vkBindBufferMemory.
      +
      6163  Also protects m_MapCount, m_pMappedData.
      +
      6164  Allocations, deallocations, any change in m_pMetadata is protected by parent's VmaBlockVector::m_Mutex.
      +
      6165  */
      +
      6166  VMA_MUTEX m_Mutex;
      +
      6167  uint32_t m_MapCount;
      +
      6168  void* m_pMappedData;
      +
      6169 };
      6170 
      -
      6171  void GetPoolStats(VmaPoolStats* pStats);
      -
      6172 
      -
      6173  bool IsEmpty() const { return m_Blocks.empty(); }
      -
      6174  bool IsCorruptionDetectionEnabled() const;
      -
      6175 
      -
      6176  VkResult Allocate(
      -
      6177  uint32_t currentFrameIndex,
      -
      6178  VkDeviceSize size,
      -
      6179  VkDeviceSize alignment,
      -
      6180  const VmaAllocationCreateInfo& createInfo,
      -
      6181  VmaSuballocationType suballocType,
      -
      6182  size_t allocationCount,
      -
      6183  VmaAllocation* pAllocations);
      -
      6184 
      -
      6185  void Free(const VmaAllocation hAllocation);
      -
      6186 
      -
      6187  // Adds statistics of this BlockVector to pStats.
      -
      6188  void AddStats(VmaStats* pStats);
      +
      6171 struct VmaPointerLess
      +
      6172 {
      +
      6173  bool operator()(const void* lhs, const void* rhs) const
      +
      6174  {
      +
      6175  return lhs < rhs;
      +
      6176  }
      +
      6177 };
      +
      6178 
      +
      6179 struct VmaDefragmentationMove
      +
      6180 {
      +
      6181  size_t srcBlockIndex;
      +
      6182  size_t dstBlockIndex;
      +
      6183  VkDeviceSize srcOffset;
      +
      6184  VkDeviceSize dstOffset;
      +
      6185  VkDeviceSize size;
      +
      6186 };
      +
      6187 
      +
      6188 class VmaDefragmentationAlgorithm;
      6189 
      -
      6190 #if VMA_STATS_STRING_ENABLED
      -
      6191  void PrintDetailedMap(class VmaJsonWriter& json);
      -
      6192 #endif
      -
      6193 
      -
      6194  void MakePoolAllocationsLost(
      -
      6195  uint32_t currentFrameIndex,
      -
      6196  size_t* pLostAllocationCount);
      -
      6197  VkResult CheckCorruption();
      -
      6198 
      -
      6199  // Saves results in pCtx->res.
      -
      6200  void Defragment(
      -
      6201  class VmaBlockVectorDefragmentationContext* pCtx,
      -
      6202  VmaDefragmentationStats* pStats,
      -
      6203  VkDeviceSize& maxCpuBytesToMove, uint32_t& maxCpuAllocationsToMove,
      -
      6204  VkDeviceSize& maxGpuBytesToMove, uint32_t& maxGpuAllocationsToMove,
      -
      6205  VkCommandBuffer commandBuffer);
      -
      6206  void DefragmentationEnd(
      -
      6207  class VmaBlockVectorDefragmentationContext* pCtx,
      -
      6208  VmaDefragmentationStats* pStats);
      -
      6209 
      -
      6211  // To be used only while the m_Mutex is locked. Used during defragmentation.
      +
      6190 /*
      +
      6191 Sequence of VmaDeviceMemoryBlock. Represents memory blocks allocated for a specific
      +
      6192 Vulkan memory type.
      +
      6193 
      +
      6194 Synchronized internally with a mutex.
      +
      6195 */
      +
      6196 struct VmaBlockVector
      +
      6197 {
      +
      6198  VMA_CLASS_NO_COPY(VmaBlockVector)
      +
      6199 public:
      +
      6200  VmaBlockVector(
      +
      6201  VmaAllocator hAllocator,
      +
      6202  VmaPool hParentPool,
      +
      6203  uint32_t memoryTypeIndex,
      +
      6204  VkDeviceSize preferredBlockSize,
      +
      6205  size_t minBlockCount,
      +
      6206  size_t maxBlockCount,
      +
      6207  VkDeviceSize bufferImageGranularity,
      +
      6208  uint32_t frameInUseCount,
      +
      6209  bool explicitBlockSize,
      +
      6210  uint32_t algorithm);
      +
      6211  ~VmaBlockVector();
      6212 
      -
      6213  size_t GetBlockCount() const { return m_Blocks.size(); }
      -
      6214  VmaDeviceMemoryBlock* GetBlock(size_t index) const { return m_Blocks[index]; }
      -
      6215  size_t CalcAllocationCount() const;
      -
      6216  bool IsBufferImageGranularityConflictPossible() const;
      -
      6217 
      -
      6218 private:
      -
      6219  friend class VmaDefragmentationAlgorithm_Generic;
      -
      6220 
      -
      6221  const VmaAllocator m_hAllocator;
      -
      6222  const VmaPool m_hParentPool;
      -
      6223  const uint32_t m_MemoryTypeIndex;
      -
      6224  const VkDeviceSize m_PreferredBlockSize;
      -
      6225  const size_t m_MinBlockCount;
      -
      6226  const size_t m_MaxBlockCount;
      -
      6227  const VkDeviceSize m_BufferImageGranularity;
      -
      6228  const uint32_t m_FrameInUseCount;
      -
      6229  const bool m_IsCustomPool;
      -
      6230  const bool m_ExplicitBlockSize;
      -
      6231  const uint32_t m_Algorithm;
      -
      6232  /* There can be at most one allocation that is completely empty - a
      -
      6233  hysteresis to avoid pessimistic case of alternating creation and destruction
      -
      6234  of a VkDeviceMemory. */
      -
      6235  bool m_HasEmptyBlock;
      -
      6236  VMA_RW_MUTEX m_Mutex;
      -
      6237  // Incrementally sorted by sumFreeSize, ascending.
      -
      6238  VmaVector< VmaDeviceMemoryBlock*, VmaStlAllocator<VmaDeviceMemoryBlock*> > m_Blocks;
      -
      6239  uint32_t m_NextBlockId;
      -
      6240 
      -
      6241  VkDeviceSize CalcMaxBlockSize() const;
      +
      6213  VkResult CreateMinBlocks();
      +
      6214 
      +
      6215  VmaAllocator GetAllocator() const { return m_hAllocator; }
      +
      6216  VmaPool GetParentPool() const { return m_hParentPool; }
      +
      6217  bool IsCustomPool() const { return m_hParentPool != VMA_NULL; }
      +
      6218  uint32_t GetMemoryTypeIndex() const { return m_MemoryTypeIndex; }
      +
      6219  VkDeviceSize GetPreferredBlockSize() const { return m_PreferredBlockSize; }
      +
      6220  VkDeviceSize GetBufferImageGranularity() const { return m_BufferImageGranularity; }
      +
      6221  uint32_t GetFrameInUseCount() const { return m_FrameInUseCount; }
      +
      6222  uint32_t GetAlgorithm() const { return m_Algorithm; }
      +
      6223 
      +
      6224  void GetPoolStats(VmaPoolStats* pStats);
      +
      6225 
      +
      6226  bool IsEmpty() const { return m_Blocks.empty(); }
      +
      6227  bool IsCorruptionDetectionEnabled() const;
      +
      6228 
      +
      6229  VkResult Allocate(
      +
      6230  uint32_t currentFrameIndex,
      +
      6231  VkDeviceSize size,
      +
      6232  VkDeviceSize alignment,
      +
      6233  const VmaAllocationCreateInfo& createInfo,
      +
      6234  VmaSuballocationType suballocType,
      +
      6235  size_t allocationCount,
      +
      6236  VmaAllocation* pAllocations);
      +
      6237 
      +
      6238  void Free(const VmaAllocation hAllocation);
      +
      6239 
      +
      6240  // Adds statistics of this BlockVector to pStats.
      +
      6241  void AddStats(VmaStats* pStats);
      6242 
      -
      6243  // Finds and removes given block from vector.
      -
      6244  void Remove(VmaDeviceMemoryBlock* pBlock);
      -
      6245 
      -
      6246  // Performs single step in sorting m_Blocks. They may not be fully sorted
      -
      6247  // after this call.
      -
      6248  void IncrementallySortBlocks();
      -
      6249 
      -
      6250  VkResult AllocatePage(
      -
      6251  uint32_t currentFrameIndex,
      -
      6252  VkDeviceSize size,
      -
      6253  VkDeviceSize alignment,
      -
      6254  const VmaAllocationCreateInfo& createInfo,
      -
      6255  VmaSuballocationType suballocType,
      -
      6256  VmaAllocation* pAllocation);
      -
      6257 
      -
      6258  // To be used only without CAN_MAKE_OTHER_LOST flag.
      -
      6259  VkResult AllocateFromBlock(
      -
      6260  VmaDeviceMemoryBlock* pBlock,
      -
      6261  uint32_t currentFrameIndex,
      -
      6262  VkDeviceSize size,
      -
      6263  VkDeviceSize alignment,
      -
      6264  VmaAllocationCreateFlags allocFlags,
      -
      6265  void* pUserData,
      -
      6266  VmaSuballocationType suballocType,
      -
      6267  uint32_t strategy,
      -
      6268  VmaAllocation* pAllocation);
      -
      6269 
      -
      6270  VkResult CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIndex);
      -
      6271 
      -
      6272  // Saves result to pCtx->res.
      -
      6273  void ApplyDefragmentationMovesCpu(
      -
      6274  class VmaBlockVectorDefragmentationContext* pDefragCtx,
      -
      6275  const VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves);
      -
      6276  // Saves result to pCtx->res.
      -
      6277  void ApplyDefragmentationMovesGpu(
      -
      6278  class VmaBlockVectorDefragmentationContext* pDefragCtx,
      -
      6279  const VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
      -
      6280  VkCommandBuffer commandBuffer);
      -
      6281 
      -
      6282  /*
      -
      6283  Used during defragmentation. pDefragmentationStats is optional. It's in/out
      -
      6284  - updated with new data.
      -
      6285  */
      -
      6286  void FreeEmptyBlocks(VmaDefragmentationStats* pDefragmentationStats);
      -
      6287 };
      -
      6288 
      -
      6289 struct VmaPool_T
      -
      6290 {
      -
      6291  VMA_CLASS_NO_COPY(VmaPool_T)
      -
      6292 public:
      -
      6293  VmaBlockVector m_BlockVector;
      +
      6243 #if VMA_STATS_STRING_ENABLED
      +
      6244  void PrintDetailedMap(class VmaJsonWriter& json);
      +
      6245 #endif
      +
      6246 
      +
      6247  void MakePoolAllocationsLost(
      +
      6248  uint32_t currentFrameIndex,
      +
      6249  size_t* pLostAllocationCount);
      +
      6250  VkResult CheckCorruption();
      +
      6251 
      +
      6252  // Saves results in pCtx->res.
      +
      6253  void Defragment(
      +
      6254  class VmaBlockVectorDefragmentationContext* pCtx,
      +
      6255  VmaDefragmentationStats* pStats,
      +
      6256  VkDeviceSize& maxCpuBytesToMove, uint32_t& maxCpuAllocationsToMove,
      +
      6257  VkDeviceSize& maxGpuBytesToMove, uint32_t& maxGpuAllocationsToMove,
      +
      6258  VkCommandBuffer commandBuffer);
      +
      6259  void DefragmentationEnd(
      +
      6260  class VmaBlockVectorDefragmentationContext* pCtx,
      +
      6261  VmaDefragmentationStats* pStats);
      +
      6262 
      +
      6264  // To be used only while the m_Mutex is locked. Used during defragmentation.
      +
      6265 
      +
      6266  size_t GetBlockCount() const { return m_Blocks.size(); }
      +
      6267  VmaDeviceMemoryBlock* GetBlock(size_t index) const { return m_Blocks[index]; }
      +
      6268  size_t CalcAllocationCount() const;
      +
      6269  bool IsBufferImageGranularityConflictPossible() const;
      +
      6270 
      +
      6271 private:
      +
      6272  friend class VmaDefragmentationAlgorithm_Generic;
      +
      6273 
      +
      6274  const VmaAllocator m_hAllocator;
      +
      6275  const VmaPool m_hParentPool;
      +
      6276  const uint32_t m_MemoryTypeIndex;
      +
      6277  const VkDeviceSize m_PreferredBlockSize;
      +
      6278  const size_t m_MinBlockCount;
      +
      6279  const size_t m_MaxBlockCount;
      +
      6280  const VkDeviceSize m_BufferImageGranularity;
      +
      6281  const uint32_t m_FrameInUseCount;
      +
      6282  const bool m_ExplicitBlockSize;
      +
      6283  const uint32_t m_Algorithm;
      +
      6284  /* There can be at most one allocation that is completely empty - a
      +
      6285  hysteresis to avoid pessimistic case of alternating creation and destruction
      +
      6286  of a VkDeviceMemory. */
      +
      6287  bool m_HasEmptyBlock;
      +
      6288  VMA_RW_MUTEX m_Mutex;
      +
      6289  // Incrementally sorted by sumFreeSize, ascending.
      +
      6290  VmaVector< VmaDeviceMemoryBlock*, VmaStlAllocator<VmaDeviceMemoryBlock*> > m_Blocks;
      +
      6291  uint32_t m_NextBlockId;
      +
      6292 
      +
      6293  VkDeviceSize CalcMaxBlockSize() const;
      6294 
      -
      6295  VmaPool_T(
      -
      6296  VmaAllocator hAllocator,
      -
      6297  const VmaPoolCreateInfo& createInfo,
      -
      6298  VkDeviceSize preferredBlockSize);
      -
      6299  ~VmaPool_T();
      -
      6300 
      -
      6301  uint32_t GetId() const { return m_Id; }
      -
      6302  void SetId(uint32_t id) { VMA_ASSERT(m_Id == 0); m_Id = id; }
      -
      6303 
      -
      6304 #if VMA_STATS_STRING_ENABLED
      -
      6305  //void PrintDetailedMap(class VmaStringBuilder& sb);
      -
      6306 #endif
      -
      6307 
      -
      6308 private:
      -
      6309  uint32_t m_Id;
      -
      6310 };
      -
      6311 
      -
      6312 /*
      -
      6313 Performs defragmentation:
      -
      6314 
      -
      6315 - Updates `pBlockVector->m_pMetadata`.
      -
      6316 - Updates allocations by calling ChangeBlockAllocation() or ChangeOffset().
      -
      6317 - Does not move actual data, only returns requested moves as `moves`.
      -
      6318 */
      -
      6319 class VmaDefragmentationAlgorithm
      -
      6320 {
      -
      6321  VMA_CLASS_NO_COPY(VmaDefragmentationAlgorithm)
      -
      6322 public:
      -
      6323  VmaDefragmentationAlgorithm(
      -
      6324  VmaAllocator hAllocator,
      -
      6325  VmaBlockVector* pBlockVector,
      -
      6326  uint32_t currentFrameIndex) :
      -
      6327  m_hAllocator(hAllocator),
      -
      6328  m_pBlockVector(pBlockVector),
      -
      6329  m_CurrentFrameIndex(currentFrameIndex)
      -
      6330  {
      -
      6331  }
      -
      6332  virtual ~VmaDefragmentationAlgorithm()
      -
      6333  {
      -
      6334  }
      -
      6335 
      -
      6336  virtual void AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged) = 0;
      -
      6337  virtual void AddAll() = 0;
      -
      6338 
      -
      6339  virtual VkResult Defragment(
      -
      6340  VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
      -
      6341  VkDeviceSize maxBytesToMove,
      -
      6342  uint32_t maxAllocationsToMove) = 0;
      -
      6343 
      -
      6344  virtual VkDeviceSize GetBytesMoved() const = 0;
      -
      6345  virtual uint32_t GetAllocationsMoved() const = 0;
      +
      6295  // Finds and removes given block from vector.
      +
      6296  void Remove(VmaDeviceMemoryBlock* pBlock);
      +
      6297 
      +
      6298  // Performs single step in sorting m_Blocks. They may not be fully sorted
      +
      6299  // after this call.
      +
      6300  void IncrementallySortBlocks();
      +
      6301 
      +
      6302  VkResult AllocatePage(
      +
      6303  uint32_t currentFrameIndex,
      +
      6304  VkDeviceSize size,
      +
      6305  VkDeviceSize alignment,
      +
      6306  const VmaAllocationCreateInfo& createInfo,
      +
      6307  VmaSuballocationType suballocType,
      +
      6308  VmaAllocation* pAllocation);
      +
      6309 
      +
      6310  // To be used only without CAN_MAKE_OTHER_LOST flag.
      +
      6311  VkResult AllocateFromBlock(
      +
      6312  VmaDeviceMemoryBlock* pBlock,
      +
      6313  uint32_t currentFrameIndex,
      +
      6314  VkDeviceSize size,
      +
      6315  VkDeviceSize alignment,
      +
      6316  VmaAllocationCreateFlags allocFlags,
      +
      6317  void* pUserData,
      +
      6318  VmaSuballocationType suballocType,
      +
      6319  uint32_t strategy,
      +
      6320  VmaAllocation* pAllocation);
      +
      6321 
      +
      6322  VkResult CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIndex);
      +
      6323 
      +
      6324  // Saves result to pCtx->res.
      +
      6325  void ApplyDefragmentationMovesCpu(
      +
      6326  class VmaBlockVectorDefragmentationContext* pDefragCtx,
      +
      6327  const VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves);
      +
      6328  // Saves result to pCtx->res.
      +
      6329  void ApplyDefragmentationMovesGpu(
      +
      6330  class VmaBlockVectorDefragmentationContext* pDefragCtx,
      +
      6331  const VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
      +
      6332  VkCommandBuffer commandBuffer);
      +
      6333 
      +
      6334  /*
      +
      6335  Used during defragmentation. pDefragmentationStats is optional. It's in/out
      +
      6336  - updated with new data.
      +
      6337  */
      +
      6338  void FreeEmptyBlocks(VmaDefragmentationStats* pDefragmentationStats);
      +
      6339 };
      +
      6340 
      +
      6341 struct VmaPool_T
      +
      6342 {
      +
      6343  VMA_CLASS_NO_COPY(VmaPool_T)
      +
      6344 public:
      +
      6345  VmaBlockVector m_BlockVector;
      6346 
      -
      6347 protected:
      -
      6348  VmaAllocator const m_hAllocator;
      -
      6349  VmaBlockVector* const m_pBlockVector;
      -
      6350  const uint32_t m_CurrentFrameIndex;
      -
      6351 
      -
      6352  struct AllocationInfo
      -
      6353  {
      -
      6354  VmaAllocation m_hAllocation;
      -
      6355  VkBool32* m_pChanged;
      -
      6356 
      -
      6357  AllocationInfo() :
      -
      6358  m_hAllocation(VK_NULL_HANDLE),
      -
      6359  m_pChanged(VMA_NULL)
      -
      6360  {
      -
      6361  }
      -
      6362  AllocationInfo(VmaAllocation hAlloc, VkBool32* pChanged) :
      -
      6363  m_hAllocation(hAlloc),
      -
      6364  m_pChanged(pChanged)
      -
      6365  {
      -
      6366  }
      -
      6367  };
      -
      6368 };
      -
      6369 
      -
      6370 class VmaDefragmentationAlgorithm_Generic : public VmaDefragmentationAlgorithm
      -
      6371 {
      -
      6372  VMA_CLASS_NO_COPY(VmaDefragmentationAlgorithm_Generic)
      -
      6373 public:
      -
      6374  VmaDefragmentationAlgorithm_Generic(
      -
      6375  VmaAllocator hAllocator,
      -
      6376  VmaBlockVector* pBlockVector,
      -
      6377  uint32_t currentFrameIndex,
      -
      6378  bool overlappingMoveSupported);
      -
      6379  virtual ~VmaDefragmentationAlgorithm_Generic();
      -
      6380 
      -
      6381  virtual void AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged);
      -
      6382  virtual void AddAll() { m_AllAllocations = true; }
      -
      6383 
      -
      6384  virtual VkResult Defragment(
      -
      6385  VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
      -
      6386  VkDeviceSize maxBytesToMove,
      -
      6387  uint32_t maxAllocationsToMove);
      -
      6388 
      -
      6389  virtual VkDeviceSize GetBytesMoved() const { return m_BytesMoved; }
      -
      6390  virtual uint32_t GetAllocationsMoved() const { return m_AllocationsMoved; }
      +
      6347  VmaPool_T(
      +
      6348  VmaAllocator hAllocator,
      +
      6349  const VmaPoolCreateInfo& createInfo,
      +
      6350  VkDeviceSize preferredBlockSize);
      +
      6351  ~VmaPool_T();
      +
      6352 
      +
      6353  uint32_t GetId() const { return m_Id; }
      +
      6354  void SetId(uint32_t id) { VMA_ASSERT(m_Id == 0); m_Id = id; }
      +
      6355 
      +
      6356  const char* GetName() const { return m_Name; }
      +
      6357  void SetName(const char* pName);
      +
      6358 
      +
      6359 #if VMA_STATS_STRING_ENABLED
      +
      6360  //void PrintDetailedMap(class VmaStringBuilder& sb);
      +
      6361 #endif
      +
      6362 
      +
      6363 private:
      +
      6364  uint32_t m_Id;
      +
      6365  char* m_Name;
      +
      6366 };
      +
      6367 
      +
      6368 /*
      +
      6369 Performs defragmentation:
      +
      6370 
      +
      6371 - Updates `pBlockVector->m_pMetadata`.
      +
      6372 - Updates allocations by calling ChangeBlockAllocation() or ChangeOffset().
      +
      6373 - Does not move actual data, only returns requested moves as `moves`.
      +
      6374 */
      +
      6375 class VmaDefragmentationAlgorithm
      +
      6376 {
      +
      6377  VMA_CLASS_NO_COPY(VmaDefragmentationAlgorithm)
      +
      6378 public:
      +
      6379  VmaDefragmentationAlgorithm(
      +
      6380  VmaAllocator hAllocator,
      +
      6381  VmaBlockVector* pBlockVector,
      +
      6382  uint32_t currentFrameIndex) :
      +
      6383  m_hAllocator(hAllocator),
      +
      6384  m_pBlockVector(pBlockVector),
      +
      6385  m_CurrentFrameIndex(currentFrameIndex)
      +
      6386  {
      +
      6387  }
      +
      6388  virtual ~VmaDefragmentationAlgorithm()
      +
      6389  {
      +
      6390  }
      6391 
      -
      6392 private:
      -
      6393  uint32_t m_AllocationCount;
      -
      6394  bool m_AllAllocations;
      -
      6395 
      -
      6396  VkDeviceSize m_BytesMoved;
      -
      6397  uint32_t m_AllocationsMoved;
      -
      6398 
      -
      6399  struct AllocationInfoSizeGreater
      -
      6400  {
      -
      6401  bool operator()(const AllocationInfo& lhs, const AllocationInfo& rhs) const
      -
      6402  {
      -
      6403  return lhs.m_hAllocation->GetSize() > rhs.m_hAllocation->GetSize();
      -
      6404  }
      -
      6405  };
      -
      6406 
      -
      6407  struct AllocationInfoOffsetGreater
      -
      6408  {
      -
      6409  bool operator()(const AllocationInfo& lhs, const AllocationInfo& rhs) const
      -
      6410  {
      -
      6411  return lhs.m_hAllocation->GetOffset() > rhs.m_hAllocation->GetOffset();
      -
      6412  }
      -
      6413  };
      -
      6414 
      -
      6415  struct BlockInfo
      -
      6416  {
      -
      6417  size_t m_OriginalBlockIndex;
      -
      6418  VmaDeviceMemoryBlock* m_pBlock;
      -
      6419  bool m_HasNonMovableAllocations;
      -
      6420  VmaVector< AllocationInfo, VmaStlAllocator<AllocationInfo> > m_Allocations;
      -
      6421 
      -
      6422  BlockInfo(const VkAllocationCallbacks* pAllocationCallbacks) :
      -
      6423  m_OriginalBlockIndex(SIZE_MAX),
      -
      6424  m_pBlock(VMA_NULL),
      -
      6425  m_HasNonMovableAllocations(true),
      -
      6426  m_Allocations(pAllocationCallbacks)
      -
      6427  {
      -
      6428  }
      -
      6429 
      -
      6430  void CalcHasNonMovableAllocations()
      -
      6431  {
      -
      6432  const size_t blockAllocCount = m_pBlock->m_pMetadata->GetAllocationCount();
      -
      6433  const size_t defragmentAllocCount = m_Allocations.size();
      -
      6434  m_HasNonMovableAllocations = blockAllocCount != defragmentAllocCount;
      -
      6435  }
      +
      6392  virtual void AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged) = 0;
      +
      6393  virtual void AddAll() = 0;
      +
      6394 
      +
      6395  virtual VkResult Defragment(
      +
      6396  VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
      +
      6397  VkDeviceSize maxBytesToMove,
      +
      6398  uint32_t maxAllocationsToMove) = 0;
      +
      6399 
      +
      6400  virtual VkDeviceSize GetBytesMoved() const = 0;
      +
      6401  virtual uint32_t GetAllocationsMoved() const = 0;
      +
      6402 
      +
      6403 protected:
      +
      6404  VmaAllocator const m_hAllocator;
      +
      6405  VmaBlockVector* const m_pBlockVector;
      +
      6406  const uint32_t m_CurrentFrameIndex;
      +
      6407 
      +
      6408  struct AllocationInfo
      +
      6409  {
      +
      6410  VmaAllocation m_hAllocation;
      +
      6411  VkBool32* m_pChanged;
      +
      6412 
      +
      6413  AllocationInfo() :
      +
      6414  m_hAllocation(VK_NULL_HANDLE),
      +
      6415  m_pChanged(VMA_NULL)
      +
      6416  {
      +
      6417  }
      +
      6418  AllocationInfo(VmaAllocation hAlloc, VkBool32* pChanged) :
      +
      6419  m_hAllocation(hAlloc),
      +
      6420  m_pChanged(pChanged)
      +
      6421  {
      +
      6422  }
      +
      6423  };
      +
      6424 };
      +
      6425 
      +
      6426 class VmaDefragmentationAlgorithm_Generic : public VmaDefragmentationAlgorithm
      +
      6427 {
      +
      6428  VMA_CLASS_NO_COPY(VmaDefragmentationAlgorithm_Generic)
      +
      6429 public:
      +
      6430  VmaDefragmentationAlgorithm_Generic(
      +
      6431  VmaAllocator hAllocator,
      +
      6432  VmaBlockVector* pBlockVector,
      +
      6433  uint32_t currentFrameIndex,
      +
      6434  bool overlappingMoveSupported);
      +
      6435  virtual ~VmaDefragmentationAlgorithm_Generic();
      6436 
      -
      6437  void SortAllocationsBySizeDescending()
      -
      6438  {
      -
      6439  VMA_SORT(m_Allocations.begin(), m_Allocations.end(), AllocationInfoSizeGreater());
      -
      6440  }
      -
      6441 
      -
      6442  void SortAllocationsByOffsetDescending()
      -
      6443  {
      -
      6444  VMA_SORT(m_Allocations.begin(), m_Allocations.end(), AllocationInfoOffsetGreater());
      -
      6445  }
      -
      6446  };
      +
      6437  virtual void AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged);
      +
      6438  virtual void AddAll() { m_AllAllocations = true; }
      +
      6439 
      +
      6440  virtual VkResult Defragment(
      +
      6441  VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
      +
      6442  VkDeviceSize maxBytesToMove,
      +
      6443  uint32_t maxAllocationsToMove);
      +
      6444 
      +
      6445  virtual VkDeviceSize GetBytesMoved() const { return m_BytesMoved; }
      +
      6446  virtual uint32_t GetAllocationsMoved() const { return m_AllocationsMoved; }
      6447 
      -
      6448  struct BlockPointerLess
      -
      6449  {
      -
      6450  bool operator()(const BlockInfo* pLhsBlockInfo, const VmaDeviceMemoryBlock* pRhsBlock) const
      -
      6451  {
      -
      6452  return pLhsBlockInfo->m_pBlock < pRhsBlock;
      -
      6453  }
      -
      6454  bool operator()(const BlockInfo* pLhsBlockInfo, const BlockInfo* pRhsBlockInfo) const
      -
      6455  {
      -
      6456  return pLhsBlockInfo->m_pBlock < pRhsBlockInfo->m_pBlock;
      -
      6457  }
      -
      6458  };
      -
      6459 
      -
      6460  // 1. Blocks with some non-movable allocations go first.
      -
      6461  // 2. Blocks with smaller sumFreeSize go first.
      -
      6462  struct BlockInfoCompareMoveDestination
      -
      6463  {
      -
      6464  bool operator()(const BlockInfo* pLhsBlockInfo, const BlockInfo* pRhsBlockInfo) const
      -
      6465  {
      -
      6466  if(pLhsBlockInfo->m_HasNonMovableAllocations && !pRhsBlockInfo->m_HasNonMovableAllocations)
      -
      6467  {
      -
      6468  return true;
      -
      6469  }
      -
      6470  if(!pLhsBlockInfo->m_HasNonMovableAllocations && pRhsBlockInfo->m_HasNonMovableAllocations)
      -
      6471  {
      -
      6472  return false;
      -
      6473  }
      -
      6474  if(pLhsBlockInfo->m_pBlock->m_pMetadata->GetSumFreeSize() < pRhsBlockInfo->m_pBlock->m_pMetadata->GetSumFreeSize())
      -
      6475  {
      -
      6476  return true;
      -
      6477  }
      -
      6478  return false;
      -
      6479  }
      -
      6480  };
      -
      6481 
      -
      6482  typedef VmaVector< BlockInfo*, VmaStlAllocator<BlockInfo*> > BlockInfoVector;
      -
      6483  BlockInfoVector m_Blocks;
      -
      6484 
      -
      6485  VkResult DefragmentRound(
      -
      6486  VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
      -
      6487  VkDeviceSize maxBytesToMove,
      -
      6488  uint32_t maxAllocationsToMove);
      -
      6489 
      -
      6490  size_t CalcBlocksWithNonMovableCount() const;
      -
      6491 
      -
      6492  static bool MoveMakesSense(
      -
      6493  size_t dstBlockIndex, VkDeviceSize dstOffset,
      -
      6494  size_t srcBlockIndex, VkDeviceSize srcOffset);
      -
      6495 };
      -
      6496 
      -
      6497 class VmaDefragmentationAlgorithm_Fast : public VmaDefragmentationAlgorithm
      -
      6498 {
      -
      6499  VMA_CLASS_NO_COPY(VmaDefragmentationAlgorithm_Fast)
      -
      6500 public:
      -
      6501  VmaDefragmentationAlgorithm_Fast(
      -
      6502  VmaAllocator hAllocator,
      -
      6503  VmaBlockVector* pBlockVector,
      -
      6504  uint32_t currentFrameIndex,
      -
      6505  bool overlappingMoveSupported);
      -
      6506  virtual ~VmaDefragmentationAlgorithm_Fast();
      -
      6507 
      -
      6508  virtual void AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged) { ++m_AllocationCount; }
      -
      6509  virtual void AddAll() { m_AllAllocations = true; }
      -
      6510 
      -
      6511  virtual VkResult Defragment(
      -
      6512  VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
      -
      6513  VkDeviceSize maxBytesToMove,
      -
      6514  uint32_t maxAllocationsToMove);
      +
      6448 private:
      +
      6449  uint32_t m_AllocationCount;
      +
      6450  bool m_AllAllocations;
      +
      6451 
      +
      6452  VkDeviceSize m_BytesMoved;
      +
      6453  uint32_t m_AllocationsMoved;
      +
      6454 
      +
      6455  struct AllocationInfoSizeGreater
      +
      6456  {
      +
      6457  bool operator()(const AllocationInfo& lhs, const AllocationInfo& rhs) const
      +
      6458  {
      +
      6459  return lhs.m_hAllocation->GetSize() > rhs.m_hAllocation->GetSize();
      +
      6460  }
      +
      6461  };
      +
      6462 
      +
      6463  struct AllocationInfoOffsetGreater
      +
      6464  {
      +
      6465  bool operator()(const AllocationInfo& lhs, const AllocationInfo& rhs) const
      +
      6466  {
      +
      6467  return lhs.m_hAllocation->GetOffset() > rhs.m_hAllocation->GetOffset();
      +
      6468  }
      +
      6469  };
      +
      6470 
      +
      6471  struct BlockInfo
      +
      6472  {
      +
      6473  size_t m_OriginalBlockIndex;
      +
      6474  VmaDeviceMemoryBlock* m_pBlock;
      +
      6475  bool m_HasNonMovableAllocations;
      +
      6476  VmaVector< AllocationInfo, VmaStlAllocator<AllocationInfo> > m_Allocations;
      +
      6477 
      +
      6478  BlockInfo(const VkAllocationCallbacks* pAllocationCallbacks) :
      +
      6479  m_OriginalBlockIndex(SIZE_MAX),
      +
      6480  m_pBlock(VMA_NULL),
      +
      6481  m_HasNonMovableAllocations(true),
      +
      6482  m_Allocations(pAllocationCallbacks)
      +
      6483  {
      +
      6484  }
      +
      6485 
      +
      6486  void CalcHasNonMovableAllocations()
      +
      6487  {
      +
      6488  const size_t blockAllocCount = m_pBlock->m_pMetadata->GetAllocationCount();
      +
      6489  const size_t defragmentAllocCount = m_Allocations.size();
      +
      6490  m_HasNonMovableAllocations = blockAllocCount != defragmentAllocCount;
      +
      6491  }
      +
      6492 
      +
      6493  void SortAllocationsBySizeDescending()
      +
      6494  {
      +
      6495  VMA_SORT(m_Allocations.begin(), m_Allocations.end(), AllocationInfoSizeGreater());
      +
      6496  }
      +
      6497 
      +
      6498  void SortAllocationsByOffsetDescending()
      +
      6499  {
      +
      6500  VMA_SORT(m_Allocations.begin(), m_Allocations.end(), AllocationInfoOffsetGreater());
      +
      6501  }
      +
      6502  };
      +
      6503 
      +
      6504  struct BlockPointerLess
      +
      6505  {
      +
      6506  bool operator()(const BlockInfo* pLhsBlockInfo, const VmaDeviceMemoryBlock* pRhsBlock) const
      +
      6507  {
      +
      6508  return pLhsBlockInfo->m_pBlock < pRhsBlock;
      +
      6509  }
      +
      6510  bool operator()(const BlockInfo* pLhsBlockInfo, const BlockInfo* pRhsBlockInfo) const
      +
      6511  {
      +
      6512  return pLhsBlockInfo->m_pBlock < pRhsBlockInfo->m_pBlock;
      +
      6513  }
      +
      6514  };
      6515 
      -
      6516  virtual VkDeviceSize GetBytesMoved() const { return m_BytesMoved; }
      -
      6517  virtual uint32_t GetAllocationsMoved() const { return m_AllocationsMoved; }
      -
      6518 
      -
      6519 private:
      -
      6520  struct BlockInfo
      -
      6521  {
      -
      6522  size_t origBlockIndex;
      -
      6523  };
      -
      6524 
      -
      6525  class FreeSpaceDatabase
      -
      6526  {
      -
      6527  public:
      -
      6528  FreeSpaceDatabase()
      -
      6529  {
      -
      6530  FreeSpace s = {};
      -
      6531  s.blockInfoIndex = SIZE_MAX;
      -
      6532  for(size_t i = 0; i < MAX_COUNT; ++i)
      -
      6533  {
      -
      6534  m_FreeSpaces[i] = s;
      -
      6535  }
      -
      6536  }
      +
      6516  // 1. Blocks with some non-movable allocations go first.
      +
      6517  // 2. Blocks with smaller sumFreeSize go first.
      +
      6518  struct BlockInfoCompareMoveDestination
      +
      6519  {
      +
      6520  bool operator()(const BlockInfo* pLhsBlockInfo, const BlockInfo* pRhsBlockInfo) const
      +
      6521  {
      +
      6522  if(pLhsBlockInfo->m_HasNonMovableAllocations && !pRhsBlockInfo->m_HasNonMovableAllocations)
      +
      6523  {
      +
      6524  return true;
      +
      6525  }
      +
      6526  if(!pLhsBlockInfo->m_HasNonMovableAllocations && pRhsBlockInfo->m_HasNonMovableAllocations)
      +
      6527  {
      +
      6528  return false;
      +
      6529  }
      +
      6530  if(pLhsBlockInfo->m_pBlock->m_pMetadata->GetSumFreeSize() < pRhsBlockInfo->m_pBlock->m_pMetadata->GetSumFreeSize())
      +
      6531  {
      +
      6532  return true;
      +
      6533  }
      +
      6534  return false;
      +
      6535  }
      +
      6536  };
      6537 
      -
      6538  void Register(size_t blockInfoIndex, VkDeviceSize offset, VkDeviceSize size)
      -
      6539  {
      -
      6540  if(size < VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
      -
      6541  {
      -
      6542  return;
      -
      6543  }
      -
      6544 
      -
      6545  // Find first invalid or the smallest structure.
      -
      6546  size_t bestIndex = SIZE_MAX;
      -
      6547  for(size_t i = 0; i < MAX_COUNT; ++i)
      -
      6548  {
      -
      6549  // Empty structure.
      -
      6550  if(m_FreeSpaces[i].blockInfoIndex == SIZE_MAX)
      -
      6551  {
      -
      6552  bestIndex = i;
      -
      6553  break;
      -
      6554  }
      -
      6555  if(m_FreeSpaces[i].size < size &&
      -
      6556  (bestIndex == SIZE_MAX || m_FreeSpaces[bestIndex].size > m_FreeSpaces[i].size))
      -
      6557  {
      -
      6558  bestIndex = i;
      -
      6559  }
      -
      6560  }
      -
      6561 
      -
      6562  if(bestIndex != SIZE_MAX)
      -
      6563  {
      -
      6564  m_FreeSpaces[bestIndex].blockInfoIndex = blockInfoIndex;
      -
      6565  m_FreeSpaces[bestIndex].offset = offset;
      -
      6566  m_FreeSpaces[bestIndex].size = size;
      -
      6567  }
      -
      6568  }
      -
      6569 
      -
      6570  bool Fetch(VkDeviceSize alignment, VkDeviceSize size,
      -
      6571  size_t& outBlockInfoIndex, VkDeviceSize& outDstOffset)
      -
      6572  {
      -
      6573  size_t bestIndex = SIZE_MAX;
      -
      6574  VkDeviceSize bestFreeSpaceAfter = 0;
      -
      6575  for(size_t i = 0; i < MAX_COUNT; ++i)
      -
      6576  {
      -
      6577  // Structure is valid.
      -
      6578  if(m_FreeSpaces[i].blockInfoIndex != SIZE_MAX)
      -
      6579  {
      -
      6580  const VkDeviceSize dstOffset = VmaAlignUp(m_FreeSpaces[i].offset, alignment);
      -
      6581  // Allocation fits into this structure.
      -
      6582  if(dstOffset + size <= m_FreeSpaces[i].offset + m_FreeSpaces[i].size)
      -
      6583  {
      -
      6584  const VkDeviceSize freeSpaceAfter = (m_FreeSpaces[i].offset + m_FreeSpaces[i].size) -
      -
      6585  (dstOffset + size);
      -
      6586  if(bestIndex == SIZE_MAX || freeSpaceAfter > bestFreeSpaceAfter)
      -
      6587  {
      -
      6588  bestIndex = i;
      -
      6589  bestFreeSpaceAfter = freeSpaceAfter;
      -
      6590  }
      -
      6591  }
      -
      6592  }
      -
      6593  }
      -
      6594 
      -
      6595  if(bestIndex != SIZE_MAX)
      -
      6596  {
      -
      6597  outBlockInfoIndex = m_FreeSpaces[bestIndex].blockInfoIndex;
      -
      6598  outDstOffset = VmaAlignUp(m_FreeSpaces[bestIndex].offset, alignment);
      -
      6599 
      -
      6600  if(bestFreeSpaceAfter >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
      -
      6601  {
      -
      6602  // Leave this structure for remaining empty space.
      -
      6603  const VkDeviceSize alignmentPlusSize = (outDstOffset - m_FreeSpaces[bestIndex].offset) + size;
      -
      6604  m_FreeSpaces[bestIndex].offset += alignmentPlusSize;
      -
      6605  m_FreeSpaces[bestIndex].size -= alignmentPlusSize;
      -
      6606  }
      -
      6607  else
      -
      6608  {
      -
      6609  // This structure becomes invalid.
      -
      6610  m_FreeSpaces[bestIndex].blockInfoIndex = SIZE_MAX;
      -
      6611  }
      -
      6612 
      -
      6613  return true;
      -
      6614  }
      -
      6615 
      -
      6616  return false;
      -
      6617  }
      -
      6618 
      -
      6619  private:
      -
      6620  static const size_t MAX_COUNT = 4;
      -
      6621 
      -
      6622  struct FreeSpace
      -
      6623  {
      -
      6624  size_t blockInfoIndex; // SIZE_MAX means this structure is invalid.
      -
      6625  VkDeviceSize offset;
      -
      6626  VkDeviceSize size;
      -
      6627  } m_FreeSpaces[MAX_COUNT];
      -
      6628  };
      -
      6629 
      -
      6630  const bool m_OverlappingMoveSupported;
      -
      6631 
      -
      6632  uint32_t m_AllocationCount;
      -
      6633  bool m_AllAllocations;
      -
      6634 
      -
      6635  VkDeviceSize m_BytesMoved;
      -
      6636  uint32_t m_AllocationsMoved;
      -
      6637 
      -
      6638  VmaVector< BlockInfo, VmaStlAllocator<BlockInfo> > m_BlockInfos;
      -
      6639 
      -
      6640  void PreprocessMetadata();
      -
      6641  void PostprocessMetadata();
      -
      6642  void InsertSuballoc(VmaBlockMetadata_Generic* pMetadata, const VmaSuballocation& suballoc);
      -
      6643 };
      -
      6644 
      -
      6645 struct VmaBlockDefragmentationContext
      -
      6646 {
      -
      6647  enum BLOCK_FLAG
      -
      6648  {
      -
      6649  BLOCK_FLAG_USED = 0x00000001,
      -
      6650  };
      -
      6651  uint32_t flags;
      -
      6652  VkBuffer hBuffer;
      -
      6653 };
      -
      6654 
      -
      6655 class VmaBlockVectorDefragmentationContext
      -
      6656 {
      -
      6657  VMA_CLASS_NO_COPY(VmaBlockVectorDefragmentationContext)
      -
      6658 public:
      -
      6659  VkResult res;
      -
      6660  bool mutexLocked;
      -
      6661  VmaVector< VmaBlockDefragmentationContext, VmaStlAllocator<VmaBlockDefragmentationContext> > blockContexts;
      -
      6662 
      -
      6663  VmaBlockVectorDefragmentationContext(
      -
      6664  VmaAllocator hAllocator,
      -
      6665  VmaPool hCustomPool, // Optional.
      -
      6666  VmaBlockVector* pBlockVector,
      -
      6667  uint32_t currFrameIndex);
      -
      6668  ~VmaBlockVectorDefragmentationContext();
      -
      6669 
      -
      6670  VmaPool GetCustomPool() const { return m_hCustomPool; }
      -
      6671  VmaBlockVector* GetBlockVector() const { return m_pBlockVector; }
      -
      6672  VmaDefragmentationAlgorithm* GetAlgorithm() const { return m_pAlgorithm; }
      -
      6673 
      -
      6674  void AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged);
      -
      6675  void AddAll() { m_AllAllocations = true; }
      -
      6676 
      -
      6677  void Begin(bool overlappingMoveSupported);
      -
      6678 
      -
      6679 private:
      -
      6680  const VmaAllocator m_hAllocator;
      -
      6681  // Null if not from custom pool.
      -
      6682  const VmaPool m_hCustomPool;
      -
      6683  // Redundant, for convenience not to fetch from m_hCustomPool->m_BlockVector or m_hAllocator->m_pBlockVectors.
      -
      6684  VmaBlockVector* const m_pBlockVector;
      -
      6685  const uint32_t m_CurrFrameIndex;
      -
      6686  // Owner of this object.
      -
      6687  VmaDefragmentationAlgorithm* m_pAlgorithm;
      -
      6688 
      -
      6689  struct AllocInfo
      -
      6690  {
      -
      6691  VmaAllocation hAlloc;
      -
      6692  VkBool32* pChanged;
      -
      6693  };
      -
      6694  // Used between constructor and Begin.
      -
      6695  VmaVector< AllocInfo, VmaStlAllocator<AllocInfo> > m_Allocations;
      -
      6696  bool m_AllAllocations;
      -
      6697 };
      -
      6698 
      -
      6699 struct VmaDefragmentationContext_T
      -
      6700 {
      -
      6701 private:
      -
      6702  VMA_CLASS_NO_COPY(VmaDefragmentationContext_T)
      -
      6703 public:
      -
      6704  VmaDefragmentationContext_T(
      -
      6705  VmaAllocator hAllocator,
      -
      6706  uint32_t currFrameIndex,
      -
      6707  uint32_t flags,
      -
      6708  VmaDefragmentationStats* pStats);
      -
      6709  ~VmaDefragmentationContext_T();
      +
      6538  typedef VmaVector< BlockInfo*, VmaStlAllocator<BlockInfo*> > BlockInfoVector;
      +
      6539  BlockInfoVector m_Blocks;
      +
      6540 
      +
      6541  VkResult DefragmentRound(
      +
      6542  VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
      +
      6543  VkDeviceSize maxBytesToMove,
      +
      6544  uint32_t maxAllocationsToMove);
      +
      6545 
      +
      6546  size_t CalcBlocksWithNonMovableCount() const;
      +
      6547 
      +
      6548  static bool MoveMakesSense(
      +
      6549  size_t dstBlockIndex, VkDeviceSize dstOffset,
      +
      6550  size_t srcBlockIndex, VkDeviceSize srcOffset);
      +
      6551 };
      +
      6552 
      +
      6553 class VmaDefragmentationAlgorithm_Fast : public VmaDefragmentationAlgorithm
      +
      6554 {
      +
      6555  VMA_CLASS_NO_COPY(VmaDefragmentationAlgorithm_Fast)
      +
      6556 public:
      +
      6557  VmaDefragmentationAlgorithm_Fast(
      +
      6558  VmaAllocator hAllocator,
      +
      6559  VmaBlockVector* pBlockVector,
      +
      6560  uint32_t currentFrameIndex,
      +
      6561  bool overlappingMoveSupported);
      +
      6562  virtual ~VmaDefragmentationAlgorithm_Fast();
      +
      6563 
      +
      6564  virtual void AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged) { ++m_AllocationCount; }
      +
      6565  virtual void AddAll() { m_AllAllocations = true; }
      +
      6566 
      +
      6567  virtual VkResult Defragment(
      +
      6568  VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
      +
      6569  VkDeviceSize maxBytesToMove,
      +
      6570  uint32_t maxAllocationsToMove);
      +
      6571 
      +
      6572  virtual VkDeviceSize GetBytesMoved() const { return m_BytesMoved; }
      +
      6573  virtual uint32_t GetAllocationsMoved() const { return m_AllocationsMoved; }
      +
      6574 
      +
      6575 private:
      +
      6576  struct BlockInfo
      +
      6577  {
      +
      6578  size_t origBlockIndex;
      +
      6579  };
      +
      6580 
      +
      6581  class FreeSpaceDatabase
      +
      6582  {
      +
      6583  public:
      +
      6584  FreeSpaceDatabase()
      +
      6585  {
      +
      6586  FreeSpace s = {};
      +
      6587  s.blockInfoIndex = SIZE_MAX;
      +
      6588  for(size_t i = 0; i < MAX_COUNT; ++i)
      +
      6589  {
      +
      6590  m_FreeSpaces[i] = s;
      +
      6591  }
      +
      6592  }
      +
      6593 
      +
      6594  void Register(size_t blockInfoIndex, VkDeviceSize offset, VkDeviceSize size)
      +
      6595  {
      +
      6596  if(size < VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
      +
      6597  {
      +
      6598  return;
      +
      6599  }
      +
      6600 
      +
      6601  // Find first invalid or the smallest structure.
      +
      6602  size_t bestIndex = SIZE_MAX;
      +
      6603  for(size_t i = 0; i < MAX_COUNT; ++i)
      +
      6604  {
      +
      6605  // Empty structure.
      +
      6606  if(m_FreeSpaces[i].blockInfoIndex == SIZE_MAX)
      +
      6607  {
      +
      6608  bestIndex = i;
      +
      6609  break;
      +
      6610  }
      +
      6611  if(m_FreeSpaces[i].size < size &&
      +
      6612  (bestIndex == SIZE_MAX || m_FreeSpaces[bestIndex].size > m_FreeSpaces[i].size))
      +
      6613  {
      +
      6614  bestIndex = i;
      +
      6615  }
      +
      6616  }
      +
      6617 
      +
      6618  if(bestIndex != SIZE_MAX)
      +
      6619  {
      +
      6620  m_FreeSpaces[bestIndex].blockInfoIndex = blockInfoIndex;
      +
      6621  m_FreeSpaces[bestIndex].offset = offset;
      +
      6622  m_FreeSpaces[bestIndex].size = size;
      +
      6623  }
      +
      6624  }
      +
      6625 
      +
      6626  bool Fetch(VkDeviceSize alignment, VkDeviceSize size,
      +
      6627  size_t& outBlockInfoIndex, VkDeviceSize& outDstOffset)
      +
      6628  {
      +
      6629  size_t bestIndex = SIZE_MAX;
      +
      6630  VkDeviceSize bestFreeSpaceAfter = 0;
      +
      6631  for(size_t i = 0; i < MAX_COUNT; ++i)
      +
      6632  {
      +
      6633  // Structure is valid.
      +
      6634  if(m_FreeSpaces[i].blockInfoIndex != SIZE_MAX)
      +
      6635  {
      +
      6636  const VkDeviceSize dstOffset = VmaAlignUp(m_FreeSpaces[i].offset, alignment);
      +
      6637  // Allocation fits into this structure.
      +
      6638  if(dstOffset + size <= m_FreeSpaces[i].offset + m_FreeSpaces[i].size)
      +
      6639  {
      +
      6640  const VkDeviceSize freeSpaceAfter = (m_FreeSpaces[i].offset + m_FreeSpaces[i].size) -
      +
      6641  (dstOffset + size);
      +
      6642  if(bestIndex == SIZE_MAX || freeSpaceAfter > bestFreeSpaceAfter)
      +
      6643  {
      +
      6644  bestIndex = i;
      +
      6645  bestFreeSpaceAfter = freeSpaceAfter;
      +
      6646  }
      +
      6647  }
      +
      6648  }
      +
      6649  }
      +
      6650 
      +
      6651  if(bestIndex != SIZE_MAX)
      +
      6652  {
      +
      6653  outBlockInfoIndex = m_FreeSpaces[bestIndex].blockInfoIndex;
      +
      6654  outDstOffset = VmaAlignUp(m_FreeSpaces[bestIndex].offset, alignment);
      +
      6655 
      +
      6656  if(bestFreeSpaceAfter >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
      +
      6657  {
      +
      6658  // Leave this structure for remaining empty space.
      +
      6659  const VkDeviceSize alignmentPlusSize = (outDstOffset - m_FreeSpaces[bestIndex].offset) + size;
      +
      6660  m_FreeSpaces[bestIndex].offset += alignmentPlusSize;
      +
      6661  m_FreeSpaces[bestIndex].size -= alignmentPlusSize;
      +
      6662  }
      +
      6663  else
      +
      6664  {
      +
      6665  // This structure becomes invalid.
      +
      6666  m_FreeSpaces[bestIndex].blockInfoIndex = SIZE_MAX;
      +
      6667  }
      +
      6668 
      +
      6669  return true;
      +
      6670  }
      +
      6671 
      +
      6672  return false;
      +
      6673  }
      +
      6674 
      +
      6675  private:
      +
      6676  static const size_t MAX_COUNT = 4;
      +
      6677 
      +
      6678  struct FreeSpace
      +
      6679  {
      +
      6680  size_t blockInfoIndex; // SIZE_MAX means this structure is invalid.
      +
      6681  VkDeviceSize offset;
      +
      6682  VkDeviceSize size;
      +
      6683  } m_FreeSpaces[MAX_COUNT];
      +
      6684  };
      +
      6685 
      +
      6686  const bool m_OverlappingMoveSupported;
      +
      6687 
      +
      6688  uint32_t m_AllocationCount;
      +
      6689  bool m_AllAllocations;
      +
      6690 
      +
      6691  VkDeviceSize m_BytesMoved;
      +
      6692  uint32_t m_AllocationsMoved;
      +
      6693 
      +
      6694  VmaVector< BlockInfo, VmaStlAllocator<BlockInfo> > m_BlockInfos;
      +
      6695 
      +
      6696  void PreprocessMetadata();
      +
      6697  void PostprocessMetadata();
      +
      6698  void InsertSuballoc(VmaBlockMetadata_Generic* pMetadata, const VmaSuballocation& suballoc);
      +
      6699 };
      +
      6700 
      +
      6701 struct VmaBlockDefragmentationContext
      +
      6702 {
      +
      6703  enum BLOCK_FLAG
      +
      6704  {
      +
      6705  BLOCK_FLAG_USED = 0x00000001,
      +
      6706  };
      +
      6707  uint32_t flags;
      +
      6708  VkBuffer hBuffer;
      +
      6709 };
      6710 
      -
      6711  void AddPools(uint32_t poolCount, VmaPool* pPools);
      -
      6712  void AddAllocations(
      -
      6713  uint32_t allocationCount,
      -
      6714  VmaAllocation* pAllocations,
      -
      6715  VkBool32* pAllocationsChanged);
      -
      6716 
      -
      6717  /*
      -
      6718  Returns:
      -
      6719  - `VK_SUCCESS` if succeeded and object can be destroyed immediately.
      -
      6720  - `VK_NOT_READY` if succeeded but the object must remain alive until vmaDefragmentationEnd().
      -
      6721  - Negative value if error occured and object can be destroyed immediately.
      -
      6722  */
      -
      6723  VkResult Defragment(
      -
      6724  VkDeviceSize maxCpuBytesToMove, uint32_t maxCpuAllocationsToMove,
      -
      6725  VkDeviceSize maxGpuBytesToMove, uint32_t maxGpuAllocationsToMove,
      -
      6726  VkCommandBuffer commandBuffer, VmaDefragmentationStats* pStats);
      -
      6727 
      -
      6728 private:
      -
      6729  const VmaAllocator m_hAllocator;
      -
      6730  const uint32_t m_CurrFrameIndex;
      -
      6731  const uint32_t m_Flags;
      -
      6732  VmaDefragmentationStats* const m_pStats;
      -
      6733  // Owner of these objects.
      -
      6734  VmaBlockVectorDefragmentationContext* m_DefaultPoolContexts[VK_MAX_MEMORY_TYPES];
      -
      6735  // Owner of these objects.
      -
      6736  VmaVector< VmaBlockVectorDefragmentationContext*, VmaStlAllocator<VmaBlockVectorDefragmentationContext*> > m_CustomPoolContexts;
      -
      6737 };
      -
      6738 
      -
      6739 #if VMA_RECORDING_ENABLED
      -
      6740 
      -
      6741 class VmaRecorder
      -
      6742 {
      -
      6743 public:
      -
      6744  VmaRecorder();
      -
      6745  VkResult Init(const VmaRecordSettings& settings, bool useMutex);
      -
      6746  void WriteConfiguration(
      -
      6747  const VkPhysicalDeviceProperties& devProps,
      -
      6748  const VkPhysicalDeviceMemoryProperties& memProps,
      -
      6749  bool dedicatedAllocationExtensionEnabled,
      -
      6750  bool bindMemory2ExtensionEnabled);
      -
      6751  ~VmaRecorder();
      -
      6752 
      -
      6753  void RecordCreateAllocator(uint32_t frameIndex);
      -
      6754  void RecordDestroyAllocator(uint32_t frameIndex);
      -
      6755  void RecordCreatePool(uint32_t frameIndex,
      -
      6756  const VmaPoolCreateInfo& createInfo,
      -
      6757  VmaPool pool);
      -
      6758  void RecordDestroyPool(uint32_t frameIndex, VmaPool pool);
      -
      6759  void RecordAllocateMemory(uint32_t frameIndex,
      -
      6760  const VkMemoryRequirements& vkMemReq,
      -
      6761  const VmaAllocationCreateInfo& createInfo,
      -
      6762  VmaAllocation allocation);
      -
      6763  void RecordAllocateMemoryPages(uint32_t frameIndex,
      -
      6764  const VkMemoryRequirements& vkMemReq,
      -
      6765  const VmaAllocationCreateInfo& createInfo,
      -
      6766  uint64_t allocationCount,
      -
      6767  const VmaAllocation* pAllocations);
      -
      6768  void RecordAllocateMemoryForBuffer(uint32_t frameIndex,
      -
      6769  const VkMemoryRequirements& vkMemReq,
      -
      6770  bool requiresDedicatedAllocation,
      -
      6771  bool prefersDedicatedAllocation,
      -
      6772  const VmaAllocationCreateInfo& createInfo,
      -
      6773  VmaAllocation allocation);
      -
      6774  void RecordAllocateMemoryForImage(uint32_t frameIndex,
      -
      6775  const VkMemoryRequirements& vkMemReq,
      -
      6776  bool requiresDedicatedAllocation,
      -
      6777  bool prefersDedicatedAllocation,
      -
      6778  const VmaAllocationCreateInfo& createInfo,
      -
      6779  VmaAllocation allocation);
      -
      6780  void RecordFreeMemory(uint32_t frameIndex,
      -
      6781  VmaAllocation allocation);
      -
      6782  void RecordFreeMemoryPages(uint32_t frameIndex,
      -
      6783  uint64_t allocationCount,
      -
      6784  const VmaAllocation* pAllocations);
      -
      6785  void RecordSetAllocationUserData(uint32_t frameIndex,
      -
      6786  VmaAllocation allocation,
      -
      6787  const void* pUserData);
      -
      6788  void RecordCreateLostAllocation(uint32_t frameIndex,
      -
      6789  VmaAllocation allocation);
      -
      6790  void RecordMapMemory(uint32_t frameIndex,
      -
      6791  VmaAllocation allocation);
      -
      6792  void RecordUnmapMemory(uint32_t frameIndex,
      -
      6793  VmaAllocation allocation);
      -
      6794  void RecordFlushAllocation(uint32_t frameIndex,
      -
      6795  VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size);
      -
      6796  void RecordInvalidateAllocation(uint32_t frameIndex,
      -
      6797  VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size);
      -
      6798  void RecordCreateBuffer(uint32_t frameIndex,
      -
      6799  const VkBufferCreateInfo& bufCreateInfo,
      -
      6800  const VmaAllocationCreateInfo& allocCreateInfo,
      -
      6801  VmaAllocation allocation);
      -
      6802  void RecordCreateImage(uint32_t frameIndex,
      -
      6803  const VkImageCreateInfo& imageCreateInfo,
      -
      6804  const VmaAllocationCreateInfo& allocCreateInfo,
      -
      6805  VmaAllocation allocation);
      -
      6806  void RecordDestroyBuffer(uint32_t frameIndex,
      -
      6807  VmaAllocation allocation);
      -
      6808  void RecordDestroyImage(uint32_t frameIndex,
      -
      6809  VmaAllocation allocation);
      -
      6810  void RecordTouchAllocation(uint32_t frameIndex,
      -
      6811  VmaAllocation allocation);
      -
      6812  void RecordGetAllocationInfo(uint32_t frameIndex,
      -
      6813  VmaAllocation allocation);
      -
      6814  void RecordMakePoolAllocationsLost(uint32_t frameIndex,
      -
      6815  VmaPool pool);
      -
      6816  void RecordDefragmentationBegin(uint32_t frameIndex,
      -
      6817  const VmaDefragmentationInfo2& info,
      -
      6818  VmaDefragmentationContext ctx);
      -
      6819  void RecordDefragmentationEnd(uint32_t frameIndex,
      -
      6820  VmaDefragmentationContext ctx);
      -
      6821 
      -
      6822 private:
      -
      6823  struct CallParams
      -
      6824  {
      -
      6825  uint32_t threadId;
      -
      6826  double time;
      -
      6827  };
      -
      6828 
      -
      6829  class UserDataString
      -
      6830  {
      -
      6831  public:
      -
      6832  UserDataString(VmaAllocationCreateFlags allocFlags, const void* pUserData);
      -
      6833  const char* GetString() const { return m_Str; }
      -
      6834 
      -
      6835  private:
      -
      6836  char m_PtrStr[17];
      -
      6837  const char* m_Str;
      -
      6838  };
      -
      6839 
      -
      6840  bool m_UseMutex;
      -
      6841  VmaRecordFlags m_Flags;
      -
      6842  FILE* m_File;
      -
      6843  VMA_MUTEX m_FileMutex;
      -
      6844  int64_t m_Freq;
      -
      6845  int64_t m_StartCounter;
      -
      6846 
      -
      6847  void GetBasicParams(CallParams& outParams);
      -
      6848 
      -
      6849  // T must be a pointer type, e.g. VmaAllocation, VmaPool.
      -
      6850  template<typename T>
      -
      6851  void PrintPointerList(uint64_t count, const T* pItems)
      -
      6852  {
      -
      6853  if(count)
      -
      6854  {
      -
      6855  fprintf(m_File, "%p", pItems[0]);
      -
      6856  for(uint64_t i = 1; i < count; ++i)
      -
      6857  {
      -
      6858  fprintf(m_File, " %p", pItems[i]);
      -
      6859  }
      -
      6860  }
      -
      6861  }
      -
      6862 
      -
      6863  void PrintPointerList(uint64_t count, const VmaAllocation* pItems);
      -
      6864  void Flush();
      -
      6865 };
      -
      6866 
      -
      6867 #endif // #if VMA_RECORDING_ENABLED
      -
      6868 
      -
      6869 /*
      -
      6870 Thread-safe wrapper over VmaPoolAllocator free list, for allocation of VmaAllocation_T objects.
      -
      6871 */
      -
      6872 class VmaAllocationObjectAllocator
      -
      6873 {
      -
      6874  VMA_CLASS_NO_COPY(VmaAllocationObjectAllocator)
      -
      6875 public:
      -
      6876  VmaAllocationObjectAllocator(const VkAllocationCallbacks* pAllocationCallbacks);
      -
      6877 
      -
      6878  VmaAllocation Allocate();
      -
      6879  void Free(VmaAllocation hAlloc);
      -
      6880 
      -
      6881 private:
      -
      6882  VMA_MUTEX m_Mutex;
      -
      6883  VmaPoolAllocator<VmaAllocation_T> m_Allocator;
      -
      6884 };
      -
      6885 
      -
      6886 struct VmaCurrentBudgetData
      -
      6887 {
      -
      6888  VMA_ATOMIC_UINT64 m_BlockBytes[VK_MAX_MEMORY_HEAPS];
      -
      6889  VMA_ATOMIC_UINT64 m_AllocationBytes[VK_MAX_MEMORY_HEAPS];
      -
      6890 
      -
      6891 #if VMA_MEMORY_BUDGET
      -
      6892  VMA_ATOMIC_UINT32 m_OperationsSinceBudgetFetch;
      -
      6893  VMA_RW_MUTEX m_BudgetMutex;
      -
      6894  uint64_t m_VulkanUsage[VK_MAX_MEMORY_HEAPS];
      -
      6895  uint64_t m_VulkanBudget[VK_MAX_MEMORY_HEAPS];
      -
      6896  uint64_t m_BlockBytesAtBudgetFetch[VK_MAX_MEMORY_HEAPS];
      -
      6897 #endif // #if VMA_MEMORY_BUDGET
      -
      6898 
      -
      6899  VmaCurrentBudgetData()
      -
      6900  {
      -
      6901  for(uint32_t heapIndex = 0; heapIndex < VK_MAX_MEMORY_HEAPS; ++heapIndex)
      -
      6902  {
      -
      6903  m_BlockBytes[heapIndex] = 0;
      -
      6904  m_AllocationBytes[heapIndex] = 0;
      -
      6905 #if VMA_MEMORY_BUDGET
      -
      6906  m_VulkanUsage[heapIndex] = 0;
      -
      6907  m_VulkanBudget[heapIndex] = 0;
      -
      6908  m_BlockBytesAtBudgetFetch[heapIndex] = 0;
      -
      6909 #endif
      -
      6910  }
      -
      6911 
      -
      6912 #if VMA_MEMORY_BUDGET
      -
      6913  m_OperationsSinceBudgetFetch = 0;
      -
      6914 #endif
      -
      6915  }
      -
      6916 };
      -
      6917 
      -
      6918 // Main allocator object.
      -
      6919 struct VmaAllocator_T
      -
      6920 {
      -
      6921  VMA_CLASS_NO_COPY(VmaAllocator_T)
      -
      6922 public:
      -
      6923  bool m_UseMutex;
      -
      6924  bool m_UseKhrDedicatedAllocation;
      -
      6925  bool m_UseKhrBindMemory2;
      -
      6926  bool m_UseExtMemoryBudget;
      -
      6927  VkDevice m_hDevice;
      -
      6928  VkInstance m_hInstance;
      -
      6929  bool m_AllocationCallbacksSpecified;
      -
      6930  VkAllocationCallbacks m_AllocationCallbacks;
      -
      6931  VmaDeviceMemoryCallbacks m_DeviceMemoryCallbacks;
      -
      6932  VmaAllocationObjectAllocator m_AllocationObjectAllocator;
      -
      6933 
      -
      6934  // Each bit (1 << i) is set if HeapSizeLimit is enabled for that heap, so cannot allocate more than the heap size.
      -
      6935  uint32_t m_HeapSizeLimitMask;
      -
      6936 
      -
      6937  VkPhysicalDeviceProperties m_PhysicalDeviceProperties;
      -
      6938  VkPhysicalDeviceMemoryProperties m_MemProps;
      -
      6939 
      -
      6940  // Default pools.
      -
      6941  VmaBlockVector* m_pBlockVectors[VK_MAX_MEMORY_TYPES];
      -
      6942 
      -
      6943  // Each vector is sorted by memory (handle value).
      -
      6944  typedef VmaVector< VmaAllocation, VmaStlAllocator<VmaAllocation> > AllocationVectorType;
      -
      6945  AllocationVectorType* m_pDedicatedAllocations[VK_MAX_MEMORY_TYPES];
      -
      6946  VMA_RW_MUTEX m_DedicatedAllocationsMutex[VK_MAX_MEMORY_TYPES];
      -
      6947 
      -
      6948  VmaCurrentBudgetData m_Budget;
      -
      6949 
      -
      6950  VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo);
      -
      6951  VkResult Init(const VmaAllocatorCreateInfo* pCreateInfo);
      -
      6952  ~VmaAllocator_T();
      -
      6953 
      -
      6954  const VkAllocationCallbacks* GetAllocationCallbacks() const
      -
      6955  {
      -
      6956  return m_AllocationCallbacksSpecified ? &m_AllocationCallbacks : 0;
      -
      6957  }
      -
      6958  const VmaVulkanFunctions& GetVulkanFunctions() const
      -
      6959  {
      -
      6960  return m_VulkanFunctions;
      -
      6961  }
      -
      6962 
      -
      6963  VkDeviceSize GetBufferImageGranularity() const
      -
      6964  {
      -
      6965  return VMA_MAX(
      -
      6966  static_cast<VkDeviceSize>(VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY),
      -
      6967  m_PhysicalDeviceProperties.limits.bufferImageGranularity);
      -
      6968  }
      -
      6969 
      -
      6970  uint32_t GetMemoryHeapCount() const { return m_MemProps.memoryHeapCount; }
      -
      6971  uint32_t GetMemoryTypeCount() const { return m_MemProps.memoryTypeCount; }
      -
      6972 
      -
      6973  uint32_t MemoryTypeIndexToHeapIndex(uint32_t memTypeIndex) const
      -
      6974  {
      -
      6975  VMA_ASSERT(memTypeIndex < m_MemProps.memoryTypeCount);
      -
      6976  return m_MemProps.memoryTypes[memTypeIndex].heapIndex;
      -
      6977  }
      -
      6978  // True when specific memory type is HOST_VISIBLE but not HOST_COHERENT.
      -
      6979  bool IsMemoryTypeNonCoherent(uint32_t memTypeIndex) const
      -
      6980  {
      -
      6981  return (m_MemProps.memoryTypes[memTypeIndex].propertyFlags & (VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) ==
      -
      6982  VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
      +
      6711 class VmaBlockVectorDefragmentationContext
      +
      6712 {
      +
      6713  VMA_CLASS_NO_COPY(VmaBlockVectorDefragmentationContext)
      +
      6714 public:
      +
      6715  VkResult res;
      +
      6716  bool mutexLocked;
      +
      6717  VmaVector< VmaBlockDefragmentationContext, VmaStlAllocator<VmaBlockDefragmentationContext> > blockContexts;
      +
      6718 
      +
      6719  VmaBlockVectorDefragmentationContext(
      +
      6720  VmaAllocator hAllocator,
      +
      6721  VmaPool hCustomPool, // Optional.
      +
      6722  VmaBlockVector* pBlockVector,
      +
      6723  uint32_t currFrameIndex);
      +
      6724  ~VmaBlockVectorDefragmentationContext();
      +
      6725 
      +
      6726  VmaPool GetCustomPool() const { return m_hCustomPool; }
      +
      6727  VmaBlockVector* GetBlockVector() const { return m_pBlockVector; }
      +
      6728  VmaDefragmentationAlgorithm* GetAlgorithm() const { return m_pAlgorithm; }
      +
      6729 
      +
      6730  void AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged);
      +
      6731  void AddAll() { m_AllAllocations = true; }
      +
      6732 
      +
      6733  void Begin(bool overlappingMoveSupported);
      +
      6734 
      +
      6735 private:
      +
      6736  const VmaAllocator m_hAllocator;
      +
      6737  // Null if not from custom pool.
      +
      6738  const VmaPool m_hCustomPool;
      +
      6739  // Redundant, for convenience not to fetch from m_hCustomPool->m_BlockVector or m_hAllocator->m_pBlockVectors.
      +
      6740  VmaBlockVector* const m_pBlockVector;
      +
      6741  const uint32_t m_CurrFrameIndex;
      +
      6742  // Owner of this object.
      +
      6743  VmaDefragmentationAlgorithm* m_pAlgorithm;
      +
      6744 
      +
      6745  struct AllocInfo
      +
      6746  {
      +
      6747  VmaAllocation hAlloc;
      +
      6748  VkBool32* pChanged;
      +
      6749  };
      +
      6750  // Used between constructor and Begin.
      +
      6751  VmaVector< AllocInfo, VmaStlAllocator<AllocInfo> > m_Allocations;
      +
      6752  bool m_AllAllocations;
      +
      6753 };
      +
      6754 
      +
      6755 struct VmaDefragmentationContext_T
      +
      6756 {
      +
      6757 private:
      +
      6758  VMA_CLASS_NO_COPY(VmaDefragmentationContext_T)
      +
      6759 public:
      +
      6760  VmaDefragmentationContext_T(
      +
      6761  VmaAllocator hAllocator,
      +
      6762  uint32_t currFrameIndex,
      +
      6763  uint32_t flags,
      +
      6764  VmaDefragmentationStats* pStats);
      +
      6765  ~VmaDefragmentationContext_T();
      +
      6766 
      +
      6767  void AddPools(uint32_t poolCount, VmaPool* pPools);
      +
      6768  void AddAllocations(
      +
      6769  uint32_t allocationCount,
      +
      6770  VmaAllocation* pAllocations,
      +
      6771  VkBool32* pAllocationsChanged);
      +
      6772 
      +
      6773  /*
      +
      6774  Returns:
      +
      6775  - `VK_SUCCESS` if succeeded and object can be destroyed immediately.
      +
      6776  - `VK_NOT_READY` if succeeded but the object must remain alive until vmaDefragmentationEnd().
      +
      6777  - Negative value if error occured and object can be destroyed immediately.
      +
      6778  */
      +
      6779  VkResult Defragment(
      +
      6780  VkDeviceSize maxCpuBytesToMove, uint32_t maxCpuAllocationsToMove,
      +
      6781  VkDeviceSize maxGpuBytesToMove, uint32_t maxGpuAllocationsToMove,
      +
      6782  VkCommandBuffer commandBuffer, VmaDefragmentationStats* pStats);
      +
      6783 
      +
      6784 private:
      +
      6785  const VmaAllocator m_hAllocator;
      +
      6786  const uint32_t m_CurrFrameIndex;
      +
      6787  const uint32_t m_Flags;
      +
      6788  VmaDefragmentationStats* const m_pStats;
      +
      6789  // Owner of these objects.
      +
      6790  VmaBlockVectorDefragmentationContext* m_DefaultPoolContexts[VK_MAX_MEMORY_TYPES];
      +
      6791  // Owner of these objects.
      +
      6792  VmaVector< VmaBlockVectorDefragmentationContext*, VmaStlAllocator<VmaBlockVectorDefragmentationContext*> > m_CustomPoolContexts;
      +
      6793 };
      +
      6794 
      +
      6795 #if VMA_RECORDING_ENABLED
      +
      6796 
      +
      6797 class VmaRecorder
      +
      6798 {
      +
      6799 public:
      +
      6800  VmaRecorder();
      +
      6801  VkResult Init(const VmaRecordSettings& settings, bool useMutex);
      +
      6802  void WriteConfiguration(
      +
      6803  const VkPhysicalDeviceProperties& devProps,
      +
      6804  const VkPhysicalDeviceMemoryProperties& memProps,
      +
      6805  bool dedicatedAllocationExtensionEnabled,
      +
      6806  bool bindMemory2ExtensionEnabled,
      +
      6807  bool memoryBudgetExtensionEnabled);
      +
      6808  ~VmaRecorder();
      +
      6809 
      +
      6810  void RecordCreateAllocator(uint32_t frameIndex);
      +
      6811  void RecordDestroyAllocator(uint32_t frameIndex);
      +
      6812  void RecordCreatePool(uint32_t frameIndex,
      +
      6813  const VmaPoolCreateInfo& createInfo,
      +
      6814  VmaPool pool);
      +
      6815  void RecordDestroyPool(uint32_t frameIndex, VmaPool pool);
      +
      6816  void RecordAllocateMemory(uint32_t frameIndex,
      +
      6817  const VkMemoryRequirements& vkMemReq,
      +
      6818  const VmaAllocationCreateInfo& createInfo,
      +
      6819  VmaAllocation allocation);
      +
      6820  void RecordAllocateMemoryPages(uint32_t frameIndex,
      +
      6821  const VkMemoryRequirements& vkMemReq,
      +
      6822  const VmaAllocationCreateInfo& createInfo,
      +
      6823  uint64_t allocationCount,
      +
      6824  const VmaAllocation* pAllocations);
      +
      6825  void RecordAllocateMemoryForBuffer(uint32_t frameIndex,
      +
      6826  const VkMemoryRequirements& vkMemReq,
      +
      6827  bool requiresDedicatedAllocation,
      +
      6828  bool prefersDedicatedAllocation,
      +
      6829  const VmaAllocationCreateInfo& createInfo,
      +
      6830  VmaAllocation allocation);
      +
      6831  void RecordAllocateMemoryForImage(uint32_t frameIndex,
      +
      6832  const VkMemoryRequirements& vkMemReq,
      +
      6833  bool requiresDedicatedAllocation,
      +
      6834  bool prefersDedicatedAllocation,
      +
      6835  const VmaAllocationCreateInfo& createInfo,
      +
      6836  VmaAllocation allocation);
      +
      6837  void RecordFreeMemory(uint32_t frameIndex,
      +
      6838  VmaAllocation allocation);
      +
      6839  void RecordFreeMemoryPages(uint32_t frameIndex,
      +
      6840  uint64_t allocationCount,
      +
      6841  const VmaAllocation* pAllocations);
      +
      6842  void RecordSetAllocationUserData(uint32_t frameIndex,
      +
      6843  VmaAllocation allocation,
      +
      6844  const void* pUserData);
      +
      6845  void RecordCreateLostAllocation(uint32_t frameIndex,
      +
      6846  VmaAllocation allocation);
      +
      6847  void RecordMapMemory(uint32_t frameIndex,
      +
      6848  VmaAllocation allocation);
      +
      6849  void RecordUnmapMemory(uint32_t frameIndex,
      +
      6850  VmaAllocation allocation);
      +
      6851  void RecordFlushAllocation(uint32_t frameIndex,
      +
      6852  VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size);
      +
      6853  void RecordInvalidateAllocation(uint32_t frameIndex,
      +
      6854  VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size);
      +
      6855  void RecordCreateBuffer(uint32_t frameIndex,
      +
      6856  const VkBufferCreateInfo& bufCreateInfo,
      +
      6857  const VmaAllocationCreateInfo& allocCreateInfo,
      +
      6858  VmaAllocation allocation);
      +
      6859  void RecordCreateImage(uint32_t frameIndex,
      +
      6860  const VkImageCreateInfo& imageCreateInfo,
      +
      6861  const VmaAllocationCreateInfo& allocCreateInfo,
      +
      6862  VmaAllocation allocation);
      +
      6863  void RecordDestroyBuffer(uint32_t frameIndex,
      +
      6864  VmaAllocation allocation);
      +
      6865  void RecordDestroyImage(uint32_t frameIndex,
      +
      6866  VmaAllocation allocation);
      +
      6867  void RecordTouchAllocation(uint32_t frameIndex,
      +
      6868  VmaAllocation allocation);
      +
      6869  void RecordGetAllocationInfo(uint32_t frameIndex,
      +
      6870  VmaAllocation allocation);
      +
      6871  void RecordMakePoolAllocationsLost(uint32_t frameIndex,
      +
      6872  VmaPool pool);
      +
      6873  void RecordDefragmentationBegin(uint32_t frameIndex,
      +
      6874  const VmaDefragmentationInfo2& info,
      +
      6875  VmaDefragmentationContext ctx);
      +
      6876  void RecordDefragmentationEnd(uint32_t frameIndex,
      +
      6877  VmaDefragmentationContext ctx);
      +
      6878  void RecordSetPoolName(uint32_t frameIndex,
      +
      6879  VmaPool pool,
      +
      6880  const char* name);
      +
      6881 
      +
      6882 private:
      +
      6883  struct CallParams
      +
      6884  {
      +
      6885  uint32_t threadId;
      +
      6886  double time;
      +
      6887  };
      +
      6888 
      +
      6889  class UserDataString
      +
      6890  {
      +
      6891  public:
      +
      6892  UserDataString(VmaAllocationCreateFlags allocFlags, const void* pUserData);
      +
      6893  const char* GetString() const { return m_Str; }
      +
      6894 
      +
      6895  private:
      +
      6896  char m_PtrStr[17];
      +
      6897  const char* m_Str;
      +
      6898  };
      +
      6899 
      +
      6900  bool m_UseMutex;
      +
      6901  VmaRecordFlags m_Flags;
      +
      6902  FILE* m_File;
      +
      6903  VMA_MUTEX m_FileMutex;
      +
      6904  int64_t m_Freq;
      +
      6905  int64_t m_StartCounter;
      +
      6906 
      +
      6907  void GetBasicParams(CallParams& outParams);
      +
      6908 
      +
      6909  // T must be a pointer type, e.g. VmaAllocation, VmaPool.
      +
      6910  template<typename T>
      +
      6911  void PrintPointerList(uint64_t count, const T* pItems)
      +
      6912  {
      +
      6913  if(count)
      +
      6914  {
      +
      6915  fprintf(m_File, "%p", pItems[0]);
      +
      6916  for(uint64_t i = 1; i < count; ++i)
      +
      6917  {
      +
      6918  fprintf(m_File, " %p", pItems[i]);
      +
      6919  }
      +
      6920  }
      +
      6921  }
      +
      6922 
      +
      6923  void PrintPointerList(uint64_t count, const VmaAllocation* pItems);
      +
      6924  void Flush();
      +
      6925 };
      +
      6926 
      +
      6927 #endif // #if VMA_RECORDING_ENABLED
      +
      6928 
      +
      6929 /*
      +
      6930 Thread-safe wrapper over VmaPoolAllocator free list, for allocation of VmaAllocation_T objects.
      +
      6931 */
      +
      6932 class VmaAllocationObjectAllocator
      +
      6933 {
      +
      6934  VMA_CLASS_NO_COPY(VmaAllocationObjectAllocator)
      +
      6935 public:
      +
      6936  VmaAllocationObjectAllocator(const VkAllocationCallbacks* pAllocationCallbacks);
      +
      6937 
      +
      6938  VmaAllocation Allocate();
      +
      6939  void Free(VmaAllocation hAlloc);
      +
      6940 
      +
      6941 private:
      +
      6942  VMA_MUTEX m_Mutex;
      +
      6943  VmaPoolAllocator<VmaAllocation_T> m_Allocator;
      +
      6944 };
      +
      6945 
      +
      6946 struct VmaCurrentBudgetData
      +
      6947 {
      +
      6948  VMA_ATOMIC_UINT64 m_BlockBytes[VK_MAX_MEMORY_HEAPS];
      +
      6949  VMA_ATOMIC_UINT64 m_AllocationBytes[VK_MAX_MEMORY_HEAPS];
      +
      6950 
      +
      6951 #if VMA_MEMORY_BUDGET
      +
      6952  VMA_ATOMIC_UINT32 m_OperationsSinceBudgetFetch;
      +
      6953  VMA_RW_MUTEX m_BudgetMutex;
      +
      6954  uint64_t m_VulkanUsage[VK_MAX_MEMORY_HEAPS];
      +
      6955  uint64_t m_VulkanBudget[VK_MAX_MEMORY_HEAPS];
      +
      6956  uint64_t m_BlockBytesAtBudgetFetch[VK_MAX_MEMORY_HEAPS];
      +
      6957 #endif // #if VMA_MEMORY_BUDGET
      +
      6958 
      +
      6959  VmaCurrentBudgetData()
      +
      6960  {
      +
      6961  for(uint32_t heapIndex = 0; heapIndex < VK_MAX_MEMORY_HEAPS; ++heapIndex)
      +
      6962  {
      +
      6963  m_BlockBytes[heapIndex] = 0;
      +
      6964  m_AllocationBytes[heapIndex] = 0;
      +
      6965 #if VMA_MEMORY_BUDGET
      +
      6966  m_VulkanUsage[heapIndex] = 0;
      +
      6967  m_VulkanBudget[heapIndex] = 0;
      +
      6968  m_BlockBytesAtBudgetFetch[heapIndex] = 0;
      +
      6969 #endif
      +
      6970  }
      +
      6971 
      +
      6972 #if VMA_MEMORY_BUDGET
      +
      6973  m_OperationsSinceBudgetFetch = 0;
      +
      6974 #endif
      +
      6975  }
      +
      6976 
      +
      6977  void AddAllocation(uint32_t heapIndex, VkDeviceSize allocationSize)
      +
      6978  {
      +
      6979  m_AllocationBytes[heapIndex] += allocationSize;
      +
      6980 #if VMA_MEMORY_BUDGET
      +
      6981  ++m_OperationsSinceBudgetFetch;
      +
      6982 #endif
      6983  }
      -
      6984  // Minimum alignment for all allocations in specific memory type.
      -
      6985  VkDeviceSize GetMemoryTypeMinAlignment(uint32_t memTypeIndex) const
      -
      6986  {
      -
      6987  return IsMemoryTypeNonCoherent(memTypeIndex) ?
      -
      6988  VMA_MAX((VkDeviceSize)VMA_DEBUG_ALIGNMENT, m_PhysicalDeviceProperties.limits.nonCoherentAtomSize) :
      -
      6989  (VkDeviceSize)VMA_DEBUG_ALIGNMENT;
      -
      6990  }
      -
      6991 
      -
      6992  bool IsIntegratedGpu() const
      -
      6993  {
      -
      6994  return m_PhysicalDeviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
      -
      6995  }
      -
      6996 
      -
      6997 #if VMA_RECORDING_ENABLED
      -
      6998  VmaRecorder* GetRecorder() const { return m_pRecorder; }
      -
      6999 #endif
      -
      7000 
      -
      7001  void GetBufferMemoryRequirements(
      -
      7002  VkBuffer hBuffer,
      -
      7003  VkMemoryRequirements& memReq,
      -
      7004  bool& requiresDedicatedAllocation,
      -
      7005  bool& prefersDedicatedAllocation) const;
      -
      7006  void GetImageMemoryRequirements(
      -
      7007  VkImage hImage,
      -
      7008  VkMemoryRequirements& memReq,
      -
      7009  bool& requiresDedicatedAllocation,
      -
      7010  bool& prefersDedicatedAllocation) const;
      -
      7011 
      -
      7012  // Main allocation function.
      -
      7013  VkResult AllocateMemory(
      -
      7014  const VkMemoryRequirements& vkMemReq,
      -
      7015  bool requiresDedicatedAllocation,
      -
      7016  bool prefersDedicatedAllocation,
      -
      7017  VkBuffer dedicatedBuffer,
      -
      7018  VkImage dedicatedImage,
      -
      7019  const VmaAllocationCreateInfo& createInfo,
      -
      7020  VmaSuballocationType suballocType,
      -
      7021  size_t allocationCount,
      -
      7022  VmaAllocation* pAllocations);
      -
      7023 
      -
      7024  // Main deallocation function.
      -
      7025  void FreeMemory(
      -
      7026  size_t allocationCount,
      -
      7027  const VmaAllocation* pAllocations);
      -
      7028 
      -
      7029  VkResult ResizeAllocation(
      -
      7030  const VmaAllocation alloc,
      -
      7031  VkDeviceSize newSize);
      -
      7032 
      -
      7033  void CalculateStats(VmaStats* pStats);
      -
      7034 
      -
      7035  void GetBudget(
      -
      7036  VmaBudget* outBudget, uint32_t firstHeap, uint32_t heapCount);
      -
      7037 
      -
      7038 #if VMA_STATS_STRING_ENABLED
      -
      7039  void PrintDetailedMap(class VmaJsonWriter& json);
      -
      7040 #endif
      -
      7041 
      -
      7042  VkResult DefragmentationBegin(
      -
      7043  const VmaDefragmentationInfo2& info,
      -
      7044  VmaDefragmentationStats* pStats,
      -
      7045  VmaDefragmentationContext* pContext);
      -
      7046  VkResult DefragmentationEnd(
      -
      7047  VmaDefragmentationContext context);
      -
      7048 
      -
      7049  void GetAllocationInfo(VmaAllocation hAllocation, VmaAllocationInfo* pAllocationInfo);
      -
      7050  bool TouchAllocation(VmaAllocation hAllocation);
      -
      7051 
      -
      7052  VkResult CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool);
      -
      7053  void DestroyPool(VmaPool pool);
      -
      7054  void GetPoolStats(VmaPool pool, VmaPoolStats* pPoolStats);
      -
      7055 
      -
      7056  void SetCurrentFrameIndex(uint32_t frameIndex);
      -
      7057  uint32_t GetCurrentFrameIndex() const { return m_CurrentFrameIndex.load(); }
      -
      7058 
      -
      7059  void MakePoolAllocationsLost(
      -
      7060  VmaPool hPool,
      -
      7061  size_t* pLostAllocationCount);
      -
      7062  VkResult CheckPoolCorruption(VmaPool hPool);
      -
      7063  VkResult CheckCorruption(uint32_t memoryTypeBits);
      -
      7064 
      -
      7065  void CreateLostAllocation(VmaAllocation* pAllocation);
      -
      7066 
      -
      7067  // Call to Vulkan function vkAllocateMemory with accompanying bookkeeping.
      -
      7068  VkResult AllocateVulkanMemory(const VkMemoryAllocateInfo* pAllocateInfo, VkDeviceMemory* pMemory);
      -
      7069  // Call to Vulkan function vkFreeMemory with accompanying bookkeeping.
      -
      7070  void FreeVulkanMemory(uint32_t memoryType, VkDeviceSize size, VkDeviceMemory hMemory);
      -
      7071  // Call to Vulkan function vkBindBufferMemory or vkBindBufferMemory2KHR.
      -
      7072  VkResult BindVulkanBuffer(
      -
      7073  VkDeviceMemory memory,
      -
      7074  VkDeviceSize memoryOffset,
      -
      7075  VkBuffer buffer,
      -
      7076  const void* pNext);
      -
      7077  // Call to Vulkan function vkBindImageMemory or vkBindImageMemory2KHR.
      -
      7078  VkResult BindVulkanImage(
      -
      7079  VkDeviceMemory memory,
      -
      7080  VkDeviceSize memoryOffset,
      -
      7081  VkImage image,
      -
      7082  const void* pNext);
      -
      7083 
      -
      7084  VkResult Map(VmaAllocation hAllocation, void** ppData);
      -
      7085  void Unmap(VmaAllocation hAllocation);
      -
      7086 
      -
      7087  VkResult BindBufferMemory(
      -
      7088  VmaAllocation hAllocation,
      -
      7089  VkDeviceSize allocationLocalOffset,
      -
      7090  VkBuffer hBuffer,
      -
      7091  const void* pNext);
      -
      7092  VkResult BindImageMemory(
      -
      7093  VmaAllocation hAllocation,
      -
      7094  VkDeviceSize allocationLocalOffset,
      -
      7095  VkImage hImage,
      -
      7096  const void* pNext);
      -
      7097 
      -
      7098  void FlushOrInvalidateAllocation(
      -
      7099  VmaAllocation hAllocation,
      -
      7100  VkDeviceSize offset, VkDeviceSize size,
      -
      7101  VMA_CACHE_OPERATION op);
      -
      7102 
      -
      7103  void FillAllocation(const VmaAllocation hAllocation, uint8_t pattern);
      -
      7104 
      -
      7105  /*
      -
      7106  Returns bit mask of memory types that can support defragmentation on GPU as
      -
      7107  they support creation of required buffer for copy operations.
      -
      7108  */
      -
      7109  uint32_t GetGpuDefragmentationMemoryTypeBits();
      -
      7110 
      -
      7111 private:
      -
      7112  VkDeviceSize m_PreferredLargeHeapBlockSize;
      -
      7113 
      -
      7114  VkPhysicalDevice m_PhysicalDevice;
      -
      7115  VMA_ATOMIC_UINT32 m_CurrentFrameIndex;
      -
      7116  VMA_ATOMIC_UINT32 m_GpuDefragmentationMemoryTypeBits; // UINT32_MAX means uninitialized.
      -
      7117 
      -
      7118  VMA_RW_MUTEX m_PoolsMutex;
      -
      7119  // Protected by m_PoolsMutex. Sorted by pointer value.
      -
      7120  VmaVector<VmaPool, VmaStlAllocator<VmaPool> > m_Pools;
      -
      7121  uint32_t m_NextPoolId;
      -
      7122 
      -
      7123  VmaVulkanFunctions m_VulkanFunctions;
      -
      7124 
      -
      7125 #if VMA_RECORDING_ENABLED
      -
      7126  VmaRecorder* m_pRecorder;
      -
      7127 #endif
      +
      6984 
      +
      6985  void RemoveAllocation(uint32_t heapIndex, VkDeviceSize allocationSize)
      +
      6986  {
      +
      6987  VMA_ASSERT(m_AllocationBytes[heapIndex] >= allocationSize); // DELME
      +
      6988  m_AllocationBytes[heapIndex] -= allocationSize;
      +
      6989 #if VMA_MEMORY_BUDGET
      +
      6990  ++m_OperationsSinceBudgetFetch;
      +
      6991 #endif
      +
      6992  }
      +
      6993 };
      +
      6994 
      +
      6995 // Main allocator object.
      +
      6996 struct VmaAllocator_T
      +
      6997 {
      +
      6998  VMA_CLASS_NO_COPY(VmaAllocator_T)
      +
      6999 public:
      +
      7000  bool m_UseMutex;
      +
      7001  bool m_UseKhrDedicatedAllocation;
      +
      7002  bool m_UseKhrBindMemory2;
      +
      7003  bool m_UseExtMemoryBudget;
      +
      7004  VkDevice m_hDevice;
      +
      7005  VkInstance m_hInstance;
      +
      7006  bool m_AllocationCallbacksSpecified;
      +
      7007  VkAllocationCallbacks m_AllocationCallbacks;
      +
      7008  VmaDeviceMemoryCallbacks m_DeviceMemoryCallbacks;
      +
      7009  VmaAllocationObjectAllocator m_AllocationObjectAllocator;
      +
      7010 
      +
      7011  // Each bit (1 << i) is set if HeapSizeLimit is enabled for that heap, so cannot allocate more than the heap size.
      +
      7012  uint32_t m_HeapSizeLimitMask;
      +
      7013 
      +
      7014  VkPhysicalDeviceProperties m_PhysicalDeviceProperties;
      +
      7015  VkPhysicalDeviceMemoryProperties m_MemProps;
      +
      7016 
      +
      7017  // Default pools.
      +
      7018  VmaBlockVector* m_pBlockVectors[VK_MAX_MEMORY_TYPES];
      +
      7019 
      +
      7020  // Each vector is sorted by memory (handle value).
      +
      7021  typedef VmaVector< VmaAllocation, VmaStlAllocator<VmaAllocation> > AllocationVectorType;
      +
      7022  AllocationVectorType* m_pDedicatedAllocations[VK_MAX_MEMORY_TYPES];
      +
      7023  VMA_RW_MUTEX m_DedicatedAllocationsMutex[VK_MAX_MEMORY_TYPES];
      +
      7024 
      +
      7025  VmaCurrentBudgetData m_Budget;
      +
      7026 
      +
      7027  VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo);
      +
      7028  VkResult Init(const VmaAllocatorCreateInfo* pCreateInfo);
      +
      7029  ~VmaAllocator_T();
      +
      7030 
      +
      7031  const VkAllocationCallbacks* GetAllocationCallbacks() const
      +
      7032  {
      +
      7033  return m_AllocationCallbacksSpecified ? &m_AllocationCallbacks : 0;
      +
      7034  }
      +
      7035  const VmaVulkanFunctions& GetVulkanFunctions() const
      +
      7036  {
      +
      7037  return m_VulkanFunctions;
      +
      7038  }
      +
      7039 
      +
      7040  VkDeviceSize GetBufferImageGranularity() const
      +
      7041  {
      +
      7042  return VMA_MAX(
      +
      7043  static_cast<VkDeviceSize>(VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY),
      +
      7044  m_PhysicalDeviceProperties.limits.bufferImageGranularity);
      +
      7045  }
      +
      7046 
      +
      7047  uint32_t GetMemoryHeapCount() const { return m_MemProps.memoryHeapCount; }
      +
      7048  uint32_t GetMemoryTypeCount() const { return m_MemProps.memoryTypeCount; }
      +
      7049 
      +
      7050  uint32_t MemoryTypeIndexToHeapIndex(uint32_t memTypeIndex) const
      +
      7051  {
      +
      7052  VMA_ASSERT(memTypeIndex < m_MemProps.memoryTypeCount);
      +
      7053  return m_MemProps.memoryTypes[memTypeIndex].heapIndex;
      +
      7054  }
      +
      7055  // True when specific memory type is HOST_VISIBLE but not HOST_COHERENT.
      +
      7056  bool IsMemoryTypeNonCoherent(uint32_t memTypeIndex) const
      +
      7057  {
      +
      7058  return (m_MemProps.memoryTypes[memTypeIndex].propertyFlags & (VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) ==
      +
      7059  VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
      +
      7060  }
      +
      7061  // Minimum alignment for all allocations in specific memory type.
      +
      7062  VkDeviceSize GetMemoryTypeMinAlignment(uint32_t memTypeIndex) const
      +
      7063  {
      +
      7064  return IsMemoryTypeNonCoherent(memTypeIndex) ?
      +
      7065  VMA_MAX((VkDeviceSize)VMA_DEBUG_ALIGNMENT, m_PhysicalDeviceProperties.limits.nonCoherentAtomSize) :
      +
      7066  (VkDeviceSize)VMA_DEBUG_ALIGNMENT;
      +
      7067  }
      +
      7068 
      +
      7069  bool IsIntegratedGpu() const
      +
      7070  {
      +
      7071  return m_PhysicalDeviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
      +
      7072  }
      +
      7073 
      +
      7074 #if VMA_RECORDING_ENABLED
      +
      7075  VmaRecorder* GetRecorder() const { return m_pRecorder; }
      +
      7076 #endif
      +
      7077 
      +
      7078  void GetBufferMemoryRequirements(
      +
      7079  VkBuffer hBuffer,
      +
      7080  VkMemoryRequirements& memReq,
      +
      7081  bool& requiresDedicatedAllocation,
      +
      7082  bool& prefersDedicatedAllocation) const;
      +
      7083  void GetImageMemoryRequirements(
      +
      7084  VkImage hImage,
      +
      7085  VkMemoryRequirements& memReq,
      +
      7086  bool& requiresDedicatedAllocation,
      +
      7087  bool& prefersDedicatedAllocation) const;
      +
      7088 
      +
      7089  // Main allocation function.
      +
      7090  VkResult AllocateMemory(
      +
      7091  const VkMemoryRequirements& vkMemReq,
      +
      7092  bool requiresDedicatedAllocation,
      +
      7093  bool prefersDedicatedAllocation,
      +
      7094  VkBuffer dedicatedBuffer,
      +
      7095  VkImage dedicatedImage,
      +
      7096  const VmaAllocationCreateInfo& createInfo,
      +
      7097  VmaSuballocationType suballocType,
      +
      7098  size_t allocationCount,
      +
      7099  VmaAllocation* pAllocations);
      +
      7100 
      +
      7101  // Main deallocation function.
      +
      7102  void FreeMemory(
      +
      7103  size_t allocationCount,
      +
      7104  const VmaAllocation* pAllocations);
      +
      7105 
      +
      7106  VkResult ResizeAllocation(
      +
      7107  const VmaAllocation alloc,
      +
      7108  VkDeviceSize newSize);
      +
      7109 
      +
      7110  void CalculateStats(VmaStats* pStats);
      +
      7111 
      +
      7112  void GetBudget(
      +
      7113  VmaBudget* outBudget, uint32_t firstHeap, uint32_t heapCount);
      +
      7114 
      +
      7115 #if VMA_STATS_STRING_ENABLED
      +
      7116  void PrintDetailedMap(class VmaJsonWriter& json);
      +
      7117 #endif
      +
      7118 
      +
      7119  VkResult DefragmentationBegin(
      +
      7120  const VmaDefragmentationInfo2& info,
      +
      7121  VmaDefragmentationStats* pStats,
      +
      7122  VmaDefragmentationContext* pContext);
      +
      7123  VkResult DefragmentationEnd(
      +
      7124  VmaDefragmentationContext context);
      +
      7125 
      +
      7126  void GetAllocationInfo(VmaAllocation hAllocation, VmaAllocationInfo* pAllocationInfo);
      +
      7127  bool TouchAllocation(VmaAllocation hAllocation);
      7128 
      -
      7129  void ImportVulkanFunctions(const VmaVulkanFunctions* pVulkanFunctions);
      -
      7130 
      -
      7131  VkDeviceSize CalcPreferredBlockSize(uint32_t memTypeIndex);
      +
      7129  VkResult CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool);
      +
      7130  void DestroyPool(VmaPool pool);
      +
      7131  void GetPoolStats(VmaPool pool, VmaPoolStats* pPoolStats);
      7132 
      -
      7133  VkResult AllocateMemoryOfType(
      -
      7134  VkDeviceSize size,
      -
      7135  VkDeviceSize alignment,
      -
      7136  bool dedicatedAllocation,
      -
      7137  VkBuffer dedicatedBuffer,
      -
      7138  VkImage dedicatedImage,
      -
      7139  const VmaAllocationCreateInfo& createInfo,
      -
      7140  uint32_t memTypeIndex,
      -
      7141  VmaSuballocationType suballocType,
      -
      7142  size_t allocationCount,
      -
      7143  VmaAllocation* pAllocations);
      -
      7144 
      -
      7145  // Helper function only to be used inside AllocateDedicatedMemory.
      -
      7146  VkResult AllocateDedicatedMemoryPage(
      -
      7147  VkDeviceSize size,
      -
      7148  VmaSuballocationType suballocType,
      -
      7149  uint32_t memTypeIndex,
      -
      7150  const VkMemoryAllocateInfo& allocInfo,
      -
      7151  bool map,
      -
      7152  bool isUserDataString,
      -
      7153  void* pUserData,
      -
      7154  VmaAllocation* pAllocation);
      -
      7155 
      -
      7156  // Allocates and registers new VkDeviceMemory specifically for dedicated allocations.
      -
      7157  VkResult AllocateDedicatedMemory(
      -
      7158  VkDeviceSize size,
      -
      7159  VmaSuballocationType suballocType,
      -
      7160  uint32_t memTypeIndex,
      -
      7161  bool withinBudget,
      -
      7162  bool map,
      -
      7163  bool isUserDataString,
      -
      7164  void* pUserData,
      -
      7165  VkBuffer dedicatedBuffer,
      -
      7166  VkImage dedicatedImage,
      -
      7167  size_t allocationCount,
      -
      7168  VmaAllocation* pAllocations);
      -
      7169 
      -
      7170  void FreeDedicatedMemory(const VmaAllocation allocation);
      -
      7171 
      -
      7172  /*
      -
      7173  Calculates and returns bit mask of memory types that can support defragmentation
      -
      7174  on GPU as they support creation of required buffer for copy operations.
      -
      7175  */
      -
      7176  uint32_t CalculateGpuDefragmentationMemoryTypeBits() const;
      -
      7177 
      -
      7178 #if VMA_MEMORY_BUDGET
      -
      7179  void UpdateVulkanBudget();
      -
      7180 #endif // #if VMA_MEMORY_BUDGET
      -
      7181 };
      -
      7182 
      -
      7184 // Memory allocation #2 after VmaAllocator_T definition
      -
      7185 
      -
      7186 static void* VmaMalloc(VmaAllocator hAllocator, size_t size, size_t alignment)
      -
      7187 {
      -
      7188  return VmaMalloc(&hAllocator->m_AllocationCallbacks, size, alignment);
      -
      7189 }
      +
      7133  void SetCurrentFrameIndex(uint32_t frameIndex);
      +
      7134  uint32_t GetCurrentFrameIndex() const { return m_CurrentFrameIndex.load(); }
      +
      7135 
      +
      7136  void MakePoolAllocationsLost(
      +
      7137  VmaPool hPool,
      +
      7138  size_t* pLostAllocationCount);
      +
      7139  VkResult CheckPoolCorruption(VmaPool hPool);
      +
      7140  VkResult CheckCorruption(uint32_t memoryTypeBits);
      +
      7141 
      +
      7142  void CreateLostAllocation(VmaAllocation* pAllocation);
      +
      7143 
      +
      7144  // Call to Vulkan function vkAllocateMemory with accompanying bookkeeping.
      +
      7145  VkResult AllocateVulkanMemory(const VkMemoryAllocateInfo* pAllocateInfo, VkDeviceMemory* pMemory);
      +
      7146  // Call to Vulkan function vkFreeMemory with accompanying bookkeeping.
      +
      7147  void FreeVulkanMemory(uint32_t memoryType, VkDeviceSize size, VkDeviceMemory hMemory);
      +
      7148  // Call to Vulkan function vkBindBufferMemory or vkBindBufferMemory2KHR.
      +
      7149  VkResult BindVulkanBuffer(
      +
      7150  VkDeviceMemory memory,
      +
      7151  VkDeviceSize memoryOffset,
      +
      7152  VkBuffer buffer,
      +
      7153  const void* pNext);
      +
      7154  // Call to Vulkan function vkBindImageMemory or vkBindImageMemory2KHR.
      +
      7155  VkResult BindVulkanImage(
      +
      7156  VkDeviceMemory memory,
      +
      7157  VkDeviceSize memoryOffset,
      +
      7158  VkImage image,
      +
      7159  const void* pNext);
      +
      7160 
      +
      7161  VkResult Map(VmaAllocation hAllocation, void** ppData);
      +
      7162  void Unmap(VmaAllocation hAllocation);
      +
      7163 
      +
      7164  VkResult BindBufferMemory(
      +
      7165  VmaAllocation hAllocation,
      +
      7166  VkDeviceSize allocationLocalOffset,
      +
      7167  VkBuffer hBuffer,
      +
      7168  const void* pNext);
      +
      7169  VkResult BindImageMemory(
      +
      7170  VmaAllocation hAllocation,
      +
      7171  VkDeviceSize allocationLocalOffset,
      +
      7172  VkImage hImage,
      +
      7173  const void* pNext);
      +
      7174 
      +
      7175  void FlushOrInvalidateAllocation(
      +
      7176  VmaAllocation hAllocation,
      +
      7177  VkDeviceSize offset, VkDeviceSize size,
      +
      7178  VMA_CACHE_OPERATION op);
      +
      7179 
      +
      7180  void FillAllocation(const VmaAllocation hAllocation, uint8_t pattern);
      +
      7181 
      +
      7182  /*
      +
      7183  Returns bit mask of memory types that can support defragmentation on GPU as
      +
      7184  they support creation of required buffer for copy operations.
      +
      7185  */
      +
      7186  uint32_t GetGpuDefragmentationMemoryTypeBits();
      +
      7187 
      +
      7188 private:
      +
      7189  VkDeviceSize m_PreferredLargeHeapBlockSize;
      7190 
      -
      7191 static void VmaFree(VmaAllocator hAllocator, void* ptr)
      -
      7192 {
      -
      7193  VmaFree(&hAllocator->m_AllocationCallbacks, ptr);
      -
      7194 }
      -
      7195 
      -
      7196 template<typename T>
      -
      7197 static T* VmaAllocate(VmaAllocator hAllocator)
      -
      7198 {
      -
      7199  return (T*)VmaMalloc(hAllocator, sizeof(T), VMA_ALIGN_OF(T));
      -
      7200 }
      +
      7191  VkPhysicalDevice m_PhysicalDevice;
      +
      7192  VMA_ATOMIC_UINT32 m_CurrentFrameIndex;
      +
      7193  VMA_ATOMIC_UINT32 m_GpuDefragmentationMemoryTypeBits; // UINT32_MAX means uninitialized.
      +
      7194 
      +
      7195  VMA_RW_MUTEX m_PoolsMutex;
      +
      7196  // Protected by m_PoolsMutex. Sorted by pointer value.
      +
      7197  VmaVector<VmaPool, VmaStlAllocator<VmaPool> > m_Pools;
      +
      7198  uint32_t m_NextPoolId;
      +
      7199 
      +
      7200  VmaVulkanFunctions m_VulkanFunctions;
      7201 
      -
      7202 template<typename T>
      -
      7203 static T* VmaAllocateArray(VmaAllocator hAllocator, size_t count)
      -
      7204 {
      -
      7205  return (T*)VmaMalloc(hAllocator, sizeof(T) * count, VMA_ALIGN_OF(T));
      -
      7206 }
      +
      7202 #if VMA_RECORDING_ENABLED
      +
      7203  VmaRecorder* m_pRecorder;
      +
      7204 #endif
      +
      7205 
      +
      7206  void ImportVulkanFunctions(const VmaVulkanFunctions* pVulkanFunctions);
      7207 
      -
      7208 template<typename T>
      -
      7209 static void vma_delete(VmaAllocator hAllocator, T* ptr)
      -
      7210 {
      -
      7211  if(ptr != VMA_NULL)
      -
      7212  {
      -
      7213  ptr->~T();
      -
      7214  VmaFree(hAllocator, ptr);
      -
      7215  }
      -
      7216 }
      -
      7217 
      -
      7218 template<typename T>
      -
      7219 static void vma_delete_array(VmaAllocator hAllocator, T* ptr, size_t count)
      -
      7220 {
      -
      7221  if(ptr != VMA_NULL)
      -
      7222  {
      -
      7223  for(size_t i = count; i--; )
      -
      7224  ptr[i].~T();
      -
      7225  VmaFree(hAllocator, ptr);
      -
      7226  }
      -
      7227 }
      -
      7228 
      -
      7230 // VmaStringBuilder
      -
      7231 
      -
      7232 #if VMA_STATS_STRING_ENABLED
      -
      7233 
      -
      7234 class VmaStringBuilder
      -
      7235 {
      -
      7236 public:
      -
      7237  VmaStringBuilder(VmaAllocator alloc) : m_Data(VmaStlAllocator<char>(alloc->GetAllocationCallbacks())) { }
      -
      7238  size_t GetLength() const { return m_Data.size(); }
      -
      7239  const char* GetData() const { return m_Data.data(); }
      -
      7240 
      -
      7241  void Add(char ch) { m_Data.push_back(ch); }
      -
      7242  void Add(const char* pStr);
      -
      7243  void AddNewLine() { Add('\n'); }
      -
      7244  void AddNumber(uint32_t num);
      -
      7245  void AddNumber(uint64_t num);
      -
      7246  void AddPointer(const void* ptr);
      -
      7247 
      -
      7248 private:
      -
      7249  VmaVector< char, VmaStlAllocator<char> > m_Data;
      -
      7250 };
      -
      7251 
      -
      7252 void VmaStringBuilder::Add(const char* pStr)
      -
      7253 {
      -
      7254  const size_t strLen = strlen(pStr);
      -
      7255  if(strLen > 0)
      -
      7256  {
      -
      7257  const size_t oldCount = m_Data.size();
      -
      7258  m_Data.resize(oldCount + strLen);
      -
      7259  memcpy(m_Data.data() + oldCount, pStr, strLen);
      -
      7260  }
      -
      7261 }
      +
      7208  VkDeviceSize CalcPreferredBlockSize(uint32_t memTypeIndex);
      +
      7209 
      +
      7210  VkResult AllocateMemoryOfType(
      +
      7211  VkDeviceSize size,
      +
      7212  VkDeviceSize alignment,
      +
      7213  bool dedicatedAllocation,
      +
      7214  VkBuffer dedicatedBuffer,
      +
      7215  VkImage dedicatedImage,
      +
      7216  const VmaAllocationCreateInfo& createInfo,
      +
      7217  uint32_t memTypeIndex,
      +
      7218  VmaSuballocationType suballocType,
      +
      7219  size_t allocationCount,
      +
      7220  VmaAllocation* pAllocations);
      +
      7221 
      +
      7222  // Helper function only to be used inside AllocateDedicatedMemory.
      +
      7223  VkResult AllocateDedicatedMemoryPage(
      +
      7224  VkDeviceSize size,
      +
      7225  VmaSuballocationType suballocType,
      +
      7226  uint32_t memTypeIndex,
      +
      7227  const VkMemoryAllocateInfo& allocInfo,
      +
      7228  bool map,
      +
      7229  bool isUserDataString,
      +
      7230  void* pUserData,
      +
      7231  VmaAllocation* pAllocation);
      +
      7232 
      +
      7233  // Allocates and registers new VkDeviceMemory specifically for dedicated allocations.
      +
      7234  VkResult AllocateDedicatedMemory(
      +
      7235  VkDeviceSize size,
      +
      7236  VmaSuballocationType suballocType,
      +
      7237  uint32_t memTypeIndex,
      +
      7238  bool withinBudget,
      +
      7239  bool map,
      +
      7240  bool isUserDataString,
      +
      7241  void* pUserData,
      +
      7242  VkBuffer dedicatedBuffer,
      +
      7243  VkImage dedicatedImage,
      +
      7244  size_t allocationCount,
      +
      7245  VmaAllocation* pAllocations);
      +
      7246 
      +
      7247  void FreeDedicatedMemory(const VmaAllocation allocation);
      +
      7248 
      +
      7249  /*
      +
      7250  Calculates and returns bit mask of memory types that can support defragmentation
      +
      7251  on GPU as they support creation of required buffer for copy operations.
      +
      7252  */
      +
      7253  uint32_t CalculateGpuDefragmentationMemoryTypeBits() const;
      +
      7254 
      +
      7255 #if VMA_MEMORY_BUDGET
      +
      7256  void UpdateVulkanBudget();
      +
      7257 #endif // #if VMA_MEMORY_BUDGET
      +
      7258 };
      +
      7259 
      +
      7261 // Memory allocation #2 after VmaAllocator_T definition
      7262 
      -
      7263 void VmaStringBuilder::AddNumber(uint32_t num)
      +
      7263 static void* VmaMalloc(VmaAllocator hAllocator, size_t size, size_t alignment)
      7264 {
      -
      7265  char buf[11];
      -
      7266  buf[10] = '\0';
      -
      7267  char *p = &buf[10];
      -
      7268  do
      -
      7269  {
      -
      7270  *--p = '0' + (num % 10);
      -
      7271  num /= 10;
      -
      7272  }
      -
      7273  while(num);
      -
      7274  Add(p);
      -
      7275 }
      -
      7276 
      -
      7277 void VmaStringBuilder::AddNumber(uint64_t num)
      -
      7278 {
      -
      7279  char buf[21];
      -
      7280  buf[20] = '\0';
      -
      7281  char *p = &buf[20];
      -
      7282  do
      -
      7283  {
      -
      7284  *--p = '0' + (num % 10);
      -
      7285  num /= 10;
      -
      7286  }
      -
      7287  while(num);
      -
      7288  Add(p);
      -
      7289 }
      -
      7290 
      -
      7291 void VmaStringBuilder::AddPointer(const void* ptr)
      -
      7292 {
      -
      7293  char buf[21];
      -
      7294  VmaPtrToStr(buf, sizeof(buf), ptr);
      -
      7295  Add(buf);
      -
      7296 }
      -
      7297 
      -
      7298 #endif // #if VMA_STATS_STRING_ENABLED
      -
      7299 
      -
      7301 // VmaJsonWriter
      -
      7302 
      -
      7303 #if VMA_STATS_STRING_ENABLED
      -
      7304 
      -
      7305 class VmaJsonWriter
      -
      7306 {
      -
      7307  VMA_CLASS_NO_COPY(VmaJsonWriter)
      -
      7308 public:
      -
      7309  VmaJsonWriter(const VkAllocationCallbacks* pAllocationCallbacks, VmaStringBuilder& sb);
      -
      7310  ~VmaJsonWriter();
      -
      7311 
      -
      7312  void BeginObject(bool singleLine = false);
      -
      7313  void EndObject();
      -
      7314 
      -
      7315  void BeginArray(bool singleLine = false);
      -
      7316  void EndArray();
      -
      7317 
      -
      7318  void WriteString(const char* pStr);
      -
      7319  void BeginString(const char* pStr = VMA_NULL);
      -
      7320  void ContinueString(const char* pStr);
      -
      7321  void ContinueString(uint32_t n);
      -
      7322  void ContinueString(uint64_t n);
      -
      7323  void ContinueString_Pointer(const void* ptr);
      -
      7324  void EndString(const char* pStr = VMA_NULL);
      -
      7325 
      -
      7326  void WriteNumber(uint32_t n);
      -
      7327  void WriteNumber(uint64_t n);
      -
      7328  void WriteBool(bool b);
      -
      7329  void WriteNull();
      -
      7330 
      -
      7331 private:
      -
      7332  static const char* const INDENT;
      -
      7333 
      -
      7334  enum COLLECTION_TYPE
      -
      7335  {
      -
      7336  COLLECTION_TYPE_OBJECT,
      -
      7337  COLLECTION_TYPE_ARRAY,
      -
      7338  };
      -
      7339  struct StackItem
      -
      7340  {
      -
      7341  COLLECTION_TYPE type;
      -
      7342  uint32_t valueCount;
      -
      7343  bool singleLineMode;
      -
      7344  };
      -
      7345 
      -
      7346  VmaStringBuilder& m_SB;
      -
      7347  VmaVector< StackItem, VmaStlAllocator<StackItem> > m_Stack;
      -
      7348  bool m_InsideString;
      -
      7349 
      -
      7350  void BeginValue(bool isString);
      -
      7351  void WriteIndent(bool oneLess = false);
      -
      7352 };
      +
      7265  return VmaMalloc(&hAllocator->m_AllocationCallbacks, size, alignment);
      +
      7266 }
      +
      7267 
      +
      7268 static void VmaFree(VmaAllocator hAllocator, void* ptr)
      +
      7269 {
      +
      7270  VmaFree(&hAllocator->m_AllocationCallbacks, ptr);
      +
      7271 }
      +
      7272 
      +
      7273 template<typename T>
      +
      7274 static T* VmaAllocate(VmaAllocator hAllocator)
      +
      7275 {
      +
      7276  return (T*)VmaMalloc(hAllocator, sizeof(T), VMA_ALIGN_OF(T));
      +
      7277 }
      +
      7278 
      +
      7279 template<typename T>
      +
      7280 static T* VmaAllocateArray(VmaAllocator hAllocator, size_t count)
      +
      7281 {
      +
      7282  return (T*)VmaMalloc(hAllocator, sizeof(T) * count, VMA_ALIGN_OF(T));
      +
      7283 }
      +
      7284 
      +
      7285 template<typename T>
      +
      7286 static void vma_delete(VmaAllocator hAllocator, T* ptr)
      +
      7287 {
      +
      7288  if(ptr != VMA_NULL)
      +
      7289  {
      +
      7290  ptr->~T();
      +
      7291  VmaFree(hAllocator, ptr);
      +
      7292  }
      +
      7293 }
      +
      7294 
      +
      7295 template<typename T>
      +
      7296 static void vma_delete_array(VmaAllocator hAllocator, T* ptr, size_t count)
      +
      7297 {
      +
      7298  if(ptr != VMA_NULL)
      +
      7299  {
      +
      7300  for(size_t i = count; i--; )
      +
      7301  ptr[i].~T();
      +
      7302  VmaFree(hAllocator, ptr);
      +
      7303  }
      +
      7304 }
      +
      7305 
      +
      7307 // VmaStringBuilder
      +
      7308 
      +
      7309 #if VMA_STATS_STRING_ENABLED
      +
      7310 
      +
      7311 class VmaStringBuilder
      +
      7312 {
      +
      7313 public:
      +
      7314  VmaStringBuilder(VmaAllocator alloc) : m_Data(VmaStlAllocator<char>(alloc->GetAllocationCallbacks())) { }
      +
      7315  size_t GetLength() const { return m_Data.size(); }
      +
      7316  const char* GetData() const { return m_Data.data(); }
      +
      7317 
      +
      7318  void Add(char ch) { m_Data.push_back(ch); }
      +
      7319  void Add(const char* pStr);
      +
      7320  void AddNewLine() { Add('\n'); }
      +
      7321  void AddNumber(uint32_t num);
      +
      7322  void AddNumber(uint64_t num);
      +
      7323  void AddPointer(const void* ptr);
      +
      7324 
      +
      7325 private:
      +
      7326  VmaVector< char, VmaStlAllocator<char> > m_Data;
      +
      7327 };
      +
      7328 
      +
      7329 void VmaStringBuilder::Add(const char* pStr)
      +
      7330 {
      +
      7331  const size_t strLen = strlen(pStr);
      +
      7332  if(strLen > 0)
      +
      7333  {
      +
      7334  const size_t oldCount = m_Data.size();
      +
      7335  m_Data.resize(oldCount + strLen);
      +
      7336  memcpy(m_Data.data() + oldCount, pStr, strLen);
      +
      7337  }
      +
      7338 }
      +
      7339 
      +
      7340 void VmaStringBuilder::AddNumber(uint32_t num)
      +
      7341 {
      +
      7342  char buf[11];
      +
      7343  buf[10] = '\0';
      +
      7344  char *p = &buf[10];
      +
      7345  do
      +
      7346  {
      +
      7347  *--p = '0' + (num % 10);
      +
      7348  num /= 10;
      +
      7349  }
      +
      7350  while(num);
      +
      7351  Add(p);
      +
      7352 }
      7353 
      -
      7354 const char* const VmaJsonWriter::INDENT = " ";
      -
      7355 
      -
      7356 VmaJsonWriter::VmaJsonWriter(const VkAllocationCallbacks* pAllocationCallbacks, VmaStringBuilder& sb) :
      -
      7357  m_SB(sb),
      -
      7358  m_Stack(VmaStlAllocator<StackItem>(pAllocationCallbacks)),
      -
      7359  m_InsideString(false)
      -
      7360 {
      -
      7361 }
      -
      7362 
      -
      7363 VmaJsonWriter::~VmaJsonWriter()
      -
      7364 {
      -
      7365  VMA_ASSERT(!m_InsideString);
      -
      7366  VMA_ASSERT(m_Stack.empty());
      -
      7367 }
      -
      7368 
      -
      7369 void VmaJsonWriter::BeginObject(bool singleLine)
      -
      7370 {
      -
      7371  VMA_ASSERT(!m_InsideString);
      -
      7372 
      -
      7373  BeginValue(false);
      -
      7374  m_SB.Add('{');
      -
      7375 
      -
      7376  StackItem item;
      -
      7377  item.type = COLLECTION_TYPE_OBJECT;
      -
      7378  item.valueCount = 0;
      -
      7379  item.singleLineMode = singleLine;
      -
      7380  m_Stack.push_back(item);
      -
      7381 }
      -
      7382 
      -
      7383 void VmaJsonWriter::EndObject()
      -
      7384 {
      -
      7385  VMA_ASSERT(!m_InsideString);
      -
      7386 
      -
      7387  WriteIndent(true);
      -
      7388  m_SB.Add('}');
      -
      7389 
      -
      7390  VMA_ASSERT(!m_Stack.empty() && m_Stack.back().type == COLLECTION_TYPE_OBJECT);
      -
      7391  m_Stack.pop_back();
      -
      7392 }
      -
      7393 
      -
      7394 void VmaJsonWriter::BeginArray(bool singleLine)
      -
      7395 {
      -
      7396  VMA_ASSERT(!m_InsideString);
      -
      7397 
      -
      7398  BeginValue(false);
      -
      7399  m_SB.Add('[');
      -
      7400 
      -
      7401  StackItem item;
      -
      7402  item.type = COLLECTION_TYPE_ARRAY;
      -
      7403  item.valueCount = 0;
      -
      7404  item.singleLineMode = singleLine;
      -
      7405  m_Stack.push_back(item);
      -
      7406 }
      +
      7354 void VmaStringBuilder::AddNumber(uint64_t num)
      +
      7355 {
      +
      7356  char buf[21];
      +
      7357  buf[20] = '\0';
      +
      7358  char *p = &buf[20];
      +
      7359  do
      +
      7360  {
      +
      7361  *--p = '0' + (num % 10);
      +
      7362  num /= 10;
      +
      7363  }
      +
      7364  while(num);
      +
      7365  Add(p);
      +
      7366 }
      +
      7367 
      +
      7368 void VmaStringBuilder::AddPointer(const void* ptr)
      +
      7369 {
      +
      7370  char buf[21];
      +
      7371  VmaPtrToStr(buf, sizeof(buf), ptr);
      +
      7372  Add(buf);
      +
      7373 }
      +
      7374 
      +
      7375 #endif // #if VMA_STATS_STRING_ENABLED
      +
      7376 
      +
      7378 // VmaJsonWriter
      +
      7379 
      +
      7380 #if VMA_STATS_STRING_ENABLED
      +
      7381 
      +
      7382 class VmaJsonWriter
      +
      7383 {
      +
      7384  VMA_CLASS_NO_COPY(VmaJsonWriter)
      +
      7385 public:
      +
      7386  VmaJsonWriter(const VkAllocationCallbacks* pAllocationCallbacks, VmaStringBuilder& sb);
      +
      7387  ~VmaJsonWriter();
      +
      7388 
      +
      7389  void BeginObject(bool singleLine = false);
      +
      7390  void EndObject();
      +
      7391 
      +
      7392  void BeginArray(bool singleLine = false);
      +
      7393  void EndArray();
      +
      7394 
      +
      7395  void WriteString(const char* pStr);
      +
      7396  void BeginString(const char* pStr = VMA_NULL);
      +
      7397  void ContinueString(const char* pStr);
      +
      7398  void ContinueString(uint32_t n);
      +
      7399  void ContinueString(uint64_t n);
      +
      7400  void ContinueString_Pointer(const void* ptr);
      +
      7401  void EndString(const char* pStr = VMA_NULL);
      +
      7402 
      +
      7403  void WriteNumber(uint32_t n);
      +
      7404  void WriteNumber(uint64_t n);
      +
      7405  void WriteBool(bool b);
      +
      7406  void WriteNull();
      7407 
      -
      7408 void VmaJsonWriter::EndArray()
      -
      7409 {
      -
      7410  VMA_ASSERT(!m_InsideString);
      -
      7411 
      -
      7412  WriteIndent(true);
      -
      7413  m_SB.Add(']');
      -
      7414 
      -
      7415  VMA_ASSERT(!m_Stack.empty() && m_Stack.back().type == COLLECTION_TYPE_ARRAY);
      -
      7416  m_Stack.pop_back();
      -
      7417 }
      -
      7418 
      -
      7419 void VmaJsonWriter::WriteString(const char* pStr)
      -
      7420 {
      -
      7421  BeginString(pStr);
      -
      7422  EndString();
      -
      7423 }
      -
      7424 
      -
      7425 void VmaJsonWriter::BeginString(const char* pStr)
      -
      7426 {
      -
      7427  VMA_ASSERT(!m_InsideString);
      -
      7428 
      -
      7429  BeginValue(true);
      -
      7430  m_SB.Add('"');
      -
      7431  m_InsideString = true;
      -
      7432  if(pStr != VMA_NULL && pStr[0] != '\0')
      -
      7433  {
      -
      7434  ContinueString(pStr);
      -
      7435  }
      -
      7436 }
      -
      7437 
      -
      7438 void VmaJsonWriter::ContinueString(const char* pStr)
      -
      7439 {
      -
      7440  VMA_ASSERT(m_InsideString);
      -
      7441 
      -
      7442  const size_t strLen = strlen(pStr);
      -
      7443  for(size_t i = 0; i < strLen; ++i)
      -
      7444  {
      -
      7445  char ch = pStr[i];
      -
      7446  if(ch == '\\')
      -
      7447  {
      -
      7448  m_SB.Add("\\\\");
      -
      7449  }
      -
      7450  else if(ch == '"')
      -
      7451  {
      -
      7452  m_SB.Add("\\\"");
      -
      7453  }
      -
      7454  else if(ch >= 32)
      -
      7455  {
      -
      7456  m_SB.Add(ch);
      -
      7457  }
      -
      7458  else switch(ch)
      -
      7459  {
      -
      7460  case '\b':
      -
      7461  m_SB.Add("\\b");
      -
      7462  break;
      -
      7463  case '\f':
      -
      7464  m_SB.Add("\\f");
      -
      7465  break;
      -
      7466  case '\n':
      -
      7467  m_SB.Add("\\n");
      -
      7468  break;
      -
      7469  case '\r':
      -
      7470  m_SB.Add("\\r");
      -
      7471  break;
      -
      7472  case '\t':
      -
      7473  m_SB.Add("\\t");
      -
      7474  break;
      -
      7475  default:
      -
      7476  VMA_ASSERT(0 && "Character not currently supported.");
      -
      7477  break;
      -
      7478  }
      -
      7479  }
      -
      7480 }
      -
      7481 
      -
      7482 void VmaJsonWriter::ContinueString(uint32_t n)
      -
      7483 {
      -
      7484  VMA_ASSERT(m_InsideString);
      -
      7485  m_SB.AddNumber(n);
      -
      7486 }
      -
      7487 
      -
      7488 void VmaJsonWriter::ContinueString(uint64_t n)
      -
      7489 {
      -
      7490  VMA_ASSERT(m_InsideString);
      -
      7491  m_SB.AddNumber(n);
      -
      7492 }
      -
      7493 
      -
      7494 void VmaJsonWriter::ContinueString_Pointer(const void* ptr)
      -
      7495 {
      -
      7496  VMA_ASSERT(m_InsideString);
      -
      7497  m_SB.AddPointer(ptr);
      -
      7498 }
      -
      7499 
      -
      7500 void VmaJsonWriter::EndString(const char* pStr)
      -
      7501 {
      -
      7502  VMA_ASSERT(m_InsideString);
      -
      7503  if(pStr != VMA_NULL && pStr[0] != '\0')
      -
      7504  {
      -
      7505  ContinueString(pStr);
      -
      7506  }
      +
      7408 private:
      +
      7409  static const char* const INDENT;
      +
      7410 
      +
      7411  enum COLLECTION_TYPE
      +
      7412  {
      +
      7413  COLLECTION_TYPE_OBJECT,
      +
      7414  COLLECTION_TYPE_ARRAY,
      +
      7415  };
      +
      7416  struct StackItem
      +
      7417  {
      +
      7418  COLLECTION_TYPE type;
      +
      7419  uint32_t valueCount;
      +
      7420  bool singleLineMode;
      +
      7421  };
      +
      7422 
      +
      7423  VmaStringBuilder& m_SB;
      +
      7424  VmaVector< StackItem, VmaStlAllocator<StackItem> > m_Stack;
      +
      7425  bool m_InsideString;
      +
      7426 
      +
      7427  void BeginValue(bool isString);
      +
      7428  void WriteIndent(bool oneLess = false);
      +
      7429 };
      +
      7430 
      +
      7431 const char* const VmaJsonWriter::INDENT = " ";
      +
      7432 
      +
      7433 VmaJsonWriter::VmaJsonWriter(const VkAllocationCallbacks* pAllocationCallbacks, VmaStringBuilder& sb) :
      +
      7434  m_SB(sb),
      +
      7435  m_Stack(VmaStlAllocator<StackItem>(pAllocationCallbacks)),
      +
      7436  m_InsideString(false)
      +
      7437 {
      +
      7438 }
      +
      7439 
      +
      7440 VmaJsonWriter::~VmaJsonWriter()
      +
      7441 {
      +
      7442  VMA_ASSERT(!m_InsideString);
      +
      7443  VMA_ASSERT(m_Stack.empty());
      +
      7444 }
      +
      7445 
      +
      7446 void VmaJsonWriter::BeginObject(bool singleLine)
      +
      7447 {
      +
      7448  VMA_ASSERT(!m_InsideString);
      +
      7449 
      +
      7450  BeginValue(false);
      +
      7451  m_SB.Add('{');
      +
      7452 
      +
      7453  StackItem item;
      +
      7454  item.type = COLLECTION_TYPE_OBJECT;
      +
      7455  item.valueCount = 0;
      +
      7456  item.singleLineMode = singleLine;
      +
      7457  m_Stack.push_back(item);
      +
      7458 }
      +
      7459 
      +
      7460 void VmaJsonWriter::EndObject()
      +
      7461 {
      +
      7462  VMA_ASSERT(!m_InsideString);
      +
      7463 
      +
      7464  WriteIndent(true);
      +
      7465  m_SB.Add('}');
      +
      7466 
      +
      7467  VMA_ASSERT(!m_Stack.empty() && m_Stack.back().type == COLLECTION_TYPE_OBJECT);
      +
      7468  m_Stack.pop_back();
      +
      7469 }
      +
      7470 
      +
      7471 void VmaJsonWriter::BeginArray(bool singleLine)
      +
      7472 {
      +
      7473  VMA_ASSERT(!m_InsideString);
      +
      7474 
      +
      7475  BeginValue(false);
      +
      7476  m_SB.Add('[');
      +
      7477 
      +
      7478  StackItem item;
      +
      7479  item.type = COLLECTION_TYPE_ARRAY;
      +
      7480  item.valueCount = 0;
      +
      7481  item.singleLineMode = singleLine;
      +
      7482  m_Stack.push_back(item);
      +
      7483 }
      +
      7484 
      +
      7485 void VmaJsonWriter::EndArray()
      +
      7486 {
      +
      7487  VMA_ASSERT(!m_InsideString);
      +
      7488 
      +
      7489  WriteIndent(true);
      +
      7490  m_SB.Add(']');
      +
      7491 
      +
      7492  VMA_ASSERT(!m_Stack.empty() && m_Stack.back().type == COLLECTION_TYPE_ARRAY);
      +
      7493  m_Stack.pop_back();
      +
      7494 }
      +
      7495 
      +
      7496 void VmaJsonWriter::WriteString(const char* pStr)
      +
      7497 {
      +
      7498  BeginString(pStr);
      +
      7499  EndString();
      +
      7500 }
      +
      7501 
      +
      7502 void VmaJsonWriter::BeginString(const char* pStr)
      +
      7503 {
      +
      7504  VMA_ASSERT(!m_InsideString);
      +
      7505 
      +
      7506  BeginValue(true);
      7507  m_SB.Add('"');
      -
      7508  m_InsideString = false;
      -
      7509 }
      -
      7510 
      -
      7511 void VmaJsonWriter::WriteNumber(uint32_t n)
      -
      7512 {
      -
      7513  VMA_ASSERT(!m_InsideString);
      -
      7514  BeginValue(false);
      -
      7515  m_SB.AddNumber(n);
      -
      7516 }
      -
      7517 
      -
      7518 void VmaJsonWriter::WriteNumber(uint64_t n)
      -
      7519 {
      -
      7520  VMA_ASSERT(!m_InsideString);
      -
      7521  BeginValue(false);
      -
      7522  m_SB.AddNumber(n);
      -
      7523 }
      -
      7524 
      -
      7525 void VmaJsonWriter::WriteBool(bool b)
      -
      7526 {
      -
      7527  VMA_ASSERT(!m_InsideString);
      -
      7528  BeginValue(false);
      -
      7529  m_SB.Add(b ? "true" : "false");
      -
      7530 }
      -
      7531 
      -
      7532 void VmaJsonWriter::WriteNull()
      -
      7533 {
      -
      7534  VMA_ASSERT(!m_InsideString);
      -
      7535  BeginValue(false);
      -
      7536  m_SB.Add("null");
      -
      7537 }
      -
      7538 
      -
      7539 void VmaJsonWriter::BeginValue(bool isString)
      -
      7540 {
      -
      7541  if(!m_Stack.empty())
      -
      7542  {
      -
      7543  StackItem& currItem = m_Stack.back();
      -
      7544  if(currItem.type == COLLECTION_TYPE_OBJECT &&
      -
      7545  currItem.valueCount % 2 == 0)
      -
      7546  {
      -
      7547  VMA_ASSERT(isString);
      -
      7548  }
      -
      7549 
      -
      7550  if(currItem.type == COLLECTION_TYPE_OBJECT &&
      -
      7551  currItem.valueCount % 2 != 0)
      -
      7552  {
      -
      7553  m_SB.Add(": ");
      -
      7554  }
      -
      7555  else if(currItem.valueCount > 0)
      -
      7556  {
      -
      7557  m_SB.Add(", ");
      -
      7558  WriteIndent();
      -
      7559  }
      -
      7560  else
      -
      7561  {
      -
      7562  WriteIndent();
      -
      7563  }
      -
      7564  ++currItem.valueCount;
      -
      7565  }
      -
      7566 }
      -
      7567 
      -
      7568 void VmaJsonWriter::WriteIndent(bool oneLess)
      -
      7569 {
      -
      7570  if(!m_Stack.empty() && !m_Stack.back().singleLineMode)
      -
      7571  {
      -
      7572  m_SB.AddNewLine();
      -
      7573 
      -
      7574  size_t count = m_Stack.size();
      -
      7575  if(count > 0 && oneLess)
      -
      7576  {
      -
      7577  --count;
      -
      7578  }
      -
      7579  for(size_t i = 0; i < count; ++i)
      -
      7580  {
      -
      7581  m_SB.Add(INDENT);
      -
      7582  }
      +
      7508  m_InsideString = true;
      +
      7509  if(pStr != VMA_NULL && pStr[0] != '\0')
      +
      7510  {
      +
      7511  ContinueString(pStr);
      +
      7512  }
      +
      7513 }
      +
      7514 
      +
      7515 void VmaJsonWriter::ContinueString(const char* pStr)
      +
      7516 {
      +
      7517  VMA_ASSERT(m_InsideString);
      +
      7518 
      +
      7519  const size_t strLen = strlen(pStr);
      +
      7520  for(size_t i = 0; i < strLen; ++i)
      +
      7521  {
      +
      7522  char ch = pStr[i];
      +
      7523  if(ch == '\\')
      +
      7524  {
      +
      7525  m_SB.Add("\\\\");
      +
      7526  }
      +
      7527  else if(ch == '"')
      +
      7528  {
      +
      7529  m_SB.Add("\\\"");
      +
      7530  }
      +
      7531  else if(ch >= 32)
      +
      7532  {
      +
      7533  m_SB.Add(ch);
      +
      7534  }
      +
      7535  else switch(ch)
      +
      7536  {
      +
      7537  case '\b':
      +
      7538  m_SB.Add("\\b");
      +
      7539  break;
      +
      7540  case '\f':
      +
      7541  m_SB.Add("\\f");
      +
      7542  break;
      +
      7543  case '\n':
      +
      7544  m_SB.Add("\\n");
      +
      7545  break;
      +
      7546  case '\r':
      +
      7547  m_SB.Add("\\r");
      +
      7548  break;
      +
      7549  case '\t':
      +
      7550  m_SB.Add("\\t");
      +
      7551  break;
      +
      7552  default:
      +
      7553  VMA_ASSERT(0 && "Character not currently supported.");
      +
      7554  break;
      +
      7555  }
      +
      7556  }
      +
      7557 }
      +
      7558 
      +
      7559 void VmaJsonWriter::ContinueString(uint32_t n)
      +
      7560 {
      +
      7561  VMA_ASSERT(m_InsideString);
      +
      7562  m_SB.AddNumber(n);
      +
      7563 }
      +
      7564 
      +
      7565 void VmaJsonWriter::ContinueString(uint64_t n)
      +
      7566 {
      +
      7567  VMA_ASSERT(m_InsideString);
      +
      7568  m_SB.AddNumber(n);
      +
      7569 }
      +
      7570 
      +
      7571 void VmaJsonWriter::ContinueString_Pointer(const void* ptr)
      +
      7572 {
      +
      7573  VMA_ASSERT(m_InsideString);
      +
      7574  m_SB.AddPointer(ptr);
      +
      7575 }
      +
      7576 
      +
      7577 void VmaJsonWriter::EndString(const char* pStr)
      +
      7578 {
      +
      7579  VMA_ASSERT(m_InsideString);
      +
      7580  if(pStr != VMA_NULL && pStr[0] != '\0')
      +
      7581  {
      +
      7582  ContinueString(pStr);
      7583  }
      -
      7584 }
      -
      7585 
      -
      7586 #endif // #if VMA_STATS_STRING_ENABLED
      +
      7584  m_SB.Add('"');
      +
      7585  m_InsideString = false;
      +
      7586 }
      7587 
      -
      7589 
      -
      7590 void VmaAllocation_T::SetUserData(VmaAllocator hAllocator, void* pUserData)
      -
      7591 {
      -
      7592  if(IsUserDataString())
      -
      7593  {
      -
      7594  VMA_ASSERT(pUserData == VMA_NULL || pUserData != m_pUserData);
      -
      7595 
      -
      7596  FreeUserDataString(hAllocator);
      -
      7597 
      -
      7598  if(pUserData != VMA_NULL)
      -
      7599  {
      -
      7600  const char* const newStrSrc = (char*)pUserData;
      -
      7601  const size_t newStrLen = strlen(newStrSrc);
      -
      7602  char* const newStrDst = vma_new_array(hAllocator, char, newStrLen + 1);
      -
      7603  memcpy(newStrDst, newStrSrc, newStrLen + 1);
      -
      7604  m_pUserData = newStrDst;
      -
      7605  }
      -
      7606  }
      -
      7607  else
      -
      7608  {
      -
      7609  m_pUserData = pUserData;
      -
      7610  }
      -
      7611 }
      -
      7612 
      -
      7613 void VmaAllocation_T::ChangeBlockAllocation(
      -
      7614  VmaAllocator hAllocator,
      -
      7615  VmaDeviceMemoryBlock* block,
      -
      7616  VkDeviceSize offset)
      +
      7588 void VmaJsonWriter::WriteNumber(uint32_t n)
      +
      7589 {
      +
      7590  VMA_ASSERT(!m_InsideString);
      +
      7591  BeginValue(false);
      +
      7592  m_SB.AddNumber(n);
      +
      7593 }
      +
      7594 
      +
      7595 void VmaJsonWriter::WriteNumber(uint64_t n)
      +
      7596 {
      +
      7597  VMA_ASSERT(!m_InsideString);
      +
      7598  BeginValue(false);
      +
      7599  m_SB.AddNumber(n);
      +
      7600 }
      +
      7601 
      +
      7602 void VmaJsonWriter::WriteBool(bool b)
      +
      7603 {
      +
      7604  VMA_ASSERT(!m_InsideString);
      +
      7605  BeginValue(false);
      +
      7606  m_SB.Add(b ? "true" : "false");
      +
      7607 }
      +
      7608 
      +
      7609 void VmaJsonWriter::WriteNull()
      +
      7610 {
      +
      7611  VMA_ASSERT(!m_InsideString);
      +
      7612  BeginValue(false);
      +
      7613  m_SB.Add("null");
      +
      7614 }
      +
      7615 
      +
      7616 void VmaJsonWriter::BeginValue(bool isString)
      7617 {
      -
      7618  VMA_ASSERT(block != VMA_NULL);
      -
      7619  VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
      -
      7620 
      -
      7621  // Move mapping reference counter from old block to new block.
      -
      7622  if(block != m_BlockAllocation.m_Block)
      -
      7623  {
      -
      7624  uint32_t mapRefCount = m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP;
      -
      7625  if(IsPersistentMap())
      -
      7626  ++mapRefCount;
      -
      7627  m_BlockAllocation.m_Block->Unmap(hAllocator, mapRefCount);
      -
      7628  block->Map(hAllocator, mapRefCount, VMA_NULL);
      -
      7629  }
      -
      7630 
      -
      7631  m_BlockAllocation.m_Block = block;
      -
      7632  m_BlockAllocation.m_Offset = offset;
      -
      7633 }
      -
      7634 
      -
      7635 void VmaAllocation_T::ChangeOffset(VkDeviceSize newOffset)
      -
      7636 {
      -
      7637  VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
      -
      7638  m_BlockAllocation.m_Offset = newOffset;
      -
      7639 }
      -
      7640 
      -
      7641 VkDeviceSize VmaAllocation_T::GetOffset() const
      -
      7642 {
      -
      7643  switch(m_Type)
      -
      7644  {
      -
      7645  case ALLOCATION_TYPE_BLOCK:
      -
      7646  return m_BlockAllocation.m_Offset;
      -
      7647  case ALLOCATION_TYPE_DEDICATED:
      -
      7648  return 0;
      -
      7649  default:
      -
      7650  VMA_ASSERT(0);
      -
      7651  return 0;
      -
      7652  }
      -
      7653 }
      -
      7654 
      -
      7655 VkDeviceMemory VmaAllocation_T::GetMemory() const
      -
      7656 {
      -
      7657  switch(m_Type)
      -
      7658  {
      -
      7659  case ALLOCATION_TYPE_BLOCK:
      -
      7660  return m_BlockAllocation.m_Block->GetDeviceMemory();
      -
      7661  case ALLOCATION_TYPE_DEDICATED:
      -
      7662  return m_DedicatedAllocation.m_hMemory;
      -
      7663  default:
      -
      7664  VMA_ASSERT(0);
      -
      7665  return VK_NULL_HANDLE;
      -
      7666  }
      -
      7667 }
      -
      7668 
      -
      7669 uint32_t VmaAllocation_T::GetMemoryTypeIndex() const
      -
      7670 {
      -
      7671  switch(m_Type)
      -
      7672  {
      -
      7673  case ALLOCATION_TYPE_BLOCK:
      -
      7674  return m_BlockAllocation.m_Block->GetMemoryTypeIndex();
      -
      7675  case ALLOCATION_TYPE_DEDICATED:
      -
      7676  return m_DedicatedAllocation.m_MemoryTypeIndex;
      -
      7677  default:
      -
      7678  VMA_ASSERT(0);
      -
      7679  return UINT32_MAX;
      -
      7680  }
      -
      7681 }
      -
      7682 
      -
      7683 void* VmaAllocation_T::GetMappedData() const
      -
      7684 {
      -
      7685  switch(m_Type)
      -
      7686  {
      -
      7687  case ALLOCATION_TYPE_BLOCK:
      -
      7688  if(m_MapCount != 0)
      -
      7689  {
      -
      7690  void* pBlockData = m_BlockAllocation.m_Block->GetMappedData();
      -
      7691  VMA_ASSERT(pBlockData != VMA_NULL);
      -
      7692  return (char*)pBlockData + m_BlockAllocation.m_Offset;
      -
      7693  }
      -
      7694  else
      -
      7695  {
      -
      7696  return VMA_NULL;
      -
      7697  }
      -
      7698  break;
      -
      7699  case ALLOCATION_TYPE_DEDICATED:
      -
      7700  VMA_ASSERT((m_DedicatedAllocation.m_pMappedData != VMA_NULL) == (m_MapCount != 0));
      -
      7701  return m_DedicatedAllocation.m_pMappedData;
      -
      7702  default:
      -
      7703  VMA_ASSERT(0);
      -
      7704  return VMA_NULL;
      -
      7705  }
      +
      7618  if(!m_Stack.empty())
      +
      7619  {
      +
      7620  StackItem& currItem = m_Stack.back();
      +
      7621  if(currItem.type == COLLECTION_TYPE_OBJECT &&
      +
      7622  currItem.valueCount % 2 == 0)
      +
      7623  {
      +
      7624  VMA_ASSERT(isString);
      +
      7625  }
      +
      7626 
      +
      7627  if(currItem.type == COLLECTION_TYPE_OBJECT &&
      +
      7628  currItem.valueCount % 2 != 0)
      +
      7629  {
      +
      7630  m_SB.Add(": ");
      +
      7631  }
      +
      7632  else if(currItem.valueCount > 0)
      +
      7633  {
      +
      7634  m_SB.Add(", ");
      +
      7635  WriteIndent();
      +
      7636  }
      +
      7637  else
      +
      7638  {
      +
      7639  WriteIndent();
      +
      7640  }
      +
      7641  ++currItem.valueCount;
      +
      7642  }
      +
      7643 }
      +
      7644 
      +
      7645 void VmaJsonWriter::WriteIndent(bool oneLess)
      +
      7646 {
      +
      7647  if(!m_Stack.empty() && !m_Stack.back().singleLineMode)
      +
      7648  {
      +
      7649  m_SB.AddNewLine();
      +
      7650 
      +
      7651  size_t count = m_Stack.size();
      +
      7652  if(count > 0 && oneLess)
      +
      7653  {
      +
      7654  --count;
      +
      7655  }
      +
      7656  for(size_t i = 0; i < count; ++i)
      +
      7657  {
      +
      7658  m_SB.Add(INDENT);
      +
      7659  }
      +
      7660  }
      +
      7661 }
      +
      7662 
      +
      7663 #endif // #if VMA_STATS_STRING_ENABLED
      +
      7664 
      +
      7666 
      +
      7667 void VmaAllocation_T::SetUserData(VmaAllocator hAllocator, void* pUserData)
      +
      7668 {
      +
      7669  if(IsUserDataString())
      +
      7670  {
      +
      7671  VMA_ASSERT(pUserData == VMA_NULL || pUserData != m_pUserData);
      +
      7672 
      +
      7673  FreeUserDataString(hAllocator);
      +
      7674 
      +
      7675  if(pUserData != VMA_NULL)
      +
      7676  {
      +
      7677  m_pUserData = VmaCreateStringCopy(hAllocator->GetAllocationCallbacks(), (const char*)pUserData);
      +
      7678  }
      +
      7679  }
      +
      7680  else
      +
      7681  {
      +
      7682  m_pUserData = pUserData;
      +
      7683  }
      +
      7684 }
      +
      7685 
      +
      7686 void VmaAllocation_T::ChangeBlockAllocation(
      +
      7687  VmaAllocator hAllocator,
      +
      7688  VmaDeviceMemoryBlock* block,
      +
      7689  VkDeviceSize offset)
      +
      7690 {
      +
      7691  VMA_ASSERT(block != VMA_NULL);
      +
      7692  VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
      +
      7693 
      +
      7694  // Move mapping reference counter from old block to new block.
      +
      7695  if(block != m_BlockAllocation.m_Block)
      +
      7696  {
      +
      7697  uint32_t mapRefCount = m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP;
      +
      7698  if(IsPersistentMap())
      +
      7699  ++mapRefCount;
      +
      7700  m_BlockAllocation.m_Block->Unmap(hAllocator, mapRefCount);
      +
      7701  block->Map(hAllocator, mapRefCount, VMA_NULL);
      +
      7702  }
      +
      7703 
      +
      7704  m_BlockAllocation.m_Block = block;
      +
      7705  m_BlockAllocation.m_Offset = offset;
      7706 }
      7707 
      -
      7708 bool VmaAllocation_T::CanBecomeLost() const
      -
      7709 {
      -
      7710  switch(m_Type)
      -
      7711  {
      -
      7712  case ALLOCATION_TYPE_BLOCK:
      -
      7713  return m_BlockAllocation.m_CanBecomeLost;
      -
      7714  case ALLOCATION_TYPE_DEDICATED:
      -
      7715  return false;
      -
      7716  default:
      -
      7717  VMA_ASSERT(0);
      -
      7718  return false;
      -
      7719  }
      -
      7720 }
      -
      7721 
      -
      7722 bool VmaAllocation_T::MakeLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
      -
      7723 {
      -
      7724  VMA_ASSERT(CanBecomeLost());
      -
      7725 
      -
      7726  /*
      -
      7727  Warning: This is a carefully designed algorithm.
      -
      7728  Do not modify unless you really know what you're doing :)
      -
      7729  */
      -
      7730  uint32_t localLastUseFrameIndex = GetLastUseFrameIndex();
      -
      7731  for(;;)
      -
      7732  {
      -
      7733  if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)
      -
      7734  {
      -
      7735  VMA_ASSERT(0);
      -
      7736  return false;
      -
      7737  }
      -
      7738  else if(localLastUseFrameIndex + frameInUseCount >= currentFrameIndex)
      -
      7739  {
      -
      7740  return false;
      -
      7741  }
      -
      7742  else // Last use time earlier than current time.
      -
      7743  {
      -
      7744  if(CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, VMA_FRAME_INDEX_LOST))
      -
      7745  {
      -
      7746  // Setting hAllocation.LastUseFrameIndex atomic to VMA_FRAME_INDEX_LOST is enough to mark it as LOST.
      -
      7747  // Calling code just needs to unregister this allocation in owning VmaDeviceMemoryBlock.
      -
      7748  return true;
      -
      7749  }
      -
      7750  }
      -
      7751  }
      -
      7752 }
      -
      7753 
      -
      7754 #if VMA_STATS_STRING_ENABLED
      -
      7755 
      -
      7756 // Correspond to values of enum VmaSuballocationType.
      -
      7757 static const char* VMA_SUBALLOCATION_TYPE_NAMES[] = {
      -
      7758  "FREE",
      -
      7759  "UNKNOWN",
      -
      7760  "BUFFER",
      -
      7761  "IMAGE_UNKNOWN",
      -
      7762  "IMAGE_LINEAR",
      -
      7763  "IMAGE_OPTIMAL",
      -
      7764 };
      -
      7765 
      -
      7766 void VmaAllocation_T::PrintParameters(class VmaJsonWriter& json) const
      -
      7767 {
      -
      7768  json.WriteString("Type");
      -
      7769  json.WriteString(VMA_SUBALLOCATION_TYPE_NAMES[m_SuballocationType]);
      -
      7770 
      -
      7771  json.WriteString("Size");
      -
      7772  json.WriteNumber(m_Size);
      -
      7773 
      -
      7774  if(m_pUserData != VMA_NULL)
      -
      7775  {
      -
      7776  json.WriteString("UserData");
      -
      7777  if(IsUserDataString())
      -
      7778  {
      -
      7779  json.WriteString((const char*)m_pUserData);
      -
      7780  }
      -
      7781  else
      -
      7782  {
      -
      7783  json.BeginString();
      -
      7784  json.ContinueString_Pointer(m_pUserData);
      -
      7785  json.EndString();
      -
      7786  }
      -
      7787  }
      -
      7788 
      -
      7789  json.WriteString("CreationFrameIndex");
      -
      7790  json.WriteNumber(m_CreationFrameIndex);
      -
      7791 
      -
      7792  json.WriteString("LastUseFrameIndex");
      -
      7793  json.WriteNumber(GetLastUseFrameIndex());
      -
      7794 
      -
      7795  if(m_BufferImageUsage != 0)
      -
      7796  {
      -
      7797  json.WriteString("Usage");
      -
      7798  json.WriteNumber(m_BufferImageUsage);
      -
      7799  }
      -
      7800 }
      -
      7801 
      -
      7802 #endif
      -
      7803 
      -
      7804 void VmaAllocation_T::FreeUserDataString(VmaAllocator hAllocator)
      -
      7805 {
      -
      7806  VMA_ASSERT(IsUserDataString());
      -
      7807  if(m_pUserData != VMA_NULL)
      -
      7808  {
      -
      7809  char* const oldStr = (char*)m_pUserData;
      -
      7810  const size_t oldStrLen = strlen(oldStr);
      -
      7811  vma_delete_array(hAllocator, oldStr, oldStrLen + 1);
      -
      7812  m_pUserData = VMA_NULL;
      -
      7813  }
      -
      7814 }
      -
      7815 
      -
      7816 void VmaAllocation_T::BlockAllocMap()
      -
      7817 {
      -
      7818  VMA_ASSERT(GetType() == ALLOCATION_TYPE_BLOCK);
      -
      7819 
      -
      7820  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) < 0x7F)
      -
      7821  {
      -
      7822  ++m_MapCount;
      -
      7823  }
      -
      7824  else
      -
      7825  {
      -
      7826  VMA_ASSERT(0 && "Allocation mapped too many times simultaneously.");
      -
      7827  }
      -
      7828 }
      +
      7708 void VmaAllocation_T::ChangeOffset(VkDeviceSize newOffset)
      +
      7709 {
      +
      7710  VMA_ASSERT(m_Type == ALLOCATION_TYPE_BLOCK);
      +
      7711  m_BlockAllocation.m_Offset = newOffset;
      +
      7712 }
      +
      7713 
      +
      7714 VkDeviceSize VmaAllocation_T::GetOffset() const
      +
      7715 {
      +
      7716  switch(m_Type)
      +
      7717  {
      +
      7718  case ALLOCATION_TYPE_BLOCK:
      +
      7719  return m_BlockAllocation.m_Offset;
      +
      7720  case ALLOCATION_TYPE_DEDICATED:
      +
      7721  return 0;
      +
      7722  default:
      +
      7723  VMA_ASSERT(0);
      +
      7724  return 0;
      +
      7725  }
      +
      7726 }
      +
      7727 
      +
      7728 VkDeviceMemory VmaAllocation_T::GetMemory() const
      +
      7729 {
      +
      7730  switch(m_Type)
      +
      7731  {
      +
      7732  case ALLOCATION_TYPE_BLOCK:
      +
      7733  return m_BlockAllocation.m_Block->GetDeviceMemory();
      +
      7734  case ALLOCATION_TYPE_DEDICATED:
      +
      7735  return m_DedicatedAllocation.m_hMemory;
      +
      7736  default:
      +
      7737  VMA_ASSERT(0);
      +
      7738  return VK_NULL_HANDLE;
      +
      7739  }
      +
      7740 }
      +
      7741 
      +
      7742 void* VmaAllocation_T::GetMappedData() const
      +
      7743 {
      +
      7744  switch(m_Type)
      +
      7745  {
      +
      7746  case ALLOCATION_TYPE_BLOCK:
      +
      7747  if(m_MapCount != 0)
      +
      7748  {
      +
      7749  void* pBlockData = m_BlockAllocation.m_Block->GetMappedData();
      +
      7750  VMA_ASSERT(pBlockData != VMA_NULL);
      +
      7751  return (char*)pBlockData + m_BlockAllocation.m_Offset;
      +
      7752  }
      +
      7753  else
      +
      7754  {
      +
      7755  return VMA_NULL;
      +
      7756  }
      +
      7757  break;
      +
      7758  case ALLOCATION_TYPE_DEDICATED:
      +
      7759  VMA_ASSERT((m_DedicatedAllocation.m_pMappedData != VMA_NULL) == (m_MapCount != 0));
      +
      7760  return m_DedicatedAllocation.m_pMappedData;
      +
      7761  default:
      +
      7762  VMA_ASSERT(0);
      +
      7763  return VMA_NULL;
      +
      7764  }
      +
      7765 }
      +
      7766 
      +
      7767 bool VmaAllocation_T::CanBecomeLost() const
      +
      7768 {
      +
      7769  switch(m_Type)
      +
      7770  {
      +
      7771  case ALLOCATION_TYPE_BLOCK:
      +
      7772  return m_BlockAllocation.m_CanBecomeLost;
      +
      7773  case ALLOCATION_TYPE_DEDICATED:
      +
      7774  return false;
      +
      7775  default:
      +
      7776  VMA_ASSERT(0);
      +
      7777  return false;
      +
      7778  }
      +
      7779 }
      +
      7780 
      +
      7781 bool VmaAllocation_T::MakeLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
      +
      7782 {
      +
      7783  VMA_ASSERT(CanBecomeLost());
      +
      7784 
      +
      7785  /*
      +
      7786  Warning: This is a carefully designed algorithm.
      +
      7787  Do not modify unless you really know what you're doing :)
      +
      7788  */
      +
      7789  uint32_t localLastUseFrameIndex = GetLastUseFrameIndex();
      +
      7790  for(;;)
      +
      7791  {
      +
      7792  if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)
      +
      7793  {
      +
      7794  VMA_ASSERT(0);
      +
      7795  return false;
      +
      7796  }
      +
      7797  else if(localLastUseFrameIndex + frameInUseCount >= currentFrameIndex)
      +
      7798  {
      +
      7799  return false;
      +
      7800  }
      +
      7801  else // Last use time earlier than current time.
      +
      7802  {
      +
      7803  if(CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, VMA_FRAME_INDEX_LOST))
      +
      7804  {
      +
      7805  // Setting hAllocation.LastUseFrameIndex atomic to VMA_FRAME_INDEX_LOST is enough to mark it as LOST.
      +
      7806  // Calling code just needs to unregister this allocation in owning VmaDeviceMemoryBlock.
      +
      7807  return true;
      +
      7808  }
      +
      7809  }
      +
      7810  }
      +
      7811 }
      +
      7812 
      +
      7813 #if VMA_STATS_STRING_ENABLED
      +
      7814 
      +
      7815 // Correspond to values of enum VmaSuballocationType.
      +
      7816 static const char* VMA_SUBALLOCATION_TYPE_NAMES[] = {
      +
      7817  "FREE",
      +
      7818  "UNKNOWN",
      +
      7819  "BUFFER",
      +
      7820  "IMAGE_UNKNOWN",
      +
      7821  "IMAGE_LINEAR",
      +
      7822  "IMAGE_OPTIMAL",
      +
      7823 };
      +
      7824 
      +
      7825 void VmaAllocation_T::PrintParameters(class VmaJsonWriter& json) const
      +
      7826 {
      +
      7827  json.WriteString("Type");
      +
      7828  json.WriteString(VMA_SUBALLOCATION_TYPE_NAMES[m_SuballocationType]);
      7829 
      -
      7830 void VmaAllocation_T::BlockAllocUnmap()
      -
      7831 {
      -
      7832  VMA_ASSERT(GetType() == ALLOCATION_TYPE_BLOCK);
      -
      7833 
      -
      7834  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) != 0)
      -
      7835  {
      -
      7836  --m_MapCount;
      -
      7837  }
      -
      7838  else
      -
      7839  {
      -
      7840  VMA_ASSERT(0 && "Unmapping allocation not previously mapped.");
      -
      7841  }
      -
      7842 }
      -
      7843 
      -
      7844 VkResult VmaAllocation_T::DedicatedAllocMap(VmaAllocator hAllocator, void** ppData)
      -
      7845 {
      -
      7846  VMA_ASSERT(GetType() == ALLOCATION_TYPE_DEDICATED);
      +
      7830  json.WriteString("Size");
      +
      7831  json.WriteNumber(m_Size);
      +
      7832 
      +
      7833  if(m_pUserData != VMA_NULL)
      +
      7834  {
      +
      7835  json.WriteString("UserData");
      +
      7836  if(IsUserDataString())
      +
      7837  {
      +
      7838  json.WriteString((const char*)m_pUserData);
      +
      7839  }
      +
      7840  else
      +
      7841  {
      +
      7842  json.BeginString();
      +
      7843  json.ContinueString_Pointer(m_pUserData);
      +
      7844  json.EndString();
      +
      7845  }
      +
      7846  }
      7847 
      -
      7848  if(m_MapCount != 0)
      -
      7849  {
      -
      7850  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) < 0x7F)
      -
      7851  {
      -
      7852  VMA_ASSERT(m_DedicatedAllocation.m_pMappedData != VMA_NULL);
      -
      7853  *ppData = m_DedicatedAllocation.m_pMappedData;
      -
      7854  ++m_MapCount;
      -
      7855  return VK_SUCCESS;
      -
      7856  }
      -
      7857  else
      -
      7858  {
      -
      7859  VMA_ASSERT(0 && "Dedicated allocation mapped too many times simultaneously.");
      -
      7860  return VK_ERROR_MEMORY_MAP_FAILED;
      -
      7861  }
      -
      7862  }
      -
      7863  else
      -
      7864  {
      -
      7865  VkResult result = (*hAllocator->GetVulkanFunctions().vkMapMemory)(
      -
      7866  hAllocator->m_hDevice,
      -
      7867  m_DedicatedAllocation.m_hMemory,
      -
      7868  0, // offset
      -
      7869  VK_WHOLE_SIZE,
      -
      7870  0, // flags
      -
      7871  ppData);
      -
      7872  if(result == VK_SUCCESS)
      -
      7873  {
      -
      7874  m_DedicatedAllocation.m_pMappedData = *ppData;
      -
      7875  m_MapCount = 1;
      -
      7876  }
      -
      7877  return result;
      -
      7878  }
      -
      7879 }
      -
      7880 
      -
      7881 void VmaAllocation_T::DedicatedAllocUnmap(VmaAllocator hAllocator)
      -
      7882 {
      -
      7883  VMA_ASSERT(GetType() == ALLOCATION_TYPE_DEDICATED);
      -
      7884 
      -
      7885  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) != 0)
      -
      7886  {
      -
      7887  --m_MapCount;
      -
      7888  if(m_MapCount == 0)
      -
      7889  {
      -
      7890  m_DedicatedAllocation.m_pMappedData = VMA_NULL;
      -
      7891  (*hAllocator->GetVulkanFunctions().vkUnmapMemory)(
      -
      7892  hAllocator->m_hDevice,
      -
      7893  m_DedicatedAllocation.m_hMemory);
      -
      7894  }
      +
      7848  json.WriteString("CreationFrameIndex");
      +
      7849  json.WriteNumber(m_CreationFrameIndex);
      +
      7850 
      +
      7851  json.WriteString("LastUseFrameIndex");
      +
      7852  json.WriteNumber(GetLastUseFrameIndex());
      +
      7853 
      +
      7854  if(m_BufferImageUsage != 0)
      +
      7855  {
      +
      7856  json.WriteString("Usage");
      +
      7857  json.WriteNumber(m_BufferImageUsage);
      +
      7858  }
      +
      7859 }
      +
      7860 
      +
      7861 #endif
      +
      7862 
      +
      7863 void VmaAllocation_T::FreeUserDataString(VmaAllocator hAllocator)
      +
      7864 {
      +
      7865  VMA_ASSERT(IsUserDataString());
      +
      7866  VmaFreeString(hAllocator->GetAllocationCallbacks(), (char*)m_pUserData);
      +
      7867  m_pUserData = VMA_NULL;
      +
      7868 }
      +
      7869 
      +
      7870 void VmaAllocation_T::BlockAllocMap()
      +
      7871 {
      +
      7872  VMA_ASSERT(GetType() == ALLOCATION_TYPE_BLOCK);
      +
      7873 
      +
      7874  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) < 0x7F)
      +
      7875  {
      +
      7876  ++m_MapCount;
      +
      7877  }
      +
      7878  else
      +
      7879  {
      +
      7880  VMA_ASSERT(0 && "Allocation mapped too many times simultaneously.");
      +
      7881  }
      +
      7882 }
      +
      7883 
      +
      7884 void VmaAllocation_T::BlockAllocUnmap()
      +
      7885 {
      +
      7886  VMA_ASSERT(GetType() == ALLOCATION_TYPE_BLOCK);
      +
      7887 
      +
      7888  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) != 0)
      +
      7889  {
      +
      7890  --m_MapCount;
      +
      7891  }
      +
      7892  else
      +
      7893  {
      +
      7894  VMA_ASSERT(0 && "Unmapping allocation not previously mapped.");
      7895  }
      -
      7896  else
      -
      7897  {
      -
      7898  VMA_ASSERT(0 && "Unmapping dedicated allocation not previously mapped.");
      -
      7899  }
      -
      7900 }
      +
      7896 }
      +
      7897 
      +
      7898 VkResult VmaAllocation_T::DedicatedAllocMap(VmaAllocator hAllocator, void** ppData)
      +
      7899 {
      +
      7900  VMA_ASSERT(GetType() == ALLOCATION_TYPE_DEDICATED);
      7901 
      -
      7902 #if VMA_STATS_STRING_ENABLED
      -
      7903 
      -
      7904 static void VmaPrintStatInfo(VmaJsonWriter& json, const VmaStatInfo& stat)
      -
      7905 {
      -
      7906  json.BeginObject();
      -
      7907 
      -
      7908  json.WriteString("Blocks");
      -
      7909  json.WriteNumber(stat.blockCount);
      -
      7910 
      -
      7911  json.WriteString("Allocations");
      -
      7912  json.WriteNumber(stat.allocationCount);
      -
      7913 
      -
      7914  json.WriteString("UnusedRanges");
      -
      7915  json.WriteNumber(stat.unusedRangeCount);
      -
      7916 
      -
      7917  json.WriteString("UsedBytes");
      -
      7918  json.WriteNumber(stat.usedBytes);
      -
      7919 
      -
      7920  json.WriteString("UnusedBytes");
      -
      7921  json.WriteNumber(stat.unusedBytes);
      -
      7922 
      -
      7923  if(stat.allocationCount > 1)
      -
      7924  {
      -
      7925  json.WriteString("AllocationSize");
      -
      7926  json.BeginObject(true);
      -
      7927  json.WriteString("Min");
      -
      7928  json.WriteNumber(stat.allocationSizeMin);
      -
      7929  json.WriteString("Avg");
      -
      7930  json.WriteNumber(stat.allocationSizeAvg);
      -
      7931  json.WriteString("Max");
      -
      7932  json.WriteNumber(stat.allocationSizeMax);
      -
      7933  json.EndObject();
      -
      7934  }
      -
      7935 
      -
      7936  if(stat.unusedRangeCount > 1)
      -
      7937  {
      -
      7938  json.WriteString("UnusedRangeSize");
      -
      7939  json.BeginObject(true);
      -
      7940  json.WriteString("Min");
      -
      7941  json.WriteNumber(stat.unusedRangeSizeMin);
      -
      7942  json.WriteString("Avg");
      -
      7943  json.WriteNumber(stat.unusedRangeSizeAvg);
      -
      7944  json.WriteString("Max");
      -
      7945  json.WriteNumber(stat.unusedRangeSizeMax);
      -
      7946  json.EndObject();
      -
      7947  }
      -
      7948 
      -
      7949  json.EndObject();
      -
      7950 }
      -
      7951 
      -
      7952 #endif // #if VMA_STATS_STRING_ENABLED
      -
      7953 
      -
      7954 struct VmaSuballocationItemSizeLess
      -
      7955 {
      -
      7956  bool operator()(
      -
      7957  const VmaSuballocationList::iterator lhs,
      -
      7958  const VmaSuballocationList::iterator rhs) const
      -
      7959  {
      -
      7960  return lhs->size < rhs->size;
      -
      7961  }
      -
      7962  bool operator()(
      -
      7963  const VmaSuballocationList::iterator lhs,
      -
      7964  VkDeviceSize rhsSize) const
      -
      7965  {
      -
      7966  return lhs->size < rhsSize;
      -
      7967  }
      -
      7968 };
      -
      7969 
      +
      7902  if(m_MapCount != 0)
      +
      7903  {
      +
      7904  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) < 0x7F)
      +
      7905  {
      +
      7906  VMA_ASSERT(m_DedicatedAllocation.m_pMappedData != VMA_NULL);
      +
      7907  *ppData = m_DedicatedAllocation.m_pMappedData;
      +
      7908  ++m_MapCount;
      +
      7909  return VK_SUCCESS;
      +
      7910  }
      +
      7911  else
      +
      7912  {
      +
      7913  VMA_ASSERT(0 && "Dedicated allocation mapped too many times simultaneously.");
      +
      7914  return VK_ERROR_MEMORY_MAP_FAILED;
      +
      7915  }
      +
      7916  }
      +
      7917  else
      +
      7918  {
      +
      7919  VkResult result = (*hAllocator->GetVulkanFunctions().vkMapMemory)(
      +
      7920  hAllocator->m_hDevice,
      +
      7921  m_DedicatedAllocation.m_hMemory,
      +
      7922  0, // offset
      +
      7923  VK_WHOLE_SIZE,
      +
      7924  0, // flags
      +
      7925  ppData);
      +
      7926  if(result == VK_SUCCESS)
      +
      7927  {
      +
      7928  m_DedicatedAllocation.m_pMappedData = *ppData;
      +
      7929  m_MapCount = 1;
      +
      7930  }
      +
      7931  return result;
      +
      7932  }
      +
      7933 }
      +
      7934 
      +
      7935 void VmaAllocation_T::DedicatedAllocUnmap(VmaAllocator hAllocator)
      +
      7936 {
      +
      7937  VMA_ASSERT(GetType() == ALLOCATION_TYPE_DEDICATED);
      +
      7938 
      +
      7939  if((m_MapCount & ~MAP_COUNT_FLAG_PERSISTENT_MAP) != 0)
      +
      7940  {
      +
      7941  --m_MapCount;
      +
      7942  if(m_MapCount == 0)
      +
      7943  {
      +
      7944  m_DedicatedAllocation.m_pMappedData = VMA_NULL;
      +
      7945  (*hAllocator->GetVulkanFunctions().vkUnmapMemory)(
      +
      7946  hAllocator->m_hDevice,
      +
      7947  m_DedicatedAllocation.m_hMemory);
      +
      7948  }
      +
      7949  }
      +
      7950  else
      +
      7951  {
      +
      7952  VMA_ASSERT(0 && "Unmapping dedicated allocation not previously mapped.");
      +
      7953  }
      +
      7954 }
      +
      7955 
      +
      7956 #if VMA_STATS_STRING_ENABLED
      +
      7957 
      +
      7958 static void VmaPrintStatInfo(VmaJsonWriter& json, const VmaStatInfo& stat)
      +
      7959 {
      +
      7960  json.BeginObject();
      +
      7961 
      +
      7962  json.WriteString("Blocks");
      +
      7963  json.WriteNumber(stat.blockCount);
      +
      7964 
      +
      7965  json.WriteString("Allocations");
      +
      7966  json.WriteNumber(stat.allocationCount);
      +
      7967 
      +
      7968  json.WriteString("UnusedRanges");
      +
      7969  json.WriteNumber(stat.unusedRangeCount);
      7970 
      -
      7972 // class VmaBlockMetadata
      +
      7971  json.WriteString("UsedBytes");
      +
      7972  json.WriteNumber(stat.usedBytes);
      7973 
      -
      7974 VmaBlockMetadata::VmaBlockMetadata(VmaAllocator hAllocator) :
      -
      7975  m_Size(0),
      -
      7976  m_pAllocationCallbacks(hAllocator->GetAllocationCallbacks())
      -
      7977 {
      -
      7978 }
      -
      7979 
      -
      7980 #if VMA_STATS_STRING_ENABLED
      -
      7981 
      -
      7982 void VmaBlockMetadata::PrintDetailedMap_Begin(class VmaJsonWriter& json,
      -
      7983  VkDeviceSize unusedBytes,
      -
      7984  size_t allocationCount,
      -
      7985  size_t unusedRangeCount) const
      -
      7986 {
      -
      7987  json.BeginObject();
      -
      7988 
      -
      7989  json.WriteString("TotalBytes");
      -
      7990  json.WriteNumber(GetSize());
      -
      7991 
      -
      7992  json.WriteString("UnusedBytes");
      -
      7993  json.WriteNumber(unusedBytes);
      -
      7994 
      -
      7995  json.WriteString("Allocations");
      -
      7996  json.WriteNumber((uint64_t)allocationCount);
      -
      7997 
      -
      7998  json.WriteString("UnusedRanges");
      -
      7999  json.WriteNumber((uint64_t)unusedRangeCount);
      -
      8000 
      -
      8001  json.WriteString("Suballocations");
      -
      8002  json.BeginArray();
      -
      8003 }
      -
      8004 
      -
      8005 void VmaBlockMetadata::PrintDetailedMap_Allocation(class VmaJsonWriter& json,
      -
      8006  VkDeviceSize offset,
      -
      8007  VmaAllocation hAllocation) const
      -
      8008 {
      -
      8009  json.BeginObject(true);
      -
      8010 
      -
      8011  json.WriteString("Offset");
      -
      8012  json.WriteNumber(offset);
      -
      8013 
      -
      8014  hAllocation->PrintParameters(json);
      -
      8015 
      -
      8016  json.EndObject();
      -
      8017 }
      -
      8018 
      -
      8019 void VmaBlockMetadata::PrintDetailedMap_UnusedRange(class VmaJsonWriter& json,
      -
      8020  VkDeviceSize offset,
      -
      8021  VkDeviceSize size) const
      -
      8022 {
      -
      8023  json.BeginObject(true);
      -
      8024 
      -
      8025  json.WriteString("Offset");
      -
      8026  json.WriteNumber(offset);
      +
      7974  json.WriteString("UnusedBytes");
      +
      7975  json.WriteNumber(stat.unusedBytes);
      +
      7976 
      +
      7977  if(stat.allocationCount > 1)
      +
      7978  {
      +
      7979  json.WriteString("AllocationSize");
      +
      7980  json.BeginObject(true);
      +
      7981  json.WriteString("Min");
      +
      7982  json.WriteNumber(stat.allocationSizeMin);
      +
      7983  json.WriteString("Avg");
      +
      7984  json.WriteNumber(stat.allocationSizeAvg);
      +
      7985  json.WriteString("Max");
      +
      7986  json.WriteNumber(stat.allocationSizeMax);
      +
      7987  json.EndObject();
      +
      7988  }
      +
      7989 
      +
      7990  if(stat.unusedRangeCount > 1)
      +
      7991  {
      +
      7992  json.WriteString("UnusedRangeSize");
      +
      7993  json.BeginObject(true);
      +
      7994  json.WriteString("Min");
      +
      7995  json.WriteNumber(stat.unusedRangeSizeMin);
      +
      7996  json.WriteString("Avg");
      +
      7997  json.WriteNumber(stat.unusedRangeSizeAvg);
      +
      7998  json.WriteString("Max");
      +
      7999  json.WriteNumber(stat.unusedRangeSizeMax);
      +
      8000  json.EndObject();
      +
      8001  }
      +
      8002 
      +
      8003  json.EndObject();
      +
      8004 }
      +
      8005 
      +
      8006 #endif // #if VMA_STATS_STRING_ENABLED
      +
      8007 
      +
      8008 struct VmaSuballocationItemSizeLess
      +
      8009 {
      +
      8010  bool operator()(
      +
      8011  const VmaSuballocationList::iterator lhs,
      +
      8012  const VmaSuballocationList::iterator rhs) const
      +
      8013  {
      +
      8014  return lhs->size < rhs->size;
      +
      8015  }
      +
      8016  bool operator()(
      +
      8017  const VmaSuballocationList::iterator lhs,
      +
      8018  VkDeviceSize rhsSize) const
      +
      8019  {
      +
      8020  return lhs->size < rhsSize;
      +
      8021  }
      +
      8022 };
      +
      8023 
      +
      8024 
      +
      8026 // class VmaBlockMetadata
      8027 
      -
      8028  json.WriteString("Type");
      -
      8029  json.WriteString(VMA_SUBALLOCATION_TYPE_NAMES[VMA_SUBALLOCATION_TYPE_FREE]);
      -
      8030 
      -
      8031  json.WriteString("Size");
      -
      8032  json.WriteNumber(size);
      +
      8028 VmaBlockMetadata::VmaBlockMetadata(VmaAllocator hAllocator) :
      +
      8029  m_Size(0),
      +
      8030  m_pAllocationCallbacks(hAllocator->GetAllocationCallbacks())
      +
      8031 {
      +
      8032 }
      8033 
      -
      8034  json.EndObject();
      -
      8035 }
      -
      8036 
      -
      8037 void VmaBlockMetadata::PrintDetailedMap_End(class VmaJsonWriter& json) const
      -
      8038 {
      -
      8039  json.EndArray();
      -
      8040  json.EndObject();
      -
      8041 }
      +
      8034 #if VMA_STATS_STRING_ENABLED
      +
      8035 
      +
      8036 void VmaBlockMetadata::PrintDetailedMap_Begin(class VmaJsonWriter& json,
      +
      8037  VkDeviceSize unusedBytes,
      +
      8038  size_t allocationCount,
      +
      8039  size_t unusedRangeCount) const
      +
      8040 {
      +
      8041  json.BeginObject();
      8042 
      -
      8043 #endif // #if VMA_STATS_STRING_ENABLED
      -
      8044 
      -
      8046 // class VmaBlockMetadata_Generic
      -
      8047 
      -
      8048 VmaBlockMetadata_Generic::VmaBlockMetadata_Generic(VmaAllocator hAllocator) :
      -
      8049  VmaBlockMetadata(hAllocator),
      -
      8050  m_FreeCount(0),
      -
      8051  m_SumFreeSize(0),
      -
      8052  m_Suballocations(VmaStlAllocator<VmaSuballocation>(hAllocator->GetAllocationCallbacks())),
      -
      8053  m_FreeSuballocationsBySize(VmaStlAllocator<VmaSuballocationList::iterator>(hAllocator->GetAllocationCallbacks()))
      -
      8054 {
      -
      8055 }
      -
      8056 
      -
      8057 VmaBlockMetadata_Generic::~VmaBlockMetadata_Generic()
      -
      8058 {
      -
      8059 }
      -
      8060 
      -
      8061 void VmaBlockMetadata_Generic::Init(VkDeviceSize size)
      -
      8062 {
      -
      8063  VmaBlockMetadata::Init(size);
      -
      8064 
      -
      8065  m_FreeCount = 1;
      -
      8066  m_SumFreeSize = size;
      +
      8043  json.WriteString("TotalBytes");
      +
      8044  json.WriteNumber(GetSize());
      +
      8045 
      +
      8046  json.WriteString("UnusedBytes");
      +
      8047  json.WriteNumber(unusedBytes);
      +
      8048 
      +
      8049  json.WriteString("Allocations");
      +
      8050  json.WriteNumber((uint64_t)allocationCount);
      +
      8051 
      +
      8052  json.WriteString("UnusedRanges");
      +
      8053  json.WriteNumber((uint64_t)unusedRangeCount);
      +
      8054 
      +
      8055  json.WriteString("Suballocations");
      +
      8056  json.BeginArray();
      +
      8057 }
      +
      8058 
      +
      8059 void VmaBlockMetadata::PrintDetailedMap_Allocation(class VmaJsonWriter& json,
      +
      8060  VkDeviceSize offset,
      +
      8061  VmaAllocation hAllocation) const
      +
      8062 {
      +
      8063  json.BeginObject(true);
      +
      8064 
      +
      8065  json.WriteString("Offset");
      +
      8066  json.WriteNumber(offset);
      8067 
      -
      8068  VmaSuballocation suballoc = {};
      -
      8069  suballoc.offset = 0;
      -
      8070  suballoc.size = size;
      -
      8071  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
      -
      8072  suballoc.hAllocation = VK_NULL_HANDLE;
      -
      8073 
      -
      8074  VMA_ASSERT(size > VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER);
      -
      8075  m_Suballocations.push_back(suballoc);
      -
      8076  VmaSuballocationList::iterator suballocItem = m_Suballocations.end();
      -
      8077  --suballocItem;
      -
      8078  m_FreeSuballocationsBySize.push_back(suballocItem);
      -
      8079 }
      -
      8080 
      -
      8081 bool VmaBlockMetadata_Generic::Validate() const
      -
      8082 {
      -
      8083  VMA_VALIDATE(!m_Suballocations.empty());
      -
      8084 
      -
      8085  // Expected offset of new suballocation as calculated from previous ones.
      -
      8086  VkDeviceSize calculatedOffset = 0;
      -
      8087  // Expected number of free suballocations as calculated from traversing their list.
      -
      8088  uint32_t calculatedFreeCount = 0;
      -
      8089  // Expected sum size of free suballocations as calculated from traversing their list.
      -
      8090  VkDeviceSize calculatedSumFreeSize = 0;
      -
      8091  // Expected number of free suballocations that should be registered in
      -
      8092  // m_FreeSuballocationsBySize calculated from traversing their list.
      -
      8093  size_t freeSuballocationsToRegister = 0;
      -
      8094  // True if previous visited suballocation was free.
      -
      8095  bool prevFree = false;
      +
      8068  hAllocation->PrintParameters(json);
      +
      8069 
      +
      8070  json.EndObject();
      +
      8071 }
      +
      8072 
      +
      8073 void VmaBlockMetadata::PrintDetailedMap_UnusedRange(class VmaJsonWriter& json,
      +
      8074  VkDeviceSize offset,
      +
      8075  VkDeviceSize size) const
      +
      8076 {
      +
      8077  json.BeginObject(true);
      +
      8078 
      +
      8079  json.WriteString("Offset");
      +
      8080  json.WriteNumber(offset);
      +
      8081 
      +
      8082  json.WriteString("Type");
      +
      8083  json.WriteString(VMA_SUBALLOCATION_TYPE_NAMES[VMA_SUBALLOCATION_TYPE_FREE]);
      +
      8084 
      +
      8085  json.WriteString("Size");
      +
      8086  json.WriteNumber(size);
      +
      8087 
      +
      8088  json.EndObject();
      +
      8089 }
      +
      8090 
      +
      8091 void VmaBlockMetadata::PrintDetailedMap_End(class VmaJsonWriter& json) const
      +
      8092 {
      +
      8093  json.EndArray();
      +
      8094  json.EndObject();
      +
      8095 }
      8096 
      -
      8097  for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
      -
      8098  suballocItem != m_Suballocations.cend();
      -
      8099  ++suballocItem)
      -
      8100  {
      -
      8101  const VmaSuballocation& subAlloc = *suballocItem;
      -
      8102 
      -
      8103  // Actual offset of this suballocation doesn't match expected one.
      -
      8104  VMA_VALIDATE(subAlloc.offset == calculatedOffset);
      -
      8105 
      -
      8106  const bool currFree = (subAlloc.type == VMA_SUBALLOCATION_TYPE_FREE);
      -
      8107  // Two adjacent free suballocations are invalid. They should be merged.
      -
      8108  VMA_VALIDATE(!prevFree || !currFree);
      -
      8109 
      -
      8110  VMA_VALIDATE(currFree == (subAlloc.hAllocation == VK_NULL_HANDLE));
      -
      8111 
      -
      8112  if(currFree)
      -
      8113  {
      -
      8114  calculatedSumFreeSize += subAlloc.size;
      -
      8115  ++calculatedFreeCount;
      -
      8116  if(subAlloc.size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
      -
      8117  {
      -
      8118  ++freeSuballocationsToRegister;
      -
      8119  }
      -
      8120 
      -
      8121  // Margin required between allocations - every free space must be at least that large.
      -
      8122  VMA_VALIDATE(subAlloc.size >= VMA_DEBUG_MARGIN);
      -
      8123  }
      -
      8124  else
      -
      8125  {
      -
      8126  VMA_VALIDATE(subAlloc.hAllocation->GetOffset() == subAlloc.offset);
      -
      8127  VMA_VALIDATE(subAlloc.hAllocation->GetSize() == subAlloc.size);
      -
      8128 
      -
      8129  // Margin required between allocations - previous allocation must be free.
      -
      8130  VMA_VALIDATE(VMA_DEBUG_MARGIN == 0 || prevFree);
      -
      8131  }
      -
      8132 
      -
      8133  calculatedOffset += subAlloc.size;
      -
      8134  prevFree = currFree;
      -
      8135  }
      -
      8136 
      -
      8137  // Number of free suballocations registered in m_FreeSuballocationsBySize doesn't
      -
      8138  // match expected one.
      -
      8139  VMA_VALIDATE(m_FreeSuballocationsBySize.size() == freeSuballocationsToRegister);
      -
      8140 
      -
      8141  VkDeviceSize lastSize = 0;
      -
      8142  for(size_t i = 0; i < m_FreeSuballocationsBySize.size(); ++i)
      -
      8143  {
      -
      8144  VmaSuballocationList::iterator suballocItem = m_FreeSuballocationsBySize[i];
      -
      8145 
      -
      8146  // Only free suballocations can be registered in m_FreeSuballocationsBySize.
      -
      8147  VMA_VALIDATE(suballocItem->type == VMA_SUBALLOCATION_TYPE_FREE);
      -
      8148  // They must be sorted by size ascending.
      -
      8149  VMA_VALIDATE(suballocItem->size >= lastSize);
      +
      8097 #endif // #if VMA_STATS_STRING_ENABLED
      +
      8098 
      +
      8100 // class VmaBlockMetadata_Generic
      +
      8101 
      +
      8102 VmaBlockMetadata_Generic::VmaBlockMetadata_Generic(VmaAllocator hAllocator) :
      +
      8103  VmaBlockMetadata(hAllocator),
      +
      8104  m_FreeCount(0),
      +
      8105  m_SumFreeSize(0),
      +
      8106  m_Suballocations(VmaStlAllocator<VmaSuballocation>(hAllocator->GetAllocationCallbacks())),
      +
      8107  m_FreeSuballocationsBySize(VmaStlAllocator<VmaSuballocationList::iterator>(hAllocator->GetAllocationCallbacks()))
      +
      8108 {
      +
      8109 }
      +
      8110 
      +
      8111 VmaBlockMetadata_Generic::~VmaBlockMetadata_Generic()
      +
      8112 {
      +
      8113 }
      +
      8114 
      +
      8115 void VmaBlockMetadata_Generic::Init(VkDeviceSize size)
      +
      8116 {
      +
      8117  VmaBlockMetadata::Init(size);
      +
      8118 
      +
      8119  m_FreeCount = 1;
      +
      8120  m_SumFreeSize = size;
      +
      8121 
      +
      8122  VmaSuballocation suballoc = {};
      +
      8123  suballoc.offset = 0;
      +
      8124  suballoc.size = size;
      +
      8125  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
      +
      8126  suballoc.hAllocation = VK_NULL_HANDLE;
      +
      8127 
      +
      8128  VMA_ASSERT(size > VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER);
      +
      8129  m_Suballocations.push_back(suballoc);
      +
      8130  VmaSuballocationList::iterator suballocItem = m_Suballocations.end();
      +
      8131  --suballocItem;
      +
      8132  m_FreeSuballocationsBySize.push_back(suballocItem);
      +
      8133 }
      +
      8134 
      +
      8135 bool VmaBlockMetadata_Generic::Validate() const
      +
      8136 {
      +
      8137  VMA_VALIDATE(!m_Suballocations.empty());
      +
      8138 
      +
      8139  // Expected offset of new suballocation as calculated from previous ones.
      +
      8140  VkDeviceSize calculatedOffset = 0;
      +
      8141  // Expected number of free suballocations as calculated from traversing their list.
      +
      8142  uint32_t calculatedFreeCount = 0;
      +
      8143  // Expected sum size of free suballocations as calculated from traversing their list.
      +
      8144  VkDeviceSize calculatedSumFreeSize = 0;
      +
      8145  // Expected number of free suballocations that should be registered in
      +
      8146  // m_FreeSuballocationsBySize calculated from traversing their list.
      +
      8147  size_t freeSuballocationsToRegister = 0;
      +
      8148  // True if previous visited suballocation was free.
      +
      8149  bool prevFree = false;
      8150 
      -
      8151  lastSize = suballocItem->size;
      -
      8152  }
      -
      8153 
      -
      8154  // Check if totals match calculacted values.
      -
      8155  VMA_VALIDATE(ValidateFreeSuballocationList());
      -
      8156  VMA_VALIDATE(calculatedOffset == GetSize());
      -
      8157  VMA_VALIDATE(calculatedSumFreeSize == m_SumFreeSize);
      -
      8158  VMA_VALIDATE(calculatedFreeCount == m_FreeCount);
      +
      8151  for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
      +
      8152  suballocItem != m_Suballocations.cend();
      +
      8153  ++suballocItem)
      +
      8154  {
      +
      8155  const VmaSuballocation& subAlloc = *suballocItem;
      +
      8156 
      +
      8157  // Actual offset of this suballocation doesn't match expected one.
      +
      8158  VMA_VALIDATE(subAlloc.offset == calculatedOffset);
      8159 
      -
      8160  return true;
      -
      8161 }
      -
      8162 
      -
      8163 VkDeviceSize VmaBlockMetadata_Generic::GetUnusedRangeSizeMax() const
      -
      8164 {
      -
      8165  if(!m_FreeSuballocationsBySize.empty())
      -
      8166  {
      -
      8167  return m_FreeSuballocationsBySize.back()->size;
      -
      8168  }
      -
      8169  else
      -
      8170  {
      -
      8171  return 0;
      -
      8172  }
      -
      8173 }
      +
      8160  const bool currFree = (subAlloc.type == VMA_SUBALLOCATION_TYPE_FREE);
      +
      8161  // Two adjacent free suballocations are invalid. They should be merged.
      +
      8162  VMA_VALIDATE(!prevFree || !currFree);
      +
      8163 
      +
      8164  VMA_VALIDATE(currFree == (subAlloc.hAllocation == VK_NULL_HANDLE));
      +
      8165 
      +
      8166  if(currFree)
      +
      8167  {
      +
      8168  calculatedSumFreeSize += subAlloc.size;
      +
      8169  ++calculatedFreeCount;
      +
      8170  if(subAlloc.size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
      +
      8171  {
      +
      8172  ++freeSuballocationsToRegister;
      +
      8173  }
      8174 
      -
      8175 bool VmaBlockMetadata_Generic::IsEmpty() const
      -
      8176 {
      -
      8177  return (m_Suballocations.size() == 1) && (m_FreeCount == 1);
      -
      8178 }
      -
      8179 
      -
      8180 void VmaBlockMetadata_Generic::CalcAllocationStatInfo(VmaStatInfo& outInfo) const
      -
      8181 {
      -
      8182  outInfo.blockCount = 1;
      -
      8183 
      -
      8184  const uint32_t rangeCount = (uint32_t)m_Suballocations.size();
      -
      8185  outInfo.allocationCount = rangeCount - m_FreeCount;
      -
      8186  outInfo.unusedRangeCount = m_FreeCount;
      -
      8187 
      -
      8188  outInfo.unusedBytes = m_SumFreeSize;
      -
      8189  outInfo.usedBytes = GetSize() - outInfo.unusedBytes;
      +
      8175  // Margin required between allocations - every free space must be at least that large.
      +
      8176  VMA_VALIDATE(subAlloc.size >= VMA_DEBUG_MARGIN);
      +
      8177  }
      +
      8178  else
      +
      8179  {
      +
      8180  VMA_VALIDATE(subAlloc.hAllocation->GetOffset() == subAlloc.offset);
      +
      8181  VMA_VALIDATE(subAlloc.hAllocation->GetSize() == subAlloc.size);
      +
      8182 
      +
      8183  // Margin required between allocations - previous allocation must be free.
      +
      8184  VMA_VALIDATE(VMA_DEBUG_MARGIN == 0 || prevFree);
      +
      8185  }
      +
      8186 
      +
      8187  calculatedOffset += subAlloc.size;
      +
      8188  prevFree = currFree;
      +
      8189  }
      8190 
      -
      8191  outInfo.allocationSizeMin = UINT64_MAX;
      -
      8192  outInfo.allocationSizeMax = 0;
      -
      8193  outInfo.unusedRangeSizeMin = UINT64_MAX;
      -
      8194  outInfo.unusedRangeSizeMax = 0;
      -
      8195 
      -
      8196  for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
      -
      8197  suballocItem != m_Suballocations.cend();
      -
      8198  ++suballocItem)
      -
      8199  {
      -
      8200  const VmaSuballocation& suballoc = *suballocItem;
      -
      8201  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
      -
      8202  {
      -
      8203  outInfo.allocationSizeMin = VMA_MIN(outInfo.allocationSizeMin, suballoc.size);
      -
      8204  outInfo.allocationSizeMax = VMA_MAX(outInfo.allocationSizeMax, suballoc.size);
      -
      8205  }
      -
      8206  else
      -
      8207  {
      -
      8208  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, suballoc.size);
      -
      8209  outInfo.unusedRangeSizeMax = VMA_MAX(outInfo.unusedRangeSizeMax, suballoc.size);
      -
      8210  }
      -
      8211  }
      -
      8212 }
      +
      8191  // Number of free suballocations registered in m_FreeSuballocationsBySize doesn't
      +
      8192  // match expected one.
      +
      8193  VMA_VALIDATE(m_FreeSuballocationsBySize.size() == freeSuballocationsToRegister);
      +
      8194 
      +
      8195  VkDeviceSize lastSize = 0;
      +
      8196  for(size_t i = 0; i < m_FreeSuballocationsBySize.size(); ++i)
      +
      8197  {
      +
      8198  VmaSuballocationList::iterator suballocItem = m_FreeSuballocationsBySize[i];
      +
      8199 
      +
      8200  // Only free suballocations can be registered in m_FreeSuballocationsBySize.
      +
      8201  VMA_VALIDATE(suballocItem->type == VMA_SUBALLOCATION_TYPE_FREE);
      +
      8202  // They must be sorted by size ascending.
      +
      8203  VMA_VALIDATE(suballocItem->size >= lastSize);
      +
      8204 
      +
      8205  lastSize = suballocItem->size;
      +
      8206  }
      +
      8207 
      +
      8208  // Check if totals match calculacted values.
      +
      8209  VMA_VALIDATE(ValidateFreeSuballocationList());
      +
      8210  VMA_VALIDATE(calculatedOffset == GetSize());
      +
      8211  VMA_VALIDATE(calculatedSumFreeSize == m_SumFreeSize);
      +
      8212  VMA_VALIDATE(calculatedFreeCount == m_FreeCount);
      8213 
      -
      8214 void VmaBlockMetadata_Generic::AddPoolStats(VmaPoolStats& inoutStats) const
      -
      8215 {
      -
      8216  const uint32_t rangeCount = (uint32_t)m_Suballocations.size();
      -
      8217 
      -
      8218  inoutStats.size += GetSize();
      -
      8219  inoutStats.unusedSize += m_SumFreeSize;
      -
      8220  inoutStats.allocationCount += rangeCount - m_FreeCount;
      -
      8221  inoutStats.unusedRangeCount += m_FreeCount;
      -
      8222  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, GetUnusedRangeSizeMax());
      -
      8223 }
      -
      8224 
      -
      8225 #if VMA_STATS_STRING_ENABLED
      -
      8226 
      -
      8227 void VmaBlockMetadata_Generic::PrintDetailedMap(class VmaJsonWriter& json) const
      -
      8228 {
      -
      8229  PrintDetailedMap_Begin(json,
      -
      8230  m_SumFreeSize, // unusedBytes
      -
      8231  m_Suballocations.size() - (size_t)m_FreeCount, // allocationCount
      -
      8232  m_FreeCount); // unusedRangeCount
      +
      8214  return true;
      +
      8215 }
      +
      8216 
      +
      8217 VkDeviceSize VmaBlockMetadata_Generic::GetUnusedRangeSizeMax() const
      +
      8218 {
      +
      8219  if(!m_FreeSuballocationsBySize.empty())
      +
      8220  {
      +
      8221  return m_FreeSuballocationsBySize.back()->size;
      +
      8222  }
      +
      8223  else
      +
      8224  {
      +
      8225  return 0;
      +
      8226  }
      +
      8227 }
      +
      8228 
      +
      8229 bool VmaBlockMetadata_Generic::IsEmpty() const
      +
      8230 {
      +
      8231  return (m_Suballocations.size() == 1) && (m_FreeCount == 1);
      +
      8232 }
      8233 
      -
      8234  size_t i = 0;
      -
      8235  for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
      -
      8236  suballocItem != m_Suballocations.cend();
      -
      8237  ++suballocItem, ++i)
      -
      8238  {
      -
      8239  if(suballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)
      -
      8240  {
      -
      8241  PrintDetailedMap_UnusedRange(json, suballocItem->offset, suballocItem->size);
      -
      8242  }
      -
      8243  else
      -
      8244  {
      -
      8245  PrintDetailedMap_Allocation(json, suballocItem->offset, suballocItem->hAllocation);
      -
      8246  }
      -
      8247  }
      -
      8248 
      -
      8249  PrintDetailedMap_End(json);
      -
      8250 }
      -
      8251 
      -
      8252 #endif // #if VMA_STATS_STRING_ENABLED
      -
      8253 
      -
      8254 bool VmaBlockMetadata_Generic::CreateAllocationRequest(
      -
      8255  uint32_t currentFrameIndex,
      -
      8256  uint32_t frameInUseCount,
      -
      8257  VkDeviceSize bufferImageGranularity,
      -
      8258  VkDeviceSize allocSize,
      -
      8259  VkDeviceSize allocAlignment,
      -
      8260  bool upperAddress,
      -
      8261  VmaSuballocationType allocType,
      -
      8262  bool canMakeOtherLost,
      -
      8263  uint32_t strategy,
      -
      8264  VmaAllocationRequest* pAllocationRequest)
      -
      8265 {
      -
      8266  VMA_ASSERT(allocSize > 0);
      -
      8267  VMA_ASSERT(!upperAddress);
      -
      8268  VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
      -
      8269  VMA_ASSERT(pAllocationRequest != VMA_NULL);
      -
      8270  VMA_HEAVY_ASSERT(Validate());
      +
      8234 void VmaBlockMetadata_Generic::CalcAllocationStatInfo(VmaStatInfo& outInfo) const
      +
      8235 {
      +
      8236  outInfo.blockCount = 1;
      +
      8237 
      +
      8238  const uint32_t rangeCount = (uint32_t)m_Suballocations.size();
      +
      8239  outInfo.allocationCount = rangeCount - m_FreeCount;
      +
      8240  outInfo.unusedRangeCount = m_FreeCount;
      +
      8241 
      +
      8242  outInfo.unusedBytes = m_SumFreeSize;
      +
      8243  outInfo.usedBytes = GetSize() - outInfo.unusedBytes;
      +
      8244 
      +
      8245  outInfo.allocationSizeMin = UINT64_MAX;
      +
      8246  outInfo.allocationSizeMax = 0;
      +
      8247  outInfo.unusedRangeSizeMin = UINT64_MAX;
      +
      8248  outInfo.unusedRangeSizeMax = 0;
      +
      8249 
      +
      8250  for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
      +
      8251  suballocItem != m_Suballocations.cend();
      +
      8252  ++suballocItem)
      +
      8253  {
      +
      8254  const VmaSuballocation& suballoc = *suballocItem;
      +
      8255  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
      +
      8256  {
      +
      8257  outInfo.allocationSizeMin = VMA_MIN(outInfo.allocationSizeMin, suballoc.size);
      +
      8258  outInfo.allocationSizeMax = VMA_MAX(outInfo.allocationSizeMax, suballoc.size);
      +
      8259  }
      +
      8260  else
      +
      8261  {
      +
      8262  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, suballoc.size);
      +
      8263  outInfo.unusedRangeSizeMax = VMA_MAX(outInfo.unusedRangeSizeMax, suballoc.size);
      +
      8264  }
      +
      8265  }
      +
      8266 }
      +
      8267 
      +
      8268 void VmaBlockMetadata_Generic::AddPoolStats(VmaPoolStats& inoutStats) const
      +
      8269 {
      +
      8270  const uint32_t rangeCount = (uint32_t)m_Suballocations.size();
      8271 
      -
      8272  pAllocationRequest->type = VmaAllocationRequestType::Normal;
      -
      8273 
      -
      8274  // There is not enough total free space in this block to fullfill the request: Early return.
      -
      8275  if(canMakeOtherLost == false &&
      -
      8276  m_SumFreeSize < allocSize + 2 * VMA_DEBUG_MARGIN)
      -
      8277  {
      -
      8278  return false;
      -
      8279  }
      +
      8272  inoutStats.size += GetSize();
      +
      8273  inoutStats.unusedSize += m_SumFreeSize;
      +
      8274  inoutStats.allocationCount += rangeCount - m_FreeCount;
      +
      8275  inoutStats.unusedRangeCount += m_FreeCount;
      +
      8276  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, GetUnusedRangeSizeMax());
      +
      8277 }
      +
      8278 
      +
      8279 #if VMA_STATS_STRING_ENABLED
      8280 
      -
      8281  // New algorithm, efficiently searching freeSuballocationsBySize.
      -
      8282  const size_t freeSuballocCount = m_FreeSuballocationsBySize.size();
      -
      8283  if(freeSuballocCount > 0)
      -
      8284  {
      -
      8285  if(strategy == VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT)
      -
      8286  {
      -
      8287  // Find first free suballocation with size not less than allocSize + 2 * VMA_DEBUG_MARGIN.
      -
      8288  VmaSuballocationList::iterator* const it = VmaBinaryFindFirstNotLess(
      -
      8289  m_FreeSuballocationsBySize.data(),
      -
      8290  m_FreeSuballocationsBySize.data() + freeSuballocCount,
      -
      8291  allocSize + 2 * VMA_DEBUG_MARGIN,
      -
      8292  VmaSuballocationItemSizeLess());
      -
      8293  size_t index = it - m_FreeSuballocationsBySize.data();
      -
      8294  for(; index < freeSuballocCount; ++index)
      -
      8295  {
      -
      8296  if(CheckAllocation(
      -
      8297  currentFrameIndex,
      -
      8298  frameInUseCount,
      -
      8299  bufferImageGranularity,
      -
      8300  allocSize,
      -
      8301  allocAlignment,
      -
      8302  allocType,
      -
      8303  m_FreeSuballocationsBySize[index],
      -
      8304  false, // canMakeOtherLost
      -
      8305  &pAllocationRequest->offset,
      -
      8306  &pAllocationRequest->itemsToMakeLostCount,
      -
      8307  &pAllocationRequest->sumFreeSize,
      -
      8308  &pAllocationRequest->sumItemSize))
      -
      8309  {
      -
      8310  pAllocationRequest->item = m_FreeSuballocationsBySize[index];
      -
      8311  return true;
      -
      8312  }
      -
      8313  }
      -
      8314  }
      -
      8315  else if(strategy == VMA_ALLOCATION_INTERNAL_STRATEGY_MIN_OFFSET)
      -
      8316  {
      -
      8317  for(VmaSuballocationList::iterator it = m_Suballocations.begin();
      -
      8318  it != m_Suballocations.end();
      -
      8319  ++it)
      -
      8320  {
      -
      8321  if(it->type == VMA_SUBALLOCATION_TYPE_FREE && CheckAllocation(
      -
      8322  currentFrameIndex,
      -
      8323  frameInUseCount,
      -
      8324  bufferImageGranularity,
      -
      8325  allocSize,
      -
      8326  allocAlignment,
      -
      8327  allocType,
      -
      8328  it,
      -
      8329  false, // canMakeOtherLost
      -
      8330  &pAllocationRequest->offset,
      -
      8331  &pAllocationRequest->itemsToMakeLostCount,
      -
      8332  &pAllocationRequest->sumFreeSize,
      -
      8333  &pAllocationRequest->sumItemSize))
      -
      8334  {
      -
      8335  pAllocationRequest->item = it;
      -
      8336  return true;
      -
      8337  }
      -
      8338  }
      -
      8339  }
      -
      8340  else // WORST_FIT, FIRST_FIT
      -
      8341  {
      -
      8342  // Search staring from biggest suballocations.
      -
      8343  for(size_t index = freeSuballocCount; index--; )
      -
      8344  {
      -
      8345  if(CheckAllocation(
      -
      8346  currentFrameIndex,
      -
      8347  frameInUseCount,
      -
      8348  bufferImageGranularity,
      -
      8349  allocSize,
      -
      8350  allocAlignment,
      -
      8351  allocType,
      -
      8352  m_FreeSuballocationsBySize[index],
      -
      8353  false, // canMakeOtherLost
      -
      8354  &pAllocationRequest->offset,
      -
      8355  &pAllocationRequest->itemsToMakeLostCount,
      -
      8356  &pAllocationRequest->sumFreeSize,
      -
      8357  &pAllocationRequest->sumItemSize))
      -
      8358  {
      -
      8359  pAllocationRequest->item = m_FreeSuballocationsBySize[index];
      -
      8360  return true;
      -
      8361  }
      -
      8362  }
      -
      8363  }
      -
      8364  }
      -
      8365 
      -
      8366  if(canMakeOtherLost)
      -
      8367  {
      -
      8368  // Brute-force algorithm. TODO: Come up with something better.
      -
      8369 
      -
      8370  bool found = false;
      -
      8371  VmaAllocationRequest tmpAllocRequest = {};
      -
      8372  tmpAllocRequest.type = VmaAllocationRequestType::Normal;
      -
      8373  for(VmaSuballocationList::iterator suballocIt = m_Suballocations.begin();
      -
      8374  suballocIt != m_Suballocations.end();
      -
      8375  ++suballocIt)
      -
      8376  {
      -
      8377  if(suballocIt->type == VMA_SUBALLOCATION_TYPE_FREE ||
      -
      8378  suballocIt->hAllocation->CanBecomeLost())
      -
      8379  {
      -
      8380  if(CheckAllocation(
      -
      8381  currentFrameIndex,
      -
      8382  frameInUseCount,
      -
      8383  bufferImageGranularity,
      -
      8384  allocSize,
      -
      8385  allocAlignment,
      -
      8386  allocType,
      -
      8387  suballocIt,
      -
      8388  canMakeOtherLost,
      -
      8389  &tmpAllocRequest.offset,
      -
      8390  &tmpAllocRequest.itemsToMakeLostCount,
      -
      8391  &tmpAllocRequest.sumFreeSize,
      -
      8392  &tmpAllocRequest.sumItemSize))
      -
      8393  {
      -
      8394  if(strategy == VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT)
      -
      8395  {
      -
      8396  *pAllocationRequest = tmpAllocRequest;
      -
      8397  pAllocationRequest->item = suballocIt;
      -
      8398  break;
      -
      8399  }
      -
      8400  if(!found || tmpAllocRequest.CalcCost() < pAllocationRequest->CalcCost())
      -
      8401  {
      -
      8402  *pAllocationRequest = tmpAllocRequest;
      -
      8403  pAllocationRequest->item = suballocIt;
      -
      8404  found = true;
      -
      8405  }
      -
      8406  }
      -
      8407  }
      -
      8408  }
      -
      8409 
      -
      8410  return found;
      -
      8411  }
      -
      8412 
      -
      8413  return false;
      -
      8414 }
      -
      8415 
      -
      8416 bool VmaBlockMetadata_Generic::MakeRequestedAllocationsLost(
      -
      8417  uint32_t currentFrameIndex,
      -
      8418  uint32_t frameInUseCount,
      -
      8419  VmaAllocationRequest* pAllocationRequest)
      -
      8420 {
      -
      8421  VMA_ASSERT(pAllocationRequest && pAllocationRequest->type == VmaAllocationRequestType::Normal);
      -
      8422 
      -
      8423  while(pAllocationRequest->itemsToMakeLostCount > 0)
      -
      8424  {
      -
      8425  if(pAllocationRequest->item->type == VMA_SUBALLOCATION_TYPE_FREE)
      -
      8426  {
      -
      8427  ++pAllocationRequest->item;
      -
      8428  }
      -
      8429  VMA_ASSERT(pAllocationRequest->item != m_Suballocations.end());
      -
      8430  VMA_ASSERT(pAllocationRequest->item->hAllocation != VK_NULL_HANDLE);
      -
      8431  VMA_ASSERT(pAllocationRequest->item->hAllocation->CanBecomeLost());
      -
      8432  if(pAllocationRequest->item->hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
      -
      8433  {
      -
      8434  pAllocationRequest->item = FreeSuballocation(pAllocationRequest->item);
      -
      8435  --pAllocationRequest->itemsToMakeLostCount;
      -
      8436  }
      -
      8437  else
      -
      8438  {
      -
      8439  return false;
      -
      8440  }
      -
      8441  }
      -
      8442 
      -
      8443  VMA_HEAVY_ASSERT(Validate());
      -
      8444  VMA_ASSERT(pAllocationRequest->item != m_Suballocations.end());
      -
      8445  VMA_ASSERT(pAllocationRequest->item->type == VMA_SUBALLOCATION_TYPE_FREE);
      -
      8446 
      -
      8447  return true;
      -
      8448 }
      -
      8449 
      -
      8450 uint32_t VmaBlockMetadata_Generic::MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
      -
      8451 {
      -
      8452  uint32_t lostAllocationCount = 0;
      -
      8453  for(VmaSuballocationList::iterator it = m_Suballocations.begin();
      -
      8454  it != m_Suballocations.end();
      -
      8455  ++it)
      -
      8456  {
      -
      8457  if(it->type != VMA_SUBALLOCATION_TYPE_FREE &&
      -
      8458  it->hAllocation->CanBecomeLost() &&
      -
      8459  it->hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
      -
      8460  {
      -
      8461  it = FreeSuballocation(it);
      -
      8462  ++lostAllocationCount;
      -
      8463  }
      -
      8464  }
      -
      8465  return lostAllocationCount;
      -
      8466 }
      -
      8467 
      -
      8468 VkResult VmaBlockMetadata_Generic::CheckCorruption(const void* pBlockData)
      -
      8469 {
      -
      8470  for(VmaSuballocationList::iterator it = m_Suballocations.begin();
      -
      8471  it != m_Suballocations.end();
      -
      8472  ++it)
      -
      8473  {
      -
      8474  if(it->type != VMA_SUBALLOCATION_TYPE_FREE)
      -
      8475  {
      -
      8476  if(!VmaValidateMagicValue(pBlockData, it->offset - VMA_DEBUG_MARGIN))
      -
      8477  {
      -
      8478  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED BEFORE VALIDATED ALLOCATION!");
      -
      8479  return VK_ERROR_VALIDATION_FAILED_EXT;
      -
      8480  }
      -
      8481  if(!VmaValidateMagicValue(pBlockData, it->offset + it->size))
      -
      8482  {
      -
      8483  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER VALIDATED ALLOCATION!");
      -
      8484  return VK_ERROR_VALIDATION_FAILED_EXT;
      -
      8485  }
      -
      8486  }
      -
      8487  }
      -
      8488 
      -
      8489  return VK_SUCCESS;
      -
      8490 }
      -
      8491 
      -
      8492 void VmaBlockMetadata_Generic::Alloc(
      -
      8493  const VmaAllocationRequest& request,
      -
      8494  VmaSuballocationType type,
      -
      8495  VkDeviceSize allocSize,
      -
      8496  VmaAllocation hAllocation)
      -
      8497 {
      -
      8498  VMA_ASSERT(request.type == VmaAllocationRequestType::Normal);
      -
      8499  VMA_ASSERT(request.item != m_Suballocations.end());
      -
      8500  VmaSuballocation& suballoc = *request.item;
      -
      8501  // Given suballocation is a free block.
      -
      8502  VMA_ASSERT(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
      -
      8503  // Given offset is inside this suballocation.
      -
      8504  VMA_ASSERT(request.offset >= suballoc.offset);
      -
      8505  const VkDeviceSize paddingBegin = request.offset - suballoc.offset;
      -
      8506  VMA_ASSERT(suballoc.size >= paddingBegin + allocSize);
      -
      8507  const VkDeviceSize paddingEnd = suballoc.size - paddingBegin - allocSize;
      -
      8508 
      -
      8509  // Unregister this free suballocation from m_FreeSuballocationsBySize and update
      -
      8510  // it to become used.
      -
      8511  UnregisterFreeSuballocation(request.item);
      -
      8512 
      -
      8513  suballoc.offset = request.offset;
      -
      8514  suballoc.size = allocSize;
      -
      8515  suballoc.type = type;
      -
      8516  suballoc.hAllocation = hAllocation;
      -
      8517 
      -
      8518  // If there are any free bytes remaining at the end, insert new free suballocation after current one.
      -
      8519  if(paddingEnd)
      -
      8520  {
      -
      8521  VmaSuballocation paddingSuballoc = {};
      -
      8522  paddingSuballoc.offset = request.offset + allocSize;
      -
      8523  paddingSuballoc.size = paddingEnd;
      -
      8524  paddingSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
      -
      8525  VmaSuballocationList::iterator next = request.item;
      -
      8526  ++next;
      -
      8527  const VmaSuballocationList::iterator paddingEndItem =
      -
      8528  m_Suballocations.insert(next, paddingSuballoc);
      -
      8529  RegisterFreeSuballocation(paddingEndItem);
      -
      8530  }
      -
      8531 
      -
      8532  // If there are any free bytes remaining at the beginning, insert new free suballocation before current one.
      -
      8533  if(paddingBegin)
      -
      8534  {
      -
      8535  VmaSuballocation paddingSuballoc = {};
      -
      8536  paddingSuballoc.offset = request.offset - paddingBegin;
      -
      8537  paddingSuballoc.size = paddingBegin;
      -
      8538  paddingSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
      -
      8539  const VmaSuballocationList::iterator paddingBeginItem =
      -
      8540  m_Suballocations.insert(request.item, paddingSuballoc);
      -
      8541  RegisterFreeSuballocation(paddingBeginItem);
      -
      8542  }
      -
      8543 
      -
      8544  // Update totals.
      -
      8545  m_FreeCount = m_FreeCount - 1;
      -
      8546  if(paddingBegin > 0)
      -
      8547  {
      -
      8548  ++m_FreeCount;
      -
      8549  }
      -
      8550  if(paddingEnd > 0)
      -
      8551  {
      -
      8552  ++m_FreeCount;
      -
      8553  }
      -
      8554  m_SumFreeSize -= allocSize;
      -
      8555 }
      -
      8556 
      -
      8557 void VmaBlockMetadata_Generic::Free(const VmaAllocation allocation)
      -
      8558 {
      -
      8559  for(VmaSuballocationList::iterator suballocItem = m_Suballocations.begin();
      -
      8560  suballocItem != m_Suballocations.end();
      -
      8561  ++suballocItem)
      -
      8562  {
      -
      8563  VmaSuballocation& suballoc = *suballocItem;
      -
      8564  if(suballoc.hAllocation == allocation)
      -
      8565  {
      -
      8566  FreeSuballocation(suballocItem);
      -
      8567  VMA_HEAVY_ASSERT(Validate());
      -
      8568  return;
      -
      8569  }
      -
      8570  }
      -
      8571  VMA_ASSERT(0 && "Not found!");
      -
      8572 }
      -
      8573 
      -
      8574 void VmaBlockMetadata_Generic::FreeAtOffset(VkDeviceSize offset)
      -
      8575 {
      -
      8576  for(VmaSuballocationList::iterator suballocItem = m_Suballocations.begin();
      -
      8577  suballocItem != m_Suballocations.end();
      -
      8578  ++suballocItem)
      -
      8579  {
      -
      8580  VmaSuballocation& suballoc = *suballocItem;
      -
      8581  if(suballoc.offset == offset)
      -
      8582  {
      -
      8583  FreeSuballocation(suballocItem);
      -
      8584  return;
      -
      8585  }
      -
      8586  }
      -
      8587  VMA_ASSERT(0 && "Not found!");
      -
      8588 }
      -
      8589 
      -
      8590 bool VmaBlockMetadata_Generic::ValidateFreeSuballocationList() const
      -
      8591 {
      -
      8592  VkDeviceSize lastSize = 0;
      -
      8593  for(size_t i = 0, count = m_FreeSuballocationsBySize.size(); i < count; ++i)
      -
      8594  {
      -
      8595  const VmaSuballocationList::iterator it = m_FreeSuballocationsBySize[i];
      -
      8596 
      -
      8597  VMA_VALIDATE(it->type == VMA_SUBALLOCATION_TYPE_FREE);
      -
      8598  VMA_VALIDATE(it->size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER);
      -
      8599  VMA_VALIDATE(it->size >= lastSize);
      -
      8600  lastSize = it->size;
      -
      8601  }
      -
      8602  return true;
      -
      8603 }
      -
      8604 
      -
      8605 bool VmaBlockMetadata_Generic::CheckAllocation(
      -
      8606  uint32_t currentFrameIndex,
      -
      8607  uint32_t frameInUseCount,
      -
      8608  VkDeviceSize bufferImageGranularity,
      -
      8609  VkDeviceSize allocSize,
      -
      8610  VkDeviceSize allocAlignment,
      -
      8611  VmaSuballocationType allocType,
      -
      8612  VmaSuballocationList::const_iterator suballocItem,
      -
      8613  bool canMakeOtherLost,
      -
      8614  VkDeviceSize* pOffset,
      -
      8615  size_t* itemsToMakeLostCount,
      -
      8616  VkDeviceSize* pSumFreeSize,
      -
      8617  VkDeviceSize* pSumItemSize) const
      -
      8618 {
      -
      8619  VMA_ASSERT(allocSize > 0);
      -
      8620  VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
      -
      8621  VMA_ASSERT(suballocItem != m_Suballocations.cend());
      -
      8622  VMA_ASSERT(pOffset != VMA_NULL);
      -
      8623 
      -
      8624  *itemsToMakeLostCount = 0;
      -
      8625  *pSumFreeSize = 0;
      -
      8626  *pSumItemSize = 0;
      +
      8281 void VmaBlockMetadata_Generic::PrintDetailedMap(class VmaJsonWriter& json) const
      +
      8282 {
      +
      8283  PrintDetailedMap_Begin(json,
      +
      8284  m_SumFreeSize, // unusedBytes
      +
      8285  m_Suballocations.size() - (size_t)m_FreeCount, // allocationCount
      +
      8286  m_FreeCount); // unusedRangeCount
      +
      8287 
      +
      8288  size_t i = 0;
      +
      8289  for(VmaSuballocationList::const_iterator suballocItem = m_Suballocations.cbegin();
      +
      8290  suballocItem != m_Suballocations.cend();
      +
      8291  ++suballocItem, ++i)
      +
      8292  {
      +
      8293  if(suballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)
      +
      8294  {
      +
      8295  PrintDetailedMap_UnusedRange(json, suballocItem->offset, suballocItem->size);
      +
      8296  }
      +
      8297  else
      +
      8298  {
      +
      8299  PrintDetailedMap_Allocation(json, suballocItem->offset, suballocItem->hAllocation);
      +
      8300  }
      +
      8301  }
      +
      8302 
      +
      8303  PrintDetailedMap_End(json);
      +
      8304 }
      +
      8305 
      +
      8306 #endif // #if VMA_STATS_STRING_ENABLED
      +
      8307 
      +
      8308 bool VmaBlockMetadata_Generic::CreateAllocationRequest(
      +
      8309  uint32_t currentFrameIndex,
      +
      8310  uint32_t frameInUseCount,
      +
      8311  VkDeviceSize bufferImageGranularity,
      +
      8312  VkDeviceSize allocSize,
      +
      8313  VkDeviceSize allocAlignment,
      +
      8314  bool upperAddress,
      +
      8315  VmaSuballocationType allocType,
      +
      8316  bool canMakeOtherLost,
      +
      8317  uint32_t strategy,
      +
      8318  VmaAllocationRequest* pAllocationRequest)
      +
      8319 {
      +
      8320  VMA_ASSERT(allocSize > 0);
      +
      8321  VMA_ASSERT(!upperAddress);
      +
      8322  VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
      +
      8323  VMA_ASSERT(pAllocationRequest != VMA_NULL);
      +
      8324  VMA_HEAVY_ASSERT(Validate());
      +
      8325 
      +
      8326  pAllocationRequest->type = VmaAllocationRequestType::Normal;
      +
      8327 
      +
      8328  // There is not enough total free space in this block to fullfill the request: Early return.
      +
      8329  if(canMakeOtherLost == false &&
      +
      8330  m_SumFreeSize < allocSize + 2 * VMA_DEBUG_MARGIN)
      +
      8331  {
      +
      8332  return false;
      +
      8333  }
      +
      8334 
      +
      8335  // New algorithm, efficiently searching freeSuballocationsBySize.
      +
      8336  const size_t freeSuballocCount = m_FreeSuballocationsBySize.size();
      +
      8337  if(freeSuballocCount > 0)
      +
      8338  {
      +
      8339  if(strategy == VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT)
      +
      8340  {
      +
      8341  // Find first free suballocation with size not less than allocSize + 2 * VMA_DEBUG_MARGIN.
      +
      8342  VmaSuballocationList::iterator* const it = VmaBinaryFindFirstNotLess(
      +
      8343  m_FreeSuballocationsBySize.data(),
      +
      8344  m_FreeSuballocationsBySize.data() + freeSuballocCount,
      +
      8345  allocSize + 2 * VMA_DEBUG_MARGIN,
      +
      8346  VmaSuballocationItemSizeLess());
      +
      8347  size_t index = it - m_FreeSuballocationsBySize.data();
      +
      8348  for(; index < freeSuballocCount; ++index)
      +
      8349  {
      +
      8350  if(CheckAllocation(
      +
      8351  currentFrameIndex,
      +
      8352  frameInUseCount,
      +
      8353  bufferImageGranularity,
      +
      8354  allocSize,
      +
      8355  allocAlignment,
      +
      8356  allocType,
      +
      8357  m_FreeSuballocationsBySize[index],
      +
      8358  false, // canMakeOtherLost
      +
      8359  &pAllocationRequest->offset,
      +
      8360  &pAllocationRequest->itemsToMakeLostCount,
      +
      8361  &pAllocationRequest->sumFreeSize,
      +
      8362  &pAllocationRequest->sumItemSize))
      +
      8363  {
      +
      8364  pAllocationRequest->item = m_FreeSuballocationsBySize[index];
      +
      8365  return true;
      +
      8366  }
      +
      8367  }
      +
      8368  }
      +
      8369  else if(strategy == VMA_ALLOCATION_INTERNAL_STRATEGY_MIN_OFFSET)
      +
      8370  {
      +
      8371  for(VmaSuballocationList::iterator it = m_Suballocations.begin();
      +
      8372  it != m_Suballocations.end();
      +
      8373  ++it)
      +
      8374  {
      +
      8375  if(it->type == VMA_SUBALLOCATION_TYPE_FREE && CheckAllocation(
      +
      8376  currentFrameIndex,
      +
      8377  frameInUseCount,
      +
      8378  bufferImageGranularity,
      +
      8379  allocSize,
      +
      8380  allocAlignment,
      +
      8381  allocType,
      +
      8382  it,
      +
      8383  false, // canMakeOtherLost
      +
      8384  &pAllocationRequest->offset,
      +
      8385  &pAllocationRequest->itemsToMakeLostCount,
      +
      8386  &pAllocationRequest->sumFreeSize,
      +
      8387  &pAllocationRequest->sumItemSize))
      +
      8388  {
      +
      8389  pAllocationRequest->item = it;
      +
      8390  return true;
      +
      8391  }
      +
      8392  }
      +
      8393  }
      +
      8394  else // WORST_FIT, FIRST_FIT
      +
      8395  {
      +
      8396  // Search staring from biggest suballocations.
      +
      8397  for(size_t index = freeSuballocCount; index--; )
      +
      8398  {
      +
      8399  if(CheckAllocation(
      +
      8400  currentFrameIndex,
      +
      8401  frameInUseCount,
      +
      8402  bufferImageGranularity,
      +
      8403  allocSize,
      +
      8404  allocAlignment,
      +
      8405  allocType,
      +
      8406  m_FreeSuballocationsBySize[index],
      +
      8407  false, // canMakeOtherLost
      +
      8408  &pAllocationRequest->offset,
      +
      8409  &pAllocationRequest->itemsToMakeLostCount,
      +
      8410  &pAllocationRequest->sumFreeSize,
      +
      8411  &pAllocationRequest->sumItemSize))
      +
      8412  {
      +
      8413  pAllocationRequest->item = m_FreeSuballocationsBySize[index];
      +
      8414  return true;
      +
      8415  }
      +
      8416  }
      +
      8417  }
      +
      8418  }
      +
      8419 
      +
      8420  if(canMakeOtherLost)
      +
      8421  {
      +
      8422  // Brute-force algorithm. TODO: Come up with something better.
      +
      8423 
      +
      8424  bool found = false;
      +
      8425  VmaAllocationRequest tmpAllocRequest = {};
      +
      8426  tmpAllocRequest.type = VmaAllocationRequestType::Normal;
      +
      8427  for(VmaSuballocationList::iterator suballocIt = m_Suballocations.begin();
      +
      8428  suballocIt != m_Suballocations.end();
      +
      8429  ++suballocIt)
      +
      8430  {
      +
      8431  if(suballocIt->type == VMA_SUBALLOCATION_TYPE_FREE ||
      +
      8432  suballocIt->hAllocation->CanBecomeLost())
      +
      8433  {
      +
      8434  if(CheckAllocation(
      +
      8435  currentFrameIndex,
      +
      8436  frameInUseCount,
      +
      8437  bufferImageGranularity,
      +
      8438  allocSize,
      +
      8439  allocAlignment,
      +
      8440  allocType,
      +
      8441  suballocIt,
      +
      8442  canMakeOtherLost,
      +
      8443  &tmpAllocRequest.offset,
      +
      8444  &tmpAllocRequest.itemsToMakeLostCount,
      +
      8445  &tmpAllocRequest.sumFreeSize,
      +
      8446  &tmpAllocRequest.sumItemSize))
      +
      8447  {
      +
      8448  if(strategy == VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT)
      +
      8449  {
      +
      8450  *pAllocationRequest = tmpAllocRequest;
      +
      8451  pAllocationRequest->item = suballocIt;
      +
      8452  break;
      +
      8453  }
      +
      8454  if(!found || tmpAllocRequest.CalcCost() < pAllocationRequest->CalcCost())
      +
      8455  {
      +
      8456  *pAllocationRequest = tmpAllocRequest;
      +
      8457  pAllocationRequest->item = suballocIt;
      +
      8458  found = true;
      +
      8459  }
      +
      8460  }
      +
      8461  }
      +
      8462  }
      +
      8463 
      +
      8464  return found;
      +
      8465  }
      +
      8466 
      +
      8467  return false;
      +
      8468 }
      +
      8469 
      +
      8470 bool VmaBlockMetadata_Generic::MakeRequestedAllocationsLost(
      +
      8471  uint32_t currentFrameIndex,
      +
      8472  uint32_t frameInUseCount,
      +
      8473  VmaAllocationRequest* pAllocationRequest)
      +
      8474 {
      +
      8475  VMA_ASSERT(pAllocationRequest && pAllocationRequest->type == VmaAllocationRequestType::Normal);
      +
      8476 
      +
      8477  while(pAllocationRequest->itemsToMakeLostCount > 0)
      +
      8478  {
      +
      8479  if(pAllocationRequest->item->type == VMA_SUBALLOCATION_TYPE_FREE)
      +
      8480  {
      +
      8481  ++pAllocationRequest->item;
      +
      8482  }
      +
      8483  VMA_ASSERT(pAllocationRequest->item != m_Suballocations.end());
      +
      8484  VMA_ASSERT(pAllocationRequest->item->hAllocation != VK_NULL_HANDLE);
      +
      8485  VMA_ASSERT(pAllocationRequest->item->hAllocation->CanBecomeLost());
      +
      8486  if(pAllocationRequest->item->hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
      +
      8487  {
      +
      8488  pAllocationRequest->item = FreeSuballocation(pAllocationRequest->item);
      +
      8489  --pAllocationRequest->itemsToMakeLostCount;
      +
      8490  }
      +
      8491  else
      +
      8492  {
      +
      8493  return false;
      +
      8494  }
      +
      8495  }
      +
      8496 
      +
      8497  VMA_HEAVY_ASSERT(Validate());
      +
      8498  VMA_ASSERT(pAllocationRequest->item != m_Suballocations.end());
      +
      8499  VMA_ASSERT(pAllocationRequest->item->type == VMA_SUBALLOCATION_TYPE_FREE);
      +
      8500 
      +
      8501  return true;
      +
      8502 }
      +
      8503 
      +
      8504 uint32_t VmaBlockMetadata_Generic::MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
      +
      8505 {
      +
      8506  uint32_t lostAllocationCount = 0;
      +
      8507  for(VmaSuballocationList::iterator it = m_Suballocations.begin();
      +
      8508  it != m_Suballocations.end();
      +
      8509  ++it)
      +
      8510  {
      +
      8511  if(it->type != VMA_SUBALLOCATION_TYPE_FREE &&
      +
      8512  it->hAllocation->CanBecomeLost() &&
      +
      8513  it->hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
      +
      8514  {
      +
      8515  it = FreeSuballocation(it);
      +
      8516  ++lostAllocationCount;
      +
      8517  }
      +
      8518  }
      +
      8519  return lostAllocationCount;
      +
      8520 }
      +
      8521 
      +
      8522 VkResult VmaBlockMetadata_Generic::CheckCorruption(const void* pBlockData)
      +
      8523 {
      +
      8524  for(VmaSuballocationList::iterator it = m_Suballocations.begin();
      +
      8525  it != m_Suballocations.end();
      +
      8526  ++it)
      +
      8527  {
      +
      8528  if(it->type != VMA_SUBALLOCATION_TYPE_FREE)
      +
      8529  {
      +
      8530  if(!VmaValidateMagicValue(pBlockData, it->offset - VMA_DEBUG_MARGIN))
      +
      8531  {
      +
      8532  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED BEFORE VALIDATED ALLOCATION!");
      +
      8533  return VK_ERROR_VALIDATION_FAILED_EXT;
      +
      8534  }
      +
      8535  if(!VmaValidateMagicValue(pBlockData, it->offset + it->size))
      +
      8536  {
      +
      8537  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER VALIDATED ALLOCATION!");
      +
      8538  return VK_ERROR_VALIDATION_FAILED_EXT;
      +
      8539  }
      +
      8540  }
      +
      8541  }
      +
      8542 
      +
      8543  return VK_SUCCESS;
      +
      8544 }
      +
      8545 
      +
      8546 void VmaBlockMetadata_Generic::Alloc(
      +
      8547  const VmaAllocationRequest& request,
      +
      8548  VmaSuballocationType type,
      +
      8549  VkDeviceSize allocSize,
      +
      8550  VmaAllocation hAllocation)
      +
      8551 {
      +
      8552  VMA_ASSERT(request.type == VmaAllocationRequestType::Normal);
      +
      8553  VMA_ASSERT(request.item != m_Suballocations.end());
      +
      8554  VmaSuballocation& suballoc = *request.item;
      +
      8555  // Given suballocation is a free block.
      +
      8556  VMA_ASSERT(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
      +
      8557  // Given offset is inside this suballocation.
      +
      8558  VMA_ASSERT(request.offset >= suballoc.offset);
      +
      8559  const VkDeviceSize paddingBegin = request.offset - suballoc.offset;
      +
      8560  VMA_ASSERT(suballoc.size >= paddingBegin + allocSize);
      +
      8561  const VkDeviceSize paddingEnd = suballoc.size - paddingBegin - allocSize;
      +
      8562 
      +
      8563  // Unregister this free suballocation from m_FreeSuballocationsBySize and update
      +
      8564  // it to become used.
      +
      8565  UnregisterFreeSuballocation(request.item);
      +
      8566 
      +
      8567  suballoc.offset = request.offset;
      +
      8568  suballoc.size = allocSize;
      +
      8569  suballoc.type = type;
      +
      8570  suballoc.hAllocation = hAllocation;
      +
      8571 
      +
      8572  // If there are any free bytes remaining at the end, insert new free suballocation after current one.
      +
      8573  if(paddingEnd)
      +
      8574  {
      +
      8575  VmaSuballocation paddingSuballoc = {};
      +
      8576  paddingSuballoc.offset = request.offset + allocSize;
      +
      8577  paddingSuballoc.size = paddingEnd;
      +
      8578  paddingSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
      +
      8579  VmaSuballocationList::iterator next = request.item;
      +
      8580  ++next;
      +
      8581  const VmaSuballocationList::iterator paddingEndItem =
      +
      8582  m_Suballocations.insert(next, paddingSuballoc);
      +
      8583  RegisterFreeSuballocation(paddingEndItem);
      +
      8584  }
      +
      8585 
      +
      8586  // If there are any free bytes remaining at the beginning, insert new free suballocation before current one.
      +
      8587  if(paddingBegin)
      +
      8588  {
      +
      8589  VmaSuballocation paddingSuballoc = {};
      +
      8590  paddingSuballoc.offset = request.offset - paddingBegin;
      +
      8591  paddingSuballoc.size = paddingBegin;
      +
      8592  paddingSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
      +
      8593  const VmaSuballocationList::iterator paddingBeginItem =
      +
      8594  m_Suballocations.insert(request.item, paddingSuballoc);
      +
      8595  RegisterFreeSuballocation(paddingBeginItem);
      +
      8596  }
      +
      8597 
      +
      8598  // Update totals.
      +
      8599  m_FreeCount = m_FreeCount - 1;
      +
      8600  if(paddingBegin > 0)
      +
      8601  {
      +
      8602  ++m_FreeCount;
      +
      8603  }
      +
      8604  if(paddingEnd > 0)
      +
      8605  {
      +
      8606  ++m_FreeCount;
      +
      8607  }
      +
      8608  m_SumFreeSize -= allocSize;
      +
      8609 }
      +
      8610 
      +
      8611 void VmaBlockMetadata_Generic::Free(const VmaAllocation allocation)
      +
      8612 {
      +
      8613  for(VmaSuballocationList::iterator suballocItem = m_Suballocations.begin();
      +
      8614  suballocItem != m_Suballocations.end();
      +
      8615  ++suballocItem)
      +
      8616  {
      +
      8617  VmaSuballocation& suballoc = *suballocItem;
      +
      8618  if(suballoc.hAllocation == allocation)
      +
      8619  {
      +
      8620  FreeSuballocation(suballocItem);
      +
      8621  VMA_HEAVY_ASSERT(Validate());
      +
      8622  return;
      +
      8623  }
      +
      8624  }
      +
      8625  VMA_ASSERT(0 && "Not found!");
      +
      8626 }
      8627 
      -
      8628  if(canMakeOtherLost)
      -
      8629  {
      -
      8630  if(suballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)
      -
      8631  {
      -
      8632  *pSumFreeSize = suballocItem->size;
      -
      8633  }
      -
      8634  else
      -
      8635  {
      -
      8636  if(suballocItem->hAllocation->CanBecomeLost() &&
      -
      8637  suballocItem->hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
      -
      8638  {
      -
      8639  ++*itemsToMakeLostCount;
      -
      8640  *pSumItemSize = suballocItem->size;
      -
      8641  }
      -
      8642  else
      -
      8643  {
      -
      8644  return false;
      -
      8645  }
      -
      8646  }
      -
      8647 
      -
      8648  // Remaining size is too small for this request: Early return.
      -
      8649  if(GetSize() - suballocItem->offset < allocSize)
      -
      8650  {
      -
      8651  return false;
      -
      8652  }
      -
      8653 
      -
      8654  // Start from offset equal to beginning of this suballocation.
      -
      8655  *pOffset = suballocItem->offset;
      -
      8656 
      -
      8657  // Apply VMA_DEBUG_MARGIN at the beginning.
      -
      8658  if(VMA_DEBUG_MARGIN > 0)
      -
      8659  {
      -
      8660  *pOffset += VMA_DEBUG_MARGIN;
      -
      8661  }
      -
      8662 
      -
      8663  // Apply alignment.
      -
      8664  *pOffset = VmaAlignUp(*pOffset, allocAlignment);
      -
      8665 
      -
      8666  // Check previous suballocations for BufferImageGranularity conflicts.
      -
      8667  // Make bigger alignment if necessary.
      -
      8668  if(bufferImageGranularity > 1)
      -
      8669  {
      -
      8670  bool bufferImageGranularityConflict = false;
      -
      8671  VmaSuballocationList::const_iterator prevSuballocItem = suballocItem;
      -
      8672  while(prevSuballocItem != m_Suballocations.cbegin())
      -
      8673  {
      -
      8674  --prevSuballocItem;
      -
      8675  const VmaSuballocation& prevSuballoc = *prevSuballocItem;
      -
      8676  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, *pOffset, bufferImageGranularity))
      -
      8677  {
      -
      8678  if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
      -
      8679  {
      -
      8680  bufferImageGranularityConflict = true;
      -
      8681  break;
      -
      8682  }
      -
      8683  }
      -
      8684  else
      -
      8685  // Already on previous page.
      -
      8686  break;
      -
      8687  }
      -
      8688  if(bufferImageGranularityConflict)
      -
      8689  {
      -
      8690  *pOffset = VmaAlignUp(*pOffset, bufferImageGranularity);
      -
      8691  }
      -
      8692  }
      -
      8693 
      -
      8694  // Now that we have final *pOffset, check if we are past suballocItem.
      -
      8695  // If yes, return false - this function should be called for another suballocItem as starting point.
      -
      8696  if(*pOffset >= suballocItem->offset + suballocItem->size)
      -
      8697  {
      -
      8698  return false;
      -
      8699  }
      -
      8700 
      -
      8701  // Calculate padding at the beginning based on current offset.
      -
      8702  const VkDeviceSize paddingBegin = *pOffset - suballocItem->offset;
      -
      8703 
      -
      8704  // Calculate required margin at the end.
      -
      8705  const VkDeviceSize requiredEndMargin = VMA_DEBUG_MARGIN;
      -
      8706 
      -
      8707  const VkDeviceSize totalSize = paddingBegin + allocSize + requiredEndMargin;
      -
      8708  // Another early return check.
      -
      8709  if(suballocItem->offset + totalSize > GetSize())
      -
      8710  {
      -
      8711  return false;
      -
      8712  }
      -
      8713 
      -
      8714  // Advance lastSuballocItem until desired size is reached.
      -
      8715  // Update itemsToMakeLostCount.
      -
      8716  VmaSuballocationList::const_iterator lastSuballocItem = suballocItem;
      -
      8717  if(totalSize > suballocItem->size)
      -
      8718  {
      -
      8719  VkDeviceSize remainingSize = totalSize - suballocItem->size;
      -
      8720  while(remainingSize > 0)
      -
      8721  {
      -
      8722  ++lastSuballocItem;
      -
      8723  if(lastSuballocItem == m_Suballocations.cend())
      -
      8724  {
      -
      8725  return false;
      -
      8726  }
      -
      8727  if(lastSuballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)
      -
      8728  {
      -
      8729  *pSumFreeSize += lastSuballocItem->size;
      -
      8730  }
      -
      8731  else
      -
      8732  {
      -
      8733  VMA_ASSERT(lastSuballocItem->hAllocation != VK_NULL_HANDLE);
      -
      8734  if(lastSuballocItem->hAllocation->CanBecomeLost() &&
      -
      8735  lastSuballocItem->hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
      -
      8736  {
      -
      8737  ++*itemsToMakeLostCount;
      -
      8738  *pSumItemSize += lastSuballocItem->size;
      -
      8739  }
      -
      8740  else
      -
      8741  {
      -
      8742  return false;
      -
      8743  }
      -
      8744  }
      -
      8745  remainingSize = (lastSuballocItem->size < remainingSize) ?
      -
      8746  remainingSize - lastSuballocItem->size : 0;
      -
      8747  }
      -
      8748  }
      -
      8749 
      -
      8750  // Check next suballocations for BufferImageGranularity conflicts.
      -
      8751  // If conflict exists, we must mark more allocations lost or fail.
      -
      8752  if(bufferImageGranularity > 1)
      -
      8753  {
      -
      8754  VmaSuballocationList::const_iterator nextSuballocItem = lastSuballocItem;
      -
      8755  ++nextSuballocItem;
      -
      8756  while(nextSuballocItem != m_Suballocations.cend())
      -
      8757  {
      -
      8758  const VmaSuballocation& nextSuballoc = *nextSuballocItem;
      -
      8759  if(VmaBlocksOnSamePage(*pOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
      -
      8760  {
      -
      8761  if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
      -
      8762  {
      -
      8763  VMA_ASSERT(nextSuballoc.hAllocation != VK_NULL_HANDLE);
      -
      8764  if(nextSuballoc.hAllocation->CanBecomeLost() &&
      -
      8765  nextSuballoc.hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
      -
      8766  {
      -
      8767  ++*itemsToMakeLostCount;
      -
      8768  }
      -
      8769  else
      -
      8770  {
      -
      8771  return false;
      -
      8772  }
      -
      8773  }
      -
      8774  }
      -
      8775  else
      -
      8776  {
      -
      8777  // Already on next page.
      -
      8778  break;
      -
      8779  }
      -
      8780  ++nextSuballocItem;
      -
      8781  }
      -
      8782  }
      -
      8783  }
      -
      8784  else
      -
      8785  {
      -
      8786  const VmaSuballocation& suballoc = *suballocItem;
      -
      8787  VMA_ASSERT(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
      -
      8788 
      -
      8789  *pSumFreeSize = suballoc.size;
      -
      8790 
      -
      8791  // Size of this suballocation is too small for this request: Early return.
      -
      8792  if(suballoc.size < allocSize)
      -
      8793  {
      -
      8794  return false;
      -
      8795  }
      -
      8796 
      -
      8797  // Start from offset equal to beginning of this suballocation.
      -
      8798  *pOffset = suballoc.offset;
      -
      8799 
      -
      8800  // Apply VMA_DEBUG_MARGIN at the beginning.
      -
      8801  if(VMA_DEBUG_MARGIN > 0)
      -
      8802  {
      -
      8803  *pOffset += VMA_DEBUG_MARGIN;
      -
      8804  }
      -
      8805 
      -
      8806  // Apply alignment.
      -
      8807  *pOffset = VmaAlignUp(*pOffset, allocAlignment);
      -
      8808 
      -
      8809  // Check previous suballocations for BufferImageGranularity conflicts.
      -
      8810  // Make bigger alignment if necessary.
      -
      8811  if(bufferImageGranularity > 1)
      -
      8812  {
      -
      8813  bool bufferImageGranularityConflict = false;
      -
      8814  VmaSuballocationList::const_iterator prevSuballocItem = suballocItem;
      -
      8815  while(prevSuballocItem != m_Suballocations.cbegin())
      -
      8816  {
      -
      8817  --prevSuballocItem;
      -
      8818  const VmaSuballocation& prevSuballoc = *prevSuballocItem;
      -
      8819  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, *pOffset, bufferImageGranularity))
      -
      8820  {
      -
      8821  if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
      -
      8822  {
      -
      8823  bufferImageGranularityConflict = true;
      -
      8824  break;
      -
      8825  }
      -
      8826  }
      -
      8827  else
      -
      8828  // Already on previous page.
      -
      8829  break;
      -
      8830  }
      -
      8831  if(bufferImageGranularityConflict)
      -
      8832  {
      -
      8833  *pOffset = VmaAlignUp(*pOffset, bufferImageGranularity);
      -
      8834  }
      -
      8835  }
      -
      8836 
      -
      8837  // Calculate padding at the beginning based on current offset.
      -
      8838  const VkDeviceSize paddingBegin = *pOffset - suballoc.offset;
      -
      8839 
      -
      8840  // Calculate required margin at the end.
      -
      8841  const VkDeviceSize requiredEndMargin = VMA_DEBUG_MARGIN;
      +
      8628 void VmaBlockMetadata_Generic::FreeAtOffset(VkDeviceSize offset)
      +
      8629 {
      +
      8630  for(VmaSuballocationList::iterator suballocItem = m_Suballocations.begin();
      +
      8631  suballocItem != m_Suballocations.end();
      +
      8632  ++suballocItem)
      +
      8633  {
      +
      8634  VmaSuballocation& suballoc = *suballocItem;
      +
      8635  if(suballoc.offset == offset)
      +
      8636  {
      +
      8637  FreeSuballocation(suballocItem);
      +
      8638  return;
      +
      8639  }
      +
      8640  }
      +
      8641  VMA_ASSERT(0 && "Not found!");
      +
      8642 }
      +
      8643 
      +
      8644 bool VmaBlockMetadata_Generic::ValidateFreeSuballocationList() const
      +
      8645 {
      +
      8646  VkDeviceSize lastSize = 0;
      +
      8647  for(size_t i = 0, count = m_FreeSuballocationsBySize.size(); i < count; ++i)
      +
      8648  {
      +
      8649  const VmaSuballocationList::iterator it = m_FreeSuballocationsBySize[i];
      +
      8650 
      +
      8651  VMA_VALIDATE(it->type == VMA_SUBALLOCATION_TYPE_FREE);
      +
      8652  VMA_VALIDATE(it->size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER);
      +
      8653  VMA_VALIDATE(it->size >= lastSize);
      +
      8654  lastSize = it->size;
      +
      8655  }
      +
      8656  return true;
      +
      8657 }
      +
      8658 
      +
      8659 bool VmaBlockMetadata_Generic::CheckAllocation(
      +
      8660  uint32_t currentFrameIndex,
      +
      8661  uint32_t frameInUseCount,
      +
      8662  VkDeviceSize bufferImageGranularity,
      +
      8663  VkDeviceSize allocSize,
      +
      8664  VkDeviceSize allocAlignment,
      +
      8665  VmaSuballocationType allocType,
      +
      8666  VmaSuballocationList::const_iterator suballocItem,
      +
      8667  bool canMakeOtherLost,
      +
      8668  VkDeviceSize* pOffset,
      +
      8669  size_t* itemsToMakeLostCount,
      +
      8670  VkDeviceSize* pSumFreeSize,
      +
      8671  VkDeviceSize* pSumItemSize) const
      +
      8672 {
      +
      8673  VMA_ASSERT(allocSize > 0);
      +
      8674  VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
      +
      8675  VMA_ASSERT(suballocItem != m_Suballocations.cend());
      +
      8676  VMA_ASSERT(pOffset != VMA_NULL);
      +
      8677 
      +
      8678  *itemsToMakeLostCount = 0;
      +
      8679  *pSumFreeSize = 0;
      +
      8680  *pSumItemSize = 0;
      +
      8681 
      +
      8682  if(canMakeOtherLost)
      +
      8683  {
      +
      8684  if(suballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)
      +
      8685  {
      +
      8686  *pSumFreeSize = suballocItem->size;
      +
      8687  }
      +
      8688  else
      +
      8689  {
      +
      8690  if(suballocItem->hAllocation->CanBecomeLost() &&
      +
      8691  suballocItem->hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
      +
      8692  {
      +
      8693  ++*itemsToMakeLostCount;
      +
      8694  *pSumItemSize = suballocItem->size;
      +
      8695  }
      +
      8696  else
      +
      8697  {
      +
      8698  return false;
      +
      8699  }
      +
      8700  }
      +
      8701 
      +
      8702  // Remaining size is too small for this request: Early return.
      +
      8703  if(GetSize() - suballocItem->offset < allocSize)
      +
      8704  {
      +
      8705  return false;
      +
      8706  }
      +
      8707 
      +
      8708  // Start from offset equal to beginning of this suballocation.
      +
      8709  *pOffset = suballocItem->offset;
      +
      8710 
      +
      8711  // Apply VMA_DEBUG_MARGIN at the beginning.
      +
      8712  if(VMA_DEBUG_MARGIN > 0)
      +
      8713  {
      +
      8714  *pOffset += VMA_DEBUG_MARGIN;
      +
      8715  }
      +
      8716 
      +
      8717  // Apply alignment.
      +
      8718  *pOffset = VmaAlignUp(*pOffset, allocAlignment);
      +
      8719 
      +
      8720  // Check previous suballocations for BufferImageGranularity conflicts.
      +
      8721  // Make bigger alignment if necessary.
      +
      8722  if(bufferImageGranularity > 1)
      +
      8723  {
      +
      8724  bool bufferImageGranularityConflict = false;
      +
      8725  VmaSuballocationList::const_iterator prevSuballocItem = suballocItem;
      +
      8726  while(prevSuballocItem != m_Suballocations.cbegin())
      +
      8727  {
      +
      8728  --prevSuballocItem;
      +
      8729  const VmaSuballocation& prevSuballoc = *prevSuballocItem;
      +
      8730  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, *pOffset, bufferImageGranularity))
      +
      8731  {
      +
      8732  if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
      +
      8733  {
      +
      8734  bufferImageGranularityConflict = true;
      +
      8735  break;
      +
      8736  }
      +
      8737  }
      +
      8738  else
      +
      8739  // Already on previous page.
      +
      8740  break;
      +
      8741  }
      +
      8742  if(bufferImageGranularityConflict)
      +
      8743  {
      +
      8744  *pOffset = VmaAlignUp(*pOffset, bufferImageGranularity);
      +
      8745  }
      +
      8746  }
      +
      8747 
      +
      8748  // Now that we have final *pOffset, check if we are past suballocItem.
      +
      8749  // If yes, return false - this function should be called for another suballocItem as starting point.
      +
      8750  if(*pOffset >= suballocItem->offset + suballocItem->size)
      +
      8751  {
      +
      8752  return false;
      +
      8753  }
      +
      8754 
      +
      8755  // Calculate padding at the beginning based on current offset.
      +
      8756  const VkDeviceSize paddingBegin = *pOffset - suballocItem->offset;
      +
      8757 
      +
      8758  // Calculate required margin at the end.
      +
      8759  const VkDeviceSize requiredEndMargin = VMA_DEBUG_MARGIN;
      +
      8760 
      +
      8761  const VkDeviceSize totalSize = paddingBegin + allocSize + requiredEndMargin;
      +
      8762  // Another early return check.
      +
      8763  if(suballocItem->offset + totalSize > GetSize())
      +
      8764  {
      +
      8765  return false;
      +
      8766  }
      +
      8767 
      +
      8768  // Advance lastSuballocItem until desired size is reached.
      +
      8769  // Update itemsToMakeLostCount.
      +
      8770  VmaSuballocationList::const_iterator lastSuballocItem = suballocItem;
      +
      8771  if(totalSize > suballocItem->size)
      +
      8772  {
      +
      8773  VkDeviceSize remainingSize = totalSize - suballocItem->size;
      +
      8774  while(remainingSize > 0)
      +
      8775  {
      +
      8776  ++lastSuballocItem;
      +
      8777  if(lastSuballocItem == m_Suballocations.cend())
      +
      8778  {
      +
      8779  return false;
      +
      8780  }
      +
      8781  if(lastSuballocItem->type == VMA_SUBALLOCATION_TYPE_FREE)
      +
      8782  {
      +
      8783  *pSumFreeSize += lastSuballocItem->size;
      +
      8784  }
      +
      8785  else
      +
      8786  {
      +
      8787  VMA_ASSERT(lastSuballocItem->hAllocation != VK_NULL_HANDLE);
      +
      8788  if(lastSuballocItem->hAllocation->CanBecomeLost() &&
      +
      8789  lastSuballocItem->hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
      +
      8790  {
      +
      8791  ++*itemsToMakeLostCount;
      +
      8792  *pSumItemSize += lastSuballocItem->size;
      +
      8793  }
      +
      8794  else
      +
      8795  {
      +
      8796  return false;
      +
      8797  }
      +
      8798  }
      +
      8799  remainingSize = (lastSuballocItem->size < remainingSize) ?
      +
      8800  remainingSize - lastSuballocItem->size : 0;
      +
      8801  }
      +
      8802  }
      +
      8803 
      +
      8804  // Check next suballocations for BufferImageGranularity conflicts.
      +
      8805  // If conflict exists, we must mark more allocations lost or fail.
      +
      8806  if(bufferImageGranularity > 1)
      +
      8807  {
      +
      8808  VmaSuballocationList::const_iterator nextSuballocItem = lastSuballocItem;
      +
      8809  ++nextSuballocItem;
      +
      8810  while(nextSuballocItem != m_Suballocations.cend())
      +
      8811  {
      +
      8812  const VmaSuballocation& nextSuballoc = *nextSuballocItem;
      +
      8813  if(VmaBlocksOnSamePage(*pOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
      +
      8814  {
      +
      8815  if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
      +
      8816  {
      +
      8817  VMA_ASSERT(nextSuballoc.hAllocation != VK_NULL_HANDLE);
      +
      8818  if(nextSuballoc.hAllocation->CanBecomeLost() &&
      +
      8819  nextSuballoc.hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
      +
      8820  {
      +
      8821  ++*itemsToMakeLostCount;
      +
      8822  }
      +
      8823  else
      +
      8824  {
      +
      8825  return false;
      +
      8826  }
      +
      8827  }
      +
      8828  }
      +
      8829  else
      +
      8830  {
      +
      8831  // Already on next page.
      +
      8832  break;
      +
      8833  }
      +
      8834  ++nextSuballocItem;
      +
      8835  }
      +
      8836  }
      +
      8837  }
      +
      8838  else
      +
      8839  {
      +
      8840  const VmaSuballocation& suballoc = *suballocItem;
      +
      8841  VMA_ASSERT(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
      8842 
      -
      8843  // Fail if requested size plus margin before and after is bigger than size of this suballocation.
      -
      8844  if(paddingBegin + allocSize + requiredEndMargin > suballoc.size)
      -
      8845  {
      -
      8846  return false;
      -
      8847  }
      -
      8848 
      -
      8849  // Check next suballocations for BufferImageGranularity conflicts.
      -
      8850  // If conflict exists, allocation cannot be made here.
      -
      8851  if(bufferImageGranularity > 1)
      -
      8852  {
      -
      8853  VmaSuballocationList::const_iterator nextSuballocItem = suballocItem;
      -
      8854  ++nextSuballocItem;
      -
      8855  while(nextSuballocItem != m_Suballocations.cend())
      -
      8856  {
      -
      8857  const VmaSuballocation& nextSuballoc = *nextSuballocItem;
      -
      8858  if(VmaBlocksOnSamePage(*pOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
      -
      8859  {
      -
      8860  if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
      -
      8861  {
      -
      8862  return false;
      -
      8863  }
      -
      8864  }
      -
      8865  else
      -
      8866  {
      -
      8867  // Already on next page.
      -
      8868  break;
      -
      8869  }
      -
      8870  ++nextSuballocItem;
      -
      8871  }
      -
      8872  }
      -
      8873  }
      -
      8874 
      -
      8875  // All tests passed: Success. pOffset is already filled.
      -
      8876  return true;
      -
      8877 }
      -
      8878 
      -
      8879 void VmaBlockMetadata_Generic::MergeFreeWithNext(VmaSuballocationList::iterator item)
      -
      8880 {
      -
      8881  VMA_ASSERT(item != m_Suballocations.end());
      -
      8882  VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
      -
      8883 
      -
      8884  VmaSuballocationList::iterator nextItem = item;
      -
      8885  ++nextItem;
      -
      8886  VMA_ASSERT(nextItem != m_Suballocations.end());
      -
      8887  VMA_ASSERT(nextItem->type == VMA_SUBALLOCATION_TYPE_FREE);
      -
      8888 
      -
      8889  item->size += nextItem->size;
      -
      8890  --m_FreeCount;
      -
      8891  m_Suballocations.erase(nextItem);
      -
      8892 }
      +
      8843  *pSumFreeSize = suballoc.size;
      +
      8844 
      +
      8845  // Size of this suballocation is too small for this request: Early return.
      +
      8846  if(suballoc.size < allocSize)
      +
      8847  {
      +
      8848  return false;
      +
      8849  }
      +
      8850 
      +
      8851  // Start from offset equal to beginning of this suballocation.
      +
      8852  *pOffset = suballoc.offset;
      +
      8853 
      +
      8854  // Apply VMA_DEBUG_MARGIN at the beginning.
      +
      8855  if(VMA_DEBUG_MARGIN > 0)
      +
      8856  {
      +
      8857  *pOffset += VMA_DEBUG_MARGIN;
      +
      8858  }
      +
      8859 
      +
      8860  // Apply alignment.
      +
      8861  *pOffset = VmaAlignUp(*pOffset, allocAlignment);
      +
      8862 
      +
      8863  // Check previous suballocations for BufferImageGranularity conflicts.
      +
      8864  // Make bigger alignment if necessary.
      +
      8865  if(bufferImageGranularity > 1)
      +
      8866  {
      +
      8867  bool bufferImageGranularityConflict = false;
      +
      8868  VmaSuballocationList::const_iterator prevSuballocItem = suballocItem;
      +
      8869  while(prevSuballocItem != m_Suballocations.cbegin())
      +
      8870  {
      +
      8871  --prevSuballocItem;
      +
      8872  const VmaSuballocation& prevSuballoc = *prevSuballocItem;
      +
      8873  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, *pOffset, bufferImageGranularity))
      +
      8874  {
      +
      8875  if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
      +
      8876  {
      +
      8877  bufferImageGranularityConflict = true;
      +
      8878  break;
      +
      8879  }
      +
      8880  }
      +
      8881  else
      +
      8882  // Already on previous page.
      +
      8883  break;
      +
      8884  }
      +
      8885  if(bufferImageGranularityConflict)
      +
      8886  {
      +
      8887  *pOffset = VmaAlignUp(*pOffset, bufferImageGranularity);
      +
      8888  }
      +
      8889  }
      +
      8890 
      +
      8891  // Calculate padding at the beginning based on current offset.
      +
      8892  const VkDeviceSize paddingBegin = *pOffset - suballoc.offset;
      8893 
      -
      8894 VmaSuballocationList::iterator VmaBlockMetadata_Generic::FreeSuballocation(VmaSuballocationList::iterator suballocItem)
      -
      8895 {
      -
      8896  // Change this suballocation to be marked as free.
      -
      8897  VmaSuballocation& suballoc = *suballocItem;
      -
      8898  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
      -
      8899  suballoc.hAllocation = VK_NULL_HANDLE;
      -
      8900 
      -
      8901  // Update totals.
      -
      8902  ++m_FreeCount;
      -
      8903  m_SumFreeSize += suballoc.size;
      -
      8904 
      -
      8905  // Merge with previous and/or next suballocation if it's also free.
      -
      8906  bool mergeWithNext = false;
      -
      8907  bool mergeWithPrev = false;
      -
      8908 
      -
      8909  VmaSuballocationList::iterator nextItem = suballocItem;
      -
      8910  ++nextItem;
      -
      8911  if((nextItem != m_Suballocations.end()) && (nextItem->type == VMA_SUBALLOCATION_TYPE_FREE))
      -
      8912  {
      -
      8913  mergeWithNext = true;
      -
      8914  }
      -
      8915 
      -
      8916  VmaSuballocationList::iterator prevItem = suballocItem;
      -
      8917  if(suballocItem != m_Suballocations.begin())
      -
      8918  {
      -
      8919  --prevItem;
      -
      8920  if(prevItem->type == VMA_SUBALLOCATION_TYPE_FREE)
      -
      8921  {
      -
      8922  mergeWithPrev = true;
      -
      8923  }
      -
      8924  }
      -
      8925 
      -
      8926  if(mergeWithNext)
      -
      8927  {
      -
      8928  UnregisterFreeSuballocation(nextItem);
      -
      8929  MergeFreeWithNext(suballocItem);
      -
      8930  }
      -
      8931 
      -
      8932  if(mergeWithPrev)
      -
      8933  {
      -
      8934  UnregisterFreeSuballocation(prevItem);
      -
      8935  MergeFreeWithNext(prevItem);
      -
      8936  RegisterFreeSuballocation(prevItem);
      -
      8937  return prevItem;
      -
      8938  }
      -
      8939  else
      -
      8940  {
      -
      8941  RegisterFreeSuballocation(suballocItem);
      -
      8942  return suballocItem;
      -
      8943  }
      -
      8944 }
      -
      8945 
      -
      8946 void VmaBlockMetadata_Generic::RegisterFreeSuballocation(VmaSuballocationList::iterator item)
      -
      8947 {
      -
      8948  VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
      -
      8949  VMA_ASSERT(item->size > 0);
      -
      8950 
      -
      8951  // You may want to enable this validation at the beginning or at the end of
      -
      8952  // this function, depending on what do you want to check.
      -
      8953  VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
      -
      8954 
      -
      8955  if(item->size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
      -
      8956  {
      -
      8957  if(m_FreeSuballocationsBySize.empty())
      -
      8958  {
      -
      8959  m_FreeSuballocationsBySize.push_back(item);
      -
      8960  }
      -
      8961  else
      -
      8962  {
      -
      8963  VmaVectorInsertSorted<VmaSuballocationItemSizeLess>(m_FreeSuballocationsBySize, item);
      -
      8964  }
      -
      8965  }
      -
      8966 
      -
      8967  //VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
      -
      8968 }
      +
      8894  // Calculate required margin at the end.
      +
      8895  const VkDeviceSize requiredEndMargin = VMA_DEBUG_MARGIN;
      +
      8896 
      +
      8897  // Fail if requested size plus margin before and after is bigger than size of this suballocation.
      +
      8898  if(paddingBegin + allocSize + requiredEndMargin > suballoc.size)
      +
      8899  {
      +
      8900  return false;
      +
      8901  }
      +
      8902 
      +
      8903  // Check next suballocations for BufferImageGranularity conflicts.
      +
      8904  // If conflict exists, allocation cannot be made here.
      +
      8905  if(bufferImageGranularity > 1)
      +
      8906  {
      +
      8907  VmaSuballocationList::const_iterator nextSuballocItem = suballocItem;
      +
      8908  ++nextSuballocItem;
      +
      8909  while(nextSuballocItem != m_Suballocations.cend())
      +
      8910  {
      +
      8911  const VmaSuballocation& nextSuballoc = *nextSuballocItem;
      +
      8912  if(VmaBlocksOnSamePage(*pOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
      +
      8913  {
      +
      8914  if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
      +
      8915  {
      +
      8916  return false;
      +
      8917  }
      +
      8918  }
      +
      8919  else
      +
      8920  {
      +
      8921  // Already on next page.
      +
      8922  break;
      +
      8923  }
      +
      8924  ++nextSuballocItem;
      +
      8925  }
      +
      8926  }
      +
      8927  }
      +
      8928 
      +
      8929  // All tests passed: Success. pOffset is already filled.
      +
      8930  return true;
      +
      8931 }
      +
      8932 
      +
      8933 void VmaBlockMetadata_Generic::MergeFreeWithNext(VmaSuballocationList::iterator item)
      +
      8934 {
      +
      8935  VMA_ASSERT(item != m_Suballocations.end());
      +
      8936  VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
      +
      8937 
      +
      8938  VmaSuballocationList::iterator nextItem = item;
      +
      8939  ++nextItem;
      +
      8940  VMA_ASSERT(nextItem != m_Suballocations.end());
      +
      8941  VMA_ASSERT(nextItem->type == VMA_SUBALLOCATION_TYPE_FREE);
      +
      8942 
      +
      8943  item->size += nextItem->size;
      +
      8944  --m_FreeCount;
      +
      8945  m_Suballocations.erase(nextItem);
      +
      8946 }
      +
      8947 
      +
      8948 VmaSuballocationList::iterator VmaBlockMetadata_Generic::FreeSuballocation(VmaSuballocationList::iterator suballocItem)
      +
      8949 {
      +
      8950  // Change this suballocation to be marked as free.
      +
      8951  VmaSuballocation& suballoc = *suballocItem;
      +
      8952  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
      +
      8953  suballoc.hAllocation = VK_NULL_HANDLE;
      +
      8954 
      +
      8955  // Update totals.
      +
      8956  ++m_FreeCount;
      +
      8957  m_SumFreeSize += suballoc.size;
      +
      8958 
      +
      8959  // Merge with previous and/or next suballocation if it's also free.
      +
      8960  bool mergeWithNext = false;
      +
      8961  bool mergeWithPrev = false;
      +
      8962 
      +
      8963  VmaSuballocationList::iterator nextItem = suballocItem;
      +
      8964  ++nextItem;
      +
      8965  if((nextItem != m_Suballocations.end()) && (nextItem->type == VMA_SUBALLOCATION_TYPE_FREE))
      +
      8966  {
      +
      8967  mergeWithNext = true;
      +
      8968  }
      8969 
      -
      8970 
      -
      8971 void VmaBlockMetadata_Generic::UnregisterFreeSuballocation(VmaSuballocationList::iterator item)
      -
      8972 {
      -
      8973  VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
      -
      8974  VMA_ASSERT(item->size > 0);
      -
      8975 
      -
      8976  // You may want to enable this validation at the beginning or at the end of
      -
      8977  // this function, depending on what do you want to check.
      -
      8978  VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
      +
      8970  VmaSuballocationList::iterator prevItem = suballocItem;
      +
      8971  if(suballocItem != m_Suballocations.begin())
      +
      8972  {
      +
      8973  --prevItem;
      +
      8974  if(prevItem->type == VMA_SUBALLOCATION_TYPE_FREE)
      +
      8975  {
      +
      8976  mergeWithPrev = true;
      +
      8977  }
      +
      8978  }
      8979 
      -
      8980  if(item->size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
      +
      8980  if(mergeWithNext)
      8981  {
      -
      8982  VmaSuballocationList::iterator* const it = VmaBinaryFindFirstNotLess(
      -
      8983  m_FreeSuballocationsBySize.data(),
      -
      8984  m_FreeSuballocationsBySize.data() + m_FreeSuballocationsBySize.size(),
      -
      8985  item,
      -
      8986  VmaSuballocationItemSizeLess());
      -
      8987  for(size_t index = it - m_FreeSuballocationsBySize.data();
      -
      8988  index < m_FreeSuballocationsBySize.size();
      -
      8989  ++index)
      -
      8990  {
      -
      8991  if(m_FreeSuballocationsBySize[index] == item)
      -
      8992  {
      -
      8993  VmaVectorRemove(m_FreeSuballocationsBySize, index);
      -
      8994  return;
      -
      8995  }
      -
      8996  VMA_ASSERT((m_FreeSuballocationsBySize[index]->size == item->size) && "Not found.");
      -
      8997  }
      -
      8998  VMA_ASSERT(0 && "Not found.");
      -
      8999  }
      -
      9000 
      -
      9001  //VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
      -
      9002 }
      -
      9003 
      -
      9004 bool VmaBlockMetadata_Generic::IsBufferImageGranularityConflictPossible(
      -
      9005  VkDeviceSize bufferImageGranularity,
      -
      9006  VmaSuballocationType& inOutPrevSuballocType) const
      -
      9007 {
      -
      9008  if(bufferImageGranularity == 1 || IsEmpty())
      -
      9009  {
      -
      9010  return false;
      -
      9011  }
      -
      9012 
      -
      9013  VkDeviceSize minAlignment = VK_WHOLE_SIZE;
      -
      9014  bool typeConflictFound = false;
      -
      9015  for(VmaSuballocationList::const_iterator it = m_Suballocations.cbegin();
      -
      9016  it != m_Suballocations.cend();
      -
      9017  ++it)
      -
      9018  {
      -
      9019  const VmaSuballocationType suballocType = it->type;
      -
      9020  if(suballocType != VMA_SUBALLOCATION_TYPE_FREE)
      -
      9021  {
      -
      9022  minAlignment = VMA_MIN(minAlignment, it->hAllocation->GetAlignment());
      -
      9023  if(VmaIsBufferImageGranularityConflict(inOutPrevSuballocType, suballocType))
      -
      9024  {
      -
      9025  typeConflictFound = true;
      -
      9026  }
      -
      9027  inOutPrevSuballocType = suballocType;
      -
      9028  }
      -
      9029  }
      -
      9030 
      -
      9031  return typeConflictFound || minAlignment >= bufferImageGranularity;
      -
      9032 }
      +
      8982  UnregisterFreeSuballocation(nextItem);
      +
      8983  MergeFreeWithNext(suballocItem);
      +
      8984  }
      +
      8985 
      +
      8986  if(mergeWithPrev)
      +
      8987  {
      +
      8988  UnregisterFreeSuballocation(prevItem);
      +
      8989  MergeFreeWithNext(prevItem);
      +
      8990  RegisterFreeSuballocation(prevItem);
      +
      8991  return prevItem;
      +
      8992  }
      +
      8993  else
      +
      8994  {
      +
      8995  RegisterFreeSuballocation(suballocItem);
      +
      8996  return suballocItem;
      +
      8997  }
      +
      8998 }
      +
      8999 
      +
      9000 void VmaBlockMetadata_Generic::RegisterFreeSuballocation(VmaSuballocationList::iterator item)
      +
      9001 {
      +
      9002  VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
      +
      9003  VMA_ASSERT(item->size > 0);
      +
      9004 
      +
      9005  // You may want to enable this validation at the beginning or at the end of
      +
      9006  // this function, depending on what do you want to check.
      +
      9007  VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
      +
      9008 
      +
      9009  if(item->size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
      +
      9010  {
      +
      9011  if(m_FreeSuballocationsBySize.empty())
      +
      9012  {
      +
      9013  m_FreeSuballocationsBySize.push_back(item);
      +
      9014  }
      +
      9015  else
      +
      9016  {
      +
      9017  VmaVectorInsertSorted<VmaSuballocationItemSizeLess>(m_FreeSuballocationsBySize, item);
      +
      9018  }
      +
      9019  }
      +
      9020 
      +
      9021  //VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
      +
      9022 }
      +
      9023 
      +
      9024 
      +
      9025 void VmaBlockMetadata_Generic::UnregisterFreeSuballocation(VmaSuballocationList::iterator item)
      +
      9026 {
      +
      9027  VMA_ASSERT(item->type == VMA_SUBALLOCATION_TYPE_FREE);
      +
      9028  VMA_ASSERT(item->size > 0);
      +
      9029 
      +
      9030  // You may want to enable this validation at the beginning or at the end of
      +
      9031  // this function, depending on what do you want to check.
      +
      9032  VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
      9033 
      -
      9035 // class VmaBlockMetadata_Linear
      -
      9036 
      -
      9037 VmaBlockMetadata_Linear::VmaBlockMetadata_Linear(VmaAllocator hAllocator) :
      -
      9038  VmaBlockMetadata(hAllocator),
      -
      9039  m_SumFreeSize(0),
      -
      9040  m_Suballocations0(VmaStlAllocator<VmaSuballocation>(hAllocator->GetAllocationCallbacks())),
      -
      9041  m_Suballocations1(VmaStlAllocator<VmaSuballocation>(hAllocator->GetAllocationCallbacks())),
      -
      9042  m_1stVectorIndex(0),
      -
      9043  m_2ndVectorMode(SECOND_VECTOR_EMPTY),
      -
      9044  m_1stNullItemsBeginCount(0),
      -
      9045  m_1stNullItemsMiddleCount(0),
      -
      9046  m_2ndNullItemsCount(0)
      -
      9047 {
      -
      9048 }
      -
      9049 
      -
      9050 VmaBlockMetadata_Linear::~VmaBlockMetadata_Linear()
      -
      9051 {
      -
      9052 }
      -
      9053 
      -
      9054 void VmaBlockMetadata_Linear::Init(VkDeviceSize size)
      -
      9055 {
      -
      9056  VmaBlockMetadata::Init(size);
      -
      9057  m_SumFreeSize = size;
      -
      9058 }
      -
      9059 
      -
      9060 bool VmaBlockMetadata_Linear::Validate() const
      +
      9034  if(item->size >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
      +
      9035  {
      +
      9036  VmaSuballocationList::iterator* const it = VmaBinaryFindFirstNotLess(
      +
      9037  m_FreeSuballocationsBySize.data(),
      +
      9038  m_FreeSuballocationsBySize.data() + m_FreeSuballocationsBySize.size(),
      +
      9039  item,
      +
      9040  VmaSuballocationItemSizeLess());
      +
      9041  for(size_t index = it - m_FreeSuballocationsBySize.data();
      +
      9042  index < m_FreeSuballocationsBySize.size();
      +
      9043  ++index)
      +
      9044  {
      +
      9045  if(m_FreeSuballocationsBySize[index] == item)
      +
      9046  {
      +
      9047  VmaVectorRemove(m_FreeSuballocationsBySize, index);
      +
      9048  return;
      +
      9049  }
      +
      9050  VMA_ASSERT((m_FreeSuballocationsBySize[index]->size == item->size) && "Not found.");
      +
      9051  }
      +
      9052  VMA_ASSERT(0 && "Not found.");
      +
      9053  }
      +
      9054 
      +
      9055  //VMA_HEAVY_ASSERT(ValidateFreeSuballocationList());
      +
      9056 }
      +
      9057 
      +
      9058 bool VmaBlockMetadata_Generic::IsBufferImageGranularityConflictPossible(
      +
      9059  VkDeviceSize bufferImageGranularity,
      +
      9060  VmaSuballocationType& inOutPrevSuballocType) const
      9061 {
      -
      9062  const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
      -
      9063  const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
      -
      9064 
      -
      9065  VMA_VALIDATE(suballocations2nd.empty() == (m_2ndVectorMode == SECOND_VECTOR_EMPTY));
      -
      9066  VMA_VALIDATE(!suballocations1st.empty() ||
      -
      9067  suballocations2nd.empty() ||
      -
      9068  m_2ndVectorMode != SECOND_VECTOR_RING_BUFFER);
      -
      9069 
      -
      9070  if(!suballocations1st.empty())
      -
      9071  {
      -
      9072  // Null item at the beginning should be accounted into m_1stNullItemsBeginCount.
      -
      9073  VMA_VALIDATE(suballocations1st[m_1stNullItemsBeginCount].hAllocation != VK_NULL_HANDLE);
      -
      9074  // Null item at the end should be just pop_back().
      -
      9075  VMA_VALIDATE(suballocations1st.back().hAllocation != VK_NULL_HANDLE);
      -
      9076  }
      -
      9077  if(!suballocations2nd.empty())
      -
      9078  {
      -
      9079  // Null item at the end should be just pop_back().
      -
      9080  VMA_VALIDATE(suballocations2nd.back().hAllocation != VK_NULL_HANDLE);
      -
      9081  }
      -
      9082 
      -
      9083  VMA_VALIDATE(m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount <= suballocations1st.size());
      -
      9084  VMA_VALIDATE(m_2ndNullItemsCount <= suballocations2nd.size());
      -
      9085 
      -
      9086  VkDeviceSize sumUsedSize = 0;
      -
      9087  const size_t suballoc1stCount = suballocations1st.size();
      -
      9088  VkDeviceSize offset = VMA_DEBUG_MARGIN;
      -
      9089 
      -
      9090  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
      -
      9091  {
      -
      9092  const size_t suballoc2ndCount = suballocations2nd.size();
      -
      9093  size_t nullItem2ndCount = 0;
      -
      9094  for(size_t i = 0; i < suballoc2ndCount; ++i)
      -
      9095  {
      -
      9096  const VmaSuballocation& suballoc = suballocations2nd[i];
      -
      9097  const bool currFree = (suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
      -
      9098 
      -
      9099  VMA_VALIDATE(currFree == (suballoc.hAllocation == VK_NULL_HANDLE));
      -
      9100  VMA_VALIDATE(suballoc.offset >= offset);
      -
      9101 
      -
      9102  if(!currFree)
      -
      9103  {
      -
      9104  VMA_VALIDATE(suballoc.hAllocation->GetOffset() == suballoc.offset);
      -
      9105  VMA_VALIDATE(suballoc.hAllocation->GetSize() == suballoc.size);
      -
      9106  sumUsedSize += suballoc.size;
      -
      9107  }
      -
      9108  else
      -
      9109  {
      -
      9110  ++nullItem2ndCount;
      -
      9111  }
      -
      9112 
      -
      9113  offset = suballoc.offset + suballoc.size + VMA_DEBUG_MARGIN;
      -
      9114  }
      -
      9115 
      -
      9116  VMA_VALIDATE(nullItem2ndCount == m_2ndNullItemsCount);
      -
      9117  }
      +
      9062  if(bufferImageGranularity == 1 || IsEmpty())
      +
      9063  {
      +
      9064  return false;
      +
      9065  }
      +
      9066 
      +
      9067  VkDeviceSize minAlignment = VK_WHOLE_SIZE;
      +
      9068  bool typeConflictFound = false;
      +
      9069  for(VmaSuballocationList::const_iterator it = m_Suballocations.cbegin();
      +
      9070  it != m_Suballocations.cend();
      +
      9071  ++it)
      +
      9072  {
      +
      9073  const VmaSuballocationType suballocType = it->type;
      +
      9074  if(suballocType != VMA_SUBALLOCATION_TYPE_FREE)
      +
      9075  {
      +
      9076  minAlignment = VMA_MIN(minAlignment, it->hAllocation->GetAlignment());
      +
      9077  if(VmaIsBufferImageGranularityConflict(inOutPrevSuballocType, suballocType))
      +
      9078  {
      +
      9079  typeConflictFound = true;
      +
      9080  }
      +
      9081  inOutPrevSuballocType = suballocType;
      +
      9082  }
      +
      9083  }
      +
      9084 
      +
      9085  return typeConflictFound || minAlignment >= bufferImageGranularity;
      +
      9086 }
      +
      9087 
      +
      9089 // class VmaBlockMetadata_Linear
      +
      9090 
      +
      9091 VmaBlockMetadata_Linear::VmaBlockMetadata_Linear(VmaAllocator hAllocator) :
      +
      9092  VmaBlockMetadata(hAllocator),
      +
      9093  m_SumFreeSize(0),
      +
      9094  m_Suballocations0(VmaStlAllocator<VmaSuballocation>(hAllocator->GetAllocationCallbacks())),
      +
      9095  m_Suballocations1(VmaStlAllocator<VmaSuballocation>(hAllocator->GetAllocationCallbacks())),
      +
      9096  m_1stVectorIndex(0),
      +
      9097  m_2ndVectorMode(SECOND_VECTOR_EMPTY),
      +
      9098  m_1stNullItemsBeginCount(0),
      +
      9099  m_1stNullItemsMiddleCount(0),
      +
      9100  m_2ndNullItemsCount(0)
      +
      9101 {
      +
      9102 }
      +
      9103 
      +
      9104 VmaBlockMetadata_Linear::~VmaBlockMetadata_Linear()
      +
      9105 {
      +
      9106 }
      +
      9107 
      +
      9108 void VmaBlockMetadata_Linear::Init(VkDeviceSize size)
      +
      9109 {
      +
      9110  VmaBlockMetadata::Init(size);
      +
      9111  m_SumFreeSize = size;
      +
      9112 }
      +
      9113 
      +
      9114 bool VmaBlockMetadata_Linear::Validate() const
      +
      9115 {
      +
      9116  const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
      +
      9117  const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
      9118 
      -
      9119  for(size_t i = 0; i < m_1stNullItemsBeginCount; ++i)
      -
      9120  {
      -
      9121  const VmaSuballocation& suballoc = suballocations1st[i];
      -
      9122  VMA_VALIDATE(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE &&
      -
      9123  suballoc.hAllocation == VK_NULL_HANDLE);
      -
      9124  }
      -
      9125 
      -
      9126  size_t nullItem1stCount = m_1stNullItemsBeginCount;
      -
      9127 
      -
      9128  for(size_t i = m_1stNullItemsBeginCount; i < suballoc1stCount; ++i)
      -
      9129  {
      -
      9130  const VmaSuballocation& suballoc = suballocations1st[i];
      -
      9131  const bool currFree = (suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
      -
      9132 
      -
      9133  VMA_VALIDATE(currFree == (suballoc.hAllocation == VK_NULL_HANDLE));
      -
      9134  VMA_VALIDATE(suballoc.offset >= offset);
      -
      9135  VMA_VALIDATE(i >= m_1stNullItemsBeginCount || currFree);
      +
      9119  VMA_VALIDATE(suballocations2nd.empty() == (m_2ndVectorMode == SECOND_VECTOR_EMPTY));
      +
      9120  VMA_VALIDATE(!suballocations1st.empty() ||
      +
      9121  suballocations2nd.empty() ||
      +
      9122  m_2ndVectorMode != SECOND_VECTOR_RING_BUFFER);
      +
      9123 
      +
      9124  if(!suballocations1st.empty())
      +
      9125  {
      +
      9126  // Null item at the beginning should be accounted into m_1stNullItemsBeginCount.
      +
      9127  VMA_VALIDATE(suballocations1st[m_1stNullItemsBeginCount].hAllocation != VK_NULL_HANDLE);
      +
      9128  // Null item at the end should be just pop_back().
      +
      9129  VMA_VALIDATE(suballocations1st.back().hAllocation != VK_NULL_HANDLE);
      +
      9130  }
      +
      9131  if(!suballocations2nd.empty())
      +
      9132  {
      +
      9133  // Null item at the end should be just pop_back().
      +
      9134  VMA_VALIDATE(suballocations2nd.back().hAllocation != VK_NULL_HANDLE);
      +
      9135  }
      9136 
      -
      9137  if(!currFree)
      -
      9138  {
      -
      9139  VMA_VALIDATE(suballoc.hAllocation->GetOffset() == suballoc.offset);
      -
      9140  VMA_VALIDATE(suballoc.hAllocation->GetSize() == suballoc.size);
      -
      9141  sumUsedSize += suballoc.size;
      -
      9142  }
      -
      9143  else
      -
      9144  {
      -
      9145  ++nullItem1stCount;
      -
      9146  }
      -
      9147 
      -
      9148  offset = suballoc.offset + suballoc.size + VMA_DEBUG_MARGIN;
      -
      9149  }
      -
      9150  VMA_VALIDATE(nullItem1stCount == m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount);
      -
      9151 
      -
      9152  if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
      -
      9153  {
      -
      9154  const size_t suballoc2ndCount = suballocations2nd.size();
      -
      9155  size_t nullItem2ndCount = 0;
      -
      9156  for(size_t i = suballoc2ndCount; i--; )
      -
      9157  {
      -
      9158  const VmaSuballocation& suballoc = suballocations2nd[i];
      -
      9159  const bool currFree = (suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
      -
      9160 
      -
      9161  VMA_VALIDATE(currFree == (suballoc.hAllocation == VK_NULL_HANDLE));
      -
      9162  VMA_VALIDATE(suballoc.offset >= offset);
      -
      9163 
      -
      9164  if(!currFree)
      -
      9165  {
      -
      9166  VMA_VALIDATE(suballoc.hAllocation->GetOffset() == suballoc.offset);
      -
      9167  VMA_VALIDATE(suballoc.hAllocation->GetSize() == suballoc.size);
      -
      9168  sumUsedSize += suballoc.size;
      -
      9169  }
      -
      9170  else
      -
      9171  {
      -
      9172  ++nullItem2ndCount;
      -
      9173  }
      -
      9174 
      -
      9175  offset = suballoc.offset + suballoc.size + VMA_DEBUG_MARGIN;
      -
      9176  }
      -
      9177 
      -
      9178  VMA_VALIDATE(nullItem2ndCount == m_2ndNullItemsCount);
      -
      9179  }
      -
      9180 
      -
      9181  VMA_VALIDATE(offset <= GetSize());
      -
      9182  VMA_VALIDATE(m_SumFreeSize == GetSize() - sumUsedSize);
      -
      9183 
      -
      9184  return true;
      -
      9185 }
      +
      9137  VMA_VALIDATE(m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount <= suballocations1st.size());
      +
      9138  VMA_VALIDATE(m_2ndNullItemsCount <= suballocations2nd.size());
      +
      9139 
      +
      9140  VkDeviceSize sumUsedSize = 0;
      +
      9141  const size_t suballoc1stCount = suballocations1st.size();
      +
      9142  VkDeviceSize offset = VMA_DEBUG_MARGIN;
      +
      9143 
      +
      9144  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
      +
      9145  {
      +
      9146  const size_t suballoc2ndCount = suballocations2nd.size();
      +
      9147  size_t nullItem2ndCount = 0;
      +
      9148  for(size_t i = 0; i < suballoc2ndCount; ++i)
      +
      9149  {
      +
      9150  const VmaSuballocation& suballoc = suballocations2nd[i];
      +
      9151  const bool currFree = (suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
      +
      9152 
      +
      9153  VMA_VALIDATE(currFree == (suballoc.hAllocation == VK_NULL_HANDLE));
      +
      9154  VMA_VALIDATE(suballoc.offset >= offset);
      +
      9155 
      +
      9156  if(!currFree)
      +
      9157  {
      +
      9158  VMA_VALIDATE(suballoc.hAllocation->GetOffset() == suballoc.offset);
      +
      9159  VMA_VALIDATE(suballoc.hAllocation->GetSize() == suballoc.size);
      +
      9160  sumUsedSize += suballoc.size;
      +
      9161  }
      +
      9162  else
      +
      9163  {
      +
      9164  ++nullItem2ndCount;
      +
      9165  }
      +
      9166 
      +
      9167  offset = suballoc.offset + suballoc.size + VMA_DEBUG_MARGIN;
      +
      9168  }
      +
      9169 
      +
      9170  VMA_VALIDATE(nullItem2ndCount == m_2ndNullItemsCount);
      +
      9171  }
      +
      9172 
      +
      9173  for(size_t i = 0; i < m_1stNullItemsBeginCount; ++i)
      +
      9174  {
      +
      9175  const VmaSuballocation& suballoc = suballocations1st[i];
      +
      9176  VMA_VALIDATE(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE &&
      +
      9177  suballoc.hAllocation == VK_NULL_HANDLE);
      +
      9178  }
      +
      9179 
      +
      9180  size_t nullItem1stCount = m_1stNullItemsBeginCount;
      +
      9181 
      +
      9182  for(size_t i = m_1stNullItemsBeginCount; i < suballoc1stCount; ++i)
      +
      9183  {
      +
      9184  const VmaSuballocation& suballoc = suballocations1st[i];
      +
      9185  const bool currFree = (suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
      9186 
      -
      9187 size_t VmaBlockMetadata_Linear::GetAllocationCount() const
      -
      9188 {
      -
      9189  return AccessSuballocations1st().size() - (m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount) +
      -
      9190  AccessSuballocations2nd().size() - m_2ndNullItemsCount;
      -
      9191 }
      -
      9192 
      -
      9193 VkDeviceSize VmaBlockMetadata_Linear::GetUnusedRangeSizeMax() const
      -
      9194 {
      -
      9195  const VkDeviceSize size = GetSize();
      -
      9196 
      -
      9197  /*
      -
      9198  We don't consider gaps inside allocation vectors with freed allocations because
      -
      9199  they are not suitable for reuse in linear allocator. We consider only space that
      -
      9200  is available for new allocations.
      -
      9201  */
      -
      9202  if(IsEmpty())
      -
      9203  {
      -
      9204  return size;
      -
      9205  }
      -
      9206 
      -
      9207  const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
      -
      9208 
      -
      9209  switch(m_2ndVectorMode)
      -
      9210  {
      -
      9211  case SECOND_VECTOR_EMPTY:
      -
      9212  /*
      -
      9213  Available space is after end of 1st, as well as before beginning of 1st (which
      -
      9214  whould make it a ring buffer).
      -
      9215  */
      -
      9216  {
      -
      9217  const size_t suballocations1stCount = suballocations1st.size();
      -
      9218  VMA_ASSERT(suballocations1stCount > m_1stNullItemsBeginCount);
      -
      9219  const VmaSuballocation& firstSuballoc = suballocations1st[m_1stNullItemsBeginCount];
      -
      9220  const VmaSuballocation& lastSuballoc = suballocations1st[suballocations1stCount - 1];
      -
      9221  return VMA_MAX(
      -
      9222  firstSuballoc.offset,
      -
      9223  size - (lastSuballoc.offset + lastSuballoc.size));
      -
      9224  }
      -
      9225  break;
      -
      9226 
      -
      9227  case SECOND_VECTOR_RING_BUFFER:
      -
      9228  /*
      -
      9229  Available space is only between end of 2nd and beginning of 1st.
      -
      9230  */
      -
      9231  {
      -
      9232  const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
      -
      9233  const VmaSuballocation& lastSuballoc2nd = suballocations2nd.back();
      -
      9234  const VmaSuballocation& firstSuballoc1st = suballocations1st[m_1stNullItemsBeginCount];
      -
      9235  return firstSuballoc1st.offset - (lastSuballoc2nd.offset + lastSuballoc2nd.size);
      -
      9236  }
      -
      9237  break;
      -
      9238 
      -
      9239  case SECOND_VECTOR_DOUBLE_STACK:
      -
      9240  /*
      -
      9241  Available space is only between end of 1st and top of 2nd.
      -
      9242  */
      -
      9243  {
      -
      9244  const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
      -
      9245  const VmaSuballocation& topSuballoc2nd = suballocations2nd.back();
      -
      9246  const VmaSuballocation& lastSuballoc1st = suballocations1st.back();
      -
      9247  return topSuballoc2nd.offset - (lastSuballoc1st.offset + lastSuballoc1st.size);
      -
      9248  }
      -
      9249  break;
      +
      9187  VMA_VALIDATE(currFree == (suballoc.hAllocation == VK_NULL_HANDLE));
      +
      9188  VMA_VALIDATE(suballoc.offset >= offset);
      +
      9189  VMA_VALIDATE(i >= m_1stNullItemsBeginCount || currFree);
      +
      9190 
      +
      9191  if(!currFree)
      +
      9192  {
      +
      9193  VMA_VALIDATE(suballoc.hAllocation->GetOffset() == suballoc.offset);
      +
      9194  VMA_VALIDATE(suballoc.hAllocation->GetSize() == suballoc.size);
      +
      9195  sumUsedSize += suballoc.size;
      +
      9196  }
      +
      9197  else
      +
      9198  {
      +
      9199  ++nullItem1stCount;
      +
      9200  }
      +
      9201 
      +
      9202  offset = suballoc.offset + suballoc.size + VMA_DEBUG_MARGIN;
      +
      9203  }
      +
      9204  VMA_VALIDATE(nullItem1stCount == m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount);
      +
      9205 
      +
      9206  if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
      +
      9207  {
      +
      9208  const size_t suballoc2ndCount = suballocations2nd.size();
      +
      9209  size_t nullItem2ndCount = 0;
      +
      9210  for(size_t i = suballoc2ndCount; i--; )
      +
      9211  {
      +
      9212  const VmaSuballocation& suballoc = suballocations2nd[i];
      +
      9213  const bool currFree = (suballoc.type == VMA_SUBALLOCATION_TYPE_FREE);
      +
      9214 
      +
      9215  VMA_VALIDATE(currFree == (suballoc.hAllocation == VK_NULL_HANDLE));
      +
      9216  VMA_VALIDATE(suballoc.offset >= offset);
      +
      9217 
      +
      9218  if(!currFree)
      +
      9219  {
      +
      9220  VMA_VALIDATE(suballoc.hAllocation->GetOffset() == suballoc.offset);
      +
      9221  VMA_VALIDATE(suballoc.hAllocation->GetSize() == suballoc.size);
      +
      9222  sumUsedSize += suballoc.size;
      +
      9223  }
      +
      9224  else
      +
      9225  {
      +
      9226  ++nullItem2ndCount;
      +
      9227  }
      +
      9228 
      +
      9229  offset = suballoc.offset + suballoc.size + VMA_DEBUG_MARGIN;
      +
      9230  }
      +
      9231 
      +
      9232  VMA_VALIDATE(nullItem2ndCount == m_2ndNullItemsCount);
      +
      9233  }
      +
      9234 
      +
      9235  VMA_VALIDATE(offset <= GetSize());
      +
      9236  VMA_VALIDATE(m_SumFreeSize == GetSize() - sumUsedSize);
      +
      9237 
      +
      9238  return true;
      +
      9239 }
      +
      9240 
      +
      9241 size_t VmaBlockMetadata_Linear::GetAllocationCount() const
      +
      9242 {
      +
      9243  return AccessSuballocations1st().size() - (m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount) +
      +
      9244  AccessSuballocations2nd().size() - m_2ndNullItemsCount;
      +
      9245 }
      +
      9246 
      +
      9247 VkDeviceSize VmaBlockMetadata_Linear::GetUnusedRangeSizeMax() const
      +
      9248 {
      +
      9249  const VkDeviceSize size = GetSize();
      9250 
      -
      9251  default:
      -
      9252  VMA_ASSERT(0);
      -
      9253  return 0;
      -
      9254  }
      -
      9255 }
      -
      9256 
      -
      9257 void VmaBlockMetadata_Linear::CalcAllocationStatInfo(VmaStatInfo& outInfo) const
      -
      9258 {
      -
      9259  const VkDeviceSize size = GetSize();
      -
      9260  const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
      -
      9261  const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
      -
      9262  const size_t suballoc1stCount = suballocations1st.size();
      -
      9263  const size_t suballoc2ndCount = suballocations2nd.size();
      -
      9264 
      -
      9265  outInfo.blockCount = 1;
      -
      9266  outInfo.allocationCount = (uint32_t)GetAllocationCount();
      -
      9267  outInfo.unusedRangeCount = 0;
      -
      9268  outInfo.usedBytes = 0;
      -
      9269  outInfo.allocationSizeMin = UINT64_MAX;
      -
      9270  outInfo.allocationSizeMax = 0;
      -
      9271  outInfo.unusedRangeSizeMin = UINT64_MAX;
      -
      9272  outInfo.unusedRangeSizeMax = 0;
      -
      9273 
      -
      9274  VkDeviceSize lastOffset = 0;
      -
      9275 
      -
      9276  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
      -
      9277  {
      -
      9278  const VkDeviceSize freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
      -
      9279  size_t nextAlloc2ndIndex = 0;
      -
      9280  while(lastOffset < freeSpace2ndTo1stEnd)
      -
      9281  {
      -
      9282  // Find next non-null allocation or move nextAllocIndex to the end.
      -
      9283  while(nextAlloc2ndIndex < suballoc2ndCount &&
      -
      9284  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
      -
      9285  {
      -
      9286  ++nextAlloc2ndIndex;
      -
      9287  }
      -
      9288 
      -
      9289  // Found non-null allocation.
      -
      9290  if(nextAlloc2ndIndex < suballoc2ndCount)
      -
      9291  {
      -
      9292  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
      -
      9293 
      -
      9294  // 1. Process free space before this allocation.
      -
      9295  if(lastOffset < suballoc.offset)
      -
      9296  {
      -
      9297  // There is free space from lastOffset to suballoc.offset.
      -
      9298  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
      -
      9299  ++outInfo.unusedRangeCount;
      -
      9300  outInfo.unusedBytes += unusedRangeSize;
      -
      9301  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
      -
      9302  outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
      -
      9303  }
      -
      9304 
      -
      9305  // 2. Process this allocation.
      -
      9306  // There is allocation with suballoc.offset, suballoc.size.
      -
      9307  outInfo.usedBytes += suballoc.size;
      -
      9308  outInfo.allocationSizeMin = VMA_MIN(outInfo.allocationSizeMin, suballoc.size);
      -
      9309  outInfo.allocationSizeMax = VMA_MIN(outInfo.allocationSizeMax, suballoc.size);
      -
      9310 
      -
      9311  // 3. Prepare for next iteration.
      -
      9312  lastOffset = suballoc.offset + suballoc.size;
      -
      9313  ++nextAlloc2ndIndex;
      -
      9314  }
      -
      9315  // We are at the end.
      -
      9316  else
      -
      9317  {
      -
      9318  // There is free space from lastOffset to freeSpace2ndTo1stEnd.
      -
      9319  if(lastOffset < freeSpace2ndTo1stEnd)
      -
      9320  {
      -
      9321  const VkDeviceSize unusedRangeSize = freeSpace2ndTo1stEnd - lastOffset;
      -
      9322  ++outInfo.unusedRangeCount;
      -
      9323  outInfo.unusedBytes += unusedRangeSize;
      -
      9324  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
      -
      9325  outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
      -
      9326  }
      +
      9251  /*
      +
      9252  We don't consider gaps inside allocation vectors with freed allocations because
      +
      9253  they are not suitable for reuse in linear allocator. We consider only space that
      +
      9254  is available for new allocations.
      +
      9255  */
      +
      9256  if(IsEmpty())
      +
      9257  {
      +
      9258  return size;
      +
      9259  }
      +
      9260 
      +
      9261  const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
      +
      9262 
      +
      9263  switch(m_2ndVectorMode)
      +
      9264  {
      +
      9265  case SECOND_VECTOR_EMPTY:
      +
      9266  /*
      +
      9267  Available space is after end of 1st, as well as before beginning of 1st (which
      +
      9268  whould make it a ring buffer).
      +
      9269  */
      +
      9270  {
      +
      9271  const size_t suballocations1stCount = suballocations1st.size();
      +
      9272  VMA_ASSERT(suballocations1stCount > m_1stNullItemsBeginCount);
      +
      9273  const VmaSuballocation& firstSuballoc = suballocations1st[m_1stNullItemsBeginCount];
      +
      9274  const VmaSuballocation& lastSuballoc = suballocations1st[suballocations1stCount - 1];
      +
      9275  return VMA_MAX(
      +
      9276  firstSuballoc.offset,
      +
      9277  size - (lastSuballoc.offset + lastSuballoc.size));
      +
      9278  }
      +
      9279  break;
      +
      9280 
      +
      9281  case SECOND_VECTOR_RING_BUFFER:
      +
      9282  /*
      +
      9283  Available space is only between end of 2nd and beginning of 1st.
      +
      9284  */
      +
      9285  {
      +
      9286  const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
      +
      9287  const VmaSuballocation& lastSuballoc2nd = suballocations2nd.back();
      +
      9288  const VmaSuballocation& firstSuballoc1st = suballocations1st[m_1stNullItemsBeginCount];
      +
      9289  return firstSuballoc1st.offset - (lastSuballoc2nd.offset + lastSuballoc2nd.size);
      +
      9290  }
      +
      9291  break;
      +
      9292 
      +
      9293  case SECOND_VECTOR_DOUBLE_STACK:
      +
      9294  /*
      +
      9295  Available space is only between end of 1st and top of 2nd.
      +
      9296  */
      +
      9297  {
      +
      9298  const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
      +
      9299  const VmaSuballocation& topSuballoc2nd = suballocations2nd.back();
      +
      9300  const VmaSuballocation& lastSuballoc1st = suballocations1st.back();
      +
      9301  return topSuballoc2nd.offset - (lastSuballoc1st.offset + lastSuballoc1st.size);
      +
      9302  }
      +
      9303  break;
      +
      9304 
      +
      9305  default:
      +
      9306  VMA_ASSERT(0);
      +
      9307  return 0;
      +
      9308  }
      +
      9309 }
      +
      9310 
      +
      9311 void VmaBlockMetadata_Linear::CalcAllocationStatInfo(VmaStatInfo& outInfo) const
      +
      9312 {
      +
      9313  const VkDeviceSize size = GetSize();
      +
      9314  const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
      +
      9315  const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
      +
      9316  const size_t suballoc1stCount = suballocations1st.size();
      +
      9317  const size_t suballoc2ndCount = suballocations2nd.size();
      +
      9318 
      +
      9319  outInfo.blockCount = 1;
      +
      9320  outInfo.allocationCount = (uint32_t)GetAllocationCount();
      +
      9321  outInfo.unusedRangeCount = 0;
      +
      9322  outInfo.usedBytes = 0;
      +
      9323  outInfo.allocationSizeMin = UINT64_MAX;
      +
      9324  outInfo.allocationSizeMax = 0;
      +
      9325  outInfo.unusedRangeSizeMin = UINT64_MAX;
      +
      9326  outInfo.unusedRangeSizeMax = 0;
      9327 
      -
      9328  // End of loop.
      -
      9329  lastOffset = freeSpace2ndTo1stEnd;
      -
      9330  }
      -
      9331  }
      -
      9332  }
      -
      9333 
      -
      9334  size_t nextAlloc1stIndex = m_1stNullItemsBeginCount;
      -
      9335  const VkDeviceSize freeSpace1stTo2ndEnd =
      -
      9336  m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ? suballocations2nd.back().offset : size;
      -
      9337  while(lastOffset < freeSpace1stTo2ndEnd)
      -
      9338  {
      -
      9339  // Find next non-null allocation or move nextAllocIndex to the end.
      -
      9340  while(nextAlloc1stIndex < suballoc1stCount &&
      -
      9341  suballocations1st[nextAlloc1stIndex].hAllocation == VK_NULL_HANDLE)
      -
      9342  {
      -
      9343  ++nextAlloc1stIndex;
      -
      9344  }
      -
      9345 
      -
      9346  // Found non-null allocation.
      -
      9347  if(nextAlloc1stIndex < suballoc1stCount)
      -
      9348  {
      -
      9349  const VmaSuballocation& suballoc = suballocations1st[nextAlloc1stIndex];
      -
      9350 
      -
      9351  // 1. Process free space before this allocation.
      -
      9352  if(lastOffset < suballoc.offset)
      -
      9353  {
      -
      9354  // There is free space from lastOffset to suballoc.offset.
      -
      9355  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
      -
      9356  ++outInfo.unusedRangeCount;
      -
      9357  outInfo.unusedBytes += unusedRangeSize;
      -
      9358  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
      -
      9359  outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
      -
      9360  }
      -
      9361 
      -
      9362  // 2. Process this allocation.
      -
      9363  // There is allocation with suballoc.offset, suballoc.size.
      -
      9364  outInfo.usedBytes += suballoc.size;
      -
      9365  outInfo.allocationSizeMin = VMA_MIN(outInfo.allocationSizeMin, suballoc.size);
      -
      9366  outInfo.allocationSizeMax = VMA_MIN(outInfo.allocationSizeMax, suballoc.size);
      -
      9367 
      -
      9368  // 3. Prepare for next iteration.
      -
      9369  lastOffset = suballoc.offset + suballoc.size;
      -
      9370  ++nextAlloc1stIndex;
      -
      9371  }
      -
      9372  // We are at the end.
      -
      9373  else
      -
      9374  {
      -
      9375  // There is free space from lastOffset to freeSpace1stTo2ndEnd.
      -
      9376  if(lastOffset < freeSpace1stTo2ndEnd)
      -
      9377  {
      -
      9378  const VkDeviceSize unusedRangeSize = freeSpace1stTo2ndEnd - lastOffset;
      -
      9379  ++outInfo.unusedRangeCount;
      -
      9380  outInfo.unusedBytes += unusedRangeSize;
      -
      9381  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
      -
      9382  outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
      -
      9383  }
      -
      9384 
      -
      9385  // End of loop.
      -
      9386  lastOffset = freeSpace1stTo2ndEnd;
      -
      9387  }
      -
      9388  }
      -
      9389 
      -
      9390  if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
      -
      9391  {
      -
      9392  size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
      -
      9393  while(lastOffset < size)
      -
      9394  {
      -
      9395  // Find next non-null allocation or move nextAllocIndex to the end.
      -
      9396  while(nextAlloc2ndIndex != SIZE_MAX &&
      -
      9397  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
      -
      9398  {
      -
      9399  --nextAlloc2ndIndex;
      -
      9400  }
      -
      9401 
      -
      9402  // Found non-null allocation.
      -
      9403  if(nextAlloc2ndIndex != SIZE_MAX)
      -
      9404  {
      -
      9405  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
      -
      9406 
      -
      9407  // 1. Process free space before this allocation.
      -
      9408  if(lastOffset < suballoc.offset)
      -
      9409  {
      -
      9410  // There is free space from lastOffset to suballoc.offset.
      -
      9411  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
      -
      9412  ++outInfo.unusedRangeCount;
      -
      9413  outInfo.unusedBytes += unusedRangeSize;
      -
      9414  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
      -
      9415  outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
      -
      9416  }
      -
      9417 
      -
      9418  // 2. Process this allocation.
      -
      9419  // There is allocation with suballoc.offset, suballoc.size.
      -
      9420  outInfo.usedBytes += suballoc.size;
      -
      9421  outInfo.allocationSizeMin = VMA_MIN(outInfo.allocationSizeMin, suballoc.size);
      -
      9422  outInfo.allocationSizeMax = VMA_MIN(outInfo.allocationSizeMax, suballoc.size);
      -
      9423 
      -
      9424  // 3. Prepare for next iteration.
      -
      9425  lastOffset = suballoc.offset + suballoc.size;
      -
      9426  --nextAlloc2ndIndex;
      -
      9427  }
      -
      9428  // We are at the end.
      -
      9429  else
      -
      9430  {
      -
      9431  // There is free space from lastOffset to size.
      -
      9432  if(lastOffset < size)
      -
      9433  {
      -
      9434  const VkDeviceSize unusedRangeSize = size - lastOffset;
      -
      9435  ++outInfo.unusedRangeCount;
      -
      9436  outInfo.unusedBytes += unusedRangeSize;
      -
      9437  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
      -
      9438  outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
      -
      9439  }
      -
      9440 
      -
      9441  // End of loop.
      -
      9442  lastOffset = size;
      -
      9443  }
      -
      9444  }
      -
      9445  }
      -
      9446 
      -
      9447  outInfo.unusedBytes = size - outInfo.usedBytes;
      -
      9448 }
      -
      9449 
      -
      9450 void VmaBlockMetadata_Linear::AddPoolStats(VmaPoolStats& inoutStats) const
      -
      9451 {
      -
      9452  const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
      -
      9453  const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
      -
      9454  const VkDeviceSize size = GetSize();
      -
      9455  const size_t suballoc1stCount = suballocations1st.size();
      -
      9456  const size_t suballoc2ndCount = suballocations2nd.size();
      -
      9457 
      -
      9458  inoutStats.size += size;
      -
      9459 
      -
      9460  VkDeviceSize lastOffset = 0;
      -
      9461 
      -
      9462  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
      -
      9463  {
      -
      9464  const VkDeviceSize freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
      -
      9465  size_t nextAlloc2ndIndex = m_1stNullItemsBeginCount;
      -
      9466  while(lastOffset < freeSpace2ndTo1stEnd)
      -
      9467  {
      -
      9468  // Find next non-null allocation or move nextAlloc2ndIndex to the end.
      -
      9469  while(nextAlloc2ndIndex < suballoc2ndCount &&
      -
      9470  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
      -
      9471  {
      -
      9472  ++nextAlloc2ndIndex;
      -
      9473  }
      -
      9474 
      -
      9475  // Found non-null allocation.
      -
      9476  if(nextAlloc2ndIndex < suballoc2ndCount)
      -
      9477  {
      -
      9478  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
      -
      9479 
      -
      9480  // 1. Process free space before this allocation.
      -
      9481  if(lastOffset < suballoc.offset)
      -
      9482  {
      -
      9483  // There is free space from lastOffset to suballoc.offset.
      -
      9484  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
      -
      9485  inoutStats.unusedSize += unusedRangeSize;
      -
      9486  ++inoutStats.unusedRangeCount;
      -
      9487  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
      -
      9488  }
      -
      9489 
      -
      9490  // 2. Process this allocation.
      -
      9491  // There is allocation with suballoc.offset, suballoc.size.
      -
      9492  ++inoutStats.allocationCount;
      -
      9493 
      -
      9494  // 3. Prepare for next iteration.
      -
      9495  lastOffset = suballoc.offset + suballoc.size;
      -
      9496  ++nextAlloc2ndIndex;
      +
      9328  VkDeviceSize lastOffset = 0;
      +
      9329 
      +
      9330  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
      +
      9331  {
      +
      9332  const VkDeviceSize freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
      +
      9333  size_t nextAlloc2ndIndex = 0;
      +
      9334  while(lastOffset < freeSpace2ndTo1stEnd)
      +
      9335  {
      +
      9336  // Find next non-null allocation or move nextAllocIndex to the end.
      +
      9337  while(nextAlloc2ndIndex < suballoc2ndCount &&
      +
      9338  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
      +
      9339  {
      +
      9340  ++nextAlloc2ndIndex;
      +
      9341  }
      +
      9342 
      +
      9343  // Found non-null allocation.
      +
      9344  if(nextAlloc2ndIndex < suballoc2ndCount)
      +
      9345  {
      +
      9346  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
      +
      9347 
      +
      9348  // 1. Process free space before this allocation.
      +
      9349  if(lastOffset < suballoc.offset)
      +
      9350  {
      +
      9351  // There is free space from lastOffset to suballoc.offset.
      +
      9352  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
      +
      9353  ++outInfo.unusedRangeCount;
      +
      9354  outInfo.unusedBytes += unusedRangeSize;
      +
      9355  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
      +
      9356  outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
      +
      9357  }
      +
      9358 
      +
      9359  // 2. Process this allocation.
      +
      9360  // There is allocation with suballoc.offset, suballoc.size.
      +
      9361  outInfo.usedBytes += suballoc.size;
      +
      9362  outInfo.allocationSizeMin = VMA_MIN(outInfo.allocationSizeMin, suballoc.size);
      +
      9363  outInfo.allocationSizeMax = VMA_MIN(outInfo.allocationSizeMax, suballoc.size);
      +
      9364 
      +
      9365  // 3. Prepare for next iteration.
      +
      9366  lastOffset = suballoc.offset + suballoc.size;
      +
      9367  ++nextAlloc2ndIndex;
      +
      9368  }
      +
      9369  // We are at the end.
      +
      9370  else
      +
      9371  {
      +
      9372  // There is free space from lastOffset to freeSpace2ndTo1stEnd.
      +
      9373  if(lastOffset < freeSpace2ndTo1stEnd)
      +
      9374  {
      +
      9375  const VkDeviceSize unusedRangeSize = freeSpace2ndTo1stEnd - lastOffset;
      +
      9376  ++outInfo.unusedRangeCount;
      +
      9377  outInfo.unusedBytes += unusedRangeSize;
      +
      9378  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
      +
      9379  outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
      +
      9380  }
      +
      9381 
      +
      9382  // End of loop.
      +
      9383  lastOffset = freeSpace2ndTo1stEnd;
      +
      9384  }
      +
      9385  }
      +
      9386  }
      +
      9387 
      +
      9388  size_t nextAlloc1stIndex = m_1stNullItemsBeginCount;
      +
      9389  const VkDeviceSize freeSpace1stTo2ndEnd =
      +
      9390  m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ? suballocations2nd.back().offset : size;
      +
      9391  while(lastOffset < freeSpace1stTo2ndEnd)
      +
      9392  {
      +
      9393  // Find next non-null allocation or move nextAllocIndex to the end.
      +
      9394  while(nextAlloc1stIndex < suballoc1stCount &&
      +
      9395  suballocations1st[nextAlloc1stIndex].hAllocation == VK_NULL_HANDLE)
      +
      9396  {
      +
      9397  ++nextAlloc1stIndex;
      +
      9398  }
      +
      9399 
      +
      9400  // Found non-null allocation.
      +
      9401  if(nextAlloc1stIndex < suballoc1stCount)
      +
      9402  {
      +
      9403  const VmaSuballocation& suballoc = suballocations1st[nextAlloc1stIndex];
      +
      9404 
      +
      9405  // 1. Process free space before this allocation.
      +
      9406  if(lastOffset < suballoc.offset)
      +
      9407  {
      +
      9408  // There is free space from lastOffset to suballoc.offset.
      +
      9409  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
      +
      9410  ++outInfo.unusedRangeCount;
      +
      9411  outInfo.unusedBytes += unusedRangeSize;
      +
      9412  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
      +
      9413  outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
      +
      9414  }
      +
      9415 
      +
      9416  // 2. Process this allocation.
      +
      9417  // There is allocation with suballoc.offset, suballoc.size.
      +
      9418  outInfo.usedBytes += suballoc.size;
      +
      9419  outInfo.allocationSizeMin = VMA_MIN(outInfo.allocationSizeMin, suballoc.size);
      +
      9420  outInfo.allocationSizeMax = VMA_MIN(outInfo.allocationSizeMax, suballoc.size);
      +
      9421 
      +
      9422  // 3. Prepare for next iteration.
      +
      9423  lastOffset = suballoc.offset + suballoc.size;
      +
      9424  ++nextAlloc1stIndex;
      +
      9425  }
      +
      9426  // We are at the end.
      +
      9427  else
      +
      9428  {
      +
      9429  // There is free space from lastOffset to freeSpace1stTo2ndEnd.
      +
      9430  if(lastOffset < freeSpace1stTo2ndEnd)
      +
      9431  {
      +
      9432  const VkDeviceSize unusedRangeSize = freeSpace1stTo2ndEnd - lastOffset;
      +
      9433  ++outInfo.unusedRangeCount;
      +
      9434  outInfo.unusedBytes += unusedRangeSize;
      +
      9435  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
      +
      9436  outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
      +
      9437  }
      +
      9438 
      +
      9439  // End of loop.
      +
      9440  lastOffset = freeSpace1stTo2ndEnd;
      +
      9441  }
      +
      9442  }
      +
      9443 
      +
      9444  if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
      +
      9445  {
      +
      9446  size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
      +
      9447  while(lastOffset < size)
      +
      9448  {
      +
      9449  // Find next non-null allocation or move nextAllocIndex to the end.
      +
      9450  while(nextAlloc2ndIndex != SIZE_MAX &&
      +
      9451  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
      +
      9452  {
      +
      9453  --nextAlloc2ndIndex;
      +
      9454  }
      +
      9455 
      +
      9456  // Found non-null allocation.
      +
      9457  if(nextAlloc2ndIndex != SIZE_MAX)
      +
      9458  {
      +
      9459  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
      +
      9460 
      +
      9461  // 1. Process free space before this allocation.
      +
      9462  if(lastOffset < suballoc.offset)
      +
      9463  {
      +
      9464  // There is free space from lastOffset to suballoc.offset.
      +
      9465  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
      +
      9466  ++outInfo.unusedRangeCount;
      +
      9467  outInfo.unusedBytes += unusedRangeSize;
      +
      9468  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
      +
      9469  outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
      +
      9470  }
      +
      9471 
      +
      9472  // 2. Process this allocation.
      +
      9473  // There is allocation with suballoc.offset, suballoc.size.
      +
      9474  outInfo.usedBytes += suballoc.size;
      +
      9475  outInfo.allocationSizeMin = VMA_MIN(outInfo.allocationSizeMin, suballoc.size);
      +
      9476  outInfo.allocationSizeMax = VMA_MIN(outInfo.allocationSizeMax, suballoc.size);
      +
      9477 
      +
      9478  // 3. Prepare for next iteration.
      +
      9479  lastOffset = suballoc.offset + suballoc.size;
      +
      9480  --nextAlloc2ndIndex;
      +
      9481  }
      +
      9482  // We are at the end.
      +
      9483  else
      +
      9484  {
      +
      9485  // There is free space from lastOffset to size.
      +
      9486  if(lastOffset < size)
      +
      9487  {
      +
      9488  const VkDeviceSize unusedRangeSize = size - lastOffset;
      +
      9489  ++outInfo.unusedRangeCount;
      +
      9490  outInfo.unusedBytes += unusedRangeSize;
      +
      9491  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusedRangeSize);
      +
      9492  outInfo.unusedRangeSizeMax = VMA_MIN(outInfo.unusedRangeSizeMax, unusedRangeSize);
      +
      9493  }
      +
      9494 
      +
      9495  // End of loop.
      +
      9496  lastOffset = size;
      9497  }
      -
      9498  // We are at the end.
      -
      9499  else
      -
      9500  {
      -
      9501  if(lastOffset < freeSpace2ndTo1stEnd)
      -
      9502  {
      -
      9503  // There is free space from lastOffset to freeSpace2ndTo1stEnd.
      -
      9504  const VkDeviceSize unusedRangeSize = freeSpace2ndTo1stEnd - lastOffset;
      -
      9505  inoutStats.unusedSize += unusedRangeSize;
      -
      9506  ++inoutStats.unusedRangeCount;
      -
      9507  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
      -
      9508  }
      -
      9509 
      -
      9510  // End of loop.
      -
      9511  lastOffset = freeSpace2ndTo1stEnd;
      -
      9512  }
      -
      9513  }
      -
      9514  }
      +
      9498  }
      +
      9499  }
      +
      9500 
      +
      9501  outInfo.unusedBytes = size - outInfo.usedBytes;
      +
      9502 }
      +
      9503 
      +
      9504 void VmaBlockMetadata_Linear::AddPoolStats(VmaPoolStats& inoutStats) const
      +
      9505 {
      +
      9506  const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
      +
      9507  const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
      +
      9508  const VkDeviceSize size = GetSize();
      +
      9509  const size_t suballoc1stCount = suballocations1st.size();
      +
      9510  const size_t suballoc2ndCount = suballocations2nd.size();
      +
      9511 
      +
      9512  inoutStats.size += size;
      +
      9513 
      +
      9514  VkDeviceSize lastOffset = 0;
      9515 
      -
      9516  size_t nextAlloc1stIndex = m_1stNullItemsBeginCount;
      -
      9517  const VkDeviceSize freeSpace1stTo2ndEnd =
      -
      9518  m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ? suballocations2nd.back().offset : size;
      -
      9519  while(lastOffset < freeSpace1stTo2ndEnd)
      -
      9520  {
      -
      9521  // Find next non-null allocation or move nextAllocIndex to the end.
      -
      9522  while(nextAlloc1stIndex < suballoc1stCount &&
      -
      9523  suballocations1st[nextAlloc1stIndex].hAllocation == VK_NULL_HANDLE)
      -
      9524  {
      -
      9525  ++nextAlloc1stIndex;
      -
      9526  }
      -
      9527 
      -
      9528  // Found non-null allocation.
      -
      9529  if(nextAlloc1stIndex < suballoc1stCount)
      -
      9530  {
      -
      9531  const VmaSuballocation& suballoc = suballocations1st[nextAlloc1stIndex];
      -
      9532 
      -
      9533  // 1. Process free space before this allocation.
      -
      9534  if(lastOffset < suballoc.offset)
      -
      9535  {
      -
      9536  // There is free space from lastOffset to suballoc.offset.
      -
      9537  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
      -
      9538  inoutStats.unusedSize += unusedRangeSize;
      -
      9539  ++inoutStats.unusedRangeCount;
      -
      9540  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
      -
      9541  }
      -
      9542 
      -
      9543  // 2. Process this allocation.
      -
      9544  // There is allocation with suballoc.offset, suballoc.size.
      -
      9545  ++inoutStats.allocationCount;
      -
      9546 
      -
      9547  // 3. Prepare for next iteration.
      -
      9548  lastOffset = suballoc.offset + suballoc.size;
      -
      9549  ++nextAlloc1stIndex;
      -
      9550  }
      -
      9551  // We are at the end.
      -
      9552  else
      -
      9553  {
      -
      9554  if(lastOffset < freeSpace1stTo2ndEnd)
      -
      9555  {
      -
      9556  // There is free space from lastOffset to freeSpace1stTo2ndEnd.
      -
      9557  const VkDeviceSize unusedRangeSize = freeSpace1stTo2ndEnd - lastOffset;
      -
      9558  inoutStats.unusedSize += unusedRangeSize;
      -
      9559  ++inoutStats.unusedRangeCount;
      -
      9560  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
      -
      9561  }
      -
      9562 
      -
      9563  // End of loop.
      -
      9564  lastOffset = freeSpace1stTo2ndEnd;
      -
      9565  }
      -
      9566  }
      -
      9567 
      -
      9568  if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
      -
      9569  {
      -
      9570  size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
      -
      9571  while(lastOffset < size)
      -
      9572  {
      -
      9573  // Find next non-null allocation or move nextAlloc2ndIndex to the end.
      -
      9574  while(nextAlloc2ndIndex != SIZE_MAX &&
      -
      9575  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
      -
      9576  {
      -
      9577  --nextAlloc2ndIndex;
      -
      9578  }
      -
      9579 
      -
      9580  // Found non-null allocation.
      -
      9581  if(nextAlloc2ndIndex != SIZE_MAX)
      -
      9582  {
      -
      9583  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
      -
      9584 
      -
      9585  // 1. Process free space before this allocation.
      -
      9586  if(lastOffset < suballoc.offset)
      -
      9587  {
      -
      9588  // There is free space from lastOffset to suballoc.offset.
      -
      9589  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
      -
      9590  inoutStats.unusedSize += unusedRangeSize;
      -
      9591  ++inoutStats.unusedRangeCount;
      -
      9592  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
      -
      9593  }
      -
      9594 
      -
      9595  // 2. Process this allocation.
      -
      9596  // There is allocation with suballoc.offset, suballoc.size.
      -
      9597  ++inoutStats.allocationCount;
      -
      9598 
      -
      9599  // 3. Prepare for next iteration.
      -
      9600  lastOffset = suballoc.offset + suballoc.size;
      -
      9601  --nextAlloc2ndIndex;
      -
      9602  }
      -
      9603  // We are at the end.
      -
      9604  else
      -
      9605  {
      -
      9606  if(lastOffset < size)
      -
      9607  {
      -
      9608  // There is free space from lastOffset to size.
      -
      9609  const VkDeviceSize unusedRangeSize = size - lastOffset;
      -
      9610  inoutStats.unusedSize += unusedRangeSize;
      -
      9611  ++inoutStats.unusedRangeCount;
      -
      9612  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
      -
      9613  }
      -
      9614 
      -
      9615  // End of loop.
      -
      9616  lastOffset = size;
      -
      9617  }
      -
      9618  }
      -
      9619  }
      -
      9620 }
      +
      9516  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
      +
      9517  {
      +
      9518  const VkDeviceSize freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
      +
      9519  size_t nextAlloc2ndIndex = m_1stNullItemsBeginCount;
      +
      9520  while(lastOffset < freeSpace2ndTo1stEnd)
      +
      9521  {
      +
      9522  // Find next non-null allocation or move nextAlloc2ndIndex to the end.
      +
      9523  while(nextAlloc2ndIndex < suballoc2ndCount &&
      +
      9524  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
      +
      9525  {
      +
      9526  ++nextAlloc2ndIndex;
      +
      9527  }
      +
      9528 
      +
      9529  // Found non-null allocation.
      +
      9530  if(nextAlloc2ndIndex < suballoc2ndCount)
      +
      9531  {
      +
      9532  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
      +
      9533 
      +
      9534  // 1. Process free space before this allocation.
      +
      9535  if(lastOffset < suballoc.offset)
      +
      9536  {
      +
      9537  // There is free space from lastOffset to suballoc.offset.
      +
      9538  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
      +
      9539  inoutStats.unusedSize += unusedRangeSize;
      +
      9540  ++inoutStats.unusedRangeCount;
      +
      9541  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
      +
      9542  }
      +
      9543 
      +
      9544  // 2. Process this allocation.
      +
      9545  // There is allocation with suballoc.offset, suballoc.size.
      +
      9546  ++inoutStats.allocationCount;
      +
      9547 
      +
      9548  // 3. Prepare for next iteration.
      +
      9549  lastOffset = suballoc.offset + suballoc.size;
      +
      9550  ++nextAlloc2ndIndex;
      +
      9551  }
      +
      9552  // We are at the end.
      +
      9553  else
      +
      9554  {
      +
      9555  if(lastOffset < freeSpace2ndTo1stEnd)
      +
      9556  {
      +
      9557  // There is free space from lastOffset to freeSpace2ndTo1stEnd.
      +
      9558  const VkDeviceSize unusedRangeSize = freeSpace2ndTo1stEnd - lastOffset;
      +
      9559  inoutStats.unusedSize += unusedRangeSize;
      +
      9560  ++inoutStats.unusedRangeCount;
      +
      9561  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
      +
      9562  }
      +
      9563 
      +
      9564  // End of loop.
      +
      9565  lastOffset = freeSpace2ndTo1stEnd;
      +
      9566  }
      +
      9567  }
      +
      9568  }
      +
      9569 
      +
      9570  size_t nextAlloc1stIndex = m_1stNullItemsBeginCount;
      +
      9571  const VkDeviceSize freeSpace1stTo2ndEnd =
      +
      9572  m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ? suballocations2nd.back().offset : size;
      +
      9573  while(lastOffset < freeSpace1stTo2ndEnd)
      +
      9574  {
      +
      9575  // Find next non-null allocation or move nextAllocIndex to the end.
      +
      9576  while(nextAlloc1stIndex < suballoc1stCount &&
      +
      9577  suballocations1st[nextAlloc1stIndex].hAllocation == VK_NULL_HANDLE)
      +
      9578  {
      +
      9579  ++nextAlloc1stIndex;
      +
      9580  }
      +
      9581 
      +
      9582  // Found non-null allocation.
      +
      9583  if(nextAlloc1stIndex < suballoc1stCount)
      +
      9584  {
      +
      9585  const VmaSuballocation& suballoc = suballocations1st[nextAlloc1stIndex];
      +
      9586 
      +
      9587  // 1. Process free space before this allocation.
      +
      9588  if(lastOffset < suballoc.offset)
      +
      9589  {
      +
      9590  // There is free space from lastOffset to suballoc.offset.
      +
      9591  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
      +
      9592  inoutStats.unusedSize += unusedRangeSize;
      +
      9593  ++inoutStats.unusedRangeCount;
      +
      9594  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
      +
      9595  }
      +
      9596 
      +
      9597  // 2. Process this allocation.
      +
      9598  // There is allocation with suballoc.offset, suballoc.size.
      +
      9599  ++inoutStats.allocationCount;
      +
      9600 
      +
      9601  // 3. Prepare for next iteration.
      +
      9602  lastOffset = suballoc.offset + suballoc.size;
      +
      9603  ++nextAlloc1stIndex;
      +
      9604  }
      +
      9605  // We are at the end.
      +
      9606  else
      +
      9607  {
      +
      9608  if(lastOffset < freeSpace1stTo2ndEnd)
      +
      9609  {
      +
      9610  // There is free space from lastOffset to freeSpace1stTo2ndEnd.
      +
      9611  const VkDeviceSize unusedRangeSize = freeSpace1stTo2ndEnd - lastOffset;
      +
      9612  inoutStats.unusedSize += unusedRangeSize;
      +
      9613  ++inoutStats.unusedRangeCount;
      +
      9614  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
      +
      9615  }
      +
      9616 
      +
      9617  // End of loop.
      +
      9618  lastOffset = freeSpace1stTo2ndEnd;
      +
      9619  }
      +
      9620  }
      9621 
      -
      9622 #if VMA_STATS_STRING_ENABLED
      -
      9623 void VmaBlockMetadata_Linear::PrintDetailedMap(class VmaJsonWriter& json) const
      -
      9624 {
      -
      9625  const VkDeviceSize size = GetSize();
      -
      9626  const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
      -
      9627  const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
      -
      9628  const size_t suballoc1stCount = suballocations1st.size();
      -
      9629  const size_t suballoc2ndCount = suballocations2nd.size();
      -
      9630 
      -
      9631  // FIRST PASS
      -
      9632 
      -
      9633  size_t unusedRangeCount = 0;
      -
      9634  VkDeviceSize usedBytes = 0;
      -
      9635 
      -
      9636  VkDeviceSize lastOffset = 0;
      -
      9637 
      -
      9638  size_t alloc2ndCount = 0;
      -
      9639  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
      -
      9640  {
      -
      9641  const VkDeviceSize freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
      -
      9642  size_t nextAlloc2ndIndex = 0;
      -
      9643  while(lastOffset < freeSpace2ndTo1stEnd)
      -
      9644  {
      -
      9645  // Find next non-null allocation or move nextAlloc2ndIndex to the end.
      -
      9646  while(nextAlloc2ndIndex < suballoc2ndCount &&
      -
      9647  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
      -
      9648  {
      -
      9649  ++nextAlloc2ndIndex;
      -
      9650  }
      -
      9651 
      -
      9652  // Found non-null allocation.
      -
      9653  if(nextAlloc2ndIndex < suballoc2ndCount)
      -
      9654  {
      -
      9655  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
      -
      9656 
      -
      9657  // 1. Process free space before this allocation.
      -
      9658  if(lastOffset < suballoc.offset)
      -
      9659  {
      -
      9660  // There is free space from lastOffset to suballoc.offset.
      -
      9661  ++unusedRangeCount;
      -
      9662  }
      -
      9663 
      -
      9664  // 2. Process this allocation.
      -
      9665  // There is allocation with suballoc.offset, suballoc.size.
      -
      9666  ++alloc2ndCount;
      -
      9667  usedBytes += suballoc.size;
      -
      9668 
      -
      9669  // 3. Prepare for next iteration.
      -
      9670  lastOffset = suballoc.offset + suballoc.size;
      -
      9671  ++nextAlloc2ndIndex;
      -
      9672  }
      -
      9673  // We are at the end.
      -
      9674  else
      -
      9675  {
      -
      9676  if(lastOffset < freeSpace2ndTo1stEnd)
      -
      9677  {
      -
      9678  // There is free space from lastOffset to freeSpace2ndTo1stEnd.
      -
      9679  ++unusedRangeCount;
      -
      9680  }
      -
      9681 
      -
      9682  // End of loop.
      -
      9683  lastOffset = freeSpace2ndTo1stEnd;
      -
      9684  }
      -
      9685  }
      -
      9686  }
      -
      9687 
      -
      9688  size_t nextAlloc1stIndex = m_1stNullItemsBeginCount;
      -
      9689  size_t alloc1stCount = 0;
      -
      9690  const VkDeviceSize freeSpace1stTo2ndEnd =
      -
      9691  m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ? suballocations2nd.back().offset : size;
      -
      9692  while(lastOffset < freeSpace1stTo2ndEnd)
      -
      9693  {
      -
      9694  // Find next non-null allocation or move nextAllocIndex to the end.
      -
      9695  while(nextAlloc1stIndex < suballoc1stCount &&
      -
      9696  suballocations1st[nextAlloc1stIndex].hAllocation == VK_NULL_HANDLE)
      -
      9697  {
      -
      9698  ++nextAlloc1stIndex;
      -
      9699  }
      -
      9700 
      -
      9701  // Found non-null allocation.
      -
      9702  if(nextAlloc1stIndex < suballoc1stCount)
      -
      9703  {
      -
      9704  const VmaSuballocation& suballoc = suballocations1st[nextAlloc1stIndex];
      -
      9705 
      -
      9706  // 1. Process free space before this allocation.
      -
      9707  if(lastOffset < suballoc.offset)
      +
      9622  if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
      +
      9623  {
      +
      9624  size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
      +
      9625  while(lastOffset < size)
      +
      9626  {
      +
      9627  // Find next non-null allocation or move nextAlloc2ndIndex to the end.
      +
      9628  while(nextAlloc2ndIndex != SIZE_MAX &&
      +
      9629  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
      +
      9630  {
      +
      9631  --nextAlloc2ndIndex;
      +
      9632  }
      +
      9633 
      +
      9634  // Found non-null allocation.
      +
      9635  if(nextAlloc2ndIndex != SIZE_MAX)
      +
      9636  {
      +
      9637  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
      +
      9638 
      +
      9639  // 1. Process free space before this allocation.
      +
      9640  if(lastOffset < suballoc.offset)
      +
      9641  {
      +
      9642  // There is free space from lastOffset to suballoc.offset.
      +
      9643  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
      +
      9644  inoutStats.unusedSize += unusedRangeSize;
      +
      9645  ++inoutStats.unusedRangeCount;
      +
      9646  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
      +
      9647  }
      +
      9648 
      +
      9649  // 2. Process this allocation.
      +
      9650  // There is allocation with suballoc.offset, suballoc.size.
      +
      9651  ++inoutStats.allocationCount;
      +
      9652 
      +
      9653  // 3. Prepare for next iteration.
      +
      9654  lastOffset = suballoc.offset + suballoc.size;
      +
      9655  --nextAlloc2ndIndex;
      +
      9656  }
      +
      9657  // We are at the end.
      +
      9658  else
      +
      9659  {
      +
      9660  if(lastOffset < size)
      +
      9661  {
      +
      9662  // There is free space from lastOffset to size.
      +
      9663  const VkDeviceSize unusedRangeSize = size - lastOffset;
      +
      9664  inoutStats.unusedSize += unusedRangeSize;
      +
      9665  ++inoutStats.unusedRangeCount;
      +
      9666  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, unusedRangeSize);
      +
      9667  }
      +
      9668 
      +
      9669  // End of loop.
      +
      9670  lastOffset = size;
      +
      9671  }
      +
      9672  }
      +
      9673  }
      +
      9674 }
      +
      9675 
      +
      9676 #if VMA_STATS_STRING_ENABLED
      +
      9677 void VmaBlockMetadata_Linear::PrintDetailedMap(class VmaJsonWriter& json) const
      +
      9678 {
      +
      9679  const VkDeviceSize size = GetSize();
      +
      9680  const SuballocationVectorType& suballocations1st = AccessSuballocations1st();
      +
      9681  const SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
      +
      9682  const size_t suballoc1stCount = suballocations1st.size();
      +
      9683  const size_t suballoc2ndCount = suballocations2nd.size();
      +
      9684 
      +
      9685  // FIRST PASS
      +
      9686 
      +
      9687  size_t unusedRangeCount = 0;
      +
      9688  VkDeviceSize usedBytes = 0;
      +
      9689 
      +
      9690  VkDeviceSize lastOffset = 0;
      +
      9691 
      +
      9692  size_t alloc2ndCount = 0;
      +
      9693  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
      +
      9694  {
      +
      9695  const VkDeviceSize freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
      +
      9696  size_t nextAlloc2ndIndex = 0;
      +
      9697  while(lastOffset < freeSpace2ndTo1stEnd)
      +
      9698  {
      +
      9699  // Find next non-null allocation or move nextAlloc2ndIndex to the end.
      +
      9700  while(nextAlloc2ndIndex < suballoc2ndCount &&
      +
      9701  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
      +
      9702  {
      +
      9703  ++nextAlloc2ndIndex;
      +
      9704  }
      +
      9705 
      +
      9706  // Found non-null allocation.
      +
      9707  if(nextAlloc2ndIndex < suballoc2ndCount)
      9708  {
      -
      9709  // There is free space from lastOffset to suballoc.offset.
      -
      9710  ++unusedRangeCount;
      -
      9711  }
      -
      9712 
      -
      9713  // 2. Process this allocation.
      -
      9714  // There is allocation with suballoc.offset, suballoc.size.
      -
      9715  ++alloc1stCount;
      -
      9716  usedBytes += suballoc.size;
      +
      9709  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
      +
      9710 
      +
      9711  // 1. Process free space before this allocation.
      +
      9712  if(lastOffset < suballoc.offset)
      +
      9713  {
      +
      9714  // There is free space from lastOffset to suballoc.offset.
      +
      9715  ++unusedRangeCount;
      +
      9716  }
      9717 
      -
      9718  // 3. Prepare for next iteration.
      -
      9719  lastOffset = suballoc.offset + suballoc.size;
      -
      9720  ++nextAlloc1stIndex;
      -
      9721  }
      -
      9722  // We are at the end.
      -
      9723  else
      -
      9724  {
      -
      9725  if(lastOffset < size)
      -
      9726  {
      -
      9727  // There is free space from lastOffset to freeSpace1stTo2ndEnd.
      -
      9728  ++unusedRangeCount;
      -
      9729  }
      -
      9730 
      -
      9731  // End of loop.
      -
      9732  lastOffset = freeSpace1stTo2ndEnd;
      -
      9733  }
      -
      9734  }
      +
      9718  // 2. Process this allocation.
      +
      9719  // There is allocation with suballoc.offset, suballoc.size.
      +
      9720  ++alloc2ndCount;
      +
      9721  usedBytes += suballoc.size;
      +
      9722 
      +
      9723  // 3. Prepare for next iteration.
      +
      9724  lastOffset = suballoc.offset + suballoc.size;
      +
      9725  ++nextAlloc2ndIndex;
      +
      9726  }
      +
      9727  // We are at the end.
      +
      9728  else
      +
      9729  {
      +
      9730  if(lastOffset < freeSpace2ndTo1stEnd)
      +
      9731  {
      +
      9732  // There is free space from lastOffset to freeSpace2ndTo1stEnd.
      +
      9733  ++unusedRangeCount;
      +
      9734  }
      9735 
      -
      9736  if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
      -
      9737  {
      -
      9738  size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
      -
      9739  while(lastOffset < size)
      -
      9740  {
      -
      9741  // Find next non-null allocation or move nextAlloc2ndIndex to the end.
      -
      9742  while(nextAlloc2ndIndex != SIZE_MAX &&
      -
      9743  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
      -
      9744  {
      -
      9745  --nextAlloc2ndIndex;
      -
      9746  }
      -
      9747 
      -
      9748  // Found non-null allocation.
      -
      9749  if(nextAlloc2ndIndex != SIZE_MAX)
      -
      9750  {
      -
      9751  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
      -
      9752 
      -
      9753  // 1. Process free space before this allocation.
      -
      9754  if(lastOffset < suballoc.offset)
      -
      9755  {
      -
      9756  // There is free space from lastOffset to suballoc.offset.
      -
      9757  ++unusedRangeCount;
      -
      9758  }
      +
      9736  // End of loop.
      +
      9737  lastOffset = freeSpace2ndTo1stEnd;
      +
      9738  }
      +
      9739  }
      +
      9740  }
      +
      9741 
      +
      9742  size_t nextAlloc1stIndex = m_1stNullItemsBeginCount;
      +
      9743  size_t alloc1stCount = 0;
      +
      9744  const VkDeviceSize freeSpace1stTo2ndEnd =
      +
      9745  m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ? suballocations2nd.back().offset : size;
      +
      9746  while(lastOffset < freeSpace1stTo2ndEnd)
      +
      9747  {
      +
      9748  // Find next non-null allocation or move nextAllocIndex to the end.
      +
      9749  while(nextAlloc1stIndex < suballoc1stCount &&
      +
      9750  suballocations1st[nextAlloc1stIndex].hAllocation == VK_NULL_HANDLE)
      +
      9751  {
      +
      9752  ++nextAlloc1stIndex;
      +
      9753  }
      +
      9754 
      +
      9755  // Found non-null allocation.
      +
      9756  if(nextAlloc1stIndex < suballoc1stCount)
      +
      9757  {
      +
      9758  const VmaSuballocation& suballoc = suballocations1st[nextAlloc1stIndex];
      9759 
      -
      9760  // 2. Process this allocation.
      -
      9761  // There is allocation with suballoc.offset, suballoc.size.
      -
      9762  ++alloc2ndCount;
      -
      9763  usedBytes += suballoc.size;
      -
      9764 
      -
      9765  // 3. Prepare for next iteration.
      -
      9766  lastOffset = suballoc.offset + suballoc.size;
      -
      9767  --nextAlloc2ndIndex;
      -
      9768  }
      -
      9769  // We are at the end.
      -
      9770  else
      -
      9771  {
      -
      9772  if(lastOffset < size)
      -
      9773  {
      -
      9774  // There is free space from lastOffset to size.
      -
      9775  ++unusedRangeCount;
      -
      9776  }
      -
      9777 
      -
      9778  // End of loop.
      -
      9779  lastOffset = size;
      -
      9780  }
      -
      9781  }
      -
      9782  }
      -
      9783 
      -
      9784  const VkDeviceSize unusedBytes = size - usedBytes;
      -
      9785  PrintDetailedMap_Begin(json, unusedBytes, alloc1stCount + alloc2ndCount, unusedRangeCount);
      -
      9786 
      -
      9787  // SECOND PASS
      -
      9788  lastOffset = 0;
      +
      9760  // 1. Process free space before this allocation.
      +
      9761  if(lastOffset < suballoc.offset)
      +
      9762  {
      +
      9763  // There is free space from lastOffset to suballoc.offset.
      +
      9764  ++unusedRangeCount;
      +
      9765  }
      +
      9766 
      +
      9767  // 2. Process this allocation.
      +
      9768  // There is allocation with suballoc.offset, suballoc.size.
      +
      9769  ++alloc1stCount;
      +
      9770  usedBytes += suballoc.size;
      +
      9771 
      +
      9772  // 3. Prepare for next iteration.
      +
      9773  lastOffset = suballoc.offset + suballoc.size;
      +
      9774  ++nextAlloc1stIndex;
      +
      9775  }
      +
      9776  // We are at the end.
      +
      9777  else
      +
      9778  {
      +
      9779  if(lastOffset < size)
      +
      9780  {
      +
      9781  // There is free space from lastOffset to freeSpace1stTo2ndEnd.
      +
      9782  ++unusedRangeCount;
      +
      9783  }
      +
      9784 
      +
      9785  // End of loop.
      +
      9786  lastOffset = freeSpace1stTo2ndEnd;
      +
      9787  }
      +
      9788  }
      9789 
      -
      9790  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
      +
      9790  if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
      9791  {
      -
      9792  const VkDeviceSize freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
      -
      9793  size_t nextAlloc2ndIndex = 0;
      -
      9794  while(lastOffset < freeSpace2ndTo1stEnd)
      -
      9795  {
      -
      9796  // Find next non-null allocation or move nextAlloc2ndIndex to the end.
      -
      9797  while(nextAlloc2ndIndex < suballoc2ndCount &&
      -
      9798  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
      -
      9799  {
      -
      9800  ++nextAlloc2ndIndex;
      -
      9801  }
      -
      9802 
      -
      9803  // Found non-null allocation.
      -
      9804  if(nextAlloc2ndIndex < suballoc2ndCount)
      -
      9805  {
      -
      9806  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
      -
      9807 
      -
      9808  // 1. Process free space before this allocation.
      -
      9809  if(lastOffset < suballoc.offset)
      -
      9810  {
      -
      9811  // There is free space from lastOffset to suballoc.offset.
      -
      9812  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
      -
      9813  PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
      -
      9814  }
      -
      9815 
      -
      9816  // 2. Process this allocation.
      -
      9817  // There is allocation with suballoc.offset, suballoc.size.
      -
      9818  PrintDetailedMap_Allocation(json, suballoc.offset, suballoc.hAllocation);
      -
      9819 
      -
      9820  // 3. Prepare for next iteration.
      -
      9821  lastOffset = suballoc.offset + suballoc.size;
      -
      9822  ++nextAlloc2ndIndex;
      -
      9823  }
      -
      9824  // We are at the end.
      -
      9825  else
      -
      9826  {
      -
      9827  if(lastOffset < freeSpace2ndTo1stEnd)
      -
      9828  {
      -
      9829  // There is free space from lastOffset to freeSpace2ndTo1stEnd.
      -
      9830  const VkDeviceSize unusedRangeSize = freeSpace2ndTo1stEnd - lastOffset;
      -
      9831  PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
      -
      9832  }
      -
      9833 
      -
      9834  // End of loop.
      -
      9835  lastOffset = freeSpace2ndTo1stEnd;
      -
      9836  }
      -
      9837  }
      -
      9838  }
      -
      9839 
      -
      9840  nextAlloc1stIndex = m_1stNullItemsBeginCount;
      -
      9841  while(lastOffset < freeSpace1stTo2ndEnd)
      -
      9842  {
      -
      9843  // Find next non-null allocation or move nextAllocIndex to the end.
      -
      9844  while(nextAlloc1stIndex < suballoc1stCount &&
      -
      9845  suballocations1st[nextAlloc1stIndex].hAllocation == VK_NULL_HANDLE)
      -
      9846  {
      -
      9847  ++nextAlloc1stIndex;
      -
      9848  }
      -
      9849 
      -
      9850  // Found non-null allocation.
      -
      9851  if(nextAlloc1stIndex < suballoc1stCount)
      -
      9852  {
      -
      9853  const VmaSuballocation& suballoc = suballocations1st[nextAlloc1stIndex];
      -
      9854 
      -
      9855  // 1. Process free space before this allocation.
      -
      9856  if(lastOffset < suballoc.offset)
      -
      9857  {
      -
      9858  // There is free space from lastOffset to suballoc.offset.
      -
      9859  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
      -
      9860  PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
      -
      9861  }
      -
      9862 
      -
      9863  // 2. Process this allocation.
      -
      9864  // There is allocation with suballoc.offset, suballoc.size.
      -
      9865  PrintDetailedMap_Allocation(json, suballoc.offset, suballoc.hAllocation);
      -
      9866 
      -
      9867  // 3. Prepare for next iteration.
      -
      9868  lastOffset = suballoc.offset + suballoc.size;
      -
      9869  ++nextAlloc1stIndex;
      -
      9870  }
      -
      9871  // We are at the end.
      -
      9872  else
      -
      9873  {
      -
      9874  if(lastOffset < freeSpace1stTo2ndEnd)
      -
      9875  {
      -
      9876  // There is free space from lastOffset to freeSpace1stTo2ndEnd.
      -
      9877  const VkDeviceSize unusedRangeSize = freeSpace1stTo2ndEnd - lastOffset;
      -
      9878  PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
      -
      9879  }
      -
      9880 
      -
      9881  // End of loop.
      -
      9882  lastOffset = freeSpace1stTo2ndEnd;
      -
      9883  }
      -
      9884  }
      -
      9885 
      -
      9886  if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
      -
      9887  {
      -
      9888  size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
      -
      9889  while(lastOffset < size)
      -
      9890  {
      -
      9891  // Find next non-null allocation or move nextAlloc2ndIndex to the end.
      -
      9892  while(nextAlloc2ndIndex != SIZE_MAX &&
      -
      9893  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
      -
      9894  {
      -
      9895  --nextAlloc2ndIndex;
      -
      9896  }
      -
      9897 
      -
      9898  // Found non-null allocation.
      -
      9899  if(nextAlloc2ndIndex != SIZE_MAX)
      -
      9900  {
      -
      9901  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
      -
      9902 
      -
      9903  // 1. Process free space before this allocation.
      -
      9904  if(lastOffset < suballoc.offset)
      -
      9905  {
      -
      9906  // There is free space from lastOffset to suballoc.offset.
      -
      9907  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
      -
      9908  PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
      -
      9909  }
      -
      9910 
      -
      9911  // 2. Process this allocation.
      -
      9912  // There is allocation with suballoc.offset, suballoc.size.
      -
      9913  PrintDetailedMap_Allocation(json, suballoc.offset, suballoc.hAllocation);
      -
      9914 
      -
      9915  // 3. Prepare for next iteration.
      -
      9916  lastOffset = suballoc.offset + suballoc.size;
      -
      9917  --nextAlloc2ndIndex;
      -
      9918  }
      -
      9919  // We are at the end.
      -
      9920  else
      -
      9921  {
      -
      9922  if(lastOffset < size)
      -
      9923  {
      -
      9924  // There is free space from lastOffset to size.
      -
      9925  const VkDeviceSize unusedRangeSize = size - lastOffset;
      -
      9926  PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
      -
      9927  }
      -
      9928 
      -
      9929  // End of loop.
      -
      9930  lastOffset = size;
      -
      9931  }
      -
      9932  }
      -
      9933  }
      +
      9792  size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
      +
      9793  while(lastOffset < size)
      +
      9794  {
      +
      9795  // Find next non-null allocation or move nextAlloc2ndIndex to the end.
      +
      9796  while(nextAlloc2ndIndex != SIZE_MAX &&
      +
      9797  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
      +
      9798  {
      +
      9799  --nextAlloc2ndIndex;
      +
      9800  }
      +
      9801 
      +
      9802  // Found non-null allocation.
      +
      9803  if(nextAlloc2ndIndex != SIZE_MAX)
      +
      9804  {
      +
      9805  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
      +
      9806 
      +
      9807  // 1. Process free space before this allocation.
      +
      9808  if(lastOffset < suballoc.offset)
      +
      9809  {
      +
      9810  // There is free space from lastOffset to suballoc.offset.
      +
      9811  ++unusedRangeCount;
      +
      9812  }
      +
      9813 
      +
      9814  // 2. Process this allocation.
      +
      9815  // There is allocation with suballoc.offset, suballoc.size.
      +
      9816  ++alloc2ndCount;
      +
      9817  usedBytes += suballoc.size;
      +
      9818 
      +
      9819  // 3. Prepare for next iteration.
      +
      9820  lastOffset = suballoc.offset + suballoc.size;
      +
      9821  --nextAlloc2ndIndex;
      +
      9822  }
      +
      9823  // We are at the end.
      +
      9824  else
      +
      9825  {
      +
      9826  if(lastOffset < size)
      +
      9827  {
      +
      9828  // There is free space from lastOffset to size.
      +
      9829  ++unusedRangeCount;
      +
      9830  }
      +
      9831 
      +
      9832  // End of loop.
      +
      9833  lastOffset = size;
      +
      9834  }
      +
      9835  }
      +
      9836  }
      +
      9837 
      +
      9838  const VkDeviceSize unusedBytes = size - usedBytes;
      +
      9839  PrintDetailedMap_Begin(json, unusedBytes, alloc1stCount + alloc2ndCount, unusedRangeCount);
      +
      9840 
      +
      9841  // SECOND PASS
      +
      9842  lastOffset = 0;
      +
      9843 
      +
      9844  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
      +
      9845  {
      +
      9846  const VkDeviceSize freeSpace2ndTo1stEnd = suballocations1st[m_1stNullItemsBeginCount].offset;
      +
      9847  size_t nextAlloc2ndIndex = 0;
      +
      9848  while(lastOffset < freeSpace2ndTo1stEnd)
      +
      9849  {
      +
      9850  // Find next non-null allocation or move nextAlloc2ndIndex to the end.
      +
      9851  while(nextAlloc2ndIndex < suballoc2ndCount &&
      +
      9852  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
      +
      9853  {
      +
      9854  ++nextAlloc2ndIndex;
      +
      9855  }
      +
      9856 
      +
      9857  // Found non-null allocation.
      +
      9858  if(nextAlloc2ndIndex < suballoc2ndCount)
      +
      9859  {
      +
      9860  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
      +
      9861 
      +
      9862  // 1. Process free space before this allocation.
      +
      9863  if(lastOffset < suballoc.offset)
      +
      9864  {
      +
      9865  // There is free space from lastOffset to suballoc.offset.
      +
      9866  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
      +
      9867  PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
      +
      9868  }
      +
      9869 
      +
      9870  // 2. Process this allocation.
      +
      9871  // There is allocation with suballoc.offset, suballoc.size.
      +
      9872  PrintDetailedMap_Allocation(json, suballoc.offset, suballoc.hAllocation);
      +
      9873 
      +
      9874  // 3. Prepare for next iteration.
      +
      9875  lastOffset = suballoc.offset + suballoc.size;
      +
      9876  ++nextAlloc2ndIndex;
      +
      9877  }
      +
      9878  // We are at the end.
      +
      9879  else
      +
      9880  {
      +
      9881  if(lastOffset < freeSpace2ndTo1stEnd)
      +
      9882  {
      +
      9883  // There is free space from lastOffset to freeSpace2ndTo1stEnd.
      +
      9884  const VkDeviceSize unusedRangeSize = freeSpace2ndTo1stEnd - lastOffset;
      +
      9885  PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
      +
      9886  }
      +
      9887 
      +
      9888  // End of loop.
      +
      9889  lastOffset = freeSpace2ndTo1stEnd;
      +
      9890  }
      +
      9891  }
      +
      9892  }
      +
      9893 
      +
      9894  nextAlloc1stIndex = m_1stNullItemsBeginCount;
      +
      9895  while(lastOffset < freeSpace1stTo2ndEnd)
      +
      9896  {
      +
      9897  // Find next non-null allocation or move nextAllocIndex to the end.
      +
      9898  while(nextAlloc1stIndex < suballoc1stCount &&
      +
      9899  suballocations1st[nextAlloc1stIndex].hAllocation == VK_NULL_HANDLE)
      +
      9900  {
      +
      9901  ++nextAlloc1stIndex;
      +
      9902  }
      +
      9903 
      +
      9904  // Found non-null allocation.
      +
      9905  if(nextAlloc1stIndex < suballoc1stCount)
      +
      9906  {
      +
      9907  const VmaSuballocation& suballoc = suballocations1st[nextAlloc1stIndex];
      +
      9908 
      +
      9909  // 1. Process free space before this allocation.
      +
      9910  if(lastOffset < suballoc.offset)
      +
      9911  {
      +
      9912  // There is free space from lastOffset to suballoc.offset.
      +
      9913  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
      +
      9914  PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
      +
      9915  }
      +
      9916 
      +
      9917  // 2. Process this allocation.
      +
      9918  // There is allocation with suballoc.offset, suballoc.size.
      +
      9919  PrintDetailedMap_Allocation(json, suballoc.offset, suballoc.hAllocation);
      +
      9920 
      +
      9921  // 3. Prepare for next iteration.
      +
      9922  lastOffset = suballoc.offset + suballoc.size;
      +
      9923  ++nextAlloc1stIndex;
      +
      9924  }
      +
      9925  // We are at the end.
      +
      9926  else
      +
      9927  {
      +
      9928  if(lastOffset < freeSpace1stTo2ndEnd)
      +
      9929  {
      +
      9930  // There is free space from lastOffset to freeSpace1stTo2ndEnd.
      +
      9931  const VkDeviceSize unusedRangeSize = freeSpace1stTo2ndEnd - lastOffset;
      +
      9932  PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
      +
      9933  }
      9934 
      -
      9935  PrintDetailedMap_End(json);
      -
      9936 }
      -
      9937 #endif // #if VMA_STATS_STRING_ENABLED
      -
      9938 
      -
      9939 bool VmaBlockMetadata_Linear::CreateAllocationRequest(
      -
      9940  uint32_t currentFrameIndex,
      -
      9941  uint32_t frameInUseCount,
      -
      9942  VkDeviceSize bufferImageGranularity,
      -
      9943  VkDeviceSize allocSize,
      -
      9944  VkDeviceSize allocAlignment,
      -
      9945  bool upperAddress,
      -
      9946  VmaSuballocationType allocType,
      -
      9947  bool canMakeOtherLost,
      -
      9948  uint32_t strategy,
      -
      9949  VmaAllocationRequest* pAllocationRequest)
      -
      9950 {
      -
      9951  VMA_ASSERT(allocSize > 0);
      -
      9952  VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
      -
      9953  VMA_ASSERT(pAllocationRequest != VMA_NULL);
      -
      9954  VMA_HEAVY_ASSERT(Validate());
      -
      9955  return upperAddress ?
      -
      9956  CreateAllocationRequest_UpperAddress(
      -
      9957  currentFrameIndex, frameInUseCount, bufferImageGranularity,
      -
      9958  allocSize, allocAlignment, allocType, canMakeOtherLost, strategy, pAllocationRequest) :
      -
      9959  CreateAllocationRequest_LowerAddress(
      -
      9960  currentFrameIndex, frameInUseCount, bufferImageGranularity,
      -
      9961  allocSize, allocAlignment, allocType, canMakeOtherLost, strategy, pAllocationRequest);
      -
      9962 }
      -
      9963 
      -
      9964 bool VmaBlockMetadata_Linear::CreateAllocationRequest_UpperAddress(
      -
      9965  uint32_t currentFrameIndex,
      -
      9966  uint32_t frameInUseCount,
      -
      9967  VkDeviceSize bufferImageGranularity,
      -
      9968  VkDeviceSize allocSize,
      -
      9969  VkDeviceSize allocAlignment,
      -
      9970  VmaSuballocationType allocType,
      -
      9971  bool canMakeOtherLost,
      -
      9972  uint32_t strategy,
      -
      9973  VmaAllocationRequest* pAllocationRequest)
      -
      9974 {
      -
      9975  const VkDeviceSize size = GetSize();
      -
      9976  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
      -
      9977  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
      -
      9978 
      -
      9979  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
      -
      9980  {
      -
      9981  VMA_ASSERT(0 && "Trying to use pool with linear algorithm as double stack, while it is already being used as ring buffer.");
      -
      9982  return false;
      -
      9983  }
      -
      9984 
      -
      9985  // Try to allocate before 2nd.back(), or end of block if 2nd.empty().
      -
      9986  if(allocSize > size)
      -
      9987  {
      -
      9988  return false;
      -
      9989  }
      -
      9990  VkDeviceSize resultBaseOffset = size - allocSize;
      -
      9991  if(!suballocations2nd.empty())
      -
      9992  {
      -
      9993  const VmaSuballocation& lastSuballoc = suballocations2nd.back();
      -
      9994  resultBaseOffset = lastSuballoc.offset - allocSize;
      -
      9995  if(allocSize > lastSuballoc.offset)
      -
      9996  {
      -
      9997  return false;
      -
      9998  }
      -
      9999  }
      -
      10000 
      -
      10001  // Start from offset equal to end of free space.
      -
      10002  VkDeviceSize resultOffset = resultBaseOffset;
      -
      10003 
      -
      10004  // Apply VMA_DEBUG_MARGIN at the end.
      -
      10005  if(VMA_DEBUG_MARGIN > 0)
      -
      10006  {
      -
      10007  if(resultOffset < VMA_DEBUG_MARGIN)
      -
      10008  {
      -
      10009  return false;
      -
      10010  }
      -
      10011  resultOffset -= VMA_DEBUG_MARGIN;
      -
      10012  }
      -
      10013 
      -
      10014  // Apply alignment.
      -
      10015  resultOffset = VmaAlignDown(resultOffset, allocAlignment);
      -
      10016 
      -
      10017  // Check next suballocations from 2nd for BufferImageGranularity conflicts.
      -
      10018  // Make bigger alignment if necessary.
      -
      10019  if(bufferImageGranularity > 1 && !suballocations2nd.empty())
      -
      10020  {
      -
      10021  bool bufferImageGranularityConflict = false;
      -
      10022  for(size_t nextSuballocIndex = suballocations2nd.size(); nextSuballocIndex--; )
      -
      10023  {
      -
      10024  const VmaSuballocation& nextSuballoc = suballocations2nd[nextSuballocIndex];
      -
      10025  if(VmaBlocksOnSamePage(resultOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
      -
      10026  {
      -
      10027  if(VmaIsBufferImageGranularityConflict(nextSuballoc.type, allocType))
      -
      10028  {
      -
      10029  bufferImageGranularityConflict = true;
      -
      10030  break;
      -
      10031  }
      -
      10032  }
      -
      10033  else
      -
      10034  // Already on previous page.
      -
      10035  break;
      -
      10036  }
      -
      10037  if(bufferImageGranularityConflict)
      -
      10038  {
      -
      10039  resultOffset = VmaAlignDown(resultOffset, bufferImageGranularity);
      -
      10040  }
      -
      10041  }
      -
      10042 
      -
      10043  // There is enough free space.
      -
      10044  const VkDeviceSize endOf1st = !suballocations1st.empty() ?
      -
      10045  suballocations1st.back().offset + suballocations1st.back().size :
      -
      10046  0;
      -
      10047  if(endOf1st + VMA_DEBUG_MARGIN <= resultOffset)
      -
      10048  {
      -
      10049  // Check previous suballocations for BufferImageGranularity conflicts.
      -
      10050  // If conflict exists, allocation cannot be made here.
      -
      10051  if(bufferImageGranularity > 1)
      -
      10052  {
      -
      10053  for(size_t prevSuballocIndex = suballocations1st.size(); prevSuballocIndex--; )
      -
      10054  {
      -
      10055  const VmaSuballocation& prevSuballoc = suballocations1st[prevSuballocIndex];
      -
      10056  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, resultOffset, bufferImageGranularity))
      -
      10057  {
      -
      10058  if(VmaIsBufferImageGranularityConflict(allocType, prevSuballoc.type))
      -
      10059  {
      -
      10060  return false;
      -
      10061  }
      -
      10062  }
      -
      10063  else
      -
      10064  {
      -
      10065  // Already on next page.
      -
      10066  break;
      -
      10067  }
      -
      10068  }
      -
      10069  }
      +
      9935  // End of loop.
      +
      9936  lastOffset = freeSpace1stTo2ndEnd;
      +
      9937  }
      +
      9938  }
      +
      9939 
      +
      9940  if(m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
      +
      9941  {
      +
      9942  size_t nextAlloc2ndIndex = suballocations2nd.size() - 1;
      +
      9943  while(lastOffset < size)
      +
      9944  {
      +
      9945  // Find next non-null allocation or move nextAlloc2ndIndex to the end.
      +
      9946  while(nextAlloc2ndIndex != SIZE_MAX &&
      +
      9947  suballocations2nd[nextAlloc2ndIndex].hAllocation == VK_NULL_HANDLE)
      +
      9948  {
      +
      9949  --nextAlloc2ndIndex;
      +
      9950  }
      +
      9951 
      +
      9952  // Found non-null allocation.
      +
      9953  if(nextAlloc2ndIndex != SIZE_MAX)
      +
      9954  {
      +
      9955  const VmaSuballocation& suballoc = suballocations2nd[nextAlloc2ndIndex];
      +
      9956 
      +
      9957  // 1. Process free space before this allocation.
      +
      9958  if(lastOffset < suballoc.offset)
      +
      9959  {
      +
      9960  // There is free space from lastOffset to suballoc.offset.
      +
      9961  const VkDeviceSize unusedRangeSize = suballoc.offset - lastOffset;
      +
      9962  PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
      +
      9963  }
      +
      9964 
      +
      9965  // 2. Process this allocation.
      +
      9966  // There is allocation with suballoc.offset, suballoc.size.
      +
      9967  PrintDetailedMap_Allocation(json, suballoc.offset, suballoc.hAllocation);
      +
      9968 
      +
      9969  // 3. Prepare for next iteration.
      +
      9970  lastOffset = suballoc.offset + suballoc.size;
      +
      9971  --nextAlloc2ndIndex;
      +
      9972  }
      +
      9973  // We are at the end.
      +
      9974  else
      +
      9975  {
      +
      9976  if(lastOffset < size)
      +
      9977  {
      +
      9978  // There is free space from lastOffset to size.
      +
      9979  const VkDeviceSize unusedRangeSize = size - lastOffset;
      +
      9980  PrintDetailedMap_UnusedRange(json, lastOffset, unusedRangeSize);
      +
      9981  }
      +
      9982 
      +
      9983  // End of loop.
      +
      9984  lastOffset = size;
      +
      9985  }
      +
      9986  }
      +
      9987  }
      +
      9988 
      +
      9989  PrintDetailedMap_End(json);
      +
      9990 }
      +
      9991 #endif // #if VMA_STATS_STRING_ENABLED
      +
      9992 
      +
      9993 bool VmaBlockMetadata_Linear::CreateAllocationRequest(
      +
      9994  uint32_t currentFrameIndex,
      +
      9995  uint32_t frameInUseCount,
      +
      9996  VkDeviceSize bufferImageGranularity,
      +
      9997  VkDeviceSize allocSize,
      +
      9998  VkDeviceSize allocAlignment,
      +
      9999  bool upperAddress,
      +
      10000  VmaSuballocationType allocType,
      +
      10001  bool canMakeOtherLost,
      +
      10002  uint32_t strategy,
      +
      10003  VmaAllocationRequest* pAllocationRequest)
      +
      10004 {
      +
      10005  VMA_ASSERT(allocSize > 0);
      +
      10006  VMA_ASSERT(allocType != VMA_SUBALLOCATION_TYPE_FREE);
      +
      10007  VMA_ASSERT(pAllocationRequest != VMA_NULL);
      +
      10008  VMA_HEAVY_ASSERT(Validate());
      +
      10009  return upperAddress ?
      +
      10010  CreateAllocationRequest_UpperAddress(
      +
      10011  currentFrameIndex, frameInUseCount, bufferImageGranularity,
      +
      10012  allocSize, allocAlignment, allocType, canMakeOtherLost, strategy, pAllocationRequest) :
      +
      10013  CreateAllocationRequest_LowerAddress(
      +
      10014  currentFrameIndex, frameInUseCount, bufferImageGranularity,
      +
      10015  allocSize, allocAlignment, allocType, canMakeOtherLost, strategy, pAllocationRequest);
      +
      10016 }
      +
      10017 
      +
      10018 bool VmaBlockMetadata_Linear::CreateAllocationRequest_UpperAddress(
      +
      10019  uint32_t currentFrameIndex,
      +
      10020  uint32_t frameInUseCount,
      +
      10021  VkDeviceSize bufferImageGranularity,
      +
      10022  VkDeviceSize allocSize,
      +
      10023  VkDeviceSize allocAlignment,
      +
      10024  VmaSuballocationType allocType,
      +
      10025  bool canMakeOtherLost,
      +
      10026  uint32_t strategy,
      +
      10027  VmaAllocationRequest* pAllocationRequest)
      +
      10028 {
      +
      10029  const VkDeviceSize size = GetSize();
      +
      10030  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
      +
      10031  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
      +
      10032 
      +
      10033  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
      +
      10034  {
      +
      10035  VMA_ASSERT(0 && "Trying to use pool with linear algorithm as double stack, while it is already being used as ring buffer.");
      +
      10036  return false;
      +
      10037  }
      +
      10038 
      +
      10039  // Try to allocate before 2nd.back(), or end of block if 2nd.empty().
      +
      10040  if(allocSize > size)
      +
      10041  {
      +
      10042  return false;
      +
      10043  }
      +
      10044  VkDeviceSize resultBaseOffset = size - allocSize;
      +
      10045  if(!suballocations2nd.empty())
      +
      10046  {
      +
      10047  const VmaSuballocation& lastSuballoc = suballocations2nd.back();
      +
      10048  resultBaseOffset = lastSuballoc.offset - allocSize;
      +
      10049  if(allocSize > lastSuballoc.offset)
      +
      10050  {
      +
      10051  return false;
      +
      10052  }
      +
      10053  }
      +
      10054 
      +
      10055  // Start from offset equal to end of free space.
      +
      10056  VkDeviceSize resultOffset = resultBaseOffset;
      +
      10057 
      +
      10058  // Apply VMA_DEBUG_MARGIN at the end.
      +
      10059  if(VMA_DEBUG_MARGIN > 0)
      +
      10060  {
      +
      10061  if(resultOffset < VMA_DEBUG_MARGIN)
      +
      10062  {
      +
      10063  return false;
      +
      10064  }
      +
      10065  resultOffset -= VMA_DEBUG_MARGIN;
      +
      10066  }
      +
      10067 
      +
      10068  // Apply alignment.
      +
      10069  resultOffset = VmaAlignDown(resultOffset, allocAlignment);
      10070 
      -
      10071  // All tests passed: Success.
      -
      10072  pAllocationRequest->offset = resultOffset;
      -
      10073  pAllocationRequest->sumFreeSize = resultBaseOffset + allocSize - endOf1st;
      -
      10074  pAllocationRequest->sumItemSize = 0;
      -
      10075  // pAllocationRequest->item unused.
      -
      10076  pAllocationRequest->itemsToMakeLostCount = 0;
      -
      10077  pAllocationRequest->type = VmaAllocationRequestType::UpperAddress;
      -
      10078  return true;
      -
      10079  }
      -
      10080 
      -
      10081  return false;
      -
      10082 }
      -
      10083 
      -
      10084 bool VmaBlockMetadata_Linear::CreateAllocationRequest_LowerAddress(
      -
      10085  uint32_t currentFrameIndex,
      -
      10086  uint32_t frameInUseCount,
      -
      10087  VkDeviceSize bufferImageGranularity,
      -
      10088  VkDeviceSize allocSize,
      -
      10089  VkDeviceSize allocAlignment,
      -
      10090  VmaSuballocationType allocType,
      -
      10091  bool canMakeOtherLost,
      -
      10092  uint32_t strategy,
      -
      10093  VmaAllocationRequest* pAllocationRequest)
      -
      10094 {
      -
      10095  const VkDeviceSize size = GetSize();
      -
      10096  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
      -
      10097  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
      -
      10098 
      -
      10099  if(m_2ndVectorMode == SECOND_VECTOR_EMPTY || m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
      -
      10100  {
      -
      10101  // Try to allocate at the end of 1st vector.
      -
      10102 
      -
      10103  VkDeviceSize resultBaseOffset = 0;
      -
      10104  if(!suballocations1st.empty())
      -
      10105  {
      -
      10106  const VmaSuballocation& lastSuballoc = suballocations1st.back();
      -
      10107  resultBaseOffset = lastSuballoc.offset + lastSuballoc.size;
      -
      10108  }
      -
      10109 
      -
      10110  // Start from offset equal to beginning of free space.
      -
      10111  VkDeviceSize resultOffset = resultBaseOffset;
      -
      10112 
      -
      10113  // Apply VMA_DEBUG_MARGIN at the beginning.
      -
      10114  if(VMA_DEBUG_MARGIN > 0)
      -
      10115  {
      -
      10116  resultOffset += VMA_DEBUG_MARGIN;
      -
      10117  }
      -
      10118 
      -
      10119  // Apply alignment.
      -
      10120  resultOffset = VmaAlignUp(resultOffset, allocAlignment);
      -
      10121 
      -
      10122  // Check previous suballocations for BufferImageGranularity conflicts.
      -
      10123  // Make bigger alignment if necessary.
      -
      10124  if(bufferImageGranularity > 1 && !suballocations1st.empty())
      -
      10125  {
      -
      10126  bool bufferImageGranularityConflict = false;
      -
      10127  for(size_t prevSuballocIndex = suballocations1st.size(); prevSuballocIndex--; )
      -
      10128  {
      -
      10129  const VmaSuballocation& prevSuballoc = suballocations1st[prevSuballocIndex];
      -
      10130  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, resultOffset, bufferImageGranularity))
      -
      10131  {
      -
      10132  if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
      -
      10133  {
      -
      10134  bufferImageGranularityConflict = true;
      -
      10135  break;
      -
      10136  }
      -
      10137  }
      -
      10138  else
      -
      10139  // Already on previous page.
      -
      10140  break;
      -
      10141  }
      -
      10142  if(bufferImageGranularityConflict)
      -
      10143  {
      -
      10144  resultOffset = VmaAlignUp(resultOffset, bufferImageGranularity);
      -
      10145  }
      -
      10146  }
      -
      10147 
      -
      10148  const VkDeviceSize freeSpaceEnd = m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ?
      -
      10149  suballocations2nd.back().offset : size;
      -
      10150 
      -
      10151  // There is enough free space at the end after alignment.
      -
      10152  if(resultOffset + allocSize + VMA_DEBUG_MARGIN <= freeSpaceEnd)
      -
      10153  {
      -
      10154  // Check next suballocations for BufferImageGranularity conflicts.
      -
      10155  // If conflict exists, allocation cannot be made here.
      -
      10156  if(bufferImageGranularity > 1 && m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
      -
      10157  {
      -
      10158  for(size_t nextSuballocIndex = suballocations2nd.size(); nextSuballocIndex--; )
      -
      10159  {
      -
      10160  const VmaSuballocation& nextSuballoc = suballocations2nd[nextSuballocIndex];
      -
      10161  if(VmaBlocksOnSamePage(resultOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
      -
      10162  {
      -
      10163  if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
      -
      10164  {
      -
      10165  return false;
      -
      10166  }
      -
      10167  }
      -
      10168  else
      -
      10169  {
      -
      10170  // Already on previous page.
      -
      10171  break;
      -
      10172  }
      -
      10173  }
      -
      10174  }
      +
      10071  // Check next suballocations from 2nd for BufferImageGranularity conflicts.
      +
      10072  // Make bigger alignment if necessary.
      +
      10073  if(bufferImageGranularity > 1 && !suballocations2nd.empty())
      +
      10074  {
      +
      10075  bool bufferImageGranularityConflict = false;
      +
      10076  for(size_t nextSuballocIndex = suballocations2nd.size(); nextSuballocIndex--; )
      +
      10077  {
      +
      10078  const VmaSuballocation& nextSuballoc = suballocations2nd[nextSuballocIndex];
      +
      10079  if(VmaBlocksOnSamePage(resultOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
      +
      10080  {
      +
      10081  if(VmaIsBufferImageGranularityConflict(nextSuballoc.type, allocType))
      +
      10082  {
      +
      10083  bufferImageGranularityConflict = true;
      +
      10084  break;
      +
      10085  }
      +
      10086  }
      +
      10087  else
      +
      10088  // Already on previous page.
      +
      10089  break;
      +
      10090  }
      +
      10091  if(bufferImageGranularityConflict)
      +
      10092  {
      +
      10093  resultOffset = VmaAlignDown(resultOffset, bufferImageGranularity);
      +
      10094  }
      +
      10095  }
      +
      10096 
      +
      10097  // There is enough free space.
      +
      10098  const VkDeviceSize endOf1st = !suballocations1st.empty() ?
      +
      10099  suballocations1st.back().offset + suballocations1st.back().size :
      +
      10100  0;
      +
      10101  if(endOf1st + VMA_DEBUG_MARGIN <= resultOffset)
      +
      10102  {
      +
      10103  // Check previous suballocations for BufferImageGranularity conflicts.
      +
      10104  // If conflict exists, allocation cannot be made here.
      +
      10105  if(bufferImageGranularity > 1)
      +
      10106  {
      +
      10107  for(size_t prevSuballocIndex = suballocations1st.size(); prevSuballocIndex--; )
      +
      10108  {
      +
      10109  const VmaSuballocation& prevSuballoc = suballocations1st[prevSuballocIndex];
      +
      10110  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, resultOffset, bufferImageGranularity))
      +
      10111  {
      +
      10112  if(VmaIsBufferImageGranularityConflict(allocType, prevSuballoc.type))
      +
      10113  {
      +
      10114  return false;
      +
      10115  }
      +
      10116  }
      +
      10117  else
      +
      10118  {
      +
      10119  // Already on next page.
      +
      10120  break;
      +
      10121  }
      +
      10122  }
      +
      10123  }
      +
      10124 
      +
      10125  // All tests passed: Success.
      +
      10126  pAllocationRequest->offset = resultOffset;
      +
      10127  pAllocationRequest->sumFreeSize = resultBaseOffset + allocSize - endOf1st;
      +
      10128  pAllocationRequest->sumItemSize = 0;
      +
      10129  // pAllocationRequest->item unused.
      +
      10130  pAllocationRequest->itemsToMakeLostCount = 0;
      +
      10131  pAllocationRequest->type = VmaAllocationRequestType::UpperAddress;
      +
      10132  return true;
      +
      10133  }
      +
      10134 
      +
      10135  return false;
      +
      10136 }
      +
      10137 
      +
      10138 bool VmaBlockMetadata_Linear::CreateAllocationRequest_LowerAddress(
      +
      10139  uint32_t currentFrameIndex,
      +
      10140  uint32_t frameInUseCount,
      +
      10141  VkDeviceSize bufferImageGranularity,
      +
      10142  VkDeviceSize allocSize,
      +
      10143  VkDeviceSize allocAlignment,
      +
      10144  VmaSuballocationType allocType,
      +
      10145  bool canMakeOtherLost,
      +
      10146  uint32_t strategy,
      +
      10147  VmaAllocationRequest* pAllocationRequest)
      +
      10148 {
      +
      10149  const VkDeviceSize size = GetSize();
      +
      10150  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
      +
      10151  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
      +
      10152 
      +
      10153  if(m_2ndVectorMode == SECOND_VECTOR_EMPTY || m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
      +
      10154  {
      +
      10155  // Try to allocate at the end of 1st vector.
      +
      10156 
      +
      10157  VkDeviceSize resultBaseOffset = 0;
      +
      10158  if(!suballocations1st.empty())
      +
      10159  {
      +
      10160  const VmaSuballocation& lastSuballoc = suballocations1st.back();
      +
      10161  resultBaseOffset = lastSuballoc.offset + lastSuballoc.size;
      +
      10162  }
      +
      10163 
      +
      10164  // Start from offset equal to beginning of free space.
      +
      10165  VkDeviceSize resultOffset = resultBaseOffset;
      +
      10166 
      +
      10167  // Apply VMA_DEBUG_MARGIN at the beginning.
      +
      10168  if(VMA_DEBUG_MARGIN > 0)
      +
      10169  {
      +
      10170  resultOffset += VMA_DEBUG_MARGIN;
      +
      10171  }
      +
      10172 
      +
      10173  // Apply alignment.
      +
      10174  resultOffset = VmaAlignUp(resultOffset, allocAlignment);
      10175 
      -
      10176  // All tests passed: Success.
      -
      10177  pAllocationRequest->offset = resultOffset;
      -
      10178  pAllocationRequest->sumFreeSize = freeSpaceEnd - resultBaseOffset;
      -
      10179  pAllocationRequest->sumItemSize = 0;
      -
      10180  // pAllocationRequest->item, customData unused.
      -
      10181  pAllocationRequest->type = VmaAllocationRequestType::EndOf1st;
      -
      10182  pAllocationRequest->itemsToMakeLostCount = 0;
      -
      10183  return true;
      -
      10184  }
      -
      10185  }
      -
      10186 
      -
      10187  // Wrap-around to end of 2nd vector. Try to allocate there, watching for the
      -
      10188  // beginning of 1st vector as the end of free space.
      -
      10189  if(m_2ndVectorMode == SECOND_VECTOR_EMPTY || m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
      -
      10190  {
      -
      10191  VMA_ASSERT(!suballocations1st.empty());
      -
      10192 
      -
      10193  VkDeviceSize resultBaseOffset = 0;
      -
      10194  if(!suballocations2nd.empty())
      -
      10195  {
      -
      10196  const VmaSuballocation& lastSuballoc = suballocations2nd.back();
      -
      10197  resultBaseOffset = lastSuballoc.offset + lastSuballoc.size;
      -
      10198  }
      -
      10199 
      -
      10200  // Start from offset equal to beginning of free space.
      -
      10201  VkDeviceSize resultOffset = resultBaseOffset;
      -
      10202 
      -
      10203  // Apply VMA_DEBUG_MARGIN at the beginning.
      -
      10204  if(VMA_DEBUG_MARGIN > 0)
      -
      10205  {
      -
      10206  resultOffset += VMA_DEBUG_MARGIN;
      -
      10207  }
      -
      10208 
      -
      10209  // Apply alignment.
      -
      10210  resultOffset = VmaAlignUp(resultOffset, allocAlignment);
      -
      10211 
      -
      10212  // Check previous suballocations for BufferImageGranularity conflicts.
      -
      10213  // Make bigger alignment if necessary.
      -
      10214  if(bufferImageGranularity > 1 && !suballocations2nd.empty())
      -
      10215  {
      -
      10216  bool bufferImageGranularityConflict = false;
      -
      10217  for(size_t prevSuballocIndex = suballocations2nd.size(); prevSuballocIndex--; )
      -
      10218  {
      -
      10219  const VmaSuballocation& prevSuballoc = suballocations2nd[prevSuballocIndex];
      -
      10220  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, resultOffset, bufferImageGranularity))
      -
      10221  {
      -
      10222  if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
      +
      10176  // Check previous suballocations for BufferImageGranularity conflicts.
      +
      10177  // Make bigger alignment if necessary.
      +
      10178  if(bufferImageGranularity > 1 && !suballocations1st.empty())
      +
      10179  {
      +
      10180  bool bufferImageGranularityConflict = false;
      +
      10181  for(size_t prevSuballocIndex = suballocations1st.size(); prevSuballocIndex--; )
      +
      10182  {
      +
      10183  const VmaSuballocation& prevSuballoc = suballocations1st[prevSuballocIndex];
      +
      10184  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, resultOffset, bufferImageGranularity))
      +
      10185  {
      +
      10186  if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
      +
      10187  {
      +
      10188  bufferImageGranularityConflict = true;
      +
      10189  break;
      +
      10190  }
      +
      10191  }
      +
      10192  else
      +
      10193  // Already on previous page.
      +
      10194  break;
      +
      10195  }
      +
      10196  if(bufferImageGranularityConflict)
      +
      10197  {
      +
      10198  resultOffset = VmaAlignUp(resultOffset, bufferImageGranularity);
      +
      10199  }
      +
      10200  }
      +
      10201 
      +
      10202  const VkDeviceSize freeSpaceEnd = m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK ?
      +
      10203  suballocations2nd.back().offset : size;
      +
      10204 
      +
      10205  // There is enough free space at the end after alignment.
      +
      10206  if(resultOffset + allocSize + VMA_DEBUG_MARGIN <= freeSpaceEnd)
      +
      10207  {
      +
      10208  // Check next suballocations for BufferImageGranularity conflicts.
      +
      10209  // If conflict exists, allocation cannot be made here.
      +
      10210  if(bufferImageGranularity > 1 && m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
      +
      10211  {
      +
      10212  for(size_t nextSuballocIndex = suballocations2nd.size(); nextSuballocIndex--; )
      +
      10213  {
      +
      10214  const VmaSuballocation& nextSuballoc = suballocations2nd[nextSuballocIndex];
      +
      10215  if(VmaBlocksOnSamePage(resultOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
      +
      10216  {
      +
      10217  if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
      +
      10218  {
      +
      10219  return false;
      +
      10220  }
      +
      10221  }
      +
      10222  else
      10223  {
      -
      10224  bufferImageGranularityConflict = true;
      +
      10224  // Already on previous page.
      10225  break;
      10226  }
      10227  }
      -
      10228  else
      -
      10229  // Already on previous page.
      -
      10230  break;
      -
      10231  }
      -
      10232  if(bufferImageGranularityConflict)
      -
      10233  {
      -
      10234  resultOffset = VmaAlignUp(resultOffset, bufferImageGranularity);
      -
      10235  }
      -
      10236  }
      -
      10237 
      -
      10238  pAllocationRequest->itemsToMakeLostCount = 0;
      -
      10239  pAllocationRequest->sumItemSize = 0;
      -
      10240  size_t index1st = m_1stNullItemsBeginCount;
      -
      10241 
      -
      10242  if(canMakeOtherLost)
      -
      10243  {
      -
      10244  while(index1st < suballocations1st.size() &&
      -
      10245  resultOffset + allocSize + VMA_DEBUG_MARGIN > suballocations1st[index1st].offset)
      -
      10246  {
      -
      10247  // Next colliding allocation at the beginning of 1st vector found. Try to make it lost.
      -
      10248  const VmaSuballocation& suballoc = suballocations1st[index1st];
      -
      10249  if(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE)
      -
      10250  {
      -
      10251  // No problem.
      -
      10252  }
      -
      10253  else
      -
      10254  {
      -
      10255  VMA_ASSERT(suballoc.hAllocation != VK_NULL_HANDLE);
      -
      10256  if(suballoc.hAllocation->CanBecomeLost() &&
      -
      10257  suballoc.hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
      -
      10258  {
      -
      10259  ++pAllocationRequest->itemsToMakeLostCount;
      -
      10260  pAllocationRequest->sumItemSize += suballoc.size;
      -
      10261  }
      -
      10262  else
      -
      10263  {
      -
      10264  return false;
      -
      10265  }
      -
      10266  }
      -
      10267  ++index1st;
      -
      10268  }
      -
      10269 
      -
      10270  // Check next suballocations for BufferImageGranularity conflicts.
      -
      10271  // If conflict exists, we must mark more allocations lost or fail.
      -
      10272  if(bufferImageGranularity > 1)
      -
      10273  {
      -
      10274  while(index1st < suballocations1st.size())
      +
      10228  }
      +
      10229 
      +
      10230  // All tests passed: Success.
      +
      10231  pAllocationRequest->offset = resultOffset;
      +
      10232  pAllocationRequest->sumFreeSize = freeSpaceEnd - resultBaseOffset;
      +
      10233  pAllocationRequest->sumItemSize = 0;
      +
      10234  // pAllocationRequest->item, customData unused.
      +
      10235  pAllocationRequest->type = VmaAllocationRequestType::EndOf1st;
      +
      10236  pAllocationRequest->itemsToMakeLostCount = 0;
      +
      10237  return true;
      +
      10238  }
      +
      10239  }
      +
      10240 
      +
      10241  // Wrap-around to end of 2nd vector. Try to allocate there, watching for the
      +
      10242  // beginning of 1st vector as the end of free space.
      +
      10243  if(m_2ndVectorMode == SECOND_VECTOR_EMPTY || m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
      +
      10244  {
      +
      10245  VMA_ASSERT(!suballocations1st.empty());
      +
      10246 
      +
      10247  VkDeviceSize resultBaseOffset = 0;
      +
      10248  if(!suballocations2nd.empty())
      +
      10249  {
      +
      10250  const VmaSuballocation& lastSuballoc = suballocations2nd.back();
      +
      10251  resultBaseOffset = lastSuballoc.offset + lastSuballoc.size;
      +
      10252  }
      +
      10253 
      +
      10254  // Start from offset equal to beginning of free space.
      +
      10255  VkDeviceSize resultOffset = resultBaseOffset;
      +
      10256 
      +
      10257  // Apply VMA_DEBUG_MARGIN at the beginning.
      +
      10258  if(VMA_DEBUG_MARGIN > 0)
      +
      10259  {
      +
      10260  resultOffset += VMA_DEBUG_MARGIN;
      +
      10261  }
      +
      10262 
      +
      10263  // Apply alignment.
      +
      10264  resultOffset = VmaAlignUp(resultOffset, allocAlignment);
      +
      10265 
      +
      10266  // Check previous suballocations for BufferImageGranularity conflicts.
      +
      10267  // Make bigger alignment if necessary.
      +
      10268  if(bufferImageGranularity > 1 && !suballocations2nd.empty())
      +
      10269  {
      +
      10270  bool bufferImageGranularityConflict = false;
      +
      10271  for(size_t prevSuballocIndex = suballocations2nd.size(); prevSuballocIndex--; )
      +
      10272  {
      +
      10273  const VmaSuballocation& prevSuballoc = suballocations2nd[prevSuballocIndex];
      +
      10274  if(VmaBlocksOnSamePage(prevSuballoc.offset, prevSuballoc.size, resultOffset, bufferImageGranularity))
      10275  {
      -
      10276  const VmaSuballocation& suballoc = suballocations1st[index1st];
      -
      10277  if(VmaBlocksOnSamePage(resultOffset, allocSize, suballoc.offset, bufferImageGranularity))
      -
      10278  {
      -
      10279  if(suballoc.hAllocation != VK_NULL_HANDLE)
      -
      10280  {
      -
      10281  // Not checking actual VmaIsBufferImageGranularityConflict(allocType, suballoc.type).
      -
      10282  if(suballoc.hAllocation->CanBecomeLost() &&
      -
      10283  suballoc.hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
      -
      10284  {
      -
      10285  ++pAllocationRequest->itemsToMakeLostCount;
      -
      10286  pAllocationRequest->sumItemSize += suballoc.size;
      -
      10287  }
      -
      10288  else
      -
      10289  {
      -
      10290  return false;
      -
      10291  }
      -
      10292  }
      -
      10293  }
      -
      10294  else
      -
      10295  {
      -
      10296  // Already on next page.
      -
      10297  break;
      -
      10298  }
      -
      10299  ++index1st;
      -
      10300  }
      -
      10301  }
      -
      10302 
      -
      10303  // Special case: There is not enough room at the end for this allocation, even after making all from the 1st lost.
      -
      10304  if(index1st == suballocations1st.size() &&
      -
      10305  resultOffset + allocSize + VMA_DEBUG_MARGIN > size)
      -
      10306  {
      -
      10307  // TODO: This is a known bug that it's not yet implemented and the allocation is failing.
      -
      10308  VMA_DEBUG_LOG("Unsupported special case in custom pool with linear allocation algorithm used as ring buffer with allocations that can be lost.");
      -
      10309  }
      -
      10310  }
      -
      10311 
      -
      10312  // There is enough free space at the end after alignment.
      -
      10313  if((index1st == suballocations1st.size() && resultOffset + allocSize + VMA_DEBUG_MARGIN <= size) ||
      -
      10314  (index1st < suballocations1st.size() && resultOffset + allocSize + VMA_DEBUG_MARGIN <= suballocations1st[index1st].offset))
      -
      10315  {
      -
      10316  // Check next suballocations for BufferImageGranularity conflicts.
      -
      10317  // If conflict exists, allocation cannot be made here.
      -
      10318  if(bufferImageGranularity > 1)
      -
      10319  {
      -
      10320  for(size_t nextSuballocIndex = index1st;
      -
      10321  nextSuballocIndex < suballocations1st.size();
      -
      10322  nextSuballocIndex++)
      -
      10323  {
      -
      10324  const VmaSuballocation& nextSuballoc = suballocations1st[nextSuballocIndex];
      -
      10325  if(VmaBlocksOnSamePage(resultOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
      -
      10326  {
      -
      10327  if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
      -
      10328  {
      -
      10329  return false;
      -
      10330  }
      -
      10331  }
      -
      10332  else
      -
      10333  {
      -
      10334  // Already on next page.
      -
      10335  break;
      -
      10336  }
      -
      10337  }
      -
      10338  }
      -
      10339 
      -
      10340  // All tests passed: Success.
      -
      10341  pAllocationRequest->offset = resultOffset;
      -
      10342  pAllocationRequest->sumFreeSize =
      -
      10343  (index1st < suballocations1st.size() ? suballocations1st[index1st].offset : size)
      -
      10344  - resultBaseOffset
      -
      10345  - pAllocationRequest->sumItemSize;
      -
      10346  pAllocationRequest->type = VmaAllocationRequestType::EndOf2nd;
      -
      10347  // pAllocationRequest->item, customData unused.
      -
      10348  return true;
      -
      10349  }
      -
      10350  }
      -
      10351 
      -
      10352  return false;
      -
      10353 }
      -
      10354 
      -
      10355 bool VmaBlockMetadata_Linear::MakeRequestedAllocationsLost(
      -
      10356  uint32_t currentFrameIndex,
      -
      10357  uint32_t frameInUseCount,
      -
      10358  VmaAllocationRequest* pAllocationRequest)
      -
      10359 {
      -
      10360  if(pAllocationRequest->itemsToMakeLostCount == 0)
      -
      10361  {
      -
      10362  return true;
      -
      10363  }
      -
      10364 
      -
      10365  VMA_ASSERT(m_2ndVectorMode == SECOND_VECTOR_EMPTY || m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER);
      -
      10366 
      -
      10367  // We always start from 1st.
      -
      10368  SuballocationVectorType* suballocations = &AccessSuballocations1st();
      -
      10369  size_t index = m_1stNullItemsBeginCount;
      -
      10370  size_t madeLostCount = 0;
      -
      10371  while(madeLostCount < pAllocationRequest->itemsToMakeLostCount)
      -
      10372  {
      -
      10373  if(index == suballocations->size())
      -
      10374  {
      -
      10375  index = 0;
      -
      10376  // If we get to the end of 1st, we wrap around to beginning of 2nd of 1st.
      -
      10377  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
      -
      10378  {
      -
      10379  suballocations = &AccessSuballocations2nd();
      -
      10380  }
      -
      10381  // else: m_2ndVectorMode == SECOND_VECTOR_EMPTY:
      -
      10382  // suballocations continues pointing at AccessSuballocations1st().
      -
      10383  VMA_ASSERT(!suballocations->empty());
      -
      10384  }
      -
      10385  VmaSuballocation& suballoc = (*suballocations)[index];
      -
      10386  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
      -
      10387  {
      -
      10388  VMA_ASSERT(suballoc.hAllocation != VK_NULL_HANDLE);
      -
      10389  VMA_ASSERT(suballoc.hAllocation->CanBecomeLost());
      -
      10390  if(suballoc.hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
      -
      10391  {
      -
      10392  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
      -
      10393  suballoc.hAllocation = VK_NULL_HANDLE;
      -
      10394  m_SumFreeSize += suballoc.size;
      -
      10395  if(suballocations == &AccessSuballocations1st())
      -
      10396  {
      -
      10397  ++m_1stNullItemsMiddleCount;
      -
      10398  }
      -
      10399  else
      -
      10400  {
      -
      10401  ++m_2ndNullItemsCount;
      -
      10402  }
      -
      10403  ++madeLostCount;
      -
      10404  }
      -
      10405  else
      -
      10406  {
      -
      10407  return false;
      -
      10408  }
      -
      10409  }
      -
      10410  ++index;
      -
      10411  }
      -
      10412 
      -
      10413  CleanupAfterFree();
      -
      10414  //VMA_HEAVY_ASSERT(Validate()); // Already called by ClanupAfterFree().
      -
      10415 
      -
      10416  return true;
      -
      10417 }
      +
      10276  if(VmaIsBufferImageGranularityConflict(prevSuballoc.type, allocType))
      +
      10277  {
      +
      10278  bufferImageGranularityConflict = true;
      +
      10279  break;
      +
      10280  }
      +
      10281  }
      +
      10282  else
      +
      10283  // Already on previous page.
      +
      10284  break;
      +
      10285  }
      +
      10286  if(bufferImageGranularityConflict)
      +
      10287  {
      +
      10288  resultOffset = VmaAlignUp(resultOffset, bufferImageGranularity);
      +
      10289  }
      +
      10290  }
      +
      10291 
      +
      10292  pAllocationRequest->itemsToMakeLostCount = 0;
      +
      10293  pAllocationRequest->sumItemSize = 0;
      +
      10294  size_t index1st = m_1stNullItemsBeginCount;
      +
      10295 
      +
      10296  if(canMakeOtherLost)
      +
      10297  {
      +
      10298  while(index1st < suballocations1st.size() &&
      +
      10299  resultOffset + allocSize + VMA_DEBUG_MARGIN > suballocations1st[index1st].offset)
      +
      10300  {
      +
      10301  // Next colliding allocation at the beginning of 1st vector found. Try to make it lost.
      +
      10302  const VmaSuballocation& suballoc = suballocations1st[index1st];
      +
      10303  if(suballoc.type == VMA_SUBALLOCATION_TYPE_FREE)
      +
      10304  {
      +
      10305  // No problem.
      +
      10306  }
      +
      10307  else
      +
      10308  {
      +
      10309  VMA_ASSERT(suballoc.hAllocation != VK_NULL_HANDLE);
      +
      10310  if(suballoc.hAllocation->CanBecomeLost() &&
      +
      10311  suballoc.hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
      +
      10312  {
      +
      10313  ++pAllocationRequest->itemsToMakeLostCount;
      +
      10314  pAllocationRequest->sumItemSize += suballoc.size;
      +
      10315  }
      +
      10316  else
      +
      10317  {
      +
      10318  return false;
      +
      10319  }
      +
      10320  }
      +
      10321  ++index1st;
      +
      10322  }
      +
      10323 
      +
      10324  // Check next suballocations for BufferImageGranularity conflicts.
      +
      10325  // If conflict exists, we must mark more allocations lost or fail.
      +
      10326  if(bufferImageGranularity > 1)
      +
      10327  {
      +
      10328  while(index1st < suballocations1st.size())
      +
      10329  {
      +
      10330  const VmaSuballocation& suballoc = suballocations1st[index1st];
      +
      10331  if(VmaBlocksOnSamePage(resultOffset, allocSize, suballoc.offset, bufferImageGranularity))
      +
      10332  {
      +
      10333  if(suballoc.hAllocation != VK_NULL_HANDLE)
      +
      10334  {
      +
      10335  // Not checking actual VmaIsBufferImageGranularityConflict(allocType, suballoc.type).
      +
      10336  if(suballoc.hAllocation->CanBecomeLost() &&
      +
      10337  suballoc.hAllocation->GetLastUseFrameIndex() + frameInUseCount < currentFrameIndex)
      +
      10338  {
      +
      10339  ++pAllocationRequest->itemsToMakeLostCount;
      +
      10340  pAllocationRequest->sumItemSize += suballoc.size;
      +
      10341  }
      +
      10342  else
      +
      10343  {
      +
      10344  return false;
      +
      10345  }
      +
      10346  }
      +
      10347  }
      +
      10348  else
      +
      10349  {
      +
      10350  // Already on next page.
      +
      10351  break;
      +
      10352  }
      +
      10353  ++index1st;
      +
      10354  }
      +
      10355  }
      +
      10356 
      +
      10357  // Special case: There is not enough room at the end for this allocation, even after making all from the 1st lost.
      +
      10358  if(index1st == suballocations1st.size() &&
      +
      10359  resultOffset + allocSize + VMA_DEBUG_MARGIN > size)
      +
      10360  {
      +
      10361  // TODO: This is a known bug that it's not yet implemented and the allocation is failing.
      +
      10362  VMA_DEBUG_LOG("Unsupported special case in custom pool with linear allocation algorithm used as ring buffer with allocations that can be lost.");
      +
      10363  }
      +
      10364  }
      +
      10365 
      +
      10366  // There is enough free space at the end after alignment.
      +
      10367  if((index1st == suballocations1st.size() && resultOffset + allocSize + VMA_DEBUG_MARGIN <= size) ||
      +
      10368  (index1st < suballocations1st.size() && resultOffset + allocSize + VMA_DEBUG_MARGIN <= suballocations1st[index1st].offset))
      +
      10369  {
      +
      10370  // Check next suballocations for BufferImageGranularity conflicts.
      +
      10371  // If conflict exists, allocation cannot be made here.
      +
      10372  if(bufferImageGranularity > 1)
      +
      10373  {
      +
      10374  for(size_t nextSuballocIndex = index1st;
      +
      10375  nextSuballocIndex < suballocations1st.size();
      +
      10376  nextSuballocIndex++)
      +
      10377  {
      +
      10378  const VmaSuballocation& nextSuballoc = suballocations1st[nextSuballocIndex];
      +
      10379  if(VmaBlocksOnSamePage(resultOffset, allocSize, nextSuballoc.offset, bufferImageGranularity))
      +
      10380  {
      +
      10381  if(VmaIsBufferImageGranularityConflict(allocType, nextSuballoc.type))
      +
      10382  {
      +
      10383  return false;
      +
      10384  }
      +
      10385  }
      +
      10386  else
      +
      10387  {
      +
      10388  // Already on next page.
      +
      10389  break;
      +
      10390  }
      +
      10391  }
      +
      10392  }
      +
      10393 
      +
      10394  // All tests passed: Success.
      +
      10395  pAllocationRequest->offset = resultOffset;
      +
      10396  pAllocationRequest->sumFreeSize =
      +
      10397  (index1st < suballocations1st.size() ? suballocations1st[index1st].offset : size)
      +
      10398  - resultBaseOffset
      +
      10399  - pAllocationRequest->sumItemSize;
      +
      10400  pAllocationRequest->type = VmaAllocationRequestType::EndOf2nd;
      +
      10401  // pAllocationRequest->item, customData unused.
      +
      10402  return true;
      +
      10403  }
      +
      10404  }
      +
      10405 
      +
      10406  return false;
      +
      10407 }
      +
      10408 
      +
      10409 bool VmaBlockMetadata_Linear::MakeRequestedAllocationsLost(
      +
      10410  uint32_t currentFrameIndex,
      +
      10411  uint32_t frameInUseCount,
      +
      10412  VmaAllocationRequest* pAllocationRequest)
      +
      10413 {
      +
      10414  if(pAllocationRequest->itemsToMakeLostCount == 0)
      +
      10415  {
      +
      10416  return true;
      +
      10417  }
      10418 
      -
      10419 uint32_t VmaBlockMetadata_Linear::MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
      -
      10420 {
      -
      10421  uint32_t lostAllocationCount = 0;
      -
      10422 
      -
      10423  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
      -
      10424  for(size_t i = m_1stNullItemsBeginCount, count = suballocations1st.size(); i < count; ++i)
      -
      10425  {
      -
      10426  VmaSuballocation& suballoc = suballocations1st[i];
      -
      10427  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE &&
      -
      10428  suballoc.hAllocation->CanBecomeLost() &&
      -
      10429  suballoc.hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
      -
      10430  {
      -
      10431  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
      -
      10432  suballoc.hAllocation = VK_NULL_HANDLE;
      -
      10433  ++m_1stNullItemsMiddleCount;
      -
      10434  m_SumFreeSize += suballoc.size;
      -
      10435  ++lostAllocationCount;
      -
      10436  }
      -
      10437  }
      -
      10438 
      -
      10439  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
      -
      10440  for(size_t i = 0, count = suballocations2nd.size(); i < count; ++i)
      -
      10441  {
      -
      10442  VmaSuballocation& suballoc = suballocations2nd[i];
      -
      10443  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE &&
      -
      10444  suballoc.hAllocation->CanBecomeLost() &&
      -
      10445  suballoc.hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
      -
      10446  {
      -
      10447  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
      -
      10448  suballoc.hAllocation = VK_NULL_HANDLE;
      -
      10449  ++m_2ndNullItemsCount;
      -
      10450  m_SumFreeSize += suballoc.size;
      -
      10451  ++lostAllocationCount;
      -
      10452  }
      -
      10453  }
      -
      10454 
      -
      10455  if(lostAllocationCount)
      -
      10456  {
      -
      10457  CleanupAfterFree();
      -
      10458  }
      -
      10459 
      -
      10460  return lostAllocationCount;
      -
      10461 }
      -
      10462 
      -
      10463 VkResult VmaBlockMetadata_Linear::CheckCorruption(const void* pBlockData)
      -
      10464 {
      -
      10465  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
      -
      10466  for(size_t i = m_1stNullItemsBeginCount, count = suballocations1st.size(); i < count; ++i)
      -
      10467  {
      -
      10468  const VmaSuballocation& suballoc = suballocations1st[i];
      -
      10469  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
      -
      10470  {
      -
      10471  if(!VmaValidateMagicValue(pBlockData, suballoc.offset - VMA_DEBUG_MARGIN))
      -
      10472  {
      -
      10473  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED BEFORE VALIDATED ALLOCATION!");
      -
      10474  return VK_ERROR_VALIDATION_FAILED_EXT;
      -
      10475  }
      -
      10476  if(!VmaValidateMagicValue(pBlockData, suballoc.offset + suballoc.size))
      -
      10477  {
      -
      10478  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER VALIDATED ALLOCATION!");
      -
      10479  return VK_ERROR_VALIDATION_FAILED_EXT;
      -
      10480  }
      -
      10481  }
      -
      10482  }
      -
      10483 
      -
      10484  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
      -
      10485  for(size_t i = 0, count = suballocations2nd.size(); i < count; ++i)
      -
      10486  {
      -
      10487  const VmaSuballocation& suballoc = suballocations2nd[i];
      -
      10488  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
      -
      10489  {
      -
      10490  if(!VmaValidateMagicValue(pBlockData, suballoc.offset - VMA_DEBUG_MARGIN))
      -
      10491  {
      -
      10492  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED BEFORE VALIDATED ALLOCATION!");
      -
      10493  return VK_ERROR_VALIDATION_FAILED_EXT;
      -
      10494  }
      -
      10495  if(!VmaValidateMagicValue(pBlockData, suballoc.offset + suballoc.size))
      -
      10496  {
      -
      10497  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER VALIDATED ALLOCATION!");
      -
      10498  return VK_ERROR_VALIDATION_FAILED_EXT;
      -
      10499  }
      -
      10500  }
      -
      10501  }
      -
      10502 
      -
      10503  return VK_SUCCESS;
      -
      10504 }
      -
      10505 
      -
      10506 void VmaBlockMetadata_Linear::Alloc(
      -
      10507  const VmaAllocationRequest& request,
      -
      10508  VmaSuballocationType type,
      -
      10509  VkDeviceSize allocSize,
      -
      10510  VmaAllocation hAllocation)
      -
      10511 {
      -
      10512  const VmaSuballocation newSuballoc = { request.offset, allocSize, hAllocation, type };
      +
      10419  VMA_ASSERT(m_2ndVectorMode == SECOND_VECTOR_EMPTY || m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER);
      +
      10420 
      +
      10421  // We always start from 1st.
      +
      10422  SuballocationVectorType* suballocations = &AccessSuballocations1st();
      +
      10423  size_t index = m_1stNullItemsBeginCount;
      +
      10424  size_t madeLostCount = 0;
      +
      10425  while(madeLostCount < pAllocationRequest->itemsToMakeLostCount)
      +
      10426  {
      +
      10427  if(index == suballocations->size())
      +
      10428  {
      +
      10429  index = 0;
      +
      10430  // If we get to the end of 1st, we wrap around to beginning of 2nd of 1st.
      +
      10431  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
      +
      10432  {
      +
      10433  suballocations = &AccessSuballocations2nd();
      +
      10434  }
      +
      10435  // else: m_2ndVectorMode == SECOND_VECTOR_EMPTY:
      +
      10436  // suballocations continues pointing at AccessSuballocations1st().
      +
      10437  VMA_ASSERT(!suballocations->empty());
      +
      10438  }
      +
      10439  VmaSuballocation& suballoc = (*suballocations)[index];
      +
      10440  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
      +
      10441  {
      +
      10442  VMA_ASSERT(suballoc.hAllocation != VK_NULL_HANDLE);
      +
      10443  VMA_ASSERT(suballoc.hAllocation->CanBecomeLost());
      +
      10444  if(suballoc.hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
      +
      10445  {
      +
      10446  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
      +
      10447  suballoc.hAllocation = VK_NULL_HANDLE;
      +
      10448  m_SumFreeSize += suballoc.size;
      +
      10449  if(suballocations == &AccessSuballocations1st())
      +
      10450  {
      +
      10451  ++m_1stNullItemsMiddleCount;
      +
      10452  }
      +
      10453  else
      +
      10454  {
      +
      10455  ++m_2ndNullItemsCount;
      +
      10456  }
      +
      10457  ++madeLostCount;
      +
      10458  }
      +
      10459  else
      +
      10460  {
      +
      10461  return false;
      +
      10462  }
      +
      10463  }
      +
      10464  ++index;
      +
      10465  }
      +
      10466 
      +
      10467  CleanupAfterFree();
      +
      10468  //VMA_HEAVY_ASSERT(Validate()); // Already called by ClanupAfterFree().
      +
      10469 
      +
      10470  return true;
      +
      10471 }
      +
      10472 
      +
      10473 uint32_t VmaBlockMetadata_Linear::MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
      +
      10474 {
      +
      10475  uint32_t lostAllocationCount = 0;
      +
      10476 
      +
      10477  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
      +
      10478  for(size_t i = m_1stNullItemsBeginCount, count = suballocations1st.size(); i < count; ++i)
      +
      10479  {
      +
      10480  VmaSuballocation& suballoc = suballocations1st[i];
      +
      10481  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE &&
      +
      10482  suballoc.hAllocation->CanBecomeLost() &&
      +
      10483  suballoc.hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
      +
      10484  {
      +
      10485  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
      +
      10486  suballoc.hAllocation = VK_NULL_HANDLE;
      +
      10487  ++m_1stNullItemsMiddleCount;
      +
      10488  m_SumFreeSize += suballoc.size;
      +
      10489  ++lostAllocationCount;
      +
      10490  }
      +
      10491  }
      +
      10492 
      +
      10493  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
      +
      10494  for(size_t i = 0, count = suballocations2nd.size(); i < count; ++i)
      +
      10495  {
      +
      10496  VmaSuballocation& suballoc = suballocations2nd[i];
      +
      10497  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE &&
      +
      10498  suballoc.hAllocation->CanBecomeLost() &&
      +
      10499  suballoc.hAllocation->MakeLost(currentFrameIndex, frameInUseCount))
      +
      10500  {
      +
      10501  suballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
      +
      10502  suballoc.hAllocation = VK_NULL_HANDLE;
      +
      10503  ++m_2ndNullItemsCount;
      +
      10504  m_SumFreeSize += suballoc.size;
      +
      10505  ++lostAllocationCount;
      +
      10506  }
      +
      10507  }
      +
      10508 
      +
      10509  if(lostAllocationCount)
      +
      10510  {
      +
      10511  CleanupAfterFree();
      +
      10512  }
      10513 
      -
      10514  switch(request.type)
      -
      10515  {
      -
      10516  case VmaAllocationRequestType::UpperAddress:
      -
      10517  {
      -
      10518  VMA_ASSERT(m_2ndVectorMode != SECOND_VECTOR_RING_BUFFER &&
      -
      10519  "CRITICAL ERROR: Trying to use linear allocator as double stack while it was already used as ring buffer.");
      -
      10520  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
      -
      10521  suballocations2nd.push_back(newSuballoc);
      -
      10522  m_2ndVectorMode = SECOND_VECTOR_DOUBLE_STACK;
      -
      10523  }
      -
      10524  break;
      -
      10525  case VmaAllocationRequestType::EndOf1st:
      -
      10526  {
      -
      10527  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
      -
      10528 
      -
      10529  VMA_ASSERT(suballocations1st.empty() ||
      -
      10530  request.offset >= suballocations1st.back().offset + suballocations1st.back().size);
      -
      10531  // Check if it fits before the end of the block.
      -
      10532  VMA_ASSERT(request.offset + allocSize <= GetSize());
      -
      10533 
      -
      10534  suballocations1st.push_back(newSuballoc);
      +
      10514  return lostAllocationCount;
      +
      10515 }
      +
      10516 
      +
      10517 VkResult VmaBlockMetadata_Linear::CheckCorruption(const void* pBlockData)
      +
      10518 {
      +
      10519  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
      +
      10520  for(size_t i = m_1stNullItemsBeginCount, count = suballocations1st.size(); i < count; ++i)
      +
      10521  {
      +
      10522  const VmaSuballocation& suballoc = suballocations1st[i];
      +
      10523  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
      +
      10524  {
      +
      10525  if(!VmaValidateMagicValue(pBlockData, suballoc.offset - VMA_DEBUG_MARGIN))
      +
      10526  {
      +
      10527  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED BEFORE VALIDATED ALLOCATION!");
      +
      10528  return VK_ERROR_VALIDATION_FAILED_EXT;
      +
      10529  }
      +
      10530  if(!VmaValidateMagicValue(pBlockData, suballoc.offset + suballoc.size))
      +
      10531  {
      +
      10532  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER VALIDATED ALLOCATION!");
      +
      10533  return VK_ERROR_VALIDATION_FAILED_EXT;
      +
      10534  }
      10535  }
      -
      10536  break;
      -
      10537  case VmaAllocationRequestType::EndOf2nd:
      -
      10538  {
      -
      10539  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
      -
      10540  // New allocation at the end of 2-part ring buffer, so before first allocation from 1st vector.
      -
      10541  VMA_ASSERT(!suballocations1st.empty() &&
      -
      10542  request.offset + allocSize <= suballocations1st[m_1stNullItemsBeginCount].offset);
      -
      10543  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
      -
      10544 
      -
      10545  switch(m_2ndVectorMode)
      -
      10546  {
      -
      10547  case SECOND_VECTOR_EMPTY:
      -
      10548  // First allocation from second part ring buffer.
      -
      10549  VMA_ASSERT(suballocations2nd.empty());
      -
      10550  m_2ndVectorMode = SECOND_VECTOR_RING_BUFFER;
      -
      10551  break;
      -
      10552  case SECOND_VECTOR_RING_BUFFER:
      -
      10553  // 2-part ring buffer is already started.
      -
      10554  VMA_ASSERT(!suballocations2nd.empty());
      -
      10555  break;
      -
      10556  case SECOND_VECTOR_DOUBLE_STACK:
      -
      10557  VMA_ASSERT(0 && "CRITICAL ERROR: Trying to use linear allocator as ring buffer while it was already used as double stack.");
      -
      10558  break;
      -
      10559  default:
      -
      10560  VMA_ASSERT(0);
      -
      10561  }
      -
      10562 
      -
      10563  suballocations2nd.push_back(newSuballoc);
      -
      10564  }
      -
      10565  break;
      -
      10566  default:
      -
      10567  VMA_ASSERT(0 && "CRITICAL INTERNAL ERROR.");
      -
      10568  }
      -
      10569 
      -
      10570  m_SumFreeSize -= newSuballoc.size;
      -
      10571 }
      -
      10572 
      -
      10573 void VmaBlockMetadata_Linear::Free(const VmaAllocation allocation)
      -
      10574 {
      -
      10575  FreeAtOffset(allocation->GetOffset());
      -
      10576 }
      -
      10577 
      -
      10578 void VmaBlockMetadata_Linear::FreeAtOffset(VkDeviceSize offset)
      -
      10579 {
      -
      10580  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
      -
      10581  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
      +
      10536  }
      +
      10537 
      +
      10538  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
      +
      10539  for(size_t i = 0, count = suballocations2nd.size(); i < count; ++i)
      +
      10540  {
      +
      10541  const VmaSuballocation& suballoc = suballocations2nd[i];
      +
      10542  if(suballoc.type != VMA_SUBALLOCATION_TYPE_FREE)
      +
      10543  {
      +
      10544  if(!VmaValidateMagicValue(pBlockData, suballoc.offset - VMA_DEBUG_MARGIN))
      +
      10545  {
      +
      10546  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED BEFORE VALIDATED ALLOCATION!");
      +
      10547  return VK_ERROR_VALIDATION_FAILED_EXT;
      +
      10548  }
      +
      10549  if(!VmaValidateMagicValue(pBlockData, suballoc.offset + suballoc.size))
      +
      10550  {
      +
      10551  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER VALIDATED ALLOCATION!");
      +
      10552  return VK_ERROR_VALIDATION_FAILED_EXT;
      +
      10553  }
      +
      10554  }
      +
      10555  }
      +
      10556 
      +
      10557  return VK_SUCCESS;
      +
      10558 }
      +
      10559 
      +
      10560 void VmaBlockMetadata_Linear::Alloc(
      +
      10561  const VmaAllocationRequest& request,
      +
      10562  VmaSuballocationType type,
      +
      10563  VkDeviceSize allocSize,
      +
      10564  VmaAllocation hAllocation)
      +
      10565 {
      +
      10566  const VmaSuballocation newSuballoc = { request.offset, allocSize, hAllocation, type };
      +
      10567 
      +
      10568  switch(request.type)
      +
      10569  {
      +
      10570  case VmaAllocationRequestType::UpperAddress:
      +
      10571  {
      +
      10572  VMA_ASSERT(m_2ndVectorMode != SECOND_VECTOR_RING_BUFFER &&
      +
      10573  "CRITICAL ERROR: Trying to use linear allocator as double stack while it was already used as ring buffer.");
      +
      10574  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
      +
      10575  suballocations2nd.push_back(newSuballoc);
      +
      10576  m_2ndVectorMode = SECOND_VECTOR_DOUBLE_STACK;
      +
      10577  }
      +
      10578  break;
      +
      10579  case VmaAllocationRequestType::EndOf1st:
      +
      10580  {
      +
      10581  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
      10582 
      -
      10583  if(!suballocations1st.empty())
      -
      10584  {
      -
      10585  // First allocation: Mark it as next empty at the beginning.
      -
      10586  VmaSuballocation& firstSuballoc = suballocations1st[m_1stNullItemsBeginCount];
      -
      10587  if(firstSuballoc.offset == offset)
      -
      10588  {
      -
      10589  firstSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
      -
      10590  firstSuballoc.hAllocation = VK_NULL_HANDLE;
      -
      10591  m_SumFreeSize += firstSuballoc.size;
      -
      10592  ++m_1stNullItemsBeginCount;
      -
      10593  CleanupAfterFree();
      -
      10594  return;
      -
      10595  }
      -
      10596  }
      -
      10597 
      -
      10598  // Last allocation in 2-part ring buffer or top of upper stack (same logic).
      -
      10599  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER ||
      -
      10600  m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
      -
      10601  {
      -
      10602  VmaSuballocation& lastSuballoc = suballocations2nd.back();
      -
      10603  if(lastSuballoc.offset == offset)
      -
      10604  {
      -
      10605  m_SumFreeSize += lastSuballoc.size;
      -
      10606  suballocations2nd.pop_back();
      -
      10607  CleanupAfterFree();
      -
      10608  return;
      -
      10609  }
      -
      10610  }
      -
      10611  // Last allocation in 1st vector.
      -
      10612  else if(m_2ndVectorMode == SECOND_VECTOR_EMPTY)
      -
      10613  {
      -
      10614  VmaSuballocation& lastSuballoc = suballocations1st.back();
      -
      10615  if(lastSuballoc.offset == offset)
      -
      10616  {
      -
      10617  m_SumFreeSize += lastSuballoc.size;
      -
      10618  suballocations1st.pop_back();
      -
      10619  CleanupAfterFree();
      -
      10620  return;
      -
      10621  }
      +
      10583  VMA_ASSERT(suballocations1st.empty() ||
      +
      10584  request.offset >= suballocations1st.back().offset + suballocations1st.back().size);
      +
      10585  // Check if it fits before the end of the block.
      +
      10586  VMA_ASSERT(request.offset + allocSize <= GetSize());
      +
      10587 
      +
      10588  suballocations1st.push_back(newSuballoc);
      +
      10589  }
      +
      10590  break;
      +
      10591  case VmaAllocationRequestType::EndOf2nd:
      +
      10592  {
      +
      10593  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
      +
      10594  // New allocation at the end of 2-part ring buffer, so before first allocation from 1st vector.
      +
      10595  VMA_ASSERT(!suballocations1st.empty() &&
      +
      10596  request.offset + allocSize <= suballocations1st[m_1stNullItemsBeginCount].offset);
      +
      10597  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
      +
      10598 
      +
      10599  switch(m_2ndVectorMode)
      +
      10600  {
      +
      10601  case SECOND_VECTOR_EMPTY:
      +
      10602  // First allocation from second part ring buffer.
      +
      10603  VMA_ASSERT(suballocations2nd.empty());
      +
      10604  m_2ndVectorMode = SECOND_VECTOR_RING_BUFFER;
      +
      10605  break;
      +
      10606  case SECOND_VECTOR_RING_BUFFER:
      +
      10607  // 2-part ring buffer is already started.
      +
      10608  VMA_ASSERT(!suballocations2nd.empty());
      +
      10609  break;
      +
      10610  case SECOND_VECTOR_DOUBLE_STACK:
      +
      10611  VMA_ASSERT(0 && "CRITICAL ERROR: Trying to use linear allocator as ring buffer while it was already used as double stack.");
      +
      10612  break;
      +
      10613  default:
      +
      10614  VMA_ASSERT(0);
      +
      10615  }
      +
      10616 
      +
      10617  suballocations2nd.push_back(newSuballoc);
      +
      10618  }
      +
      10619  break;
      +
      10620  default:
      +
      10621  VMA_ASSERT(0 && "CRITICAL INTERNAL ERROR.");
      10622  }
      10623 
      -
      10624  // Item from the middle of 1st vector.
      -
      10625  {
      -
      10626  VmaSuballocation refSuballoc;
      -
      10627  refSuballoc.offset = offset;
      -
      10628  // Rest of members stays uninitialized intentionally for better performance.
      -
      10629  SuballocationVectorType::iterator it = VmaBinaryFindSorted(
      -
      10630  suballocations1st.begin() + m_1stNullItemsBeginCount,
      -
      10631  suballocations1st.end(),
      -
      10632  refSuballoc,
      -
      10633  VmaSuballocationOffsetLess());
      -
      10634  if(it != suballocations1st.end())
      -
      10635  {
      -
      10636  it->type = VMA_SUBALLOCATION_TYPE_FREE;
      -
      10637  it->hAllocation = VK_NULL_HANDLE;
      -
      10638  ++m_1stNullItemsMiddleCount;
      -
      10639  m_SumFreeSize += it->size;
      -
      10640  CleanupAfterFree();
      -
      10641  return;
      -
      10642  }
      -
      10643  }
      -
      10644 
      -
      10645  if(m_2ndVectorMode != SECOND_VECTOR_EMPTY)
      -
      10646  {
      -
      10647  // Item from the middle of 2nd vector.
      -
      10648  VmaSuballocation refSuballoc;
      -
      10649  refSuballoc.offset = offset;
      -
      10650  // Rest of members stays uninitialized intentionally for better performance.
      -
      10651  SuballocationVectorType::iterator it = m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER ?
      -
      10652  VmaBinaryFindSorted(suballocations2nd.begin(), suballocations2nd.end(), refSuballoc, VmaSuballocationOffsetLess()) :
      -
      10653  VmaBinaryFindSorted(suballocations2nd.begin(), suballocations2nd.end(), refSuballoc, VmaSuballocationOffsetGreater());
      -
      10654  if(it != suballocations2nd.end())
      -
      10655  {
      -
      10656  it->type = VMA_SUBALLOCATION_TYPE_FREE;
      -
      10657  it->hAllocation = VK_NULL_HANDLE;
      -
      10658  ++m_2ndNullItemsCount;
      -
      10659  m_SumFreeSize += it->size;
      -
      10660  CleanupAfterFree();
      -
      10661  return;
      -
      10662  }
      -
      10663  }
      -
      10664 
      -
      10665  VMA_ASSERT(0 && "Allocation to free not found in linear allocator!");
      -
      10666 }
      -
      10667 
      -
      10668 bool VmaBlockMetadata_Linear::ShouldCompact1st() const
      -
      10669 {
      -
      10670  const size_t nullItemCount = m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount;
      -
      10671  const size_t suballocCount = AccessSuballocations1st().size();
      -
      10672  return suballocCount > 32 && nullItemCount * 2 >= (suballocCount - nullItemCount) * 3;
      -
      10673 }
      -
      10674 
      -
      10675 void VmaBlockMetadata_Linear::CleanupAfterFree()
      -
      10676 {
      -
      10677  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
      -
      10678  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
      -
      10679 
      -
      10680  if(IsEmpty())
      -
      10681  {
      -
      10682  suballocations1st.clear();
      -
      10683  suballocations2nd.clear();
      -
      10684  m_1stNullItemsBeginCount = 0;
      -
      10685  m_1stNullItemsMiddleCount = 0;
      -
      10686  m_2ndNullItemsCount = 0;
      -
      10687  m_2ndVectorMode = SECOND_VECTOR_EMPTY;
      -
      10688  }
      -
      10689  else
      -
      10690  {
      -
      10691  const size_t suballoc1stCount = suballocations1st.size();
      -
      10692  const size_t nullItem1stCount = m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount;
      -
      10693  VMA_ASSERT(nullItem1stCount <= suballoc1stCount);
      -
      10694 
      -
      10695  // Find more null items at the beginning of 1st vector.
      -
      10696  while(m_1stNullItemsBeginCount < suballoc1stCount &&
      -
      10697  suballocations1st[m_1stNullItemsBeginCount].hAllocation == VK_NULL_HANDLE)
      -
      10698  {
      -
      10699  ++m_1stNullItemsBeginCount;
      -
      10700  --m_1stNullItemsMiddleCount;
      -
      10701  }
      -
      10702 
      -
      10703  // Find more null items at the end of 1st vector.
      -
      10704  while(m_1stNullItemsMiddleCount > 0 &&
      -
      10705  suballocations1st.back().hAllocation == VK_NULL_HANDLE)
      -
      10706  {
      -
      10707  --m_1stNullItemsMiddleCount;
      -
      10708  suballocations1st.pop_back();
      -
      10709  }
      -
      10710 
      -
      10711  // Find more null items at the end of 2nd vector.
      -
      10712  while(m_2ndNullItemsCount > 0 &&
      -
      10713  suballocations2nd.back().hAllocation == VK_NULL_HANDLE)
      -
      10714  {
      -
      10715  --m_2ndNullItemsCount;
      -
      10716  suballocations2nd.pop_back();
      -
      10717  }
      +
      10624  m_SumFreeSize -= newSuballoc.size;
      +
      10625 }
      +
      10626 
      +
      10627 void VmaBlockMetadata_Linear::Free(const VmaAllocation allocation)
      +
      10628 {
      +
      10629  FreeAtOffset(allocation->GetOffset());
      +
      10630 }
      +
      10631 
      +
      10632 void VmaBlockMetadata_Linear::FreeAtOffset(VkDeviceSize offset)
      +
      10633 {
      +
      10634  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
      +
      10635  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
      +
      10636 
      +
      10637  if(!suballocations1st.empty())
      +
      10638  {
      +
      10639  // First allocation: Mark it as next empty at the beginning.
      +
      10640  VmaSuballocation& firstSuballoc = suballocations1st[m_1stNullItemsBeginCount];
      +
      10641  if(firstSuballoc.offset == offset)
      +
      10642  {
      +
      10643  firstSuballoc.type = VMA_SUBALLOCATION_TYPE_FREE;
      +
      10644  firstSuballoc.hAllocation = VK_NULL_HANDLE;
      +
      10645  m_SumFreeSize += firstSuballoc.size;
      +
      10646  ++m_1stNullItemsBeginCount;
      +
      10647  CleanupAfterFree();
      +
      10648  return;
      +
      10649  }
      +
      10650  }
      +
      10651 
      +
      10652  // Last allocation in 2-part ring buffer or top of upper stack (same logic).
      +
      10653  if(m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER ||
      +
      10654  m_2ndVectorMode == SECOND_VECTOR_DOUBLE_STACK)
      +
      10655  {
      +
      10656  VmaSuballocation& lastSuballoc = suballocations2nd.back();
      +
      10657  if(lastSuballoc.offset == offset)
      +
      10658  {
      +
      10659  m_SumFreeSize += lastSuballoc.size;
      +
      10660  suballocations2nd.pop_back();
      +
      10661  CleanupAfterFree();
      +
      10662  return;
      +
      10663  }
      +
      10664  }
      +
      10665  // Last allocation in 1st vector.
      +
      10666  else if(m_2ndVectorMode == SECOND_VECTOR_EMPTY)
      +
      10667  {
      +
      10668  VmaSuballocation& lastSuballoc = suballocations1st.back();
      +
      10669  if(lastSuballoc.offset == offset)
      +
      10670  {
      +
      10671  m_SumFreeSize += lastSuballoc.size;
      +
      10672  suballocations1st.pop_back();
      +
      10673  CleanupAfterFree();
      +
      10674  return;
      +
      10675  }
      +
      10676  }
      +
      10677 
      +
      10678  // Item from the middle of 1st vector.
      +
      10679  {
      +
      10680  VmaSuballocation refSuballoc;
      +
      10681  refSuballoc.offset = offset;
      +
      10682  // Rest of members stays uninitialized intentionally for better performance.
      +
      10683  SuballocationVectorType::iterator it = VmaBinaryFindSorted(
      +
      10684  suballocations1st.begin() + m_1stNullItemsBeginCount,
      +
      10685  suballocations1st.end(),
      +
      10686  refSuballoc,
      +
      10687  VmaSuballocationOffsetLess());
      +
      10688  if(it != suballocations1st.end())
      +
      10689  {
      +
      10690  it->type = VMA_SUBALLOCATION_TYPE_FREE;
      +
      10691  it->hAllocation = VK_NULL_HANDLE;
      +
      10692  ++m_1stNullItemsMiddleCount;
      +
      10693  m_SumFreeSize += it->size;
      +
      10694  CleanupAfterFree();
      +
      10695  return;
      +
      10696  }
      +
      10697  }
      +
      10698 
      +
      10699  if(m_2ndVectorMode != SECOND_VECTOR_EMPTY)
      +
      10700  {
      +
      10701  // Item from the middle of 2nd vector.
      +
      10702  VmaSuballocation refSuballoc;
      +
      10703  refSuballoc.offset = offset;
      +
      10704  // Rest of members stays uninitialized intentionally for better performance.
      +
      10705  SuballocationVectorType::iterator it = m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER ?
      +
      10706  VmaBinaryFindSorted(suballocations2nd.begin(), suballocations2nd.end(), refSuballoc, VmaSuballocationOffsetLess()) :
      +
      10707  VmaBinaryFindSorted(suballocations2nd.begin(), suballocations2nd.end(), refSuballoc, VmaSuballocationOffsetGreater());
      +
      10708  if(it != suballocations2nd.end())
      +
      10709  {
      +
      10710  it->type = VMA_SUBALLOCATION_TYPE_FREE;
      +
      10711  it->hAllocation = VK_NULL_HANDLE;
      +
      10712  ++m_2ndNullItemsCount;
      +
      10713  m_SumFreeSize += it->size;
      +
      10714  CleanupAfterFree();
      +
      10715  return;
      +
      10716  }
      +
      10717  }
      10718 
      -
      10719  // Find more null items at the beginning of 2nd vector.
      -
      10720  while(m_2ndNullItemsCount > 0 &&
      -
      10721  suballocations2nd[0].hAllocation == VK_NULL_HANDLE)
      -
      10722  {
      -
      10723  --m_2ndNullItemsCount;
      -
      10724  VmaVectorRemove(suballocations2nd, 0);
      -
      10725  }
      -
      10726 
      -
      10727  if(ShouldCompact1st())
      -
      10728  {
      -
      10729  const size_t nonNullItemCount = suballoc1stCount - nullItem1stCount;
      -
      10730  size_t srcIndex = m_1stNullItemsBeginCount;
      -
      10731  for(size_t dstIndex = 0; dstIndex < nonNullItemCount; ++dstIndex)
      -
      10732  {
      -
      10733  while(suballocations1st[srcIndex].hAllocation == VK_NULL_HANDLE)
      -
      10734  {
      -
      10735  ++srcIndex;
      -
      10736  }
      -
      10737  if(dstIndex != srcIndex)
      -
      10738  {
      -
      10739  suballocations1st[dstIndex] = suballocations1st[srcIndex];
      -
      10740  }
      -
      10741  ++srcIndex;
      -
      10742  }
      -
      10743  suballocations1st.resize(nonNullItemCount);
      -
      10744  m_1stNullItemsBeginCount = 0;
      -
      10745  m_1stNullItemsMiddleCount = 0;
      -
      10746  }
      -
      10747 
      -
      10748  // 2nd vector became empty.
      -
      10749  if(suballocations2nd.empty())
      -
      10750  {
      -
      10751  m_2ndVectorMode = SECOND_VECTOR_EMPTY;
      -
      10752  }
      -
      10753 
      -
      10754  // 1st vector became empty.
      -
      10755  if(suballocations1st.size() - m_1stNullItemsBeginCount == 0)
      -
      10756  {
      -
      10757  suballocations1st.clear();
      -
      10758  m_1stNullItemsBeginCount = 0;
      -
      10759 
      -
      10760  if(!suballocations2nd.empty() && m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
      -
      10761  {
      -
      10762  // Swap 1st with 2nd. Now 2nd is empty.
      -
      10763  m_2ndVectorMode = SECOND_VECTOR_EMPTY;
      -
      10764  m_1stNullItemsMiddleCount = m_2ndNullItemsCount;
      -
      10765  while(m_1stNullItemsBeginCount < suballocations2nd.size() &&
      -
      10766  suballocations2nd[m_1stNullItemsBeginCount].hAllocation == VK_NULL_HANDLE)
      -
      10767  {
      -
      10768  ++m_1stNullItemsBeginCount;
      -
      10769  --m_1stNullItemsMiddleCount;
      -
      10770  }
      -
      10771  m_2ndNullItemsCount = 0;
      -
      10772  m_1stVectorIndex ^= 1;
      -
      10773  }
      -
      10774  }
      -
      10775  }
      -
      10776 
      -
      10777  VMA_HEAVY_ASSERT(Validate());
      -
      10778 }
      -
      10779 
      +
      10719  VMA_ASSERT(0 && "Allocation to free not found in linear allocator!");
      +
      10720 }
      +
      10721 
      +
      10722 bool VmaBlockMetadata_Linear::ShouldCompact1st() const
      +
      10723 {
      +
      10724  const size_t nullItemCount = m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount;
      +
      10725  const size_t suballocCount = AccessSuballocations1st().size();
      +
      10726  return suballocCount > 32 && nullItemCount * 2 >= (suballocCount - nullItemCount) * 3;
      +
      10727 }
      +
      10728 
      +
      10729 void VmaBlockMetadata_Linear::CleanupAfterFree()
      +
      10730 {
      +
      10731  SuballocationVectorType& suballocations1st = AccessSuballocations1st();
      +
      10732  SuballocationVectorType& suballocations2nd = AccessSuballocations2nd();
      +
      10733 
      +
      10734  if(IsEmpty())
      +
      10735  {
      +
      10736  suballocations1st.clear();
      +
      10737  suballocations2nd.clear();
      +
      10738  m_1stNullItemsBeginCount = 0;
      +
      10739  m_1stNullItemsMiddleCount = 0;
      +
      10740  m_2ndNullItemsCount = 0;
      +
      10741  m_2ndVectorMode = SECOND_VECTOR_EMPTY;
      +
      10742  }
      +
      10743  else
      +
      10744  {
      +
      10745  const size_t suballoc1stCount = suballocations1st.size();
      +
      10746  const size_t nullItem1stCount = m_1stNullItemsBeginCount + m_1stNullItemsMiddleCount;
      +
      10747  VMA_ASSERT(nullItem1stCount <= suballoc1stCount);
      +
      10748 
      +
      10749  // Find more null items at the beginning of 1st vector.
      +
      10750  while(m_1stNullItemsBeginCount < suballoc1stCount &&
      +
      10751  suballocations1st[m_1stNullItemsBeginCount].hAllocation == VK_NULL_HANDLE)
      +
      10752  {
      +
      10753  ++m_1stNullItemsBeginCount;
      +
      10754  --m_1stNullItemsMiddleCount;
      +
      10755  }
      +
      10756 
      +
      10757  // Find more null items at the end of 1st vector.
      +
      10758  while(m_1stNullItemsMiddleCount > 0 &&
      +
      10759  suballocations1st.back().hAllocation == VK_NULL_HANDLE)
      +
      10760  {
      +
      10761  --m_1stNullItemsMiddleCount;
      +
      10762  suballocations1st.pop_back();
      +
      10763  }
      +
      10764 
      +
      10765  // Find more null items at the end of 2nd vector.
      +
      10766  while(m_2ndNullItemsCount > 0 &&
      +
      10767  suballocations2nd.back().hAllocation == VK_NULL_HANDLE)
      +
      10768  {
      +
      10769  --m_2ndNullItemsCount;
      +
      10770  suballocations2nd.pop_back();
      +
      10771  }
      +
      10772 
      +
      10773  // Find more null items at the beginning of 2nd vector.
      +
      10774  while(m_2ndNullItemsCount > 0 &&
      +
      10775  suballocations2nd[0].hAllocation == VK_NULL_HANDLE)
      +
      10776  {
      +
      10777  --m_2ndNullItemsCount;
      +
      10778  VmaVectorRemove(suballocations2nd, 0);
      +
      10779  }
      10780 
      -
      10782 // class VmaBlockMetadata_Buddy
      -
      10783 
      -
      10784 VmaBlockMetadata_Buddy::VmaBlockMetadata_Buddy(VmaAllocator hAllocator) :
      -
      10785  VmaBlockMetadata(hAllocator),
      -
      10786  m_Root(VMA_NULL),
      -
      10787  m_AllocationCount(0),
      -
      10788  m_FreeCount(1),
      -
      10789  m_SumFreeSize(0)
      -
      10790 {
      -
      10791  memset(m_FreeList, 0, sizeof(m_FreeList));
      -
      10792 }
      -
      10793 
      -
      10794 VmaBlockMetadata_Buddy::~VmaBlockMetadata_Buddy()
      -
      10795 {
      -
      10796  DeleteNode(m_Root);
      -
      10797 }
      -
      10798 
      -
      10799 void VmaBlockMetadata_Buddy::Init(VkDeviceSize size)
      -
      10800 {
      -
      10801  VmaBlockMetadata::Init(size);
      -
      10802 
      -
      10803  m_UsableSize = VmaPrevPow2(size);
      -
      10804  m_SumFreeSize = m_UsableSize;
      -
      10805 
      -
      10806  // Calculate m_LevelCount.
      -
      10807  m_LevelCount = 1;
      -
      10808  while(m_LevelCount < MAX_LEVELS &&
      -
      10809  LevelToNodeSize(m_LevelCount) >= MIN_NODE_SIZE)
      -
      10810  {
      -
      10811  ++m_LevelCount;
      -
      10812  }
      +
      10781  if(ShouldCompact1st())
      +
      10782  {
      +
      10783  const size_t nonNullItemCount = suballoc1stCount - nullItem1stCount;
      +
      10784  size_t srcIndex = m_1stNullItemsBeginCount;
      +
      10785  for(size_t dstIndex = 0; dstIndex < nonNullItemCount; ++dstIndex)
      +
      10786  {
      +
      10787  while(suballocations1st[srcIndex].hAllocation == VK_NULL_HANDLE)
      +
      10788  {
      +
      10789  ++srcIndex;
      +
      10790  }
      +
      10791  if(dstIndex != srcIndex)
      +
      10792  {
      +
      10793  suballocations1st[dstIndex] = suballocations1st[srcIndex];
      +
      10794  }
      +
      10795  ++srcIndex;
      +
      10796  }
      +
      10797  suballocations1st.resize(nonNullItemCount);
      +
      10798  m_1stNullItemsBeginCount = 0;
      +
      10799  m_1stNullItemsMiddleCount = 0;
      +
      10800  }
      +
      10801 
      +
      10802  // 2nd vector became empty.
      +
      10803  if(suballocations2nd.empty())
      +
      10804  {
      +
      10805  m_2ndVectorMode = SECOND_VECTOR_EMPTY;
      +
      10806  }
      +
      10807 
      +
      10808  // 1st vector became empty.
      +
      10809  if(suballocations1st.size() - m_1stNullItemsBeginCount == 0)
      +
      10810  {
      +
      10811  suballocations1st.clear();
      +
      10812  m_1stNullItemsBeginCount = 0;
      10813 
      -
      10814  Node* rootNode = vma_new(GetAllocationCallbacks(), Node)();
      -
      10815  rootNode->offset = 0;
      -
      10816  rootNode->type = Node::TYPE_FREE;
      -
      10817  rootNode->parent = VMA_NULL;
      -
      10818  rootNode->buddy = VMA_NULL;
      -
      10819 
      -
      10820  m_Root = rootNode;
      -
      10821  AddToFreeListFront(0, rootNode);
      -
      10822 }
      -
      10823 
      -
      10824 bool VmaBlockMetadata_Buddy::Validate() const
      -
      10825 {
      -
      10826  // Validate tree.
      -
      10827  ValidationContext ctx;
      -
      10828  if(!ValidateNode(ctx, VMA_NULL, m_Root, 0, LevelToNodeSize(0)))
      -
      10829  {
      -
      10830  VMA_VALIDATE(false && "ValidateNode failed.");
      -
      10831  }
      -
      10832  VMA_VALIDATE(m_AllocationCount == ctx.calculatedAllocationCount);
      -
      10833  VMA_VALIDATE(m_SumFreeSize == ctx.calculatedSumFreeSize);
      +
      10814  if(!suballocations2nd.empty() && m_2ndVectorMode == SECOND_VECTOR_RING_BUFFER)
      +
      10815  {
      +
      10816  // Swap 1st with 2nd. Now 2nd is empty.
      +
      10817  m_2ndVectorMode = SECOND_VECTOR_EMPTY;
      +
      10818  m_1stNullItemsMiddleCount = m_2ndNullItemsCount;
      +
      10819  while(m_1stNullItemsBeginCount < suballocations2nd.size() &&
      +
      10820  suballocations2nd[m_1stNullItemsBeginCount].hAllocation == VK_NULL_HANDLE)
      +
      10821  {
      +
      10822  ++m_1stNullItemsBeginCount;
      +
      10823  --m_1stNullItemsMiddleCount;
      +
      10824  }
      +
      10825  m_2ndNullItemsCount = 0;
      +
      10826  m_1stVectorIndex ^= 1;
      +
      10827  }
      +
      10828  }
      +
      10829  }
      +
      10830 
      +
      10831  VMA_HEAVY_ASSERT(Validate());
      +
      10832 }
      +
      10833 
      10834 
      -
      10835  // Validate free node lists.
      -
      10836  for(uint32_t level = 0; level < m_LevelCount; ++level)
      -
      10837  {
      -
      10838  VMA_VALIDATE(m_FreeList[level].front == VMA_NULL ||
      -
      10839  m_FreeList[level].front->free.prev == VMA_NULL);
      -
      10840 
      -
      10841  for(Node* node = m_FreeList[level].front;
      -
      10842  node != VMA_NULL;
      -
      10843  node = node->free.next)
      -
      10844  {
      -
      10845  VMA_VALIDATE(node->type == Node::TYPE_FREE);
      -
      10846 
      -
      10847  if(node->free.next == VMA_NULL)
      -
      10848  {
      -
      10849  VMA_VALIDATE(m_FreeList[level].back == node);
      -
      10850  }
      -
      10851  else
      -
      10852  {
      -
      10853  VMA_VALIDATE(node->free.next->free.prev == node);
      -
      10854  }
      -
      10855  }
      -
      10856  }
      -
      10857 
      -
      10858  // Validate that free lists ar higher levels are empty.
      -
      10859  for(uint32_t level = m_LevelCount; level < MAX_LEVELS; ++level)
      -
      10860  {
      -
      10861  VMA_VALIDATE(m_FreeList[level].front == VMA_NULL && m_FreeList[level].back == VMA_NULL);
      -
      10862  }
      -
      10863 
      -
      10864  return true;
      -
      10865 }
      -
      10866 
      -
      10867 VkDeviceSize VmaBlockMetadata_Buddy::GetUnusedRangeSizeMax() const
      -
      10868 {
      -
      10869  for(uint32_t level = 0; level < m_LevelCount; ++level)
      -
      10870  {
      -
      10871  if(m_FreeList[level].front != VMA_NULL)
      -
      10872  {
      -
      10873  return LevelToNodeSize(level);
      -
      10874  }
      -
      10875  }
      -
      10876  return 0;
      -
      10877 }
      -
      10878 
      -
      10879 void VmaBlockMetadata_Buddy::CalcAllocationStatInfo(VmaStatInfo& outInfo) const
      -
      10880 {
      -
      10881  const VkDeviceSize unusableSize = GetUnusableSize();
      -
      10882 
      -
      10883  outInfo.blockCount = 1;
      -
      10884 
      -
      10885  outInfo.allocationCount = outInfo.unusedRangeCount = 0;
      -
      10886  outInfo.usedBytes = outInfo.unusedBytes = 0;
      -
      10887 
      -
      10888  outInfo.allocationSizeMax = outInfo.unusedRangeSizeMax = 0;
      -
      10889  outInfo.allocationSizeMin = outInfo.unusedRangeSizeMin = UINT64_MAX;
      -
      10890  outInfo.allocationSizeAvg = outInfo.unusedRangeSizeAvg = 0; // Unused.
      -
      10891 
      -
      10892  CalcAllocationStatInfoNode(outInfo, m_Root, LevelToNodeSize(0));
      -
      10893 
      -
      10894  if(unusableSize > 0)
      -
      10895  {
      -
      10896  ++outInfo.unusedRangeCount;
      -
      10897  outInfo.unusedBytes += unusableSize;
      -
      10898  outInfo.unusedRangeSizeMax = VMA_MAX(outInfo.unusedRangeSizeMax, unusableSize);
      -
      10899  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusableSize);
      -
      10900  }
      -
      10901 }
      -
      10902 
      -
      10903 void VmaBlockMetadata_Buddy::AddPoolStats(VmaPoolStats& inoutStats) const
      -
      10904 {
      -
      10905  const VkDeviceSize unusableSize = GetUnusableSize();
      -
      10906 
      -
      10907  inoutStats.size += GetSize();
      -
      10908  inoutStats.unusedSize += m_SumFreeSize + unusableSize;
      -
      10909  inoutStats.allocationCount += m_AllocationCount;
      -
      10910  inoutStats.unusedRangeCount += m_FreeCount;
      -
      10911  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, GetUnusedRangeSizeMax());
      -
      10912 
      -
      10913  if(unusableSize > 0)
      +
      10836 // class VmaBlockMetadata_Buddy
      +
      10837 
      +
      10838 VmaBlockMetadata_Buddy::VmaBlockMetadata_Buddy(VmaAllocator hAllocator) :
      +
      10839  VmaBlockMetadata(hAllocator),
      +
      10840  m_Root(VMA_NULL),
      +
      10841  m_AllocationCount(0),
      +
      10842  m_FreeCount(1),
      +
      10843  m_SumFreeSize(0)
      +
      10844 {
      +
      10845  memset(m_FreeList, 0, sizeof(m_FreeList));
      +
      10846 }
      +
      10847 
      +
      10848 VmaBlockMetadata_Buddy::~VmaBlockMetadata_Buddy()
      +
      10849 {
      +
      10850  DeleteNode(m_Root);
      +
      10851 }
      +
      10852 
      +
      10853 void VmaBlockMetadata_Buddy::Init(VkDeviceSize size)
      +
      10854 {
      +
      10855  VmaBlockMetadata::Init(size);
      +
      10856 
      +
      10857  m_UsableSize = VmaPrevPow2(size);
      +
      10858  m_SumFreeSize = m_UsableSize;
      +
      10859 
      +
      10860  // Calculate m_LevelCount.
      +
      10861  m_LevelCount = 1;
      +
      10862  while(m_LevelCount < MAX_LEVELS &&
      +
      10863  LevelToNodeSize(m_LevelCount) >= MIN_NODE_SIZE)
      +
      10864  {
      +
      10865  ++m_LevelCount;
      +
      10866  }
      +
      10867 
      +
      10868  Node* rootNode = vma_new(GetAllocationCallbacks(), Node)();
      +
      10869  rootNode->offset = 0;
      +
      10870  rootNode->type = Node::TYPE_FREE;
      +
      10871  rootNode->parent = VMA_NULL;
      +
      10872  rootNode->buddy = VMA_NULL;
      +
      10873 
      +
      10874  m_Root = rootNode;
      +
      10875  AddToFreeListFront(0, rootNode);
      +
      10876 }
      +
      10877 
      +
      10878 bool VmaBlockMetadata_Buddy::Validate() const
      +
      10879 {
      +
      10880  // Validate tree.
      +
      10881  ValidationContext ctx;
      +
      10882  if(!ValidateNode(ctx, VMA_NULL, m_Root, 0, LevelToNodeSize(0)))
      +
      10883  {
      +
      10884  VMA_VALIDATE(false && "ValidateNode failed.");
      +
      10885  }
      +
      10886  VMA_VALIDATE(m_AllocationCount == ctx.calculatedAllocationCount);
      +
      10887  VMA_VALIDATE(m_SumFreeSize == ctx.calculatedSumFreeSize);
      +
      10888 
      +
      10889  // Validate free node lists.
      +
      10890  for(uint32_t level = 0; level < m_LevelCount; ++level)
      +
      10891  {
      +
      10892  VMA_VALIDATE(m_FreeList[level].front == VMA_NULL ||
      +
      10893  m_FreeList[level].front->free.prev == VMA_NULL);
      +
      10894 
      +
      10895  for(Node* node = m_FreeList[level].front;
      +
      10896  node != VMA_NULL;
      +
      10897  node = node->free.next)
      +
      10898  {
      +
      10899  VMA_VALIDATE(node->type == Node::TYPE_FREE);
      +
      10900 
      +
      10901  if(node->free.next == VMA_NULL)
      +
      10902  {
      +
      10903  VMA_VALIDATE(m_FreeList[level].back == node);
      +
      10904  }
      +
      10905  else
      +
      10906  {
      +
      10907  VMA_VALIDATE(node->free.next->free.prev == node);
      +
      10908  }
      +
      10909  }
      +
      10910  }
      +
      10911 
      +
      10912  // Validate that free lists ar higher levels are empty.
      +
      10913  for(uint32_t level = m_LevelCount; level < MAX_LEVELS; ++level)
      10914  {
      -
      10915  ++inoutStats.unusedRangeCount;
      -
      10916  // Not updating inoutStats.unusedRangeSizeMax with unusableSize because this space is not available for allocations.
      -
      10917  }
      -
      10918 }
      -
      10919 
      -
      10920 #if VMA_STATS_STRING_ENABLED
      -
      10921 
      -
      10922 void VmaBlockMetadata_Buddy::PrintDetailedMap(class VmaJsonWriter& json) const
      -
      10923 {
      -
      10924  // TODO optimize
      -
      10925  VmaStatInfo stat;
      -
      10926  CalcAllocationStatInfo(stat);
      -
      10927 
      -
      10928  PrintDetailedMap_Begin(
      -
      10929  json,
      -
      10930  stat.unusedBytes,
      -
      10931  stat.allocationCount,
      -
      10932  stat.unusedRangeCount);
      -
      10933 
      -
      10934  PrintDetailedMapNode(json, m_Root, LevelToNodeSize(0));
      -
      10935 
      -
      10936  const VkDeviceSize unusableSize = GetUnusableSize();
      -
      10937  if(unusableSize > 0)
      -
      10938  {
      -
      10939  PrintDetailedMap_UnusedRange(json,
      -
      10940  m_UsableSize, // offset
      -
      10941  unusableSize); // size
      -
      10942  }
      -
      10943 
      -
      10944  PrintDetailedMap_End(json);
      -
      10945 }
      -
      10946 
      -
      10947 #endif // #if VMA_STATS_STRING_ENABLED
      -
      10948 
      -
      10949 bool VmaBlockMetadata_Buddy::CreateAllocationRequest(
      -
      10950  uint32_t currentFrameIndex,
      -
      10951  uint32_t frameInUseCount,
      -
      10952  VkDeviceSize bufferImageGranularity,
      -
      10953  VkDeviceSize allocSize,
      -
      10954  VkDeviceSize allocAlignment,
      -
      10955  bool upperAddress,
      -
      10956  VmaSuballocationType allocType,
      -
      10957  bool canMakeOtherLost,
      -
      10958  uint32_t strategy,
      -
      10959  VmaAllocationRequest* pAllocationRequest)
      -
      10960 {
      -
      10961  VMA_ASSERT(!upperAddress && "VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT can be used only with linear algorithm.");
      -
      10962 
      -
      10963  // Simple way to respect bufferImageGranularity. May be optimized some day.
      -
      10964  // Whenever it might be an OPTIMAL image...
      -
      10965  if(allocType == VMA_SUBALLOCATION_TYPE_UNKNOWN ||
      -
      10966  allocType == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
      -
      10967  allocType == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL)
      +
      10915  VMA_VALIDATE(m_FreeList[level].front == VMA_NULL && m_FreeList[level].back == VMA_NULL);
      +
      10916  }
      +
      10917 
      +
      10918  return true;
      +
      10919 }
      +
      10920 
      +
      10921 VkDeviceSize VmaBlockMetadata_Buddy::GetUnusedRangeSizeMax() const
      +
      10922 {
      +
      10923  for(uint32_t level = 0; level < m_LevelCount; ++level)
      +
      10924  {
      +
      10925  if(m_FreeList[level].front != VMA_NULL)
      +
      10926  {
      +
      10927  return LevelToNodeSize(level);
      +
      10928  }
      +
      10929  }
      +
      10930  return 0;
      +
      10931 }
      +
      10932 
      +
      10933 void VmaBlockMetadata_Buddy::CalcAllocationStatInfo(VmaStatInfo& outInfo) const
      +
      10934 {
      +
      10935  const VkDeviceSize unusableSize = GetUnusableSize();
      +
      10936 
      +
      10937  outInfo.blockCount = 1;
      +
      10938 
      +
      10939  outInfo.allocationCount = outInfo.unusedRangeCount = 0;
      +
      10940  outInfo.usedBytes = outInfo.unusedBytes = 0;
      +
      10941 
      +
      10942  outInfo.allocationSizeMax = outInfo.unusedRangeSizeMax = 0;
      +
      10943  outInfo.allocationSizeMin = outInfo.unusedRangeSizeMin = UINT64_MAX;
      +
      10944  outInfo.allocationSizeAvg = outInfo.unusedRangeSizeAvg = 0; // Unused.
      +
      10945 
      +
      10946  CalcAllocationStatInfoNode(outInfo, m_Root, LevelToNodeSize(0));
      +
      10947 
      +
      10948  if(unusableSize > 0)
      +
      10949  {
      +
      10950  ++outInfo.unusedRangeCount;
      +
      10951  outInfo.unusedBytes += unusableSize;
      +
      10952  outInfo.unusedRangeSizeMax = VMA_MAX(outInfo.unusedRangeSizeMax, unusableSize);
      +
      10953  outInfo.unusedRangeSizeMin = VMA_MIN(outInfo.unusedRangeSizeMin, unusableSize);
      +
      10954  }
      +
      10955 }
      +
      10956 
      +
      10957 void VmaBlockMetadata_Buddy::AddPoolStats(VmaPoolStats& inoutStats) const
      +
      10958 {
      +
      10959  const VkDeviceSize unusableSize = GetUnusableSize();
      +
      10960 
      +
      10961  inoutStats.size += GetSize();
      +
      10962  inoutStats.unusedSize += m_SumFreeSize + unusableSize;
      +
      10963  inoutStats.allocationCount += m_AllocationCount;
      +
      10964  inoutStats.unusedRangeCount += m_FreeCount;
      +
      10965  inoutStats.unusedRangeSizeMax = VMA_MAX(inoutStats.unusedRangeSizeMax, GetUnusedRangeSizeMax());
      +
      10966 
      +
      10967  if(unusableSize > 0)
      10968  {
      -
      10969  allocAlignment = VMA_MAX(allocAlignment, bufferImageGranularity);
      -
      10970  allocSize = VMA_MAX(allocSize, bufferImageGranularity);
      +
      10969  ++inoutStats.unusedRangeCount;
      +
      10970  // Not updating inoutStats.unusedRangeSizeMax with unusableSize because this space is not available for allocations.
      10971  }
      -
      10972 
      -
      10973  if(allocSize > m_UsableSize)
      -
      10974  {
      -
      10975  return false;
      -
      10976  }
      -
      10977 
      -
      10978  const uint32_t targetLevel = AllocSizeToLevel(allocSize);
      -
      10979  for(uint32_t level = targetLevel + 1; level--; )
      -
      10980  {
      -
      10981  for(Node* freeNode = m_FreeList[level].front;
      -
      10982  freeNode != VMA_NULL;
      -
      10983  freeNode = freeNode->free.next)
      -
      10984  {
      -
      10985  if(freeNode->offset % allocAlignment == 0)
      -
      10986  {
      -
      10987  pAllocationRequest->type = VmaAllocationRequestType::Normal;
      -
      10988  pAllocationRequest->offset = freeNode->offset;
      -
      10989  pAllocationRequest->sumFreeSize = LevelToNodeSize(level);
      -
      10990  pAllocationRequest->sumItemSize = 0;
      -
      10991  pAllocationRequest->itemsToMakeLostCount = 0;
      -
      10992  pAllocationRequest->customData = (void*)(uintptr_t)level;
      -
      10993  return true;
      -
      10994  }
      -
      10995  }
      +
      10972 }
      +
      10973 
      +
      10974 #if VMA_STATS_STRING_ENABLED
      +
      10975 
      +
      10976 void VmaBlockMetadata_Buddy::PrintDetailedMap(class VmaJsonWriter& json) const
      +
      10977 {
      +
      10978  // TODO optimize
      +
      10979  VmaStatInfo stat;
      +
      10980  CalcAllocationStatInfo(stat);
      +
      10981 
      +
      10982  PrintDetailedMap_Begin(
      +
      10983  json,
      +
      10984  stat.unusedBytes,
      +
      10985  stat.allocationCount,
      +
      10986  stat.unusedRangeCount);
      +
      10987 
      +
      10988  PrintDetailedMapNode(json, m_Root, LevelToNodeSize(0));
      +
      10989 
      +
      10990  const VkDeviceSize unusableSize = GetUnusableSize();
      +
      10991  if(unusableSize > 0)
      +
      10992  {
      +
      10993  PrintDetailedMap_UnusedRange(json,
      +
      10994  m_UsableSize, // offset
      +
      10995  unusableSize); // size
      10996  }
      10997 
      -
      10998  return false;
      +
      10998  PrintDetailedMap_End(json);
      10999 }
      11000 
      -
      11001 bool VmaBlockMetadata_Buddy::MakeRequestedAllocationsLost(
      -
      11002  uint32_t currentFrameIndex,
      -
      11003  uint32_t frameInUseCount,
      -
      11004  VmaAllocationRequest* pAllocationRequest)
      -
      11005 {
      -
      11006  /*
      -
      11007  Lost allocations are not supported in buddy allocator at the moment.
      -
      11008  Support might be added in the future.
      -
      11009  */
      -
      11010  return pAllocationRequest->itemsToMakeLostCount == 0;
      -
      11011 }
      -
      11012 
      -
      11013 uint32_t VmaBlockMetadata_Buddy::MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
      +
      11001 #endif // #if VMA_STATS_STRING_ENABLED
      +
      11002 
      +
      11003 bool VmaBlockMetadata_Buddy::CreateAllocationRequest(
      +
      11004  uint32_t currentFrameIndex,
      +
      11005  uint32_t frameInUseCount,
      +
      11006  VkDeviceSize bufferImageGranularity,
      +
      11007  VkDeviceSize allocSize,
      +
      11008  VkDeviceSize allocAlignment,
      +
      11009  bool upperAddress,
      +
      11010  VmaSuballocationType allocType,
      +
      11011  bool canMakeOtherLost,
      +
      11012  uint32_t strategy,
      +
      11013  VmaAllocationRequest* pAllocationRequest)
      11014 {
      -
      11015  /*
      -
      11016  Lost allocations are not supported in buddy allocator at the moment.
      -
      11017  Support might be added in the future.
      -
      11018  */
      -
      11019  return 0;
      -
      11020 }
      -
      11021 
      -
      11022 void VmaBlockMetadata_Buddy::Alloc(
      -
      11023  const VmaAllocationRequest& request,
      -
      11024  VmaSuballocationType type,
      -
      11025  VkDeviceSize allocSize,
      -
      11026  VmaAllocation hAllocation)
      -
      11027 {
      -
      11028  VMA_ASSERT(request.type == VmaAllocationRequestType::Normal);
      -
      11029 
      -
      11030  const uint32_t targetLevel = AllocSizeToLevel(allocSize);
      -
      11031  uint32_t currLevel = (uint32_t)(uintptr_t)request.customData;
      -
      11032 
      -
      11033  Node* currNode = m_FreeList[currLevel].front;
      -
      11034  VMA_ASSERT(currNode != VMA_NULL && currNode->type == Node::TYPE_FREE);
      -
      11035  while(currNode->offset != request.offset)
      -
      11036  {
      -
      11037  currNode = currNode->free.next;
      -
      11038  VMA_ASSERT(currNode != VMA_NULL && currNode->type == Node::TYPE_FREE);
      -
      11039  }
      -
      11040 
      -
      11041  // Go down, splitting free nodes.
      -
      11042  while(currLevel < targetLevel)
      -
      11043  {
      -
      11044  // currNode is already first free node at currLevel.
      -
      11045  // Remove it from list of free nodes at this currLevel.
      -
      11046  RemoveFromFreeList(currLevel, currNode);
      -
      11047 
      -
      11048  const uint32_t childrenLevel = currLevel + 1;
      -
      11049 
      -
      11050  // Create two free sub-nodes.
      -
      11051  Node* leftChild = vma_new(GetAllocationCallbacks(), Node)();
      -
      11052  Node* rightChild = vma_new(GetAllocationCallbacks(), Node)();
      -
      11053 
      -
      11054  leftChild->offset = currNode->offset;
      -
      11055  leftChild->type = Node::TYPE_FREE;
      -
      11056  leftChild->parent = currNode;
      -
      11057  leftChild->buddy = rightChild;
      -
      11058 
      -
      11059  rightChild->offset = currNode->offset + LevelToNodeSize(childrenLevel);
      -
      11060  rightChild->type = Node::TYPE_FREE;
      -
      11061  rightChild->parent = currNode;
      -
      11062  rightChild->buddy = leftChild;
      -
      11063 
      -
      11064  // Convert current currNode to split type.
      -
      11065  currNode->type = Node::TYPE_SPLIT;
      -
      11066  currNode->split.leftChild = leftChild;
      -
      11067 
      -
      11068  // Add child nodes to free list. Order is important!
      -
      11069  AddToFreeListFront(childrenLevel, rightChild);
      -
      11070  AddToFreeListFront(childrenLevel, leftChild);
      -
      11071 
      -
      11072  ++m_FreeCount;
      -
      11073  //m_SumFreeSize -= LevelToNodeSize(currLevel) % 2; // Useful only when level node sizes can be non power of 2.
      -
      11074  ++currLevel;
      -
      11075  currNode = m_FreeList[currLevel].front;
      -
      11076 
      -
      11077  /*
      -
      11078  We can be sure that currNode, as left child of node previously split,
      -
      11079  also fullfills the alignment requirement.
      -
      11080  */
      -
      11081  }
      -
      11082 
      -
      11083  // Remove from free list.
      -
      11084  VMA_ASSERT(currLevel == targetLevel &&
      -
      11085  currNode != VMA_NULL &&
      -
      11086  currNode->type == Node::TYPE_FREE);
      -
      11087  RemoveFromFreeList(currLevel, currNode);
      -
      11088 
      -
      11089  // Convert to allocation node.
      -
      11090  currNode->type = Node::TYPE_ALLOCATION;
      -
      11091  currNode->allocation.alloc = hAllocation;
      -
      11092 
      -
      11093  ++m_AllocationCount;
      -
      11094  --m_FreeCount;
      -
      11095  m_SumFreeSize -= allocSize;
      -
      11096 }
      -
      11097 
      -
      11098 void VmaBlockMetadata_Buddy::DeleteNode(Node* node)
      -
      11099 {
      -
      11100  if(node->type == Node::TYPE_SPLIT)
      -
      11101  {
      -
      11102  DeleteNode(node->split.leftChild->buddy);
      -
      11103  DeleteNode(node->split.leftChild);
      -
      11104  }
      -
      11105 
      -
      11106  vma_delete(GetAllocationCallbacks(), node);
      -
      11107 }
      -
      11108 
      -
      11109 bool VmaBlockMetadata_Buddy::ValidateNode(ValidationContext& ctx, const Node* parent, const Node* curr, uint32_t level, VkDeviceSize levelNodeSize) const
      -
      11110 {
      -
      11111  VMA_VALIDATE(level < m_LevelCount);
      -
      11112  VMA_VALIDATE(curr->parent == parent);
      -
      11113  VMA_VALIDATE((curr->buddy == VMA_NULL) == (parent == VMA_NULL));
      -
      11114  VMA_VALIDATE(curr->buddy == VMA_NULL || curr->buddy->buddy == curr);
      -
      11115  switch(curr->type)
      -
      11116  {
      -
      11117  case Node::TYPE_FREE:
      -
      11118  // curr->free.prev, next are validated separately.
      -
      11119  ctx.calculatedSumFreeSize += levelNodeSize;
      -
      11120  ++ctx.calculatedFreeCount;
      -
      11121  break;
      -
      11122  case Node::TYPE_ALLOCATION:
      -
      11123  ++ctx.calculatedAllocationCount;
      -
      11124  ctx.calculatedSumFreeSize += levelNodeSize - curr->allocation.alloc->GetSize();
      -
      11125  VMA_VALIDATE(curr->allocation.alloc != VK_NULL_HANDLE);
      -
      11126  break;
      -
      11127  case Node::TYPE_SPLIT:
      -
      11128  {
      -
      11129  const uint32_t childrenLevel = level + 1;
      -
      11130  const VkDeviceSize childrenLevelNodeSize = levelNodeSize / 2;
      -
      11131  const Node* const leftChild = curr->split.leftChild;
      -
      11132  VMA_VALIDATE(leftChild != VMA_NULL);
      -
      11133  VMA_VALIDATE(leftChild->offset == curr->offset);
      -
      11134  if(!ValidateNode(ctx, curr, leftChild, childrenLevel, childrenLevelNodeSize))
      -
      11135  {
      -
      11136  VMA_VALIDATE(false && "ValidateNode for left child failed.");
      -
      11137  }
      -
      11138  const Node* const rightChild = leftChild->buddy;
      -
      11139  VMA_VALIDATE(rightChild->offset == curr->offset + childrenLevelNodeSize);
      -
      11140  if(!ValidateNode(ctx, curr, rightChild, childrenLevel, childrenLevelNodeSize))
      -
      11141  {
      -
      11142  VMA_VALIDATE(false && "ValidateNode for right child failed.");
      -
      11143  }
      -
      11144  }
      -
      11145  break;
      -
      11146  default:
      -
      11147  return false;
      -
      11148  }
      -
      11149 
      -
      11150  return true;
      -
      11151 }
      -
      11152 
      -
      11153 uint32_t VmaBlockMetadata_Buddy::AllocSizeToLevel(VkDeviceSize allocSize) const
      -
      11154 {
      -
      11155  // I know this could be optimized somehow e.g. by using std::log2p1 from C++20.
      -
      11156  uint32_t level = 0;
      -
      11157  VkDeviceSize currLevelNodeSize = m_UsableSize;
      -
      11158  VkDeviceSize nextLevelNodeSize = currLevelNodeSize >> 1;
      -
      11159  while(allocSize <= nextLevelNodeSize && level + 1 < m_LevelCount)
      -
      11160  {
      -
      11161  ++level;
      -
      11162  currLevelNodeSize = nextLevelNodeSize;
      -
      11163  nextLevelNodeSize = currLevelNodeSize >> 1;
      -
      11164  }
      -
      11165  return level;
      -
      11166 }
      -
      11167 
      -
      11168 void VmaBlockMetadata_Buddy::FreeAtOffset(VmaAllocation alloc, VkDeviceSize offset)
      -
      11169 {
      -
      11170  // Find node and level.
      -
      11171  Node* node = m_Root;
      -
      11172  VkDeviceSize nodeOffset = 0;
      -
      11173  uint32_t level = 0;
      -
      11174  VkDeviceSize levelNodeSize = LevelToNodeSize(0);
      -
      11175  while(node->type == Node::TYPE_SPLIT)
      -
      11176  {
      -
      11177  const VkDeviceSize nextLevelSize = levelNodeSize >> 1;
      -
      11178  if(offset < nodeOffset + nextLevelSize)
      -
      11179  {
      -
      11180  node = node->split.leftChild;
      -
      11181  }
      -
      11182  else
      -
      11183  {
      -
      11184  node = node->split.leftChild->buddy;
      -
      11185  nodeOffset += nextLevelSize;
      -
      11186  }
      -
      11187  ++level;
      -
      11188  levelNodeSize = nextLevelSize;
      -
      11189  }
      -
      11190 
      -
      11191  VMA_ASSERT(node != VMA_NULL && node->type == Node::TYPE_ALLOCATION);
      -
      11192  VMA_ASSERT(alloc == VK_NULL_HANDLE || node->allocation.alloc == alloc);
      -
      11193 
      -
      11194  ++m_FreeCount;
      -
      11195  --m_AllocationCount;
      -
      11196  m_SumFreeSize += alloc->GetSize();
      -
      11197 
      -
      11198  node->type = Node::TYPE_FREE;
      -
      11199 
      -
      11200  // Join free nodes if possible.
      -
      11201  while(level > 0 && node->buddy->type == Node::TYPE_FREE)
      -
      11202  {
      -
      11203  RemoveFromFreeList(level, node->buddy);
      -
      11204  Node* const parent = node->parent;
      -
      11205 
      -
      11206  vma_delete(GetAllocationCallbacks(), node->buddy);
      -
      11207  vma_delete(GetAllocationCallbacks(), node);
      -
      11208  parent->type = Node::TYPE_FREE;
      -
      11209 
      -
      11210  node = parent;
      -
      11211  --level;
      -
      11212  //m_SumFreeSize += LevelToNodeSize(level) % 2; // Useful only when level node sizes can be non power of 2.
      -
      11213  --m_FreeCount;
      -
      11214  }
      -
      11215 
      -
      11216  AddToFreeListFront(level, node);
      -
      11217 }
      -
      11218 
      -
      11219 void VmaBlockMetadata_Buddy::CalcAllocationStatInfoNode(VmaStatInfo& outInfo, const Node* node, VkDeviceSize levelNodeSize) const
      -
      11220 {
      -
      11221  switch(node->type)
      -
      11222  {
      -
      11223  case Node::TYPE_FREE:
      -
      11224  ++outInfo.unusedRangeCount;
      -
      11225  outInfo.unusedBytes += levelNodeSize;
      -
      11226  outInfo.unusedRangeSizeMax = VMA_MAX(outInfo.unusedRangeSizeMax, levelNodeSize);
      -
      11227  outInfo.unusedRangeSizeMin = VMA_MAX(outInfo.unusedRangeSizeMin, levelNodeSize);
      -
      11228  break;
      -
      11229  case Node::TYPE_ALLOCATION:
      -
      11230  {
      -
      11231  const VkDeviceSize allocSize = node->allocation.alloc->GetSize();
      -
      11232  ++outInfo.allocationCount;
      -
      11233  outInfo.usedBytes += allocSize;
      -
      11234  outInfo.allocationSizeMax = VMA_MAX(outInfo.allocationSizeMax, allocSize);
      -
      11235  outInfo.allocationSizeMin = VMA_MAX(outInfo.allocationSizeMin, allocSize);
      -
      11236 
      -
      11237  const VkDeviceSize unusedRangeSize = levelNodeSize - allocSize;
      -
      11238  if(unusedRangeSize > 0)
      -
      11239  {
      -
      11240  ++outInfo.unusedRangeCount;
      -
      11241  outInfo.unusedBytes += unusedRangeSize;
      -
      11242  outInfo.unusedRangeSizeMax = VMA_MAX(outInfo.unusedRangeSizeMax, unusedRangeSize);
      -
      11243  outInfo.unusedRangeSizeMin = VMA_MAX(outInfo.unusedRangeSizeMin, unusedRangeSize);
      -
      11244  }
      -
      11245  }
      -
      11246  break;
      -
      11247  case Node::TYPE_SPLIT:
      -
      11248  {
      -
      11249  const VkDeviceSize childrenNodeSize = levelNodeSize / 2;
      -
      11250  const Node* const leftChild = node->split.leftChild;
      -
      11251  CalcAllocationStatInfoNode(outInfo, leftChild, childrenNodeSize);
      -
      11252  const Node* const rightChild = leftChild->buddy;
      -
      11253  CalcAllocationStatInfoNode(outInfo, rightChild, childrenNodeSize);
      -
      11254  }
      -
      11255  break;
      -
      11256  default:
      -
      11257  VMA_ASSERT(0);
      -
      11258  }
      -
      11259 }
      -
      11260 
      -
      11261 void VmaBlockMetadata_Buddy::AddToFreeListFront(uint32_t level, Node* node)
      -
      11262 {
      -
      11263  VMA_ASSERT(node->type == Node::TYPE_FREE);
      -
      11264 
      -
      11265  // List is empty.
      -
      11266  Node* const frontNode = m_FreeList[level].front;
      -
      11267  if(frontNode == VMA_NULL)
      -
      11268  {
      -
      11269  VMA_ASSERT(m_FreeList[level].back == VMA_NULL);
      -
      11270  node->free.prev = node->free.next = VMA_NULL;
      -
      11271  m_FreeList[level].front = m_FreeList[level].back = node;
      -
      11272  }
      -
      11273  else
      -
      11274  {
      -
      11275  VMA_ASSERT(frontNode->free.prev == VMA_NULL);
      -
      11276  node->free.prev = VMA_NULL;
      -
      11277  node->free.next = frontNode;
      -
      11278  frontNode->free.prev = node;
      -
      11279  m_FreeList[level].front = node;
      -
      11280  }
      -
      11281 }
      -
      11282 
      -
      11283 void VmaBlockMetadata_Buddy::RemoveFromFreeList(uint32_t level, Node* node)
      -
      11284 {
      -
      11285  VMA_ASSERT(m_FreeList[level].front != VMA_NULL);
      -
      11286 
      -
      11287  // It is at the front.
      -
      11288  if(node->free.prev == VMA_NULL)
      -
      11289  {
      -
      11290  VMA_ASSERT(m_FreeList[level].front == node);
      -
      11291  m_FreeList[level].front = node->free.next;
      -
      11292  }
      -
      11293  else
      -
      11294  {
      -
      11295  Node* const prevFreeNode = node->free.prev;
      -
      11296  VMA_ASSERT(prevFreeNode->free.next == node);
      -
      11297  prevFreeNode->free.next = node->free.next;
      -
      11298  }
      -
      11299 
      -
      11300  // It is at the back.
      -
      11301  if(node->free.next == VMA_NULL)
      -
      11302  {
      -
      11303  VMA_ASSERT(m_FreeList[level].back == node);
      -
      11304  m_FreeList[level].back = node->free.prev;
      -
      11305  }
      -
      11306  else
      -
      11307  {
      -
      11308  Node* const nextFreeNode = node->free.next;
      -
      11309  VMA_ASSERT(nextFreeNode->free.prev == node);
      -
      11310  nextFreeNode->free.prev = node->free.prev;
      -
      11311  }
      -
      11312 }
      -
      11313 
      -
      11314 #if VMA_STATS_STRING_ENABLED
      -
      11315 void VmaBlockMetadata_Buddy::PrintDetailedMapNode(class VmaJsonWriter& json, const Node* node, VkDeviceSize levelNodeSize) const
      -
      11316 {
      -
      11317  switch(node->type)
      -
      11318  {
      -
      11319  case Node::TYPE_FREE:
      -
      11320  PrintDetailedMap_UnusedRange(json, node->offset, levelNodeSize);
      -
      11321  break;
      -
      11322  case Node::TYPE_ALLOCATION:
      -
      11323  {
      -
      11324  PrintDetailedMap_Allocation(json, node->offset, node->allocation.alloc);
      -
      11325  const VkDeviceSize allocSize = node->allocation.alloc->GetSize();
      -
      11326  if(allocSize < levelNodeSize)
      -
      11327  {
      -
      11328  PrintDetailedMap_UnusedRange(json, node->offset + allocSize, levelNodeSize - allocSize);
      -
      11329  }
      -
      11330  }
      -
      11331  break;
      -
      11332  case Node::TYPE_SPLIT:
      -
      11333  {
      -
      11334  const VkDeviceSize childrenNodeSize = levelNodeSize / 2;
      -
      11335  const Node* const leftChild = node->split.leftChild;
      -
      11336  PrintDetailedMapNode(json, leftChild, childrenNodeSize);
      -
      11337  const Node* const rightChild = leftChild->buddy;
      -
      11338  PrintDetailedMapNode(json, rightChild, childrenNodeSize);
      -
      11339  }
      -
      11340  break;
      -
      11341  default:
      -
      11342  VMA_ASSERT(0);
      -
      11343  }
      -
      11344 }
      -
      11345 #endif // #if VMA_STATS_STRING_ENABLED
      -
      11346 
      -
      11347 
      -
      11349 // class VmaDeviceMemoryBlock
      -
      11350 
      -
      11351 VmaDeviceMemoryBlock::VmaDeviceMemoryBlock(VmaAllocator hAllocator) :
      -
      11352  m_pMetadata(VMA_NULL),
      -
      11353  m_MemoryTypeIndex(UINT32_MAX),
      -
      11354  m_Id(0),
      -
      11355  m_hMemory(VK_NULL_HANDLE),
      -
      11356  m_MapCount(0),
      -
      11357  m_pMappedData(VMA_NULL)
      -
      11358 {
      -
      11359 }
      -
      11360 
      -
      11361 void VmaDeviceMemoryBlock::Init(
      -
      11362  VmaAllocator hAllocator,
      -
      11363  VmaPool hParentPool,
      -
      11364  uint32_t newMemoryTypeIndex,
      -
      11365  VkDeviceMemory newMemory,
      -
      11366  VkDeviceSize newSize,
      -
      11367  uint32_t id,
      -
      11368  uint32_t algorithm)
      -
      11369 {
      -
      11370  VMA_ASSERT(m_hMemory == VK_NULL_HANDLE);
      -
      11371 
      -
      11372  m_hParentPool = hParentPool;
      -
      11373  m_MemoryTypeIndex = newMemoryTypeIndex;
      -
      11374  m_Id = id;
      -
      11375  m_hMemory = newMemory;
      -
      11376 
      -
      11377  switch(algorithm)
      -
      11378  {
      -
      11379  case VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT:
      -
      11380  m_pMetadata = vma_new(hAllocator, VmaBlockMetadata_Linear)(hAllocator);
      -
      11381  break;
      -
      11382  case VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT:
      -
      11383  m_pMetadata = vma_new(hAllocator, VmaBlockMetadata_Buddy)(hAllocator);
      -
      11384  break;
      -
      11385  default:
      -
      11386  VMA_ASSERT(0);
      -
      11387  // Fall-through.
      -
      11388  case 0:
      -
      11389  m_pMetadata = vma_new(hAllocator, VmaBlockMetadata_Generic)(hAllocator);
      -
      11390  }
      -
      11391  m_pMetadata->Init(newSize);
      -
      11392 }
      -
      11393 
      -
      11394 void VmaDeviceMemoryBlock::Destroy(VmaAllocator allocator)
      -
      11395 {
      -
      11396  // This is the most important assert in the entire library.
      -
      11397  // Hitting it means you have some memory leak - unreleased VmaAllocation objects.
      -
      11398  VMA_ASSERT(m_pMetadata->IsEmpty() && "Some allocations were not freed before destruction of this memory block!");
      -
      11399 
      -
      11400  VMA_ASSERT(m_hMemory != VK_NULL_HANDLE);
      -
      11401  allocator->FreeVulkanMemory(m_MemoryTypeIndex, m_pMetadata->GetSize(), m_hMemory);
      -
      11402  m_hMemory = VK_NULL_HANDLE;
      -
      11403 
      -
      11404  vma_delete(allocator, m_pMetadata);
      -
      11405  m_pMetadata = VMA_NULL;
      -
      11406 }
      -
      11407 
      -
      11408 bool VmaDeviceMemoryBlock::Validate() const
      -
      11409 {
      -
      11410  VMA_VALIDATE((m_hMemory != VK_NULL_HANDLE) &&
      -
      11411  (m_pMetadata->GetSize() != 0));
      -
      11412 
      -
      11413  return m_pMetadata->Validate();
      -
      11414 }
      -
      11415 
      -
      11416 VkResult VmaDeviceMemoryBlock::CheckCorruption(VmaAllocator hAllocator)
      -
      11417 {
      -
      11418  void* pData = nullptr;
      -
      11419  VkResult res = Map(hAllocator, 1, &pData);
      -
      11420  if(res != VK_SUCCESS)
      -
      11421  {
      -
      11422  return res;
      -
      11423  }
      -
      11424 
      -
      11425  res = m_pMetadata->CheckCorruption(pData);
      -
      11426 
      -
      11427  Unmap(hAllocator, 1);
      -
      11428 
      -
      11429  return res;
      -
      11430 }
      -
      11431 
      -
      11432 VkResult VmaDeviceMemoryBlock::Map(VmaAllocator hAllocator, uint32_t count, void** ppData)
      -
      11433 {
      -
      11434  if(count == 0)
      -
      11435  {
      -
      11436  return VK_SUCCESS;
      -
      11437  }
      -
      11438 
      -
      11439  VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
      -
      11440  if(m_MapCount != 0)
      -
      11441  {
      -
      11442  m_MapCount += count;
      -
      11443  VMA_ASSERT(m_pMappedData != VMA_NULL);
      -
      11444  if(ppData != VMA_NULL)
      -
      11445  {
      -
      11446  *ppData = m_pMappedData;
      -
      11447  }
      -
      11448  return VK_SUCCESS;
      -
      11449  }
      -
      11450  else
      -
      11451  {
      -
      11452  VkResult result = (*hAllocator->GetVulkanFunctions().vkMapMemory)(
      -
      11453  hAllocator->m_hDevice,
      -
      11454  m_hMemory,
      -
      11455  0, // offset
      -
      11456  VK_WHOLE_SIZE,
      -
      11457  0, // flags
      -
      11458  &m_pMappedData);
      -
      11459  if(result == VK_SUCCESS)
      -
      11460  {
      -
      11461  if(ppData != VMA_NULL)
      -
      11462  {
      -
      11463  *ppData = m_pMappedData;
      -
      11464  }
      -
      11465  m_MapCount = count;
      -
      11466  }
      -
      11467  return result;
      -
      11468  }
      -
      11469 }
      -
      11470 
      -
      11471 void VmaDeviceMemoryBlock::Unmap(VmaAllocator hAllocator, uint32_t count)
      -
      11472 {
      -
      11473  if(count == 0)
      -
      11474  {
      -
      11475  return;
      -
      11476  }
      -
      11477 
      -
      11478  VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
      -
      11479  if(m_MapCount >= count)
      -
      11480  {
      -
      11481  m_MapCount -= count;
      -
      11482  if(m_MapCount == 0)
      -
      11483  {
      -
      11484  m_pMappedData = VMA_NULL;
      -
      11485  (*hAllocator->GetVulkanFunctions().vkUnmapMemory)(hAllocator->m_hDevice, m_hMemory);
      -
      11486  }
      -
      11487  }
      -
      11488  else
      +
      11015  VMA_ASSERT(!upperAddress && "VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT can be used only with linear algorithm.");
      +
      11016 
      +
      11017  // Simple way to respect bufferImageGranularity. May be optimized some day.
      +
      11018  // Whenever it might be an OPTIMAL image...
      +
      11019  if(allocType == VMA_SUBALLOCATION_TYPE_UNKNOWN ||
      +
      11020  allocType == VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN ||
      +
      11021  allocType == VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL)
      +
      11022  {
      +
      11023  allocAlignment = VMA_MAX(allocAlignment, bufferImageGranularity);
      +
      11024  allocSize = VMA_MAX(allocSize, bufferImageGranularity);
      +
      11025  }
      +
      11026 
      +
      11027  if(allocSize > m_UsableSize)
      +
      11028  {
      +
      11029  return false;
      +
      11030  }
      +
      11031 
      +
      11032  const uint32_t targetLevel = AllocSizeToLevel(allocSize);
      +
      11033  for(uint32_t level = targetLevel + 1; level--; )
      +
      11034  {
      +
      11035  for(Node* freeNode = m_FreeList[level].front;
      +
      11036  freeNode != VMA_NULL;
      +
      11037  freeNode = freeNode->free.next)
      +
      11038  {
      +
      11039  if(freeNode->offset % allocAlignment == 0)
      +
      11040  {
      +
      11041  pAllocationRequest->type = VmaAllocationRequestType::Normal;
      +
      11042  pAllocationRequest->offset = freeNode->offset;
      +
      11043  pAllocationRequest->sumFreeSize = LevelToNodeSize(level);
      +
      11044  pAllocationRequest->sumItemSize = 0;
      +
      11045  pAllocationRequest->itemsToMakeLostCount = 0;
      +
      11046  pAllocationRequest->customData = (void*)(uintptr_t)level;
      +
      11047  return true;
      +
      11048  }
      +
      11049  }
      +
      11050  }
      +
      11051 
      +
      11052  return false;
      +
      11053 }
      +
      11054 
      +
      11055 bool VmaBlockMetadata_Buddy::MakeRequestedAllocationsLost(
      +
      11056  uint32_t currentFrameIndex,
      +
      11057  uint32_t frameInUseCount,
      +
      11058  VmaAllocationRequest* pAllocationRequest)
      +
      11059 {
      +
      11060  /*
      +
      11061  Lost allocations are not supported in buddy allocator at the moment.
      +
      11062  Support might be added in the future.
      +
      11063  */
      +
      11064  return pAllocationRequest->itemsToMakeLostCount == 0;
      +
      11065 }
      +
      11066 
      +
      11067 uint32_t VmaBlockMetadata_Buddy::MakeAllocationsLost(uint32_t currentFrameIndex, uint32_t frameInUseCount)
      +
      11068 {
      +
      11069  /*
      +
      11070  Lost allocations are not supported in buddy allocator at the moment.
      +
      11071  Support might be added in the future.
      +
      11072  */
      +
      11073  return 0;
      +
      11074 }
      +
      11075 
      +
      11076 void VmaBlockMetadata_Buddy::Alloc(
      +
      11077  const VmaAllocationRequest& request,
      +
      11078  VmaSuballocationType type,
      +
      11079  VkDeviceSize allocSize,
      +
      11080  VmaAllocation hAllocation)
      +
      11081 {
      +
      11082  VMA_ASSERT(request.type == VmaAllocationRequestType::Normal);
      +
      11083 
      +
      11084  const uint32_t targetLevel = AllocSizeToLevel(allocSize);
      +
      11085  uint32_t currLevel = (uint32_t)(uintptr_t)request.customData;
      +
      11086 
      +
      11087  Node* currNode = m_FreeList[currLevel].front;
      +
      11088  VMA_ASSERT(currNode != VMA_NULL && currNode->type == Node::TYPE_FREE);
      +
      11089  while(currNode->offset != request.offset)
      +
      11090  {
      +
      11091  currNode = currNode->free.next;
      +
      11092  VMA_ASSERT(currNode != VMA_NULL && currNode->type == Node::TYPE_FREE);
      +
      11093  }
      +
      11094 
      +
      11095  // Go down, splitting free nodes.
      +
      11096  while(currLevel < targetLevel)
      +
      11097  {
      +
      11098  // currNode is already first free node at currLevel.
      +
      11099  // Remove it from list of free nodes at this currLevel.
      +
      11100  RemoveFromFreeList(currLevel, currNode);
      +
      11101 
      +
      11102  const uint32_t childrenLevel = currLevel + 1;
      +
      11103 
      +
      11104  // Create two free sub-nodes.
      +
      11105  Node* leftChild = vma_new(GetAllocationCallbacks(), Node)();
      +
      11106  Node* rightChild = vma_new(GetAllocationCallbacks(), Node)();
      +
      11107 
      +
      11108  leftChild->offset = currNode->offset;
      +
      11109  leftChild->type = Node::TYPE_FREE;
      +
      11110  leftChild->parent = currNode;
      +
      11111  leftChild->buddy = rightChild;
      +
      11112 
      +
      11113  rightChild->offset = currNode->offset + LevelToNodeSize(childrenLevel);
      +
      11114  rightChild->type = Node::TYPE_FREE;
      +
      11115  rightChild->parent = currNode;
      +
      11116  rightChild->buddy = leftChild;
      +
      11117 
      +
      11118  // Convert current currNode to split type.
      +
      11119  currNode->type = Node::TYPE_SPLIT;
      +
      11120  currNode->split.leftChild = leftChild;
      +
      11121 
      +
      11122  // Add child nodes to free list. Order is important!
      +
      11123  AddToFreeListFront(childrenLevel, rightChild);
      +
      11124  AddToFreeListFront(childrenLevel, leftChild);
      +
      11125 
      +
      11126  ++m_FreeCount;
      +
      11127  //m_SumFreeSize -= LevelToNodeSize(currLevel) % 2; // Useful only when level node sizes can be non power of 2.
      +
      11128  ++currLevel;
      +
      11129  currNode = m_FreeList[currLevel].front;
      +
      11130 
      +
      11131  /*
      +
      11132  We can be sure that currNode, as left child of node previously split,
      +
      11133  also fullfills the alignment requirement.
      +
      11134  */
      +
      11135  }
      +
      11136 
      +
      11137  // Remove from free list.
      +
      11138  VMA_ASSERT(currLevel == targetLevel &&
      +
      11139  currNode != VMA_NULL &&
      +
      11140  currNode->type == Node::TYPE_FREE);
      +
      11141  RemoveFromFreeList(currLevel, currNode);
      +
      11142 
      +
      11143  // Convert to allocation node.
      +
      11144  currNode->type = Node::TYPE_ALLOCATION;
      +
      11145  currNode->allocation.alloc = hAllocation;
      +
      11146 
      +
      11147  ++m_AllocationCount;
      +
      11148  --m_FreeCount;
      +
      11149  m_SumFreeSize -= allocSize;
      +
      11150 }
      +
      11151 
      +
      11152 void VmaBlockMetadata_Buddy::DeleteNode(Node* node)
      +
      11153 {
      +
      11154  if(node->type == Node::TYPE_SPLIT)
      +
      11155  {
      +
      11156  DeleteNode(node->split.leftChild->buddy);
      +
      11157  DeleteNode(node->split.leftChild);
      +
      11158  }
      +
      11159 
      +
      11160  vma_delete(GetAllocationCallbacks(), node);
      +
      11161 }
      +
      11162 
      +
      11163 bool VmaBlockMetadata_Buddy::ValidateNode(ValidationContext& ctx, const Node* parent, const Node* curr, uint32_t level, VkDeviceSize levelNodeSize) const
      +
      11164 {
      +
      11165  VMA_VALIDATE(level < m_LevelCount);
      +
      11166  VMA_VALIDATE(curr->parent == parent);
      +
      11167  VMA_VALIDATE((curr->buddy == VMA_NULL) == (parent == VMA_NULL));
      +
      11168  VMA_VALIDATE(curr->buddy == VMA_NULL || curr->buddy->buddy == curr);
      +
      11169  switch(curr->type)
      +
      11170  {
      +
      11171  case Node::TYPE_FREE:
      +
      11172  // curr->free.prev, next are validated separately.
      +
      11173  ctx.calculatedSumFreeSize += levelNodeSize;
      +
      11174  ++ctx.calculatedFreeCount;
      +
      11175  break;
      +
      11176  case Node::TYPE_ALLOCATION:
      +
      11177  ++ctx.calculatedAllocationCount;
      +
      11178  ctx.calculatedSumFreeSize += levelNodeSize - curr->allocation.alloc->GetSize();
      +
      11179  VMA_VALIDATE(curr->allocation.alloc != VK_NULL_HANDLE);
      +
      11180  break;
      +
      11181  case Node::TYPE_SPLIT:
      +
      11182  {
      +
      11183  const uint32_t childrenLevel = level + 1;
      +
      11184  const VkDeviceSize childrenLevelNodeSize = levelNodeSize / 2;
      +
      11185  const Node* const leftChild = curr->split.leftChild;
      +
      11186  VMA_VALIDATE(leftChild != VMA_NULL);
      +
      11187  VMA_VALIDATE(leftChild->offset == curr->offset);
      +
      11188  if(!ValidateNode(ctx, curr, leftChild, childrenLevel, childrenLevelNodeSize))
      +
      11189  {
      +
      11190  VMA_VALIDATE(false && "ValidateNode for left child failed.");
      +
      11191  }
      +
      11192  const Node* const rightChild = leftChild->buddy;
      +
      11193  VMA_VALIDATE(rightChild->offset == curr->offset + childrenLevelNodeSize);
      +
      11194  if(!ValidateNode(ctx, curr, rightChild, childrenLevel, childrenLevelNodeSize))
      +
      11195  {
      +
      11196  VMA_VALIDATE(false && "ValidateNode for right child failed.");
      +
      11197  }
      +
      11198  }
      +
      11199  break;
      +
      11200  default:
      +
      11201  return false;
      +
      11202  }
      +
      11203 
      +
      11204  return true;
      +
      11205 }
      +
      11206 
      +
      11207 uint32_t VmaBlockMetadata_Buddy::AllocSizeToLevel(VkDeviceSize allocSize) const
      +
      11208 {
      +
      11209  // I know this could be optimized somehow e.g. by using std::log2p1 from C++20.
      +
      11210  uint32_t level = 0;
      +
      11211  VkDeviceSize currLevelNodeSize = m_UsableSize;
      +
      11212  VkDeviceSize nextLevelNodeSize = currLevelNodeSize >> 1;
      +
      11213  while(allocSize <= nextLevelNodeSize && level + 1 < m_LevelCount)
      +
      11214  {
      +
      11215  ++level;
      +
      11216  currLevelNodeSize = nextLevelNodeSize;
      +
      11217  nextLevelNodeSize = currLevelNodeSize >> 1;
      +
      11218  }
      +
      11219  return level;
      +
      11220 }
      +
      11221 
      +
      11222 void VmaBlockMetadata_Buddy::FreeAtOffset(VmaAllocation alloc, VkDeviceSize offset)
      +
      11223 {
      +
      11224  // Find node and level.
      +
      11225  Node* node = m_Root;
      +
      11226  VkDeviceSize nodeOffset = 0;
      +
      11227  uint32_t level = 0;
      +
      11228  VkDeviceSize levelNodeSize = LevelToNodeSize(0);
      +
      11229  while(node->type == Node::TYPE_SPLIT)
      +
      11230  {
      +
      11231  const VkDeviceSize nextLevelSize = levelNodeSize >> 1;
      +
      11232  if(offset < nodeOffset + nextLevelSize)
      +
      11233  {
      +
      11234  node = node->split.leftChild;
      +
      11235  }
      +
      11236  else
      +
      11237  {
      +
      11238  node = node->split.leftChild->buddy;
      +
      11239  nodeOffset += nextLevelSize;
      +
      11240  }
      +
      11241  ++level;
      +
      11242  levelNodeSize = nextLevelSize;
      +
      11243  }
      +
      11244 
      +
      11245  VMA_ASSERT(node != VMA_NULL && node->type == Node::TYPE_ALLOCATION);
      +
      11246  VMA_ASSERT(alloc == VK_NULL_HANDLE || node->allocation.alloc == alloc);
      +
      11247 
      +
      11248  ++m_FreeCount;
      +
      11249  --m_AllocationCount;
      +
      11250  m_SumFreeSize += alloc->GetSize();
      +
      11251 
      +
      11252  node->type = Node::TYPE_FREE;
      +
      11253 
      +
      11254  // Join free nodes if possible.
      +
      11255  while(level > 0 && node->buddy->type == Node::TYPE_FREE)
      +
      11256  {
      +
      11257  RemoveFromFreeList(level, node->buddy);
      +
      11258  Node* const parent = node->parent;
      +
      11259 
      +
      11260  vma_delete(GetAllocationCallbacks(), node->buddy);
      +
      11261  vma_delete(GetAllocationCallbacks(), node);
      +
      11262  parent->type = Node::TYPE_FREE;
      +
      11263 
      +
      11264  node = parent;
      +
      11265  --level;
      +
      11266  //m_SumFreeSize += LevelToNodeSize(level) % 2; // Useful only when level node sizes can be non power of 2.
      +
      11267  --m_FreeCount;
      +
      11268  }
      +
      11269 
      +
      11270  AddToFreeListFront(level, node);
      +
      11271 }
      +
      11272 
      +
      11273 void VmaBlockMetadata_Buddy::CalcAllocationStatInfoNode(VmaStatInfo& outInfo, const Node* node, VkDeviceSize levelNodeSize) const
      +
      11274 {
      +
      11275  switch(node->type)
      +
      11276  {
      +
      11277  case Node::TYPE_FREE:
      +
      11278  ++outInfo.unusedRangeCount;
      +
      11279  outInfo.unusedBytes += levelNodeSize;
      +
      11280  outInfo.unusedRangeSizeMax = VMA_MAX(outInfo.unusedRangeSizeMax, levelNodeSize);
      +
      11281  outInfo.unusedRangeSizeMin = VMA_MAX(outInfo.unusedRangeSizeMin, levelNodeSize);
      +
      11282  break;
      +
      11283  case Node::TYPE_ALLOCATION:
      +
      11284  {
      +
      11285  const VkDeviceSize allocSize = node->allocation.alloc->GetSize();
      +
      11286  ++outInfo.allocationCount;
      +
      11287  outInfo.usedBytes += allocSize;
      +
      11288  outInfo.allocationSizeMax = VMA_MAX(outInfo.allocationSizeMax, allocSize);
      +
      11289  outInfo.allocationSizeMin = VMA_MAX(outInfo.allocationSizeMin, allocSize);
      +
      11290 
      +
      11291  const VkDeviceSize unusedRangeSize = levelNodeSize - allocSize;
      +
      11292  if(unusedRangeSize > 0)
      +
      11293  {
      +
      11294  ++outInfo.unusedRangeCount;
      +
      11295  outInfo.unusedBytes += unusedRangeSize;
      +
      11296  outInfo.unusedRangeSizeMax = VMA_MAX(outInfo.unusedRangeSizeMax, unusedRangeSize);
      +
      11297  outInfo.unusedRangeSizeMin = VMA_MAX(outInfo.unusedRangeSizeMin, unusedRangeSize);
      +
      11298  }
      +
      11299  }
      +
      11300  break;
      +
      11301  case Node::TYPE_SPLIT:
      +
      11302  {
      +
      11303  const VkDeviceSize childrenNodeSize = levelNodeSize / 2;
      +
      11304  const Node* const leftChild = node->split.leftChild;
      +
      11305  CalcAllocationStatInfoNode(outInfo, leftChild, childrenNodeSize);
      +
      11306  const Node* const rightChild = leftChild->buddy;
      +
      11307  CalcAllocationStatInfoNode(outInfo, rightChild, childrenNodeSize);
      +
      11308  }
      +
      11309  break;
      +
      11310  default:
      +
      11311  VMA_ASSERT(0);
      +
      11312  }
      +
      11313 }
      +
      11314 
      +
      11315 void VmaBlockMetadata_Buddy::AddToFreeListFront(uint32_t level, Node* node)
      +
      11316 {
      +
      11317  VMA_ASSERT(node->type == Node::TYPE_FREE);
      +
      11318 
      +
      11319  // List is empty.
      +
      11320  Node* const frontNode = m_FreeList[level].front;
      +
      11321  if(frontNode == VMA_NULL)
      +
      11322  {
      +
      11323  VMA_ASSERT(m_FreeList[level].back == VMA_NULL);
      +
      11324  node->free.prev = node->free.next = VMA_NULL;
      +
      11325  m_FreeList[level].front = m_FreeList[level].back = node;
      +
      11326  }
      +
      11327  else
      +
      11328  {
      +
      11329  VMA_ASSERT(frontNode->free.prev == VMA_NULL);
      +
      11330  node->free.prev = VMA_NULL;
      +
      11331  node->free.next = frontNode;
      +
      11332  frontNode->free.prev = node;
      +
      11333  m_FreeList[level].front = node;
      +
      11334  }
      +
      11335 }
      +
      11336 
      +
      11337 void VmaBlockMetadata_Buddy::RemoveFromFreeList(uint32_t level, Node* node)
      +
      11338 {
      +
      11339  VMA_ASSERT(m_FreeList[level].front != VMA_NULL);
      +
      11340 
      +
      11341  // It is at the front.
      +
      11342  if(node->free.prev == VMA_NULL)
      +
      11343  {
      +
      11344  VMA_ASSERT(m_FreeList[level].front == node);
      +
      11345  m_FreeList[level].front = node->free.next;
      +
      11346  }
      +
      11347  else
      +
      11348  {
      +
      11349  Node* const prevFreeNode = node->free.prev;
      +
      11350  VMA_ASSERT(prevFreeNode->free.next == node);
      +
      11351  prevFreeNode->free.next = node->free.next;
      +
      11352  }
      +
      11353 
      +
      11354  // It is at the back.
      +
      11355  if(node->free.next == VMA_NULL)
      +
      11356  {
      +
      11357  VMA_ASSERT(m_FreeList[level].back == node);
      +
      11358  m_FreeList[level].back = node->free.prev;
      +
      11359  }
      +
      11360  else
      +
      11361  {
      +
      11362  Node* const nextFreeNode = node->free.next;
      +
      11363  VMA_ASSERT(nextFreeNode->free.prev == node);
      +
      11364  nextFreeNode->free.prev = node->free.prev;
      +
      11365  }
      +
      11366 }
      +
      11367 
      +
      11368 #if VMA_STATS_STRING_ENABLED
      +
      11369 void VmaBlockMetadata_Buddy::PrintDetailedMapNode(class VmaJsonWriter& json, const Node* node, VkDeviceSize levelNodeSize) const
      +
      11370 {
      +
      11371  switch(node->type)
      +
      11372  {
      +
      11373  case Node::TYPE_FREE:
      +
      11374  PrintDetailedMap_UnusedRange(json, node->offset, levelNodeSize);
      +
      11375  break;
      +
      11376  case Node::TYPE_ALLOCATION:
      +
      11377  {
      +
      11378  PrintDetailedMap_Allocation(json, node->offset, node->allocation.alloc);
      +
      11379  const VkDeviceSize allocSize = node->allocation.alloc->GetSize();
      +
      11380  if(allocSize < levelNodeSize)
      +
      11381  {
      +
      11382  PrintDetailedMap_UnusedRange(json, node->offset + allocSize, levelNodeSize - allocSize);
      +
      11383  }
      +
      11384  }
      +
      11385  break;
      +
      11386  case Node::TYPE_SPLIT:
      +
      11387  {
      +
      11388  const VkDeviceSize childrenNodeSize = levelNodeSize / 2;
      +
      11389  const Node* const leftChild = node->split.leftChild;
      +
      11390  PrintDetailedMapNode(json, leftChild, childrenNodeSize);
      +
      11391  const Node* const rightChild = leftChild->buddy;
      +
      11392  PrintDetailedMapNode(json, rightChild, childrenNodeSize);
      +
      11393  }
      +
      11394  break;
      +
      11395  default:
      +
      11396  VMA_ASSERT(0);
      +
      11397  }
      +
      11398 }
      +
      11399 #endif // #if VMA_STATS_STRING_ENABLED
      +
      11400 
      +
      11401 
      +
      11403 // class VmaDeviceMemoryBlock
      +
      11404 
      +
      11405 VmaDeviceMemoryBlock::VmaDeviceMemoryBlock(VmaAllocator hAllocator) :
      +
      11406  m_pMetadata(VMA_NULL),
      +
      11407  m_MemoryTypeIndex(UINT32_MAX),
      +
      11408  m_Id(0),
      +
      11409  m_hMemory(VK_NULL_HANDLE),
      +
      11410  m_MapCount(0),
      +
      11411  m_pMappedData(VMA_NULL)
      +
      11412 {
      +
      11413 }
      +
      11414 
      +
      11415 void VmaDeviceMemoryBlock::Init(
      +
      11416  VmaAllocator hAllocator,
      +
      11417  VmaPool hParentPool,
      +
      11418  uint32_t newMemoryTypeIndex,
      +
      11419  VkDeviceMemory newMemory,
      +
      11420  VkDeviceSize newSize,
      +
      11421  uint32_t id,
      +
      11422  uint32_t algorithm)
      +
      11423 {
      +
      11424  VMA_ASSERT(m_hMemory == VK_NULL_HANDLE);
      +
      11425 
      +
      11426  m_hParentPool = hParentPool;
      +
      11427  m_MemoryTypeIndex = newMemoryTypeIndex;
      +
      11428  m_Id = id;
      +
      11429  m_hMemory = newMemory;
      +
      11430 
      +
      11431  switch(algorithm)
      +
      11432  {
      +
      11433  case VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT:
      +
      11434  m_pMetadata = vma_new(hAllocator, VmaBlockMetadata_Linear)(hAllocator);
      +
      11435  break;
      +
      11436  case VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT:
      +
      11437  m_pMetadata = vma_new(hAllocator, VmaBlockMetadata_Buddy)(hAllocator);
      +
      11438  break;
      +
      11439  default:
      +
      11440  VMA_ASSERT(0);
      +
      11441  // Fall-through.
      +
      11442  case 0:
      +
      11443  m_pMetadata = vma_new(hAllocator, VmaBlockMetadata_Generic)(hAllocator);
      +
      11444  }
      +
      11445  m_pMetadata->Init(newSize);
      +
      11446 }
      +
      11447 
      +
      11448 void VmaDeviceMemoryBlock::Destroy(VmaAllocator allocator)
      +
      11449 {
      +
      11450  // This is the most important assert in the entire library.
      +
      11451  // Hitting it means you have some memory leak - unreleased VmaAllocation objects.
      +
      11452  VMA_ASSERT(m_pMetadata->IsEmpty() && "Some allocations were not freed before destruction of this memory block!");
      +
      11453 
      +
      11454  VMA_ASSERT(m_hMemory != VK_NULL_HANDLE);
      +
      11455  allocator->FreeVulkanMemory(m_MemoryTypeIndex, m_pMetadata->GetSize(), m_hMemory);
      +
      11456  m_hMemory = VK_NULL_HANDLE;
      +
      11457 
      +
      11458  vma_delete(allocator, m_pMetadata);
      +
      11459  m_pMetadata = VMA_NULL;
      +
      11460 }
      +
      11461 
      +
      11462 bool VmaDeviceMemoryBlock::Validate() const
      +
      11463 {
      +
      11464  VMA_VALIDATE((m_hMemory != VK_NULL_HANDLE) &&
      +
      11465  (m_pMetadata->GetSize() != 0));
      +
      11466 
      +
      11467  return m_pMetadata->Validate();
      +
      11468 }
      +
      11469 
      +
      11470 VkResult VmaDeviceMemoryBlock::CheckCorruption(VmaAllocator hAllocator)
      +
      11471 {
      +
      11472  void* pData = nullptr;
      +
      11473  VkResult res = Map(hAllocator, 1, &pData);
      +
      11474  if(res != VK_SUCCESS)
      +
      11475  {
      +
      11476  return res;
      +
      11477  }
      +
      11478 
      +
      11479  res = m_pMetadata->CheckCorruption(pData);
      +
      11480 
      +
      11481  Unmap(hAllocator, 1);
      +
      11482 
      +
      11483  return res;
      +
      11484 }
      +
      11485 
      +
      11486 VkResult VmaDeviceMemoryBlock::Map(VmaAllocator hAllocator, uint32_t count, void** ppData)
      +
      11487 {
      +
      11488  if(count == 0)
      11489  {
      -
      11490  VMA_ASSERT(0 && "VkDeviceMemory block is being unmapped while it was not previously mapped.");
      +
      11490  return VK_SUCCESS;
      11491  }
      -
      11492 }
      -
      11493 
      -
      11494 VkResult VmaDeviceMemoryBlock::WriteMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize)
      -
      11495 {
      -
      11496  VMA_ASSERT(VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_MARGIN % 4 == 0 && VMA_DEBUG_DETECT_CORRUPTION);
      -
      11497  VMA_ASSERT(allocOffset >= VMA_DEBUG_MARGIN);
      -
      11498 
      -
      11499  void* pData;
      -
      11500  VkResult res = Map(hAllocator, 1, &pData);
      -
      11501  if(res != VK_SUCCESS)
      -
      11502  {
      -
      11503  return res;
      -
      11504  }
      -
      11505 
      -
      11506  VmaWriteMagicValue(pData, allocOffset - VMA_DEBUG_MARGIN);
      -
      11507  VmaWriteMagicValue(pData, allocOffset + allocSize);
      -
      11508 
      -
      11509  Unmap(hAllocator, 1);
      -
      11510 
      -
      11511  return VK_SUCCESS;
      -
      11512 }
      -
      11513 
      -
      11514 VkResult VmaDeviceMemoryBlock::ValidateMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize)
      -
      11515 {
      -
      11516  VMA_ASSERT(VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_MARGIN % 4 == 0 && VMA_DEBUG_DETECT_CORRUPTION);
      -
      11517  VMA_ASSERT(allocOffset >= VMA_DEBUG_MARGIN);
      -
      11518 
      -
      11519  void* pData;
      -
      11520  VkResult res = Map(hAllocator, 1, &pData);
      -
      11521  if(res != VK_SUCCESS)
      -
      11522  {
      -
      11523  return res;
      -
      11524  }
      -
      11525 
      -
      11526  if(!VmaValidateMagicValue(pData, allocOffset - VMA_DEBUG_MARGIN))
      -
      11527  {
      -
      11528  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED BEFORE FREED ALLOCATION!");
      -
      11529  }
      -
      11530  else if(!VmaValidateMagicValue(pData, allocOffset + allocSize))
      -
      11531  {
      -
      11532  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER FREED ALLOCATION!");
      -
      11533  }
      -
      11534 
      -
      11535  Unmap(hAllocator, 1);
      -
      11536 
      -
      11537  return VK_SUCCESS;
      -
      11538 }
      -
      11539 
      -
      11540 VkResult VmaDeviceMemoryBlock::BindBufferMemory(
      -
      11541  const VmaAllocator hAllocator,
      -
      11542  const VmaAllocation hAllocation,
      -
      11543  VkDeviceSize allocationLocalOffset,
      -
      11544  VkBuffer hBuffer,
      -
      11545  const void* pNext)
      -
      11546 {
      -
      11547  VMA_ASSERT(hAllocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK &&
      -
      11548  hAllocation->GetBlock() == this);
      -
      11549  VMA_ASSERT(allocationLocalOffset < hAllocation->GetSize() &&
      -
      11550  "Invalid allocationLocalOffset. Did you forget that this offset is relative to the beginning of the allocation, not the whole memory block?");
      -
      11551  const VkDeviceSize memoryOffset = hAllocation->GetOffset() + allocationLocalOffset;
      -
      11552  // This lock is important so that we don't call vkBind... and/or vkMap... simultaneously on the same VkDeviceMemory from multiple threads.
      -
      11553  VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
      -
      11554  return hAllocator->BindVulkanBuffer(m_hMemory, memoryOffset, hBuffer, pNext);
      -
      11555 }
      -
      11556 
      -
      11557 VkResult VmaDeviceMemoryBlock::BindImageMemory(
      -
      11558  const VmaAllocator hAllocator,
      -
      11559  const VmaAllocation hAllocation,
      -
      11560  VkDeviceSize allocationLocalOffset,
      -
      11561  VkImage hImage,
      -
      11562  const void* pNext)
      -
      11563 {
      -
      11564  VMA_ASSERT(hAllocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK &&
      -
      11565  hAllocation->GetBlock() == this);
      -
      11566  VMA_ASSERT(allocationLocalOffset < hAllocation->GetSize() &&
      -
      11567  "Invalid allocationLocalOffset. Did you forget that this offset is relative to the beginning of the allocation, not the whole memory block?");
      -
      11568  const VkDeviceSize memoryOffset = hAllocation->GetOffset() + allocationLocalOffset;
      -
      11569  // This lock is important so that we don't call vkBind... and/or vkMap... simultaneously on the same VkDeviceMemory from multiple threads.
      -
      11570  VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
      -
      11571  return hAllocator->BindVulkanImage(m_hMemory, memoryOffset, hImage, pNext);
      -
      11572 }
      -
      11573 
      -
      11574 static void InitStatInfo(VmaStatInfo& outInfo)
      -
      11575 {
      -
      11576  memset(&outInfo, 0, sizeof(outInfo));
      -
      11577  outInfo.allocationSizeMin = UINT64_MAX;
      -
      11578  outInfo.unusedRangeSizeMin = UINT64_MAX;
      -
      11579 }
      -
      11580 
      -
      11581 // Adds statistics srcInfo into inoutInfo, like: inoutInfo += srcInfo.
      -
      11582 static void VmaAddStatInfo(VmaStatInfo& inoutInfo, const VmaStatInfo& srcInfo)
      -
      11583 {
      -
      11584  inoutInfo.blockCount += srcInfo.blockCount;
      -
      11585  inoutInfo.allocationCount += srcInfo.allocationCount;
      -
      11586  inoutInfo.unusedRangeCount += srcInfo.unusedRangeCount;
      -
      11587  inoutInfo.usedBytes += srcInfo.usedBytes;
      -
      11588  inoutInfo.unusedBytes += srcInfo.unusedBytes;
      -
      11589  inoutInfo.allocationSizeMin = VMA_MIN(inoutInfo.allocationSizeMin, srcInfo.allocationSizeMin);
      -
      11590  inoutInfo.allocationSizeMax = VMA_MAX(inoutInfo.allocationSizeMax, srcInfo.allocationSizeMax);
      -
      11591  inoutInfo.unusedRangeSizeMin = VMA_MIN(inoutInfo.unusedRangeSizeMin, srcInfo.unusedRangeSizeMin);
      -
      11592  inoutInfo.unusedRangeSizeMax = VMA_MAX(inoutInfo.unusedRangeSizeMax, srcInfo.unusedRangeSizeMax);
      -
      11593 }
      -
      11594 
      -
      11595 static void VmaPostprocessCalcStatInfo(VmaStatInfo& inoutInfo)
      -
      11596 {
      -
      11597  inoutInfo.allocationSizeAvg = (inoutInfo.allocationCount > 0) ?
      -
      11598  VmaRoundDiv<VkDeviceSize>(inoutInfo.usedBytes, inoutInfo.allocationCount) : 0;
      -
      11599  inoutInfo.unusedRangeSizeAvg = (inoutInfo.unusedRangeCount > 0) ?
      -
      11600  VmaRoundDiv<VkDeviceSize>(inoutInfo.unusedBytes, inoutInfo.unusedRangeCount) : 0;
      -
      11601 }
      -
      11602 
      -
      11603 VmaPool_T::VmaPool_T(
      -
      11604  VmaAllocator hAllocator,
      -
      11605  const VmaPoolCreateInfo& createInfo,
      -
      11606  VkDeviceSize preferredBlockSize) :
      -
      11607  m_BlockVector(
      -
      11608  hAllocator,
      -
      11609  this, // hParentPool
      -
      11610  createInfo.memoryTypeIndex,
      -
      11611  createInfo.blockSize != 0 ? createInfo.blockSize : preferredBlockSize,
      -
      11612  createInfo.minBlockCount,
      -
      11613  createInfo.maxBlockCount,
      -
      11614  (createInfo.flags & VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT) != 0 ? 1 : hAllocator->GetBufferImageGranularity(),
      -
      11615  createInfo.frameInUseCount,
      -
      11616  true, // isCustomPool
      -
      11617  createInfo.blockSize != 0, // explicitBlockSize
      -
      11618  createInfo.flags & VMA_POOL_CREATE_ALGORITHM_MASK), // algorithm
      -
      11619  m_Id(0)
      -
      11620 {
      -
      11621 }
      -
      11622 
      -
      11623 VmaPool_T::~VmaPool_T()
      -
      11624 {
      -
      11625 }
      -
      11626 
      -
      11627 #if VMA_STATS_STRING_ENABLED
      -
      11628 
      -
      11629 #endif // #if VMA_STATS_STRING_ENABLED
      -
      11630 
      -
      11631 VmaBlockVector::VmaBlockVector(
      -
      11632  VmaAllocator hAllocator,
      -
      11633  VmaPool hParentPool,
      -
      11634  uint32_t memoryTypeIndex,
      -
      11635  VkDeviceSize preferredBlockSize,
      -
      11636  size_t minBlockCount,
      -
      11637  size_t maxBlockCount,
      -
      11638  VkDeviceSize bufferImageGranularity,
      -
      11639  uint32_t frameInUseCount,
      -
      11640  bool isCustomPool,
      -
      11641  bool explicitBlockSize,
      -
      11642  uint32_t algorithm) :
      -
      11643  m_hAllocator(hAllocator),
      -
      11644  m_hParentPool(hParentPool),
      -
      11645  m_MemoryTypeIndex(memoryTypeIndex),
      -
      11646  m_PreferredBlockSize(preferredBlockSize),
      -
      11647  m_MinBlockCount(minBlockCount),
      -
      11648  m_MaxBlockCount(maxBlockCount),
      -
      11649  m_BufferImageGranularity(bufferImageGranularity),
      -
      11650  m_FrameInUseCount(frameInUseCount),
      -
      11651  m_IsCustomPool(isCustomPool),
      -
      11652  m_ExplicitBlockSize(explicitBlockSize),
      -
      11653  m_Algorithm(algorithm),
      -
      11654  m_HasEmptyBlock(false),
      -
      11655  m_Blocks(VmaStlAllocator<VmaDeviceMemoryBlock*>(hAllocator->GetAllocationCallbacks())),
      -
      11656  m_NextBlockId(0)
      -
      11657 {
      -
      11658 }
      -
      11659 
      -
      11660 VmaBlockVector::~VmaBlockVector()
      -
      11661 {
      -
      11662  for(size_t i = m_Blocks.size(); i--; )
      -
      11663  {
      -
      11664  m_Blocks[i]->Destroy(m_hAllocator);
      -
      11665  vma_delete(m_hAllocator, m_Blocks[i]);
      -
      11666  }
      -
      11667 }
      -
      11668 
      -
      11669 VkResult VmaBlockVector::CreateMinBlocks()
      -
      11670 {
      -
      11671  for(size_t i = 0; i < m_MinBlockCount; ++i)
      -
      11672  {
      -
      11673  VkResult res = CreateBlock(m_PreferredBlockSize, VMA_NULL);
      -
      11674  if(res != VK_SUCCESS)
      -
      11675  {
      -
      11676  return res;
      -
      11677  }
      -
      11678  }
      -
      11679  return VK_SUCCESS;
      -
      11680 }
      -
      11681 
      -
      11682 void VmaBlockVector::GetPoolStats(VmaPoolStats* pStats)
      -
      11683 {
      -
      11684  VmaMutexLockRead lock(m_Mutex, m_hAllocator->m_UseMutex);
      -
      11685 
      -
      11686  const size_t blockCount = m_Blocks.size();
      -
      11687 
      -
      11688  pStats->size = 0;
      -
      11689  pStats->unusedSize = 0;
      -
      11690  pStats->allocationCount = 0;
      -
      11691  pStats->unusedRangeCount = 0;
      -
      11692  pStats->unusedRangeSizeMax = 0;
      -
      11693  pStats->blockCount = blockCount;
      -
      11694 
      -
      11695  for(uint32_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
      -
      11696  {
      -
      11697  const VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
      -
      11698  VMA_ASSERT(pBlock);
      -
      11699  VMA_HEAVY_ASSERT(pBlock->Validate());
      -
      11700  pBlock->m_pMetadata->AddPoolStats(*pStats);
      -
      11701  }
      -
      11702 }
      -
      11703 
      -
      11704 bool VmaBlockVector::IsCorruptionDetectionEnabled() const
      -
      11705 {
      -
      11706  const uint32_t requiredMemFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
      -
      11707  return (VMA_DEBUG_DETECT_CORRUPTION != 0) &&
      -
      11708  (VMA_DEBUG_MARGIN > 0) &&
      -
      11709  (m_Algorithm == 0 || m_Algorithm == VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT) &&
      -
      11710  (m_hAllocator->m_MemProps.memoryTypes[m_MemoryTypeIndex].propertyFlags & requiredMemFlags) == requiredMemFlags;
      -
      11711 }
      -
      11712 
      -
      11713 static const uint32_t VMA_ALLOCATION_TRY_COUNT = 32;
      -
      11714 
      -
      11715 VkResult VmaBlockVector::Allocate(
      -
      11716  uint32_t currentFrameIndex,
      -
      11717  VkDeviceSize size,
      -
      11718  VkDeviceSize alignment,
      -
      11719  const VmaAllocationCreateInfo& createInfo,
      -
      11720  VmaSuballocationType suballocType,
      -
      11721  size_t allocationCount,
      -
      11722  VmaAllocation* pAllocations)
      -
      11723 {
      -
      11724  size_t allocIndex;
      -
      11725  VkResult res = VK_SUCCESS;
      +
      11492 
      +
      11493  VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
      +
      11494  if(m_MapCount != 0)
      +
      11495  {
      +
      11496  m_MapCount += count;
      +
      11497  VMA_ASSERT(m_pMappedData != VMA_NULL);
      +
      11498  if(ppData != VMA_NULL)
      +
      11499  {
      +
      11500  *ppData = m_pMappedData;
      +
      11501  }
      +
      11502  return VK_SUCCESS;
      +
      11503  }
      +
      11504  else
      +
      11505  {
      +
      11506  VkResult result = (*hAllocator->GetVulkanFunctions().vkMapMemory)(
      +
      11507  hAllocator->m_hDevice,
      +
      11508  m_hMemory,
      +
      11509  0, // offset
      +
      11510  VK_WHOLE_SIZE,
      +
      11511  0, // flags
      +
      11512  &m_pMappedData);
      +
      11513  if(result == VK_SUCCESS)
      +
      11514  {
      +
      11515  if(ppData != VMA_NULL)
      +
      11516  {
      +
      11517  *ppData = m_pMappedData;
      +
      11518  }
      +
      11519  m_MapCount = count;
      +
      11520  }
      +
      11521  return result;
      +
      11522  }
      +
      11523 }
      +
      11524 
      +
      11525 void VmaDeviceMemoryBlock::Unmap(VmaAllocator hAllocator, uint32_t count)
      +
      11526 {
      +
      11527  if(count == 0)
      +
      11528  {
      +
      11529  return;
      +
      11530  }
      +
      11531 
      +
      11532  VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
      +
      11533  if(m_MapCount >= count)
      +
      11534  {
      +
      11535  m_MapCount -= count;
      +
      11536  if(m_MapCount == 0)
      +
      11537  {
      +
      11538  m_pMappedData = VMA_NULL;
      +
      11539  (*hAllocator->GetVulkanFunctions().vkUnmapMemory)(hAllocator->m_hDevice, m_hMemory);
      +
      11540  }
      +
      11541  }
      +
      11542  else
      +
      11543  {
      +
      11544  VMA_ASSERT(0 && "VkDeviceMemory block is being unmapped while it was not previously mapped.");
      +
      11545  }
      +
      11546 }
      +
      11547 
      +
      11548 VkResult VmaDeviceMemoryBlock::WriteMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize)
      +
      11549 {
      +
      11550  VMA_ASSERT(VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_MARGIN % 4 == 0 && VMA_DEBUG_DETECT_CORRUPTION);
      +
      11551  VMA_ASSERT(allocOffset >= VMA_DEBUG_MARGIN);
      +
      11552 
      +
      11553  void* pData;
      +
      11554  VkResult res = Map(hAllocator, 1, &pData);
      +
      11555  if(res != VK_SUCCESS)
      +
      11556  {
      +
      11557  return res;
      +
      11558  }
      +
      11559 
      +
      11560  VmaWriteMagicValue(pData, allocOffset - VMA_DEBUG_MARGIN);
      +
      11561  VmaWriteMagicValue(pData, allocOffset + allocSize);
      +
      11562 
      +
      11563  Unmap(hAllocator, 1);
      +
      11564 
      +
      11565  return VK_SUCCESS;
      +
      11566 }
      +
      11567 
      +
      11568 VkResult VmaDeviceMemoryBlock::ValidateMagicValueAroundAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize)
      +
      11569 {
      +
      11570  VMA_ASSERT(VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_MARGIN % 4 == 0 && VMA_DEBUG_DETECT_CORRUPTION);
      +
      11571  VMA_ASSERT(allocOffset >= VMA_DEBUG_MARGIN);
      +
      11572 
      +
      11573  void* pData;
      +
      11574  VkResult res = Map(hAllocator, 1, &pData);
      +
      11575  if(res != VK_SUCCESS)
      +
      11576  {
      +
      11577  return res;
      +
      11578  }
      +
      11579 
      +
      11580  if(!VmaValidateMagicValue(pData, allocOffset - VMA_DEBUG_MARGIN))
      +
      11581  {
      +
      11582  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED BEFORE FREED ALLOCATION!");
      +
      11583  }
      +
      11584  else if(!VmaValidateMagicValue(pData, allocOffset + allocSize))
      +
      11585  {
      +
      11586  VMA_ASSERT(0 && "MEMORY CORRUPTION DETECTED AFTER FREED ALLOCATION!");
      +
      11587  }
      +
      11588 
      +
      11589  Unmap(hAllocator, 1);
      +
      11590 
      +
      11591  return VK_SUCCESS;
      +
      11592 }
      +
      11593 
      +
      11594 VkResult VmaDeviceMemoryBlock::BindBufferMemory(
      +
      11595  const VmaAllocator hAllocator,
      +
      11596  const VmaAllocation hAllocation,
      +
      11597  VkDeviceSize allocationLocalOffset,
      +
      11598  VkBuffer hBuffer,
      +
      11599  const void* pNext)
      +
      11600 {
      +
      11601  VMA_ASSERT(hAllocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK &&
      +
      11602  hAllocation->GetBlock() == this);
      +
      11603  VMA_ASSERT(allocationLocalOffset < hAllocation->GetSize() &&
      +
      11604  "Invalid allocationLocalOffset. Did you forget that this offset is relative to the beginning of the allocation, not the whole memory block?");
      +
      11605  const VkDeviceSize memoryOffset = hAllocation->GetOffset() + allocationLocalOffset;
      +
      11606  // This lock is important so that we don't call vkBind... and/or vkMap... simultaneously on the same VkDeviceMemory from multiple threads.
      +
      11607  VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
      +
      11608  return hAllocator->BindVulkanBuffer(m_hMemory, memoryOffset, hBuffer, pNext);
      +
      11609 }
      +
      11610 
      +
      11611 VkResult VmaDeviceMemoryBlock::BindImageMemory(
      +
      11612  const VmaAllocator hAllocator,
      +
      11613  const VmaAllocation hAllocation,
      +
      11614  VkDeviceSize allocationLocalOffset,
      +
      11615  VkImage hImage,
      +
      11616  const void* pNext)
      +
      11617 {
      +
      11618  VMA_ASSERT(hAllocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK &&
      +
      11619  hAllocation->GetBlock() == this);
      +
      11620  VMA_ASSERT(allocationLocalOffset < hAllocation->GetSize() &&
      +
      11621  "Invalid allocationLocalOffset. Did you forget that this offset is relative to the beginning of the allocation, not the whole memory block?");
      +
      11622  const VkDeviceSize memoryOffset = hAllocation->GetOffset() + allocationLocalOffset;
      +
      11623  // This lock is important so that we don't call vkBind... and/or vkMap... simultaneously on the same VkDeviceMemory from multiple threads.
      +
      11624  VmaMutexLock lock(m_Mutex, hAllocator->m_UseMutex);
      +
      11625  return hAllocator->BindVulkanImage(m_hMemory, memoryOffset, hImage, pNext);
      +
      11626 }
      +
      11627 
      +
      11628 static void InitStatInfo(VmaStatInfo& outInfo)
      +
      11629 {
      +
      11630  memset(&outInfo, 0, sizeof(outInfo));
      +
      11631  outInfo.allocationSizeMin = UINT64_MAX;
      +
      11632  outInfo.unusedRangeSizeMin = UINT64_MAX;
      +
      11633 }
      +
      11634 
      +
      11635 // Adds statistics srcInfo into inoutInfo, like: inoutInfo += srcInfo.
      +
      11636 static void VmaAddStatInfo(VmaStatInfo& inoutInfo, const VmaStatInfo& srcInfo)
      +
      11637 {
      +
      11638  inoutInfo.blockCount += srcInfo.blockCount;
      +
      11639  inoutInfo.allocationCount += srcInfo.allocationCount;
      +
      11640  inoutInfo.unusedRangeCount += srcInfo.unusedRangeCount;
      +
      11641  inoutInfo.usedBytes += srcInfo.usedBytes;
      +
      11642  inoutInfo.unusedBytes += srcInfo.unusedBytes;
      +
      11643  inoutInfo.allocationSizeMin = VMA_MIN(inoutInfo.allocationSizeMin, srcInfo.allocationSizeMin);
      +
      11644  inoutInfo.allocationSizeMax = VMA_MAX(inoutInfo.allocationSizeMax, srcInfo.allocationSizeMax);
      +
      11645  inoutInfo.unusedRangeSizeMin = VMA_MIN(inoutInfo.unusedRangeSizeMin, srcInfo.unusedRangeSizeMin);
      +
      11646  inoutInfo.unusedRangeSizeMax = VMA_MAX(inoutInfo.unusedRangeSizeMax, srcInfo.unusedRangeSizeMax);
      +
      11647 }
      +
      11648 
      +
      11649 static void VmaPostprocessCalcStatInfo(VmaStatInfo& inoutInfo)
      +
      11650 {
      +
      11651  inoutInfo.allocationSizeAvg = (inoutInfo.allocationCount > 0) ?
      +
      11652  VmaRoundDiv<VkDeviceSize>(inoutInfo.usedBytes, inoutInfo.allocationCount) : 0;
      +
      11653  inoutInfo.unusedRangeSizeAvg = (inoutInfo.unusedRangeCount > 0) ?
      +
      11654  VmaRoundDiv<VkDeviceSize>(inoutInfo.unusedBytes, inoutInfo.unusedRangeCount) : 0;
      +
      11655 }
      +
      11656 
      +
      11657 VmaPool_T::VmaPool_T(
      +
      11658  VmaAllocator hAllocator,
      +
      11659  const VmaPoolCreateInfo& createInfo,
      +
      11660  VkDeviceSize preferredBlockSize) :
      +
      11661  m_BlockVector(
      +
      11662  hAllocator,
      +
      11663  this, // hParentPool
      +
      11664  createInfo.memoryTypeIndex,
      +
      11665  createInfo.blockSize != 0 ? createInfo.blockSize : preferredBlockSize,
      +
      11666  createInfo.minBlockCount,
      +
      11667  createInfo.maxBlockCount,
      +
      11668  (createInfo.flags & VMA_POOL_CREATE_IGNORE_BUFFER_IMAGE_GRANULARITY_BIT) != 0 ? 1 : hAllocator->GetBufferImageGranularity(),
      +
      11669  createInfo.frameInUseCount,
      +
      11670  createInfo.blockSize != 0, // explicitBlockSize
      +
      11671  createInfo.flags & VMA_POOL_CREATE_ALGORITHM_MASK), // algorithm
      +
      11672  m_Id(0),
      +
      11673  m_Name(VMA_NULL)
      +
      11674 {
      +
      11675 }
      +
      11676 
      +
      11677 VmaPool_T::~VmaPool_T()
      +
      11678 {
      +
      11679 }
      +
      11680 
      +
      11681 void VmaPool_T::SetName(const char* pName)
      +
      11682 {
      +
      11683  const VkAllocationCallbacks* allocs = m_BlockVector.GetAllocator()->GetAllocationCallbacks();
      +
      11684  VmaFreeString(allocs, m_Name);
      +
      11685 
      +
      11686  if(pName != VMA_NULL)
      +
      11687  {
      +
      11688  m_Name = VmaCreateStringCopy(allocs, pName);
      +
      11689  }
      +
      11690  else
      +
      11691  {
      +
      11692  m_Name = VMA_NULL;
      +
      11693  }
      +
      11694 }
      +
      11695 
      +
      11696 #if VMA_STATS_STRING_ENABLED
      +
      11697 
      +
      11698 #endif // #if VMA_STATS_STRING_ENABLED
      +
      11699 
      +
      11700 VmaBlockVector::VmaBlockVector(
      +
      11701  VmaAllocator hAllocator,
      +
      11702  VmaPool hParentPool,
      +
      11703  uint32_t memoryTypeIndex,
      +
      11704  VkDeviceSize preferredBlockSize,
      +
      11705  size_t minBlockCount,
      +
      11706  size_t maxBlockCount,
      +
      11707  VkDeviceSize bufferImageGranularity,
      +
      11708  uint32_t frameInUseCount,
      +
      11709  bool explicitBlockSize,
      +
      11710  uint32_t algorithm) :
      +
      11711  m_hAllocator(hAllocator),
      +
      11712  m_hParentPool(hParentPool),
      +
      11713  m_MemoryTypeIndex(memoryTypeIndex),
      +
      11714  m_PreferredBlockSize(preferredBlockSize),
      +
      11715  m_MinBlockCount(minBlockCount),
      +
      11716  m_MaxBlockCount(maxBlockCount),
      +
      11717  m_BufferImageGranularity(bufferImageGranularity),
      +
      11718  m_FrameInUseCount(frameInUseCount),
      +
      11719  m_ExplicitBlockSize(explicitBlockSize),
      +
      11720  m_Algorithm(algorithm),
      +
      11721  m_HasEmptyBlock(false),
      +
      11722  m_Blocks(VmaStlAllocator<VmaDeviceMemoryBlock*>(hAllocator->GetAllocationCallbacks())),
      +
      11723  m_NextBlockId(0)
      +
      11724 {
      +
      11725 }
      11726 
      -
      11727  if(IsCorruptionDetectionEnabled())
      -
      11728  {
      -
      11729  size = VmaAlignUp<VkDeviceSize>(size, sizeof(VMA_CORRUPTION_DETECTION_MAGIC_VALUE));
      -
      11730  alignment = VmaAlignUp<VkDeviceSize>(alignment, sizeof(VMA_CORRUPTION_DETECTION_MAGIC_VALUE));
      -
      11731  }
      -
      11732 
      -
      11733  {
      -
      11734  VmaMutexLockWrite lock(m_Mutex, m_hAllocator->m_UseMutex);
      -
      11735  for(allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
      -
      11736  {
      -
      11737  res = AllocatePage(
      -
      11738  currentFrameIndex,
      -
      11739  size,
      -
      11740  alignment,
      -
      11741  createInfo,
      -
      11742  suballocType,
      -
      11743  pAllocations + allocIndex);
      -
      11744  if(res != VK_SUCCESS)
      -
      11745  {
      -
      11746  break;
      -
      11747  }
      -
      11748  }
      -
      11749  }
      -
      11750 
      -
      11751  if(res != VK_SUCCESS)
      -
      11752  {
      -
      11753  // Free all already created allocations.
      -
      11754  while(allocIndex--)
      -
      11755  {
      -
      11756  Free(pAllocations[allocIndex]);
      -
      11757  }
      -
      11758  memset(pAllocations, 0, sizeof(VmaAllocation) * allocationCount);
      -
      11759  }
      -
      11760 
      -
      11761  return res;
      -
      11762 }
      -
      11763 
      -
      11764 VkResult VmaBlockVector::AllocatePage(
      -
      11765  uint32_t currentFrameIndex,
      -
      11766  VkDeviceSize size,
      -
      11767  VkDeviceSize alignment,
      -
      11768  const VmaAllocationCreateInfo& createInfo,
      -
      11769  VmaSuballocationType suballocType,
      -
      11770  VmaAllocation* pAllocation)
      -
      11771 {
      -
      11772  const bool isUpperAddress = (createInfo.flags & VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT) != 0;
      -
      11773  bool canMakeOtherLost = (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT) != 0;
      -
      11774  const bool mapped = (createInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0;
      -
      11775  const bool isUserDataString = (createInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0;
      -
      11776 
      -
      11777  const bool withinBudget = (createInfo.flags & VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT) != 0;
      -
      11778  VkDeviceSize freeMemory;
      -
      11779  {
      -
      11780  const uint32_t heapIndex = m_hAllocator->MemoryTypeIndexToHeapIndex(m_MemoryTypeIndex);
      -
      11781  VmaBudget heapBudget = {};
      -
      11782  m_hAllocator->GetBudget(&heapBudget, heapIndex, 1);
      -
      11783  freeMemory = (heapBudget.usage < heapBudget.budget) ? (heapBudget.budget - heapBudget.usage) : 0;
      -
      11784  }
      -
      11785 
      -
      11786  const bool canCreateNewBlock =
      -
      11787  ((createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0) &&
      -
      11788  (m_Blocks.size() < m_MaxBlockCount) &&
      -
      11789  freeMemory >= size;
      -
      11790  uint32_t strategy = createInfo.flags & VMA_ALLOCATION_CREATE_STRATEGY_MASK;
      -
      11791 
      -
      11792  // If linearAlgorithm is used, canMakeOtherLost is available only when used as ring buffer.
      -
      11793  // Which in turn is available only when maxBlockCount = 1.
      -
      11794  if(m_Algorithm == VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT && m_MaxBlockCount > 1)
      +
      11727 VmaBlockVector::~VmaBlockVector()
      +
      11728 {
      +
      11729  for(size_t i = m_Blocks.size(); i--; )
      +
      11730  {
      +
      11731  m_Blocks[i]->Destroy(m_hAllocator);
      +
      11732  vma_delete(m_hAllocator, m_Blocks[i]);
      +
      11733  }
      +
      11734 }
      +
      11735 
      +
      11736 VkResult VmaBlockVector::CreateMinBlocks()
      +
      11737 {
      +
      11738  for(size_t i = 0; i < m_MinBlockCount; ++i)
      +
      11739  {
      +
      11740  VkResult res = CreateBlock(m_PreferredBlockSize, VMA_NULL);
      +
      11741  if(res != VK_SUCCESS)
      +
      11742  {
      +
      11743  return res;
      +
      11744  }
      +
      11745  }
      +
      11746  return VK_SUCCESS;
      +
      11747 }
      +
      11748 
      +
      11749 void VmaBlockVector::GetPoolStats(VmaPoolStats* pStats)
      +
      11750 {
      +
      11751  VmaMutexLockRead lock(m_Mutex, m_hAllocator->m_UseMutex);
      +
      11752 
      +
      11753  const size_t blockCount = m_Blocks.size();
      +
      11754 
      +
      11755  pStats->size = 0;
      +
      11756  pStats->unusedSize = 0;
      +
      11757  pStats->allocationCount = 0;
      +
      11758  pStats->unusedRangeCount = 0;
      +
      11759  pStats->unusedRangeSizeMax = 0;
      +
      11760  pStats->blockCount = blockCount;
      +
      11761 
      +
      11762  for(uint32_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
      +
      11763  {
      +
      11764  const VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
      +
      11765  VMA_ASSERT(pBlock);
      +
      11766  VMA_HEAVY_ASSERT(pBlock->Validate());
      +
      11767  pBlock->m_pMetadata->AddPoolStats(*pStats);
      +
      11768  }
      +
      11769 }
      +
      11770 
      +
      11771 bool VmaBlockVector::IsCorruptionDetectionEnabled() const
      +
      11772 {
      +
      11773  const uint32_t requiredMemFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
      +
      11774  return (VMA_DEBUG_DETECT_CORRUPTION != 0) &&
      +
      11775  (VMA_DEBUG_MARGIN > 0) &&
      +
      11776  (m_Algorithm == 0 || m_Algorithm == VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT) &&
      +
      11777  (m_hAllocator->m_MemProps.memoryTypes[m_MemoryTypeIndex].propertyFlags & requiredMemFlags) == requiredMemFlags;
      +
      11778 }
      +
      11779 
      +
      11780 static const uint32_t VMA_ALLOCATION_TRY_COUNT = 32;
      +
      11781 
      +
      11782 VkResult VmaBlockVector::Allocate(
      +
      11783  uint32_t currentFrameIndex,
      +
      11784  VkDeviceSize size,
      +
      11785  VkDeviceSize alignment,
      +
      11786  const VmaAllocationCreateInfo& createInfo,
      +
      11787  VmaSuballocationType suballocType,
      +
      11788  size_t allocationCount,
      +
      11789  VmaAllocation* pAllocations)
      +
      11790 {
      +
      11791  size_t allocIndex;
      +
      11792  VkResult res = VK_SUCCESS;
      +
      11793 
      +
      11794  if(IsCorruptionDetectionEnabled())
      11795  {
      -
      11796  canMakeOtherLost = false;
      -
      11797  }
      -
      11798 
      -
      11799  // Upper address can only be used with linear allocator and within single memory block.
      -
      11800  if(isUpperAddress &&
      -
      11801  (m_Algorithm != VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT || m_MaxBlockCount > 1))
      -
      11802  {
      -
      11803  return VK_ERROR_FEATURE_NOT_PRESENT;
      -
      11804  }
      -
      11805 
      -
      11806  // Validate strategy.
      -
      11807  switch(strategy)
      -
      11808  {
      -
      11809  case 0:
      -
      11810  strategy = VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT;
      -
      11811  break;
      -
      11812  case VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT:
      -
      11813  case VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT:
      -
      11814  case VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT:
      -
      11815  break;
      -
      11816  default:
      -
      11817  return VK_ERROR_FEATURE_NOT_PRESENT;
      -
      11818  }
      -
      11819 
      -
      11820  // Early reject: requested allocation size is larger that maximum block size for this block vector.
      -
      11821  if(size + 2 * VMA_DEBUG_MARGIN > m_PreferredBlockSize)
      -
      11822  {
      -
      11823  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      -
      11824  }
      -
      11825 
      -
      11826  /*
      -
      11827  Under certain condition, this whole section can be skipped for optimization, so
      -
      11828  we move on directly to trying to allocate with canMakeOtherLost. That's the case
      -
      11829  e.g. for custom pools with linear algorithm.
      -
      11830  */
      -
      11831  if(!canMakeOtherLost || canCreateNewBlock)
      -
      11832  {
      -
      11833  // 1. Search existing allocations. Try to allocate without making other allocations lost.
      -
      11834  VmaAllocationCreateFlags allocFlagsCopy = createInfo.flags;
      -
      11835  allocFlagsCopy &= ~VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT;
      -
      11836 
      -
      11837  if(m_Algorithm == VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT)
      -
      11838  {
      -
      11839  // Use only last block.
      -
      11840  if(!m_Blocks.empty())
      -
      11841  {
      -
      11842  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks.back();
      -
      11843  VMA_ASSERT(pCurrBlock);
      -
      11844  VkResult res = AllocateFromBlock(
      -
      11845  pCurrBlock,
      -
      11846  currentFrameIndex,
      -
      11847  size,
      -
      11848  alignment,
      -
      11849  allocFlagsCopy,
      -
      11850  createInfo.pUserData,
      -
      11851  suballocType,
      -
      11852  strategy,
      -
      11853  pAllocation);
      -
      11854  if(res == VK_SUCCESS)
      -
      11855  {
      -
      11856  VMA_DEBUG_LOG(" Returned from last block #%u", pCurrBlock->GetId());
      -
      11857  return VK_SUCCESS;
      -
      11858  }
      -
      11859  }
      -
      11860  }
      -
      11861  else
      -
      11862  {
      -
      11863  if(strategy == VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT)
      -
      11864  {
      -
      11865  // Forward order in m_Blocks - prefer blocks with smallest amount of free space.
      -
      11866  for(size_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex )
      -
      11867  {
      -
      11868  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
      -
      11869  VMA_ASSERT(pCurrBlock);
      -
      11870  VkResult res = AllocateFromBlock(
      -
      11871  pCurrBlock,
      -
      11872  currentFrameIndex,
      -
      11873  size,
      -
      11874  alignment,
      -
      11875  allocFlagsCopy,
      -
      11876  createInfo.pUserData,
      -
      11877  suballocType,
      -
      11878  strategy,
      -
      11879  pAllocation);
      -
      11880  if(res == VK_SUCCESS)
      -
      11881  {
      -
      11882  VMA_DEBUG_LOG(" Returned from existing block #%u", pCurrBlock->GetId());
      -
      11883  return VK_SUCCESS;
      -
      11884  }
      -
      11885  }
      -
      11886  }
      -
      11887  else // WORST_FIT, FIRST_FIT
      -
      11888  {
      -
      11889  // Backward order in m_Blocks - prefer blocks with largest amount of free space.
      -
      11890  for(size_t blockIndex = m_Blocks.size(); blockIndex--; )
      -
      11891  {
      -
      11892  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
      -
      11893  VMA_ASSERT(pCurrBlock);
      -
      11894  VkResult res = AllocateFromBlock(
      -
      11895  pCurrBlock,
      -
      11896  currentFrameIndex,
      -
      11897  size,
      -
      11898  alignment,
      -
      11899  allocFlagsCopy,
      -
      11900  createInfo.pUserData,
      -
      11901  suballocType,
      -
      11902  strategy,
      -
      11903  pAllocation);
      -
      11904  if(res == VK_SUCCESS)
      -
      11905  {
      -
      11906  VMA_DEBUG_LOG(" Returned from existing block #%u", pCurrBlock->GetId());
      -
      11907  return VK_SUCCESS;
      -
      11908  }
      -
      11909  }
      -
      11910  }
      -
      11911  }
      -
      11912 
      -
      11913  // 2. Try to create new block.
      -
      11914  if(canCreateNewBlock)
      -
      11915  {
      -
      11916  // Calculate optimal size for new block.
      -
      11917  VkDeviceSize newBlockSize = m_PreferredBlockSize;
      -
      11918  uint32_t newBlockSizeShift = 0;
      -
      11919  const uint32_t NEW_BLOCK_SIZE_SHIFT_MAX = 3;
      -
      11920 
      -
      11921  if(!m_ExplicitBlockSize)
      -
      11922  {
      -
      11923  // Allocate 1/8, 1/4, 1/2 as first blocks.
      -
      11924  const VkDeviceSize maxExistingBlockSize = CalcMaxBlockSize();
      -
      11925  for(uint32_t i = 0; i < NEW_BLOCK_SIZE_SHIFT_MAX; ++i)
      -
      11926  {
      -
      11927  const VkDeviceSize smallerNewBlockSize = newBlockSize / 2;
      -
      11928  if(smallerNewBlockSize > maxExistingBlockSize && smallerNewBlockSize >= size * 2)
      -
      11929  {
      -
      11930  newBlockSize = smallerNewBlockSize;
      -
      11931  ++newBlockSizeShift;
      -
      11932  }
      -
      11933  else
      -
      11934  {
      -
      11935  break;
      -
      11936  }
      -
      11937  }
      -
      11938  }
      -
      11939 
      -
      11940  size_t newBlockIndex = 0;
      -
      11941  VkResult res = newBlockSize <= freeMemory ?
      -
      11942  CreateBlock(newBlockSize, &newBlockIndex) : VK_ERROR_OUT_OF_DEVICE_MEMORY;
      -
      11943  // Allocation of this size failed? Try 1/2, 1/4, 1/8 of m_PreferredBlockSize.
      -
      11944  if(!m_ExplicitBlockSize)
      -
      11945  {
      -
      11946  while(res < 0 && newBlockSizeShift < NEW_BLOCK_SIZE_SHIFT_MAX)
      -
      11947  {
      -
      11948  const VkDeviceSize smallerNewBlockSize = newBlockSize / 2;
      -
      11949  if(smallerNewBlockSize >= size)
      -
      11950  {
      -
      11951  newBlockSize = smallerNewBlockSize;
      -
      11952  ++newBlockSizeShift;
      -
      11953  res = newBlockSize <= freeMemory ?
      -
      11954  CreateBlock(newBlockSize, &newBlockIndex) : VK_ERROR_OUT_OF_DEVICE_MEMORY;
      -
      11955  }
      -
      11956  else
      -
      11957  {
      -
      11958  break;
      -
      11959  }
      -
      11960  }
      -
      11961  }
      -
      11962 
      -
      11963  if(res == VK_SUCCESS)
      -
      11964  {
      -
      11965  VmaDeviceMemoryBlock* const pBlock = m_Blocks[newBlockIndex];
      -
      11966  VMA_ASSERT(pBlock->m_pMetadata->GetSize() >= size);
      -
      11967 
      -
      11968  res = AllocateFromBlock(
      -
      11969  pBlock,
      -
      11970  currentFrameIndex,
      -
      11971  size,
      -
      11972  alignment,
      -
      11973  allocFlagsCopy,
      -
      11974  createInfo.pUserData,
      -
      11975  suballocType,
      -
      11976  strategy,
      -
      11977  pAllocation);
      -
      11978  if(res == VK_SUCCESS)
      -
      11979  {
      -
      11980  VMA_DEBUG_LOG(" Created new block #%u Size=%llu", pBlock->GetId(), newBlockSize);
      -
      11981  return VK_SUCCESS;
      -
      11982  }
      -
      11983  else
      -
      11984  {
      -
      11985  // Allocation from new block failed, possibly due to VMA_DEBUG_MARGIN or alignment.
      -
      11986  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      -
      11987  }
      -
      11988  }
      -
      11989  }
      -
      11990  }
      -
      11991 
      -
      11992  // 3. Try to allocate from existing blocks with making other allocations lost.
      -
      11993  if(canMakeOtherLost)
      -
      11994  {
      -
      11995  uint32_t tryIndex = 0;
      -
      11996  for(; tryIndex < VMA_ALLOCATION_TRY_COUNT; ++tryIndex)
      -
      11997  {
      -
      11998  VmaDeviceMemoryBlock* pBestRequestBlock = VMA_NULL;
      -
      11999  VmaAllocationRequest bestRequest = {};
      -
      12000  VkDeviceSize bestRequestCost = VK_WHOLE_SIZE;
      -
      12001 
      -
      12002  // 1. Search existing allocations.
      -
      12003  if(strategy == VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT)
      -
      12004  {
      -
      12005  // Forward order in m_Blocks - prefer blocks with smallest amount of free space.
      -
      12006  for(size_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex )
      -
      12007  {
      -
      12008  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
      -
      12009  VMA_ASSERT(pCurrBlock);
      -
      12010  VmaAllocationRequest currRequest = {};
      -
      12011  if(pCurrBlock->m_pMetadata->CreateAllocationRequest(
      -
      12012  currentFrameIndex,
      -
      12013  m_FrameInUseCount,
      -
      12014  m_BufferImageGranularity,
      -
      12015  size,
      -
      12016  alignment,
      -
      12017  (createInfo.flags & VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT) != 0,
      -
      12018  suballocType,
      -
      12019  canMakeOtherLost,
      -
      12020  strategy,
      -
      12021  &currRequest))
      -
      12022  {
      -
      12023  const VkDeviceSize currRequestCost = currRequest.CalcCost();
      -
      12024  if(pBestRequestBlock == VMA_NULL ||
      -
      12025  currRequestCost < bestRequestCost)
      -
      12026  {
      -
      12027  pBestRequestBlock = pCurrBlock;
      -
      12028  bestRequest = currRequest;
      -
      12029  bestRequestCost = currRequestCost;
      +
      11796  size = VmaAlignUp<VkDeviceSize>(size, sizeof(VMA_CORRUPTION_DETECTION_MAGIC_VALUE));
      +
      11797  alignment = VmaAlignUp<VkDeviceSize>(alignment, sizeof(VMA_CORRUPTION_DETECTION_MAGIC_VALUE));
      +
      11798  }
      +
      11799 
      +
      11800  {
      +
      11801  VmaMutexLockWrite lock(m_Mutex, m_hAllocator->m_UseMutex);
      +
      11802  for(allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
      +
      11803  {
      +
      11804  res = AllocatePage(
      +
      11805  currentFrameIndex,
      +
      11806  size,
      +
      11807  alignment,
      +
      11808  createInfo,
      +
      11809  suballocType,
      +
      11810  pAllocations + allocIndex);
      +
      11811  if(res != VK_SUCCESS)
      +
      11812  {
      +
      11813  break;
      +
      11814  }
      +
      11815  }
      +
      11816  }
      +
      11817 
      +
      11818  if(res != VK_SUCCESS)
      +
      11819  {
      +
      11820  // Free all already created allocations.
      +
      11821  while(allocIndex--)
      +
      11822  {
      +
      11823  Free(pAllocations[allocIndex]);
      +
      11824  }
      +
      11825  memset(pAllocations, 0, sizeof(VmaAllocation) * allocationCount);
      +
      11826  }
      +
      11827 
      +
      11828  return res;
      +
      11829 }
      +
      11830 
      +
      11831 VkResult VmaBlockVector::AllocatePage(
      +
      11832  uint32_t currentFrameIndex,
      +
      11833  VkDeviceSize size,
      +
      11834  VkDeviceSize alignment,
      +
      11835  const VmaAllocationCreateInfo& createInfo,
      +
      11836  VmaSuballocationType suballocType,
      +
      11837  VmaAllocation* pAllocation)
      +
      11838 {
      +
      11839  const bool isUpperAddress = (createInfo.flags & VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT) != 0;
      +
      11840  bool canMakeOtherLost = (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT) != 0;
      +
      11841  const bool mapped = (createInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0;
      +
      11842  const bool isUserDataString = (createInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0;
      +
      11843 
      +
      11844  const bool withinBudget = (createInfo.flags & VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT) != 0;
      +
      11845  VkDeviceSize freeMemory;
      +
      11846  {
      +
      11847  const uint32_t heapIndex = m_hAllocator->MemoryTypeIndexToHeapIndex(m_MemoryTypeIndex);
      +
      11848  VmaBudget heapBudget = {};
      +
      11849  m_hAllocator->GetBudget(&heapBudget, heapIndex, 1);
      +
      11850  freeMemory = (heapBudget.usage < heapBudget.budget) ? (heapBudget.budget - heapBudget.usage) : 0;
      +
      11851  }
      +
      11852 
      +
      11853  const bool canFallbackToDedicated = !IsCustomPool();
      +
      11854  const bool canCreateNewBlock =
      +
      11855  ((createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0) &&
      +
      11856  (m_Blocks.size() < m_MaxBlockCount) &&
      +
      11857  (freeMemory >= size || !canFallbackToDedicated);
      +
      11858  uint32_t strategy = createInfo.flags & VMA_ALLOCATION_CREATE_STRATEGY_MASK;
      +
      11859 
      +
      11860  // If linearAlgorithm is used, canMakeOtherLost is available only when used as ring buffer.
      +
      11861  // Which in turn is available only when maxBlockCount = 1.
      +
      11862  if(m_Algorithm == VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT && m_MaxBlockCount > 1)
      +
      11863  {
      +
      11864  canMakeOtherLost = false;
      +
      11865  }
      +
      11866 
      +
      11867  // Upper address can only be used with linear allocator and within single memory block.
      +
      11868  if(isUpperAddress &&
      +
      11869  (m_Algorithm != VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT || m_MaxBlockCount > 1))
      +
      11870  {
      +
      11871  return VK_ERROR_FEATURE_NOT_PRESENT;
      +
      11872  }
      +
      11873 
      +
      11874  // Validate strategy.
      +
      11875  switch(strategy)
      +
      11876  {
      +
      11877  case 0:
      +
      11878  strategy = VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT;
      +
      11879  break;
      +
      11880  case VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT:
      +
      11881  case VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT:
      +
      11882  case VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT:
      +
      11883  break;
      +
      11884  default:
      +
      11885  return VK_ERROR_FEATURE_NOT_PRESENT;
      +
      11886  }
      +
      11887 
      +
      11888  // Early reject: requested allocation size is larger that maximum block size for this block vector.
      +
      11889  if(size + 2 * VMA_DEBUG_MARGIN > m_PreferredBlockSize)
      +
      11890  {
      +
      11891  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      +
      11892  }
      +
      11893 
      +
      11894  /*
      +
      11895  Under certain condition, this whole section can be skipped for optimization, so
      +
      11896  we move on directly to trying to allocate with canMakeOtherLost. That's the case
      +
      11897  e.g. for custom pools with linear algorithm.
      +
      11898  */
      +
      11899  if(!canMakeOtherLost || canCreateNewBlock)
      +
      11900  {
      +
      11901  // 1. Search existing allocations. Try to allocate without making other allocations lost.
      +
      11902  VmaAllocationCreateFlags allocFlagsCopy = createInfo.flags;
      +
      11903  allocFlagsCopy &= ~VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT;
      +
      11904 
      +
      11905  if(m_Algorithm == VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT)
      +
      11906  {
      +
      11907  // Use only last block.
      +
      11908  if(!m_Blocks.empty())
      +
      11909  {
      +
      11910  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks.back();
      +
      11911  VMA_ASSERT(pCurrBlock);
      +
      11912  VkResult res = AllocateFromBlock(
      +
      11913  pCurrBlock,
      +
      11914  currentFrameIndex,
      +
      11915  size,
      +
      11916  alignment,
      +
      11917  allocFlagsCopy,
      +
      11918  createInfo.pUserData,
      +
      11919  suballocType,
      +
      11920  strategy,
      +
      11921  pAllocation);
      +
      11922  if(res == VK_SUCCESS)
      +
      11923  {
      +
      11924  VMA_DEBUG_LOG(" Returned from last block #%u", pCurrBlock->GetId());
      +
      11925  return VK_SUCCESS;
      +
      11926  }
      +
      11927  }
      +
      11928  }
      +
      11929  else
      +
      11930  {
      +
      11931  if(strategy == VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT)
      +
      11932  {
      +
      11933  // Forward order in m_Blocks - prefer blocks with smallest amount of free space.
      +
      11934  for(size_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex )
      +
      11935  {
      +
      11936  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
      +
      11937  VMA_ASSERT(pCurrBlock);
      +
      11938  VkResult res = AllocateFromBlock(
      +
      11939  pCurrBlock,
      +
      11940  currentFrameIndex,
      +
      11941  size,
      +
      11942  alignment,
      +
      11943  allocFlagsCopy,
      +
      11944  createInfo.pUserData,
      +
      11945  suballocType,
      +
      11946  strategy,
      +
      11947  pAllocation);
      +
      11948  if(res == VK_SUCCESS)
      +
      11949  {
      +
      11950  VMA_DEBUG_LOG(" Returned from existing block #%u", pCurrBlock->GetId());
      +
      11951  return VK_SUCCESS;
      +
      11952  }
      +
      11953  }
      +
      11954  }
      +
      11955  else // WORST_FIT, FIRST_FIT
      +
      11956  {
      +
      11957  // Backward order in m_Blocks - prefer blocks with largest amount of free space.
      +
      11958  for(size_t blockIndex = m_Blocks.size(); blockIndex--; )
      +
      11959  {
      +
      11960  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
      +
      11961  VMA_ASSERT(pCurrBlock);
      +
      11962  VkResult res = AllocateFromBlock(
      +
      11963  pCurrBlock,
      +
      11964  currentFrameIndex,
      +
      11965  size,
      +
      11966  alignment,
      +
      11967  allocFlagsCopy,
      +
      11968  createInfo.pUserData,
      +
      11969  suballocType,
      +
      11970  strategy,
      +
      11971  pAllocation);
      +
      11972  if(res == VK_SUCCESS)
      +
      11973  {
      +
      11974  VMA_DEBUG_LOG(" Returned from existing block #%u", pCurrBlock->GetId());
      +
      11975  return VK_SUCCESS;
      +
      11976  }
      +
      11977  }
      +
      11978  }
      +
      11979  }
      +
      11980 
      +
      11981  // 2. Try to create new block.
      +
      11982  if(canCreateNewBlock)
      +
      11983  {
      +
      11984  // Calculate optimal size for new block.
      +
      11985  VkDeviceSize newBlockSize = m_PreferredBlockSize;
      +
      11986  uint32_t newBlockSizeShift = 0;
      +
      11987  const uint32_t NEW_BLOCK_SIZE_SHIFT_MAX = 3;
      +
      11988 
      +
      11989  if(!m_ExplicitBlockSize)
      +
      11990  {
      +
      11991  // Allocate 1/8, 1/4, 1/2 as first blocks.
      +
      11992  const VkDeviceSize maxExistingBlockSize = CalcMaxBlockSize();
      +
      11993  for(uint32_t i = 0; i < NEW_BLOCK_SIZE_SHIFT_MAX; ++i)
      +
      11994  {
      +
      11995  const VkDeviceSize smallerNewBlockSize = newBlockSize / 2;
      +
      11996  if(smallerNewBlockSize > maxExistingBlockSize && smallerNewBlockSize >= size * 2)
      +
      11997  {
      +
      11998  newBlockSize = smallerNewBlockSize;
      +
      11999  ++newBlockSizeShift;
      +
      12000  }
      +
      12001  else
      +
      12002  {
      +
      12003  break;
      +
      12004  }
      +
      12005  }
      +
      12006  }
      +
      12007 
      +
      12008  size_t newBlockIndex = 0;
      +
      12009  VkResult res = (newBlockSize <= freeMemory || !canFallbackToDedicated) ?
      +
      12010  CreateBlock(newBlockSize, &newBlockIndex) : VK_ERROR_OUT_OF_DEVICE_MEMORY;
      +
      12011  // Allocation of this size failed? Try 1/2, 1/4, 1/8 of m_PreferredBlockSize.
      +
      12012  if(!m_ExplicitBlockSize)
      +
      12013  {
      +
      12014  while(res < 0 && newBlockSizeShift < NEW_BLOCK_SIZE_SHIFT_MAX)
      +
      12015  {
      +
      12016  const VkDeviceSize smallerNewBlockSize = newBlockSize / 2;
      +
      12017  if(smallerNewBlockSize >= size)
      +
      12018  {
      +
      12019  newBlockSize = smallerNewBlockSize;
      +
      12020  ++newBlockSizeShift;
      +
      12021  res = (newBlockSize <= freeMemory || !canFallbackToDedicated) ?
      +
      12022  CreateBlock(newBlockSize, &newBlockIndex) : VK_ERROR_OUT_OF_DEVICE_MEMORY;
      +
      12023  }
      +
      12024  else
      +
      12025  {
      +
      12026  break;
      +
      12027  }
      +
      12028  }
      +
      12029  }
      12030 
      -
      12031  if(bestRequestCost == 0)
      -
      12032  {
      -
      12033  break;
      -
      12034  }
      -
      12035  }
      -
      12036  }
      -
      12037  }
      -
      12038  }
      -
      12039  else // WORST_FIT, FIRST_FIT
      -
      12040  {
      -
      12041  // Backward order in m_Blocks - prefer blocks with largest amount of free space.
      -
      12042  for(size_t blockIndex = m_Blocks.size(); blockIndex--; )
      -
      12043  {
      -
      12044  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
      -
      12045  VMA_ASSERT(pCurrBlock);
      -
      12046  VmaAllocationRequest currRequest = {};
      -
      12047  if(pCurrBlock->m_pMetadata->CreateAllocationRequest(
      -
      12048  currentFrameIndex,
      -
      12049  m_FrameInUseCount,
      -
      12050  m_BufferImageGranularity,
      -
      12051  size,
      -
      12052  alignment,
      -
      12053  (createInfo.flags & VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT) != 0,
      -
      12054  suballocType,
      -
      12055  canMakeOtherLost,
      -
      12056  strategy,
      -
      12057  &currRequest))
      -
      12058  {
      -
      12059  const VkDeviceSize currRequestCost = currRequest.CalcCost();
      -
      12060  if(pBestRequestBlock == VMA_NULL ||
      -
      12061  currRequestCost < bestRequestCost ||
      -
      12062  strategy == VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT)
      -
      12063  {
      -
      12064  pBestRequestBlock = pCurrBlock;
      -
      12065  bestRequest = currRequest;
      -
      12066  bestRequestCost = currRequestCost;
      -
      12067 
      -
      12068  if(bestRequestCost == 0 ||
      -
      12069  strategy == VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT)
      -
      12070  {
      -
      12071  break;
      -
      12072  }
      -
      12073  }
      -
      12074  }
      -
      12075  }
      -
      12076  }
      -
      12077 
      -
      12078  if(pBestRequestBlock != VMA_NULL)
      -
      12079  {
      -
      12080  if(mapped)
      -
      12081  {
      -
      12082  VkResult res = pBestRequestBlock->Map(m_hAllocator, 1, VMA_NULL);
      -
      12083  if(res != VK_SUCCESS)
      -
      12084  {
      -
      12085  return res;
      -
      12086  }
      -
      12087  }
      -
      12088 
      -
      12089  if(pBestRequestBlock->m_pMetadata->MakeRequestedAllocationsLost(
      -
      12090  currentFrameIndex,
      -
      12091  m_FrameInUseCount,
      -
      12092  &bestRequest))
      -
      12093  {
      -
      12094  // We no longer have an empty Allocation.
      -
      12095  if(pBestRequestBlock->m_pMetadata->IsEmpty())
      -
      12096  {
      -
      12097  m_HasEmptyBlock = false;
      -
      12098  }
      -
      12099  // Allocate from this pBlock.
      -
      12100  *pAllocation = m_hAllocator->m_AllocationObjectAllocator.Allocate();
      -
      12101  (*pAllocation)->Ctor(currentFrameIndex, isUserDataString);
      -
      12102  pBestRequestBlock->m_pMetadata->Alloc(bestRequest, suballocType, size, *pAllocation);
      -
      12103  (*pAllocation)->InitBlockAllocation(
      -
      12104  pBestRequestBlock,
      -
      12105  bestRequest.offset,
      -
      12106  alignment,
      -
      12107  size,
      -
      12108  suballocType,
      -
      12109  mapped,
      -
      12110  (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);
      -
      12111  VMA_HEAVY_ASSERT(pBestRequestBlock->Validate());
      -
      12112  VMA_DEBUG_LOG(" Returned from existing block");
      -
      12113  (*pAllocation)->SetUserData(m_hAllocator, createInfo.pUserData);
      -
      12114  m_hAllocator->m_Budget.m_AllocationBytes[m_hAllocator->MemoryTypeIndexToHeapIndex(m_MemoryTypeIndex)] += size;
      -
      12115  ++m_hAllocator->m_Budget.m_OperationsSinceBudgetFetch;
      -
      12116  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
      -
      12117  {
      -
      12118  m_hAllocator->FillAllocation(*pAllocation, VMA_ALLOCATION_FILL_PATTERN_CREATED);
      -
      12119  }
      -
      12120  if(IsCorruptionDetectionEnabled())
      -
      12121  {
      -
      12122  VkResult res = pBestRequestBlock->WriteMagicValueAroundAllocation(m_hAllocator, bestRequest.offset, size);
      -
      12123  VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to write magic value.");
      -
      12124  }
      -
      12125  return VK_SUCCESS;
      -
      12126  }
      -
      12127  // else: Some allocations must have been touched while we are here. Next try.
      -
      12128  }
      -
      12129  else
      -
      12130  {
      -
      12131  // Could not find place in any of the blocks - break outer loop.
      -
      12132  break;
      -
      12133  }
      -
      12134  }
      -
      12135  /* Maximum number of tries exceeded - a very unlike event when many other
      -
      12136  threads are simultaneously touching allocations making it impossible to make
      -
      12137  lost at the same time as we try to allocate. */
      -
      12138  if(tryIndex == VMA_ALLOCATION_TRY_COUNT)
      -
      12139  {
      -
      12140  return VK_ERROR_TOO_MANY_OBJECTS;
      -
      12141  }
      -
      12142  }
      -
      12143 
      -
      12144  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      -
      12145 }
      -
      12146 
      -
      12147 void VmaBlockVector::Free(
      -
      12148  const VmaAllocation hAllocation)
      -
      12149 {
      -
      12150  VmaDeviceMemoryBlock* pBlockToDelete = VMA_NULL;
      -
      12151 
      -
      12152  // Scope for lock.
      -
      12153  {
      -
      12154  VmaMutexLockWrite lock(m_Mutex, m_hAllocator->m_UseMutex);
      -
      12155 
      -
      12156  VmaDeviceMemoryBlock* pBlock = hAllocation->GetBlock();
      -
      12157 
      -
      12158  if(IsCorruptionDetectionEnabled())
      -
      12159  {
      -
      12160  VkResult res = pBlock->ValidateMagicValueAroundAllocation(m_hAllocator, hAllocation->GetOffset(), hAllocation->GetSize());
      -
      12161  VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to validate magic value.");
      -
      12162  }
      -
      12163 
      -
      12164  if(hAllocation->IsPersistentMap())
      -
      12165  {
      -
      12166  pBlock->Unmap(m_hAllocator, 1);
      -
      12167  }
      -
      12168 
      -
      12169  pBlock->m_pMetadata->Free(hAllocation);
      -
      12170  VMA_HEAVY_ASSERT(pBlock->Validate());
      -
      12171 
      -
      12172  VMA_DEBUG_LOG(" Freed from MemoryTypeIndex=%u", m_MemoryTypeIndex);
      -
      12173 
      -
      12174  // pBlock became empty after this deallocation.
      -
      12175  if(pBlock->m_pMetadata->IsEmpty())
      -
      12176  {
      -
      12177  // Already has empty Allocation. We don't want to have two, so delete this one.
      -
      12178  if(m_HasEmptyBlock && m_Blocks.size() > m_MinBlockCount)
      -
      12179  {
      -
      12180  pBlockToDelete = pBlock;
      -
      12181  Remove(pBlock);
      -
      12182  }
      -
      12183  // We now have first empty block.
      -
      12184  else
      -
      12185  {
      -
      12186  m_HasEmptyBlock = true;
      -
      12187  }
      -
      12188  }
      -
      12189  // pBlock didn't become empty, but we have another empty block - find and free that one.
      -
      12190  // (This is optional, heuristics.)
      -
      12191  else if(m_HasEmptyBlock)
      -
      12192  {
      -
      12193  VmaDeviceMemoryBlock* pLastBlock = m_Blocks.back();
      -
      12194  if(pLastBlock->m_pMetadata->IsEmpty() && m_Blocks.size() > m_MinBlockCount)
      -
      12195  {
      -
      12196  pBlockToDelete = pLastBlock;
      -
      12197  m_Blocks.pop_back();
      -
      12198  m_HasEmptyBlock = false;
      -
      12199  }
      -
      12200  }
      -
      12201 
      -
      12202  IncrementallySortBlocks();
      -
      12203  }
      -
      12204 
      -
      12205  // Destruction of a free Allocation. Deferred until this point, outside of mutex
      -
      12206  // lock, for performance reason.
      -
      12207  if(pBlockToDelete != VMA_NULL)
      -
      12208  {
      -
      12209  VMA_DEBUG_LOG(" Deleted empty allocation");
      -
      12210  pBlockToDelete->Destroy(m_hAllocator);
      -
      12211  vma_delete(m_hAllocator, pBlockToDelete);
      -
      12212  }
      +
      12031  if(res == VK_SUCCESS)
      +
      12032  {
      +
      12033  VmaDeviceMemoryBlock* const pBlock = m_Blocks[newBlockIndex];
      +
      12034  VMA_ASSERT(pBlock->m_pMetadata->GetSize() >= size);
      +
      12035 
      +
      12036  res = AllocateFromBlock(
      +
      12037  pBlock,
      +
      12038  currentFrameIndex,
      +
      12039  size,
      +
      12040  alignment,
      +
      12041  allocFlagsCopy,
      +
      12042  createInfo.pUserData,
      +
      12043  suballocType,
      +
      12044  strategy,
      +
      12045  pAllocation);
      +
      12046  if(res == VK_SUCCESS)
      +
      12047  {
      +
      12048  VMA_DEBUG_LOG(" Created new block #%u Size=%llu", pBlock->GetId(), newBlockSize);
      +
      12049  return VK_SUCCESS;
      +
      12050  }
      +
      12051  else
      +
      12052  {
      +
      12053  // Allocation from new block failed, possibly due to VMA_DEBUG_MARGIN or alignment.
      +
      12054  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      +
      12055  }
      +
      12056  }
      +
      12057  }
      +
      12058  }
      +
      12059 
      +
      12060  // 3. Try to allocate from existing blocks with making other allocations lost.
      +
      12061  if(canMakeOtherLost)
      +
      12062  {
      +
      12063  uint32_t tryIndex = 0;
      +
      12064  for(; tryIndex < VMA_ALLOCATION_TRY_COUNT; ++tryIndex)
      +
      12065  {
      +
      12066  VmaDeviceMemoryBlock* pBestRequestBlock = VMA_NULL;
      +
      12067  VmaAllocationRequest bestRequest = {};
      +
      12068  VkDeviceSize bestRequestCost = VK_WHOLE_SIZE;
      +
      12069 
      +
      12070  // 1. Search existing allocations.
      +
      12071  if(strategy == VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT)
      +
      12072  {
      +
      12073  // Forward order in m_Blocks - prefer blocks with smallest amount of free space.
      +
      12074  for(size_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex )
      +
      12075  {
      +
      12076  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
      +
      12077  VMA_ASSERT(pCurrBlock);
      +
      12078  VmaAllocationRequest currRequest = {};
      +
      12079  if(pCurrBlock->m_pMetadata->CreateAllocationRequest(
      +
      12080  currentFrameIndex,
      +
      12081  m_FrameInUseCount,
      +
      12082  m_BufferImageGranularity,
      +
      12083  size,
      +
      12084  alignment,
      +
      12085  (createInfo.flags & VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT) != 0,
      +
      12086  suballocType,
      +
      12087  canMakeOtherLost,
      +
      12088  strategy,
      +
      12089  &currRequest))
      +
      12090  {
      +
      12091  const VkDeviceSize currRequestCost = currRequest.CalcCost();
      +
      12092  if(pBestRequestBlock == VMA_NULL ||
      +
      12093  currRequestCost < bestRequestCost)
      +
      12094  {
      +
      12095  pBestRequestBlock = pCurrBlock;
      +
      12096  bestRequest = currRequest;
      +
      12097  bestRequestCost = currRequestCost;
      +
      12098 
      +
      12099  if(bestRequestCost == 0)
      +
      12100  {
      +
      12101  break;
      +
      12102  }
      +
      12103  }
      +
      12104  }
      +
      12105  }
      +
      12106  }
      +
      12107  else // WORST_FIT, FIRST_FIT
      +
      12108  {
      +
      12109  // Backward order in m_Blocks - prefer blocks with largest amount of free space.
      +
      12110  for(size_t blockIndex = m_Blocks.size(); blockIndex--; )
      +
      12111  {
      +
      12112  VmaDeviceMemoryBlock* const pCurrBlock = m_Blocks[blockIndex];
      +
      12113  VMA_ASSERT(pCurrBlock);
      +
      12114  VmaAllocationRequest currRequest = {};
      +
      12115  if(pCurrBlock->m_pMetadata->CreateAllocationRequest(
      +
      12116  currentFrameIndex,
      +
      12117  m_FrameInUseCount,
      +
      12118  m_BufferImageGranularity,
      +
      12119  size,
      +
      12120  alignment,
      +
      12121  (createInfo.flags & VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT) != 0,
      +
      12122  suballocType,
      +
      12123  canMakeOtherLost,
      +
      12124  strategy,
      +
      12125  &currRequest))
      +
      12126  {
      +
      12127  const VkDeviceSize currRequestCost = currRequest.CalcCost();
      +
      12128  if(pBestRequestBlock == VMA_NULL ||
      +
      12129  currRequestCost < bestRequestCost ||
      +
      12130  strategy == VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT)
      +
      12131  {
      +
      12132  pBestRequestBlock = pCurrBlock;
      +
      12133  bestRequest = currRequest;
      +
      12134  bestRequestCost = currRequestCost;
      +
      12135 
      +
      12136  if(bestRequestCost == 0 ||
      +
      12137  strategy == VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT)
      +
      12138  {
      +
      12139  break;
      +
      12140  }
      +
      12141  }
      +
      12142  }
      +
      12143  }
      +
      12144  }
      +
      12145 
      +
      12146  if(pBestRequestBlock != VMA_NULL)
      +
      12147  {
      +
      12148  if(mapped)
      +
      12149  {
      +
      12150  VkResult res = pBestRequestBlock->Map(m_hAllocator, 1, VMA_NULL);
      +
      12151  if(res != VK_SUCCESS)
      +
      12152  {
      +
      12153  return res;
      +
      12154  }
      +
      12155  }
      +
      12156 
      +
      12157  if(pBestRequestBlock->m_pMetadata->MakeRequestedAllocationsLost(
      +
      12158  currentFrameIndex,
      +
      12159  m_FrameInUseCount,
      +
      12160  &bestRequest))
      +
      12161  {
      +
      12162  // We no longer have an empty Allocation.
      +
      12163  if(pBestRequestBlock->m_pMetadata->IsEmpty())
      +
      12164  {
      +
      12165  m_HasEmptyBlock = false;
      +
      12166  }
      +
      12167  // Allocate from this pBlock.
      +
      12168  *pAllocation = m_hAllocator->m_AllocationObjectAllocator.Allocate();
      +
      12169  (*pAllocation)->Ctor(currentFrameIndex, isUserDataString);
      +
      12170  pBestRequestBlock->m_pMetadata->Alloc(bestRequest, suballocType, size, *pAllocation);
      +
      12171  (*pAllocation)->InitBlockAllocation(
      +
      12172  pBestRequestBlock,
      +
      12173  bestRequest.offset,
      +
      12174  alignment,
      +
      12175  size,
      +
      12176  m_MemoryTypeIndex,
      +
      12177  suballocType,
      +
      12178  mapped,
      +
      12179  (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);
      +
      12180  VMA_HEAVY_ASSERT(pBestRequestBlock->Validate());
      +
      12181  VMA_DEBUG_LOG(" Returned from existing block");
      +
      12182  (*pAllocation)->SetUserData(m_hAllocator, createInfo.pUserData);
      +
      12183  m_hAllocator->m_Budget.AddAllocation(m_hAllocator->MemoryTypeIndexToHeapIndex(m_MemoryTypeIndex), size);
      +
      12184  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
      +
      12185  {
      +
      12186  m_hAllocator->FillAllocation(*pAllocation, VMA_ALLOCATION_FILL_PATTERN_CREATED);
      +
      12187  }
      +
      12188  if(IsCorruptionDetectionEnabled())
      +
      12189  {
      +
      12190  VkResult res = pBestRequestBlock->WriteMagicValueAroundAllocation(m_hAllocator, bestRequest.offset, size);
      +
      12191  VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to write magic value.");
      +
      12192  }
      +
      12193  return VK_SUCCESS;
      +
      12194  }
      +
      12195  // else: Some allocations must have been touched while we are here. Next try.
      +
      12196  }
      +
      12197  else
      +
      12198  {
      +
      12199  // Could not find place in any of the blocks - break outer loop.
      +
      12200  break;
      +
      12201  }
      +
      12202  }
      +
      12203  /* Maximum number of tries exceeded - a very unlike event when many other
      +
      12204  threads are simultaneously touching allocations making it impossible to make
      +
      12205  lost at the same time as we try to allocate. */
      +
      12206  if(tryIndex == VMA_ALLOCATION_TRY_COUNT)
      +
      12207  {
      +
      12208  return VK_ERROR_TOO_MANY_OBJECTS;
      +
      12209  }
      +
      12210  }
      +
      12211 
      +
      12212  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      12213 }
      12214 
      -
      12215 VkDeviceSize VmaBlockVector::CalcMaxBlockSize() const
      -
      12216 {
      -
      12217  VkDeviceSize result = 0;
      -
      12218  for(size_t i = m_Blocks.size(); i--; )
      -
      12219  {
      -
      12220  result = VMA_MAX(result, m_Blocks[i]->m_pMetadata->GetSize());
      -
      12221  if(result >= m_PreferredBlockSize)
      -
      12222  {
      -
      12223  break;
      -
      12224  }
      -
      12225  }
      -
      12226  return result;
      -
      12227 }
      -
      12228 
      -
      12229 void VmaBlockVector::Remove(VmaDeviceMemoryBlock* pBlock)
      -
      12230 {
      -
      12231  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
      -
      12232  {
      -
      12233  if(m_Blocks[blockIndex] == pBlock)
      -
      12234  {
      -
      12235  VmaVectorRemove(m_Blocks, blockIndex);
      -
      12236  return;
      -
      12237  }
      -
      12238  }
      -
      12239  VMA_ASSERT(0);
      -
      12240 }
      -
      12241 
      -
      12242 void VmaBlockVector::IncrementallySortBlocks()
      -
      12243 {
      -
      12244  if(m_Algorithm != VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT)
      -
      12245  {
      -
      12246  // Bubble sort only until first swap.
      -
      12247  for(size_t i = 1; i < m_Blocks.size(); ++i)
      -
      12248  {
      -
      12249  if(m_Blocks[i - 1]->m_pMetadata->GetSumFreeSize() > m_Blocks[i]->m_pMetadata->GetSumFreeSize())
      -
      12250  {
      -
      12251  VMA_SWAP(m_Blocks[i - 1], m_Blocks[i]);
      -
      12252  return;
      -
      12253  }
      -
      12254  }
      -
      12255  }
      -
      12256 }
      -
      12257 
      -
      12258 VkResult VmaBlockVector::AllocateFromBlock(
      -
      12259  VmaDeviceMemoryBlock* pBlock,
      -
      12260  uint32_t currentFrameIndex,
      -
      12261  VkDeviceSize size,
      -
      12262  VkDeviceSize alignment,
      -
      12263  VmaAllocationCreateFlags allocFlags,
      -
      12264  void* pUserData,
      -
      12265  VmaSuballocationType suballocType,
      -
      12266  uint32_t strategy,
      -
      12267  VmaAllocation* pAllocation)
      -
      12268 {
      -
      12269  VMA_ASSERT((allocFlags & VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT) == 0);
      -
      12270  const bool isUpperAddress = (allocFlags & VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT) != 0;
      -
      12271  const bool mapped = (allocFlags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0;
      -
      12272  const bool isUserDataString = (allocFlags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0;
      -
      12273 
      -
      12274  VmaAllocationRequest currRequest = {};
      -
      12275  if(pBlock->m_pMetadata->CreateAllocationRequest(
      -
      12276  currentFrameIndex,
      -
      12277  m_FrameInUseCount,
      -
      12278  m_BufferImageGranularity,
      -
      12279  size,
      -
      12280  alignment,
      -
      12281  isUpperAddress,
      -
      12282  suballocType,
      -
      12283  false, // canMakeOtherLost
      -
      12284  strategy,
      -
      12285  &currRequest))
      -
      12286  {
      -
      12287  // Allocate from pCurrBlock.
      -
      12288  VMA_ASSERT(currRequest.itemsToMakeLostCount == 0);
      -
      12289 
      -
      12290  if(mapped)
      -
      12291  {
      -
      12292  VkResult res = pBlock->Map(m_hAllocator, 1, VMA_NULL);
      -
      12293  if(res != VK_SUCCESS)
      -
      12294  {
      -
      12295  return res;
      -
      12296  }
      -
      12297  }
      -
      12298 
      -
      12299  // We no longer have an empty Allocation.
      -
      12300  if(pBlock->m_pMetadata->IsEmpty())
      -
      12301  {
      -
      12302  m_HasEmptyBlock = false;
      -
      12303  }
      -
      12304 
      -
      12305  *pAllocation = m_hAllocator->m_AllocationObjectAllocator.Allocate();
      -
      12306  (*pAllocation)->Ctor(currentFrameIndex, isUserDataString);
      -
      12307  pBlock->m_pMetadata->Alloc(currRequest, suballocType, size, *pAllocation);
      -
      12308  (*pAllocation)->InitBlockAllocation(
      -
      12309  pBlock,
      -
      12310  currRequest.offset,
      -
      12311  alignment,
      -
      12312  size,
      -
      12313  suballocType,
      -
      12314  mapped,
      -
      12315  (allocFlags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);
      -
      12316  VMA_HEAVY_ASSERT(pBlock->Validate());
      -
      12317  (*pAllocation)->SetUserData(m_hAllocator, pUserData);
      -
      12318  m_hAllocator->m_Budget.m_AllocationBytes[m_hAllocator->MemoryTypeIndexToHeapIndex(m_MemoryTypeIndex)] += size;
      -
      12319  ++m_hAllocator->m_Budget.m_OperationsSinceBudgetFetch;
      -
      12320  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
      -
      12321  {
      -
      12322  m_hAllocator->FillAllocation(*pAllocation, VMA_ALLOCATION_FILL_PATTERN_CREATED);
      -
      12323  }
      -
      12324  if(IsCorruptionDetectionEnabled())
      +
      12215 void VmaBlockVector::Free(
      +
      12216  const VmaAllocation hAllocation)
      +
      12217 {
      +
      12218  VmaDeviceMemoryBlock* pBlockToDelete = VMA_NULL;
      +
      12219 
      +
      12220  bool budgetExceeded = false;
      +
      12221  {
      +
      12222  const uint32_t heapIndex = m_hAllocator->MemoryTypeIndexToHeapIndex(m_MemoryTypeIndex);
      +
      12223  VmaBudget heapBudget = {};
      +
      12224  m_hAllocator->GetBudget(&heapBudget, heapIndex, 1);
      +
      12225  budgetExceeded = heapBudget.usage >= heapBudget.budget;
      +
      12226  }
      +
      12227 
      +
      12228  // Scope for lock.
      +
      12229  {
      +
      12230  VmaMutexLockWrite lock(m_Mutex, m_hAllocator->m_UseMutex);
      +
      12231 
      +
      12232  VmaDeviceMemoryBlock* pBlock = hAllocation->GetBlock();
      +
      12233 
      +
      12234  if(IsCorruptionDetectionEnabled())
      +
      12235  {
      +
      12236  VkResult res = pBlock->ValidateMagicValueAroundAllocation(m_hAllocator, hAllocation->GetOffset(), hAllocation->GetSize());
      +
      12237  VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to validate magic value.");
      +
      12238  }
      +
      12239 
      +
      12240  if(hAllocation->IsPersistentMap())
      +
      12241  {
      +
      12242  pBlock->Unmap(m_hAllocator, 1);
      +
      12243  }
      +
      12244 
      +
      12245  pBlock->m_pMetadata->Free(hAllocation);
      +
      12246  VMA_HEAVY_ASSERT(pBlock->Validate());
      +
      12247 
      +
      12248  VMA_DEBUG_LOG(" Freed from MemoryTypeIndex=%u", m_MemoryTypeIndex);
      +
      12249 
      +
      12250  const bool canDeleteBlock = m_Blocks.size() > m_MinBlockCount;
      +
      12251  // pBlock became empty after this deallocation.
      +
      12252  if(pBlock->m_pMetadata->IsEmpty())
      +
      12253  {
      +
      12254  // Already has empty block. We don't want to have two, so delete this one.
      +
      12255  if((m_HasEmptyBlock || budgetExceeded) && canDeleteBlock)
      +
      12256  {
      +
      12257  pBlockToDelete = pBlock;
      +
      12258  Remove(pBlock);
      +
      12259  }
      +
      12260  // We now have first empty block.
      +
      12261  else
      +
      12262  {
      +
      12263  m_HasEmptyBlock = true;
      +
      12264  }
      +
      12265  }
      +
      12266  // pBlock didn't become empty, but we have another empty block - find and free that one.
      +
      12267  // (This is optional, heuristics.)
      +
      12268  else if(m_HasEmptyBlock && canDeleteBlock)
      +
      12269  {
      +
      12270  VmaDeviceMemoryBlock* pLastBlock = m_Blocks.back();
      +
      12271  if(pLastBlock->m_pMetadata->IsEmpty())
      +
      12272  {
      +
      12273  pBlockToDelete = pLastBlock;
      +
      12274  m_Blocks.pop_back();
      +
      12275  m_HasEmptyBlock = false;
      +
      12276  }
      +
      12277  }
      +
      12278 
      +
      12279  IncrementallySortBlocks();
      +
      12280  }
      +
      12281 
      +
      12282  // Destruction of a free block. Deferred until this point, outside of mutex
      +
      12283  // lock, for performance reason.
      +
      12284  if(pBlockToDelete != VMA_NULL)
      +
      12285  {
      +
      12286  VMA_DEBUG_LOG(" Deleted empty block");
      +
      12287  pBlockToDelete->Destroy(m_hAllocator);
      +
      12288  vma_delete(m_hAllocator, pBlockToDelete);
      +
      12289  }
      +
      12290 }
      +
      12291 
      +
      12292 VkDeviceSize VmaBlockVector::CalcMaxBlockSize() const
      +
      12293 {
      +
      12294  VkDeviceSize result = 0;
      +
      12295  for(size_t i = m_Blocks.size(); i--; )
      +
      12296  {
      +
      12297  result = VMA_MAX(result, m_Blocks[i]->m_pMetadata->GetSize());
      +
      12298  if(result >= m_PreferredBlockSize)
      +
      12299  {
      +
      12300  break;
      +
      12301  }
      +
      12302  }
      +
      12303  return result;
      +
      12304 }
      +
      12305 
      +
      12306 void VmaBlockVector::Remove(VmaDeviceMemoryBlock* pBlock)
      +
      12307 {
      +
      12308  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
      +
      12309  {
      +
      12310  if(m_Blocks[blockIndex] == pBlock)
      +
      12311  {
      +
      12312  VmaVectorRemove(m_Blocks, blockIndex);
      +
      12313  return;
      +
      12314  }
      +
      12315  }
      +
      12316  VMA_ASSERT(0);
      +
      12317 }
      +
      12318 
      +
      12319 void VmaBlockVector::IncrementallySortBlocks()
      +
      12320 {
      +
      12321  if(m_Algorithm != VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT)
      +
      12322  {
      +
      12323  // Bubble sort only until first swap.
      +
      12324  for(size_t i = 1; i < m_Blocks.size(); ++i)
      12325  {
      -
      12326  VkResult res = pBlock->WriteMagicValueAroundAllocation(m_hAllocator, currRequest.offset, size);
      -
      12327  VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to write magic value.");
      -
      12328  }
      -
      12329  return VK_SUCCESS;
      -
      12330  }
      -
      12331  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      -
      12332 }
      -
      12333 
      -
      12334 VkResult VmaBlockVector::CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIndex)
      -
      12335 {
      -
      12336  VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
      -
      12337  allocInfo.memoryTypeIndex = m_MemoryTypeIndex;
      -
      12338  allocInfo.allocationSize = blockSize;
      -
      12339  VkDeviceMemory mem = VK_NULL_HANDLE;
      -
      12340  VkResult res = m_hAllocator->AllocateVulkanMemory(&allocInfo, &mem);
      -
      12341  if(res < 0)
      -
      12342  {
      -
      12343  return res;
      -
      12344  }
      -
      12345 
      -
      12346  // New VkDeviceMemory successfully created.
      -
      12347 
      -
      12348  // Create new Allocation for it.
      -
      12349  VmaDeviceMemoryBlock* const pBlock = vma_new(m_hAllocator, VmaDeviceMemoryBlock)(m_hAllocator);
      -
      12350  pBlock->Init(
      -
      12351  m_hAllocator,
      -
      12352  m_hParentPool,
      -
      12353  m_MemoryTypeIndex,
      -
      12354  mem,
      -
      12355  allocInfo.allocationSize,
      -
      12356  m_NextBlockId++,
      -
      12357  m_Algorithm);
      -
      12358 
      -
      12359  m_Blocks.push_back(pBlock);
      -
      12360  if(pNewBlockIndex != VMA_NULL)
      -
      12361  {
      -
      12362  *pNewBlockIndex = m_Blocks.size() - 1;
      -
      12363  }
      -
      12364 
      -
      12365  return VK_SUCCESS;
      -
      12366 }
      -
      12367 
      -
      12368 void VmaBlockVector::ApplyDefragmentationMovesCpu(
      -
      12369  class VmaBlockVectorDefragmentationContext* pDefragCtx,
      -
      12370  const VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves)
      -
      12371 {
      -
      12372  const size_t blockCount = m_Blocks.size();
      -
      12373  const bool isNonCoherent = m_hAllocator->IsMemoryTypeNonCoherent(m_MemoryTypeIndex);
      -
      12374 
      -
      12375  enum BLOCK_FLAG
      -
      12376  {
      -
      12377  BLOCK_FLAG_USED = 0x00000001,
      -
      12378  BLOCK_FLAG_MAPPED_FOR_DEFRAGMENTATION = 0x00000002,
      -
      12379  };
      -
      12380 
      -
      12381  struct BlockInfo
      -
      12382  {
      -
      12383  uint32_t flags;
      -
      12384  void* pMappedData;
      -
      12385  };
      -
      12386  VmaVector< BlockInfo, VmaStlAllocator<BlockInfo> >
      -
      12387  blockInfo(blockCount, BlockInfo(), VmaStlAllocator<BlockInfo>(m_hAllocator->GetAllocationCallbacks()));
      -
      12388  memset(blockInfo.data(), 0, blockCount * sizeof(BlockInfo));
      -
      12389 
      -
      12390  // Go over all moves. Mark blocks that are used with BLOCK_FLAG_USED.
      -
      12391  const size_t moveCount = moves.size();
      -
      12392  for(size_t moveIndex = 0; moveIndex < moveCount; ++moveIndex)
      -
      12393  {
      -
      12394  const VmaDefragmentationMove& move = moves[moveIndex];
      -
      12395  blockInfo[move.srcBlockIndex].flags |= BLOCK_FLAG_USED;
      -
      12396  blockInfo[move.dstBlockIndex].flags |= BLOCK_FLAG_USED;
      -
      12397  }
      -
      12398 
      -
      12399  VMA_ASSERT(pDefragCtx->res == VK_SUCCESS);
      -
      12400 
      -
      12401  // Go over all blocks. Get mapped pointer or map if necessary.
      -
      12402  for(size_t blockIndex = 0; pDefragCtx->res == VK_SUCCESS && blockIndex < blockCount; ++blockIndex)
      -
      12403  {
      -
      12404  BlockInfo& currBlockInfo = blockInfo[blockIndex];
      -
      12405  VmaDeviceMemoryBlock* pBlock = m_Blocks[blockIndex];
      -
      12406  if((currBlockInfo.flags & BLOCK_FLAG_USED) != 0)
      -
      12407  {
      -
      12408  currBlockInfo.pMappedData = pBlock->GetMappedData();
      -
      12409  // It is not originally mapped - map it.
      -
      12410  if(currBlockInfo.pMappedData == VMA_NULL)
      -
      12411  {
      -
      12412  pDefragCtx->res = pBlock->Map(m_hAllocator, 1, &currBlockInfo.pMappedData);
      -
      12413  if(pDefragCtx->res == VK_SUCCESS)
      -
      12414  {
      -
      12415  currBlockInfo.flags |= BLOCK_FLAG_MAPPED_FOR_DEFRAGMENTATION;
      -
      12416  }
      -
      12417  }
      -
      12418  }
      -
      12419  }
      -
      12420 
      -
      12421  // Go over all moves. Do actual data transfer.
      -
      12422  if(pDefragCtx->res == VK_SUCCESS)
      -
      12423  {
      -
      12424  const VkDeviceSize nonCoherentAtomSize = m_hAllocator->m_PhysicalDeviceProperties.limits.nonCoherentAtomSize;
      -
      12425  VkMappedMemoryRange memRange = { VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE };
      -
      12426 
      -
      12427  for(size_t moveIndex = 0; moveIndex < moveCount; ++moveIndex)
      -
      12428  {
      -
      12429  const VmaDefragmentationMove& move = moves[moveIndex];
      -
      12430 
      -
      12431  const BlockInfo& srcBlockInfo = blockInfo[move.srcBlockIndex];
      -
      12432  const BlockInfo& dstBlockInfo = blockInfo[move.dstBlockIndex];
      -
      12433 
      -
      12434  VMA_ASSERT(srcBlockInfo.pMappedData && dstBlockInfo.pMappedData);
      +
      12326  if(m_Blocks[i - 1]->m_pMetadata->GetSumFreeSize() > m_Blocks[i]->m_pMetadata->GetSumFreeSize())
      +
      12327  {
      +
      12328  VMA_SWAP(m_Blocks[i - 1], m_Blocks[i]);
      +
      12329  return;
      +
      12330  }
      +
      12331  }
      +
      12332  }
      +
      12333 }
      +
      12334 
      +
      12335 VkResult VmaBlockVector::AllocateFromBlock(
      +
      12336  VmaDeviceMemoryBlock* pBlock,
      +
      12337  uint32_t currentFrameIndex,
      +
      12338  VkDeviceSize size,
      +
      12339  VkDeviceSize alignment,
      +
      12340  VmaAllocationCreateFlags allocFlags,
      +
      12341  void* pUserData,
      +
      12342  VmaSuballocationType suballocType,
      +
      12343  uint32_t strategy,
      +
      12344  VmaAllocation* pAllocation)
      +
      12345 {
      +
      12346  VMA_ASSERT((allocFlags & VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT) == 0);
      +
      12347  const bool isUpperAddress = (allocFlags & VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT) != 0;
      +
      12348  const bool mapped = (allocFlags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0;
      +
      12349  const bool isUserDataString = (allocFlags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0;
      +
      12350 
      +
      12351  VmaAllocationRequest currRequest = {};
      +
      12352  if(pBlock->m_pMetadata->CreateAllocationRequest(
      +
      12353  currentFrameIndex,
      +
      12354  m_FrameInUseCount,
      +
      12355  m_BufferImageGranularity,
      +
      12356  size,
      +
      12357  alignment,
      +
      12358  isUpperAddress,
      +
      12359  suballocType,
      +
      12360  false, // canMakeOtherLost
      +
      12361  strategy,
      +
      12362  &currRequest))
      +
      12363  {
      +
      12364  // Allocate from pCurrBlock.
      +
      12365  VMA_ASSERT(currRequest.itemsToMakeLostCount == 0);
      +
      12366 
      +
      12367  if(mapped)
      +
      12368  {
      +
      12369  VkResult res = pBlock->Map(m_hAllocator, 1, VMA_NULL);
      +
      12370  if(res != VK_SUCCESS)
      +
      12371  {
      +
      12372  return res;
      +
      12373  }
      +
      12374  }
      +
      12375 
      +
      12376  // We no longer have an empty Allocation.
      +
      12377  if(pBlock->m_pMetadata->IsEmpty())
      +
      12378  {
      +
      12379  m_HasEmptyBlock = false;
      +
      12380  }
      +
      12381 
      +
      12382  *pAllocation = m_hAllocator->m_AllocationObjectAllocator.Allocate();
      +
      12383  (*pAllocation)->Ctor(currentFrameIndex, isUserDataString);
      +
      12384  pBlock->m_pMetadata->Alloc(currRequest, suballocType, size, *pAllocation);
      +
      12385  (*pAllocation)->InitBlockAllocation(
      +
      12386  pBlock,
      +
      12387  currRequest.offset,
      +
      12388  alignment,
      +
      12389  size,
      +
      12390  m_MemoryTypeIndex,
      +
      12391  suballocType,
      +
      12392  mapped,
      +
      12393  (allocFlags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0);
      +
      12394  VMA_HEAVY_ASSERT(pBlock->Validate());
      +
      12395  (*pAllocation)->SetUserData(m_hAllocator, pUserData);
      +
      12396  m_hAllocator->m_Budget.AddAllocation(m_hAllocator->MemoryTypeIndexToHeapIndex(m_MemoryTypeIndex), size);
      +
      12397  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
      +
      12398  {
      +
      12399  m_hAllocator->FillAllocation(*pAllocation, VMA_ALLOCATION_FILL_PATTERN_CREATED);
      +
      12400  }
      +
      12401  if(IsCorruptionDetectionEnabled())
      +
      12402  {
      +
      12403  VkResult res = pBlock->WriteMagicValueAroundAllocation(m_hAllocator, currRequest.offset, size);
      +
      12404  VMA_ASSERT(res == VK_SUCCESS && "Couldn't map block memory to write magic value.");
      +
      12405  }
      +
      12406  return VK_SUCCESS;
      +
      12407  }
      +
      12408  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      +
      12409 }
      +
      12410 
      +
      12411 VkResult VmaBlockVector::CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIndex)
      +
      12412 {
      +
      12413  VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
      +
      12414  allocInfo.memoryTypeIndex = m_MemoryTypeIndex;
      +
      12415  allocInfo.allocationSize = blockSize;
      +
      12416  VkDeviceMemory mem = VK_NULL_HANDLE;
      +
      12417  VkResult res = m_hAllocator->AllocateVulkanMemory(&allocInfo, &mem);
      +
      12418  if(res < 0)
      +
      12419  {
      +
      12420  return res;
      +
      12421  }
      +
      12422 
      +
      12423  // New VkDeviceMemory successfully created.
      +
      12424 
      +
      12425  // Create new Allocation for it.
      +
      12426  VmaDeviceMemoryBlock* const pBlock = vma_new(m_hAllocator, VmaDeviceMemoryBlock)(m_hAllocator);
      +
      12427  pBlock->Init(
      +
      12428  m_hAllocator,
      +
      12429  m_hParentPool,
      +
      12430  m_MemoryTypeIndex,
      +
      12431  mem,
      +
      12432  allocInfo.allocationSize,
      +
      12433  m_NextBlockId++,
      +
      12434  m_Algorithm);
      12435 
      -
      12436  // Invalidate source.
      -
      12437  if(isNonCoherent)
      -
      12438  {
      -
      12439  VmaDeviceMemoryBlock* const pSrcBlock = m_Blocks[move.srcBlockIndex];
      -
      12440  memRange.memory = pSrcBlock->GetDeviceMemory();
      -
      12441  memRange.offset = VmaAlignDown(move.srcOffset, nonCoherentAtomSize);
      -
      12442  memRange.size = VMA_MIN(
      -
      12443  VmaAlignUp(move.size + (move.srcOffset - memRange.offset), nonCoherentAtomSize),
      -
      12444  pSrcBlock->m_pMetadata->GetSize() - memRange.offset);
      -
      12445  (*m_hAllocator->GetVulkanFunctions().vkInvalidateMappedMemoryRanges)(m_hAllocator->m_hDevice, 1, &memRange);
      -
      12446  }
      -
      12447 
      -
      12448  // THE PLACE WHERE ACTUAL DATA COPY HAPPENS.
      -
      12449  memmove(
      -
      12450  reinterpret_cast<char*>(dstBlockInfo.pMappedData) + move.dstOffset,
      -
      12451  reinterpret_cast<char*>(srcBlockInfo.pMappedData) + move.srcOffset,
      -
      12452  static_cast<size_t>(move.size));
      -
      12453 
      -
      12454  if(IsCorruptionDetectionEnabled())
      -
      12455  {
      -
      12456  VmaWriteMagicValue(dstBlockInfo.pMappedData, move.dstOffset - VMA_DEBUG_MARGIN);
      -
      12457  VmaWriteMagicValue(dstBlockInfo.pMappedData, move.dstOffset + move.size);
      -
      12458  }
      -
      12459 
      -
      12460  // Flush destination.
      -
      12461  if(isNonCoherent)
      -
      12462  {
      -
      12463  VmaDeviceMemoryBlock* const pDstBlock = m_Blocks[move.dstBlockIndex];
      -
      12464  memRange.memory = pDstBlock->GetDeviceMemory();
      -
      12465  memRange.offset = VmaAlignDown(move.dstOffset, nonCoherentAtomSize);
      -
      12466  memRange.size = VMA_MIN(
      -
      12467  VmaAlignUp(move.size + (move.dstOffset - memRange.offset), nonCoherentAtomSize),
      -
      12468  pDstBlock->m_pMetadata->GetSize() - memRange.offset);
      -
      12469  (*m_hAllocator->GetVulkanFunctions().vkFlushMappedMemoryRanges)(m_hAllocator->m_hDevice, 1, &memRange);
      -
      12470  }
      -
      12471  }
      -
      12472  }
      -
      12473 
      -
      12474  // Go over all blocks in reverse order. Unmap those that were mapped just for defragmentation.
      -
      12475  // Regardless of pCtx->res == VK_SUCCESS.
      -
      12476  for(size_t blockIndex = blockCount; blockIndex--; )
      -
      12477  {
      -
      12478  const BlockInfo& currBlockInfo = blockInfo[blockIndex];
      -
      12479  if((currBlockInfo.flags & BLOCK_FLAG_MAPPED_FOR_DEFRAGMENTATION) != 0)
      -
      12480  {
      -
      12481  VmaDeviceMemoryBlock* pBlock = m_Blocks[blockIndex];
      -
      12482  pBlock->Unmap(m_hAllocator, 1);
      -
      12483  }
      -
      12484  }
      -
      12485 }
      -
      12486 
      -
      12487 void VmaBlockVector::ApplyDefragmentationMovesGpu(
      -
      12488  class VmaBlockVectorDefragmentationContext* pDefragCtx,
      -
      12489  const VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
      -
      12490  VkCommandBuffer commandBuffer)
      -
      12491 {
      -
      12492  const size_t blockCount = m_Blocks.size();
      -
      12493 
      -
      12494  pDefragCtx->blockContexts.resize(blockCount);
      -
      12495  memset(pDefragCtx->blockContexts.data(), 0, blockCount * sizeof(VmaBlockDefragmentationContext));
      -
      12496 
      -
      12497  // Go over all moves. Mark blocks that are used with BLOCK_FLAG_USED.
      -
      12498  const size_t moveCount = moves.size();
      -
      12499  for(size_t moveIndex = 0; moveIndex < moveCount; ++moveIndex)
      +
      12436  m_Blocks.push_back(pBlock);
      +
      12437  if(pNewBlockIndex != VMA_NULL)
      +
      12438  {
      +
      12439  *pNewBlockIndex = m_Blocks.size() - 1;
      +
      12440  }
      +
      12441 
      +
      12442  return VK_SUCCESS;
      +
      12443 }
      +
      12444 
      +
      12445 void VmaBlockVector::ApplyDefragmentationMovesCpu(
      +
      12446  class VmaBlockVectorDefragmentationContext* pDefragCtx,
      +
      12447  const VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves)
      +
      12448 {
      +
      12449  const size_t blockCount = m_Blocks.size();
      +
      12450  const bool isNonCoherent = m_hAllocator->IsMemoryTypeNonCoherent(m_MemoryTypeIndex);
      +
      12451 
      +
      12452  enum BLOCK_FLAG
      +
      12453  {
      +
      12454  BLOCK_FLAG_USED = 0x00000001,
      +
      12455  BLOCK_FLAG_MAPPED_FOR_DEFRAGMENTATION = 0x00000002,
      +
      12456  };
      +
      12457 
      +
      12458  struct BlockInfo
      +
      12459  {
      +
      12460  uint32_t flags;
      +
      12461  void* pMappedData;
      +
      12462  };
      +
      12463  VmaVector< BlockInfo, VmaStlAllocator<BlockInfo> >
      +
      12464  blockInfo(blockCount, BlockInfo(), VmaStlAllocator<BlockInfo>(m_hAllocator->GetAllocationCallbacks()));
      +
      12465  memset(blockInfo.data(), 0, blockCount * sizeof(BlockInfo));
      +
      12466 
      +
      12467  // Go over all moves. Mark blocks that are used with BLOCK_FLAG_USED.
      +
      12468  const size_t moveCount = moves.size();
      +
      12469  for(size_t moveIndex = 0; moveIndex < moveCount; ++moveIndex)
      +
      12470  {
      +
      12471  const VmaDefragmentationMove& move = moves[moveIndex];
      +
      12472  blockInfo[move.srcBlockIndex].flags |= BLOCK_FLAG_USED;
      +
      12473  blockInfo[move.dstBlockIndex].flags |= BLOCK_FLAG_USED;
      +
      12474  }
      +
      12475 
      +
      12476  VMA_ASSERT(pDefragCtx->res == VK_SUCCESS);
      +
      12477 
      +
      12478  // Go over all blocks. Get mapped pointer or map if necessary.
      +
      12479  for(size_t blockIndex = 0; pDefragCtx->res == VK_SUCCESS && blockIndex < blockCount; ++blockIndex)
      +
      12480  {
      +
      12481  BlockInfo& currBlockInfo = blockInfo[blockIndex];
      +
      12482  VmaDeviceMemoryBlock* pBlock = m_Blocks[blockIndex];
      +
      12483  if((currBlockInfo.flags & BLOCK_FLAG_USED) != 0)
      +
      12484  {
      +
      12485  currBlockInfo.pMappedData = pBlock->GetMappedData();
      +
      12486  // It is not originally mapped - map it.
      +
      12487  if(currBlockInfo.pMappedData == VMA_NULL)
      +
      12488  {
      +
      12489  pDefragCtx->res = pBlock->Map(m_hAllocator, 1, &currBlockInfo.pMappedData);
      +
      12490  if(pDefragCtx->res == VK_SUCCESS)
      +
      12491  {
      +
      12492  currBlockInfo.flags |= BLOCK_FLAG_MAPPED_FOR_DEFRAGMENTATION;
      +
      12493  }
      +
      12494  }
      +
      12495  }
      +
      12496  }
      +
      12497 
      +
      12498  // Go over all moves. Do actual data transfer.
      +
      12499  if(pDefragCtx->res == VK_SUCCESS)
      12500  {
      -
      12501  const VmaDefragmentationMove& move = moves[moveIndex];
      -
      12502  pDefragCtx->blockContexts[move.srcBlockIndex].flags |= VmaBlockDefragmentationContext::BLOCK_FLAG_USED;
      -
      12503  pDefragCtx->blockContexts[move.dstBlockIndex].flags |= VmaBlockDefragmentationContext::BLOCK_FLAG_USED;
      -
      12504  }
      -
      12505 
      -
      12506  VMA_ASSERT(pDefragCtx->res == VK_SUCCESS);
      +
      12501  const VkDeviceSize nonCoherentAtomSize = m_hAllocator->m_PhysicalDeviceProperties.limits.nonCoherentAtomSize;
      +
      12502  VkMappedMemoryRange memRange = { VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE };
      +
      12503 
      +
      12504  for(size_t moveIndex = 0; moveIndex < moveCount; ++moveIndex)
      +
      12505  {
      +
      12506  const VmaDefragmentationMove& move = moves[moveIndex];
      12507 
      -
      12508  // Go over all blocks. Create and bind buffer for whole block if necessary.
      -
      12509  {
      -
      12510  VkBufferCreateInfo bufCreateInfo;
      -
      12511  VmaFillGpuDefragmentationBufferCreateInfo(bufCreateInfo);
      +
      12508  const BlockInfo& srcBlockInfo = blockInfo[move.srcBlockIndex];
      +
      12509  const BlockInfo& dstBlockInfo = blockInfo[move.dstBlockIndex];
      +
      12510 
      +
      12511  VMA_ASSERT(srcBlockInfo.pMappedData && dstBlockInfo.pMappedData);
      12512 
      -
      12513  for(size_t blockIndex = 0; pDefragCtx->res == VK_SUCCESS && blockIndex < blockCount; ++blockIndex)
      -
      12514  {
      -
      12515  VmaBlockDefragmentationContext& currBlockCtx = pDefragCtx->blockContexts[blockIndex];
      -
      12516  VmaDeviceMemoryBlock* pBlock = m_Blocks[blockIndex];
      -
      12517  if((currBlockCtx.flags & VmaBlockDefragmentationContext::BLOCK_FLAG_USED) != 0)
      -
      12518  {
      -
      12519  bufCreateInfo.size = pBlock->m_pMetadata->GetSize();
      -
      12520  pDefragCtx->res = (*m_hAllocator->GetVulkanFunctions().vkCreateBuffer)(
      -
      12521  m_hAllocator->m_hDevice, &bufCreateInfo, m_hAllocator->GetAllocationCallbacks(), &currBlockCtx.hBuffer);
      -
      12522  if(pDefragCtx->res == VK_SUCCESS)
      -
      12523  {
      -
      12524  pDefragCtx->res = (*m_hAllocator->GetVulkanFunctions().vkBindBufferMemory)(
      -
      12525  m_hAllocator->m_hDevice, currBlockCtx.hBuffer, pBlock->GetDeviceMemory(), 0);
      -
      12526  }
      -
      12527  }
      -
      12528  }
      -
      12529  }
      +
      12513  // Invalidate source.
      +
      12514  if(isNonCoherent)
      +
      12515  {
      +
      12516  VmaDeviceMemoryBlock* const pSrcBlock = m_Blocks[move.srcBlockIndex];
      +
      12517  memRange.memory = pSrcBlock->GetDeviceMemory();
      +
      12518  memRange.offset = VmaAlignDown(move.srcOffset, nonCoherentAtomSize);
      +
      12519  memRange.size = VMA_MIN(
      +
      12520  VmaAlignUp(move.size + (move.srcOffset - memRange.offset), nonCoherentAtomSize),
      +
      12521  pSrcBlock->m_pMetadata->GetSize() - memRange.offset);
      +
      12522  (*m_hAllocator->GetVulkanFunctions().vkInvalidateMappedMemoryRanges)(m_hAllocator->m_hDevice, 1, &memRange);
      +
      12523  }
      +
      12524 
      +
      12525  // THE PLACE WHERE ACTUAL DATA COPY HAPPENS.
      +
      12526  memmove(
      +
      12527  reinterpret_cast<char*>(dstBlockInfo.pMappedData) + move.dstOffset,
      +
      12528  reinterpret_cast<char*>(srcBlockInfo.pMappedData) + move.srcOffset,
      +
      12529  static_cast<size_t>(move.size));
      12530 
      -
      12531  // Go over all moves. Post data transfer commands to command buffer.
      -
      12532  if(pDefragCtx->res == VK_SUCCESS)
      -
      12533  {
      -
      12534  for(size_t moveIndex = 0; moveIndex < moveCount; ++moveIndex)
      -
      12535  {
      -
      12536  const VmaDefragmentationMove& move = moves[moveIndex];
      -
      12537 
      -
      12538  const VmaBlockDefragmentationContext& srcBlockCtx = pDefragCtx->blockContexts[move.srcBlockIndex];
      -
      12539  const VmaBlockDefragmentationContext& dstBlockCtx = pDefragCtx->blockContexts[move.dstBlockIndex];
      -
      12540 
      -
      12541  VMA_ASSERT(srcBlockCtx.hBuffer && dstBlockCtx.hBuffer);
      -
      12542 
      -
      12543  VkBufferCopy region = {
      -
      12544  move.srcOffset,
      -
      12545  move.dstOffset,
      -
      12546  move.size };
      -
      12547  (*m_hAllocator->GetVulkanFunctions().vkCmdCopyBuffer)(
      -
      12548  commandBuffer, srcBlockCtx.hBuffer, dstBlockCtx.hBuffer, 1, &region);
      -
      12549  }
      -
      12550  }
      -
      12551 
      -
      12552  // Save buffers to defrag context for later destruction.
      -
      12553  if(pDefragCtx->res == VK_SUCCESS && moveCount > 0)
      +
      12531  if(IsCorruptionDetectionEnabled())
      +
      12532  {
      +
      12533  VmaWriteMagicValue(dstBlockInfo.pMappedData, move.dstOffset - VMA_DEBUG_MARGIN);
      +
      12534  VmaWriteMagicValue(dstBlockInfo.pMappedData, move.dstOffset + move.size);
      +
      12535  }
      +
      12536 
      +
      12537  // Flush destination.
      +
      12538  if(isNonCoherent)
      +
      12539  {
      +
      12540  VmaDeviceMemoryBlock* const pDstBlock = m_Blocks[move.dstBlockIndex];
      +
      12541  memRange.memory = pDstBlock->GetDeviceMemory();
      +
      12542  memRange.offset = VmaAlignDown(move.dstOffset, nonCoherentAtomSize);
      +
      12543  memRange.size = VMA_MIN(
      +
      12544  VmaAlignUp(move.size + (move.dstOffset - memRange.offset), nonCoherentAtomSize),
      +
      12545  pDstBlock->m_pMetadata->GetSize() - memRange.offset);
      +
      12546  (*m_hAllocator->GetVulkanFunctions().vkFlushMappedMemoryRanges)(m_hAllocator->m_hDevice, 1, &memRange);
      +
      12547  }
      +
      12548  }
      +
      12549  }
      +
      12550 
      +
      12551  // Go over all blocks in reverse order. Unmap those that were mapped just for defragmentation.
      +
      12552  // Regardless of pCtx->res == VK_SUCCESS.
      +
      12553  for(size_t blockIndex = blockCount; blockIndex--; )
      12554  {
      -
      12555  pDefragCtx->res = VK_NOT_READY;
      -
      12556  }
      -
      12557 }
      -
      12558 
      -
      12559 void VmaBlockVector::FreeEmptyBlocks(VmaDefragmentationStats* pDefragmentationStats)
      -
      12560 {
      -
      12561  m_HasEmptyBlock = false;
      -
      12562  for(size_t blockIndex = m_Blocks.size(); blockIndex--; )
      -
      12563  {
      -
      12564  VmaDeviceMemoryBlock* pBlock = m_Blocks[blockIndex];
      -
      12565  if(pBlock->m_pMetadata->IsEmpty())
      -
      12566  {
      -
      12567  if(m_Blocks.size() > m_MinBlockCount)
      -
      12568  {
      -
      12569  if(pDefragmentationStats != VMA_NULL)
      -
      12570  {
      -
      12571  ++pDefragmentationStats->deviceMemoryBlocksFreed;
      -
      12572  pDefragmentationStats->bytesFreed += pBlock->m_pMetadata->GetSize();
      -
      12573  }
      -
      12574 
      -
      12575  VmaVectorRemove(m_Blocks, blockIndex);
      -
      12576  pBlock->Destroy(m_hAllocator);
      -
      12577  vma_delete(m_hAllocator, pBlock);
      -
      12578  }
      -
      12579  else
      -
      12580  {
      -
      12581  m_HasEmptyBlock = true;
      -
      12582  }
      -
      12583  }
      -
      12584  }
      -
      12585 }
      -
      12586 
      -
      12587 #if VMA_STATS_STRING_ENABLED
      -
      12588 
      -
      12589 void VmaBlockVector::PrintDetailedMap(class VmaJsonWriter& json)
      -
      12590 {
      -
      12591  VmaMutexLockRead lock(m_Mutex, m_hAllocator->m_UseMutex);
      -
      12592 
      -
      12593  json.BeginObject();
      -
      12594 
      -
      12595  if(m_IsCustomPool)
      -
      12596  {
      -
      12597  json.WriteString("MemoryTypeIndex");
      -
      12598  json.WriteNumber(m_MemoryTypeIndex);
      -
      12599 
      -
      12600  json.WriteString("BlockSize");
      -
      12601  json.WriteNumber(m_PreferredBlockSize);
      -
      12602 
      -
      12603  json.WriteString("BlockCount");
      -
      12604  json.BeginObject(true);
      -
      12605  if(m_MinBlockCount > 0)
      -
      12606  {
      -
      12607  json.WriteString("Min");
      -
      12608  json.WriteNumber((uint64_t)m_MinBlockCount);
      -
      12609  }
      -
      12610  if(m_MaxBlockCount < SIZE_MAX)
      -
      12611  {
      -
      12612  json.WriteString("Max");
      -
      12613  json.WriteNumber((uint64_t)m_MaxBlockCount);
      -
      12614  }
      -
      12615  json.WriteString("Cur");
      -
      12616  json.WriteNumber((uint64_t)m_Blocks.size());
      -
      12617  json.EndObject();
      -
      12618 
      -
      12619  if(m_FrameInUseCount > 0)
      -
      12620  {
      -
      12621  json.WriteString("FrameInUseCount");
      -
      12622  json.WriteNumber(m_FrameInUseCount);
      -
      12623  }
      -
      12624 
      -
      12625  if(m_Algorithm != 0)
      -
      12626  {
      -
      12627  json.WriteString("Algorithm");
      -
      12628  json.WriteString(VmaAlgorithmToStr(m_Algorithm));
      -
      12629  }
      -
      12630  }
      -
      12631  else
      -
      12632  {
      -
      12633  json.WriteString("PreferredBlockSize");
      -
      12634  json.WriteNumber(m_PreferredBlockSize);
      -
      12635  }
      -
      12636 
      -
      12637  json.WriteString("Blocks");
      -
      12638  json.BeginObject();
      -
      12639  for(size_t i = 0; i < m_Blocks.size(); ++i)
      +
      12555  const BlockInfo& currBlockInfo = blockInfo[blockIndex];
      +
      12556  if((currBlockInfo.flags & BLOCK_FLAG_MAPPED_FOR_DEFRAGMENTATION) != 0)
      +
      12557  {
      +
      12558  VmaDeviceMemoryBlock* pBlock = m_Blocks[blockIndex];
      +
      12559  pBlock->Unmap(m_hAllocator, 1);
      +
      12560  }
      +
      12561  }
      +
      12562 }
      +
      12563 
      +
      12564 void VmaBlockVector::ApplyDefragmentationMovesGpu(
      +
      12565  class VmaBlockVectorDefragmentationContext* pDefragCtx,
      +
      12566  const VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
      +
      12567  VkCommandBuffer commandBuffer)
      +
      12568 {
      +
      12569  const size_t blockCount = m_Blocks.size();
      +
      12570 
      +
      12571  pDefragCtx->blockContexts.resize(blockCount);
      +
      12572  memset(pDefragCtx->blockContexts.data(), 0, blockCount * sizeof(VmaBlockDefragmentationContext));
      +
      12573 
      +
      12574  // Go over all moves. Mark blocks that are used with BLOCK_FLAG_USED.
      +
      12575  const size_t moveCount = moves.size();
      +
      12576  for(size_t moveIndex = 0; moveIndex < moveCount; ++moveIndex)
      +
      12577  {
      +
      12578  const VmaDefragmentationMove& move = moves[moveIndex];
      +
      12579  pDefragCtx->blockContexts[move.srcBlockIndex].flags |= VmaBlockDefragmentationContext::BLOCK_FLAG_USED;
      +
      12580  pDefragCtx->blockContexts[move.dstBlockIndex].flags |= VmaBlockDefragmentationContext::BLOCK_FLAG_USED;
      +
      12581  }
      +
      12582 
      +
      12583  VMA_ASSERT(pDefragCtx->res == VK_SUCCESS);
      +
      12584 
      +
      12585  // Go over all blocks. Create and bind buffer for whole block if necessary.
      +
      12586  {
      +
      12587  VkBufferCreateInfo bufCreateInfo;
      +
      12588  VmaFillGpuDefragmentationBufferCreateInfo(bufCreateInfo);
      +
      12589 
      +
      12590  for(size_t blockIndex = 0; pDefragCtx->res == VK_SUCCESS && blockIndex < blockCount; ++blockIndex)
      +
      12591  {
      +
      12592  VmaBlockDefragmentationContext& currBlockCtx = pDefragCtx->blockContexts[blockIndex];
      +
      12593  VmaDeviceMemoryBlock* pBlock = m_Blocks[blockIndex];
      +
      12594  if((currBlockCtx.flags & VmaBlockDefragmentationContext::BLOCK_FLAG_USED) != 0)
      +
      12595  {
      +
      12596  bufCreateInfo.size = pBlock->m_pMetadata->GetSize();
      +
      12597  pDefragCtx->res = (*m_hAllocator->GetVulkanFunctions().vkCreateBuffer)(
      +
      12598  m_hAllocator->m_hDevice, &bufCreateInfo, m_hAllocator->GetAllocationCallbacks(), &currBlockCtx.hBuffer);
      +
      12599  if(pDefragCtx->res == VK_SUCCESS)
      +
      12600  {
      +
      12601  pDefragCtx->res = (*m_hAllocator->GetVulkanFunctions().vkBindBufferMemory)(
      +
      12602  m_hAllocator->m_hDevice, currBlockCtx.hBuffer, pBlock->GetDeviceMemory(), 0);
      +
      12603  }
      +
      12604  }
      +
      12605  }
      +
      12606  }
      +
      12607 
      +
      12608  // Go over all moves. Post data transfer commands to command buffer.
      +
      12609  if(pDefragCtx->res == VK_SUCCESS)
      +
      12610  {
      +
      12611  for(size_t moveIndex = 0; moveIndex < moveCount; ++moveIndex)
      +
      12612  {
      +
      12613  const VmaDefragmentationMove& move = moves[moveIndex];
      +
      12614 
      +
      12615  const VmaBlockDefragmentationContext& srcBlockCtx = pDefragCtx->blockContexts[move.srcBlockIndex];
      +
      12616  const VmaBlockDefragmentationContext& dstBlockCtx = pDefragCtx->blockContexts[move.dstBlockIndex];
      +
      12617 
      +
      12618  VMA_ASSERT(srcBlockCtx.hBuffer && dstBlockCtx.hBuffer);
      +
      12619 
      +
      12620  VkBufferCopy region = {
      +
      12621  move.srcOffset,
      +
      12622  move.dstOffset,
      +
      12623  move.size };
      +
      12624  (*m_hAllocator->GetVulkanFunctions().vkCmdCopyBuffer)(
      +
      12625  commandBuffer, srcBlockCtx.hBuffer, dstBlockCtx.hBuffer, 1, &region);
      +
      12626  }
      +
      12627  }
      +
      12628 
      +
      12629  // Save buffers to defrag context for later destruction.
      +
      12630  if(pDefragCtx->res == VK_SUCCESS && moveCount > 0)
      +
      12631  {
      +
      12632  pDefragCtx->res = VK_NOT_READY;
      +
      12633  }
      +
      12634 }
      +
      12635 
      +
      12636 void VmaBlockVector::FreeEmptyBlocks(VmaDefragmentationStats* pDefragmentationStats)
      +
      12637 {
      +
      12638  m_HasEmptyBlock = false;
      +
      12639  for(size_t blockIndex = m_Blocks.size(); blockIndex--; )
      12640  {
      -
      12641  json.BeginString();
      -
      12642  json.ContinueString(m_Blocks[i]->GetId());
      -
      12643  json.EndString();
      -
      12644 
      -
      12645  m_Blocks[i]->m_pMetadata->PrintDetailedMap(json);
      -
      12646  }
      -
      12647  json.EndObject();
      -
      12648 
      -
      12649  json.EndObject();
      -
      12650 }
      +
      12641  VmaDeviceMemoryBlock* pBlock = m_Blocks[blockIndex];
      +
      12642  if(pBlock->m_pMetadata->IsEmpty())
      +
      12643  {
      +
      12644  if(m_Blocks.size() > m_MinBlockCount)
      +
      12645  {
      +
      12646  if(pDefragmentationStats != VMA_NULL)
      +
      12647  {
      +
      12648  ++pDefragmentationStats->deviceMemoryBlocksFreed;
      +
      12649  pDefragmentationStats->bytesFreed += pBlock->m_pMetadata->GetSize();
      +
      12650  }
      12651 
      -
      12652 #endif // #if VMA_STATS_STRING_ENABLED
      -
      12653 
      -
      12654 void VmaBlockVector::Defragment(
      -
      12655  class VmaBlockVectorDefragmentationContext* pCtx,
      -
      12656  VmaDefragmentationStats* pStats,
      -
      12657  VkDeviceSize& maxCpuBytesToMove, uint32_t& maxCpuAllocationsToMove,
      -
      12658  VkDeviceSize& maxGpuBytesToMove, uint32_t& maxGpuAllocationsToMove,
      -
      12659  VkCommandBuffer commandBuffer)
      -
      12660 {
      -
      12661  pCtx->res = VK_SUCCESS;
      -
      12662 
      -
      12663  const VkMemoryPropertyFlags memPropFlags =
      -
      12664  m_hAllocator->m_MemProps.memoryTypes[m_MemoryTypeIndex].propertyFlags;
      -
      12665  const bool isHostVisible = (memPropFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0;
      -
      12666 
      -
      12667  const bool canDefragmentOnCpu = maxCpuBytesToMove > 0 && maxCpuAllocationsToMove > 0 &&
      -
      12668  isHostVisible;
      -
      12669  const bool canDefragmentOnGpu = maxGpuBytesToMove > 0 && maxGpuAllocationsToMove > 0 &&
      -
      12670  !IsCorruptionDetectionEnabled() &&
      -
      12671  ((1u << m_MemoryTypeIndex) & m_hAllocator->GetGpuDefragmentationMemoryTypeBits()) != 0;
      -
      12672 
      -
      12673  // There are options to defragment this memory type.
      -
      12674  if(canDefragmentOnCpu || canDefragmentOnGpu)
      -
      12675  {
      -
      12676  bool defragmentOnGpu;
      -
      12677  // There is only one option to defragment this memory type.
      -
      12678  if(canDefragmentOnGpu != canDefragmentOnCpu)
      -
      12679  {
      -
      12680  defragmentOnGpu = canDefragmentOnGpu;
      -
      12681  }
      -
      12682  // Both options are available: Heuristics to choose the best one.
      -
      12683  else
      -
      12684  {
      -
      12685  defragmentOnGpu = (memPropFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) != 0 ||
      -
      12686  m_hAllocator->IsIntegratedGpu();
      -
      12687  }
      -
      12688 
      -
      12689  bool overlappingMoveSupported = !defragmentOnGpu;
      -
      12690 
      -
      12691  if(m_hAllocator->m_UseMutex)
      -
      12692  {
      -
      12693  m_Mutex.LockWrite();
      -
      12694  pCtx->mutexLocked = true;
      -
      12695  }
      -
      12696 
      -
      12697  pCtx->Begin(overlappingMoveSupported);
      -
      12698 
      -
      12699  // Defragment.
      -
      12700 
      -
      12701  const VkDeviceSize maxBytesToMove = defragmentOnGpu ? maxGpuBytesToMove : maxCpuBytesToMove;
      -
      12702  const uint32_t maxAllocationsToMove = defragmentOnGpu ? maxGpuAllocationsToMove : maxCpuAllocationsToMove;
      -
      12703  VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> > moves =
      -
      12704  VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >(VmaStlAllocator<VmaDefragmentationMove>(m_hAllocator->GetAllocationCallbacks()));
      -
      12705  pCtx->res = pCtx->GetAlgorithm()->Defragment(moves, maxBytesToMove, maxAllocationsToMove);
      -
      12706 
      -
      12707  // Accumulate statistics.
      -
      12708  if(pStats != VMA_NULL)
      -
      12709  {
      -
      12710  const VkDeviceSize bytesMoved = pCtx->GetAlgorithm()->GetBytesMoved();
      -
      12711  const uint32_t allocationsMoved = pCtx->GetAlgorithm()->GetAllocationsMoved();
      -
      12712  pStats->bytesMoved += bytesMoved;
      -
      12713  pStats->allocationsMoved += allocationsMoved;
      -
      12714  VMA_ASSERT(bytesMoved <= maxBytesToMove);
      -
      12715  VMA_ASSERT(allocationsMoved <= maxAllocationsToMove);
      -
      12716  if(defragmentOnGpu)
      -
      12717  {
      -
      12718  maxGpuBytesToMove -= bytesMoved;
      -
      12719  maxGpuAllocationsToMove -= allocationsMoved;
      -
      12720  }
      -
      12721  else
      -
      12722  {
      -
      12723  maxCpuBytesToMove -= bytesMoved;
      -
      12724  maxCpuAllocationsToMove -= allocationsMoved;
      -
      12725  }
      -
      12726  }
      -
      12727 
      -
      12728  if(pCtx->res >= VK_SUCCESS)
      -
      12729  {
      -
      12730  if(defragmentOnGpu)
      -
      12731  {
      -
      12732  ApplyDefragmentationMovesGpu(pCtx, moves, commandBuffer);
      -
      12733  }
      -
      12734  else
      -
      12735  {
      -
      12736  ApplyDefragmentationMovesCpu(pCtx, moves);
      -
      12737  }
      -
      12738  }
      -
      12739  }
      -
      12740 }
      -
      12741 
      -
      12742 void VmaBlockVector::DefragmentationEnd(
      -
      12743  class VmaBlockVectorDefragmentationContext* pCtx,
      -
      12744  VmaDefragmentationStats* pStats)
      -
      12745 {
      -
      12746  // Destroy buffers.
      -
      12747  for(size_t blockIndex = pCtx->blockContexts.size(); blockIndex--; )
      -
      12748  {
      -
      12749  VmaBlockDefragmentationContext& blockCtx = pCtx->blockContexts[blockIndex];
      -
      12750  if(blockCtx.hBuffer)
      -
      12751  {
      -
      12752  (*m_hAllocator->GetVulkanFunctions().vkDestroyBuffer)(
      -
      12753  m_hAllocator->m_hDevice, blockCtx.hBuffer, m_hAllocator->GetAllocationCallbacks());
      -
      12754  }
      -
      12755  }
      +
      12652  VmaVectorRemove(m_Blocks, blockIndex);
      +
      12653  pBlock->Destroy(m_hAllocator);
      +
      12654  vma_delete(m_hAllocator, pBlock);
      +
      12655  }
      +
      12656  else
      +
      12657  {
      +
      12658  m_HasEmptyBlock = true;
      +
      12659  }
      +
      12660  }
      +
      12661  }
      +
      12662 }
      +
      12663 
      +
      12664 #if VMA_STATS_STRING_ENABLED
      +
      12665 
      +
      12666 void VmaBlockVector::PrintDetailedMap(class VmaJsonWriter& json)
      +
      12667 {
      +
      12668  VmaMutexLockRead lock(m_Mutex, m_hAllocator->m_UseMutex);
      +
      12669 
      +
      12670  json.BeginObject();
      +
      12671 
      +
      12672  if(IsCustomPool())
      +
      12673  {
      +
      12674  const char* poolName = m_hParentPool->GetName();
      +
      12675  if(poolName != VMA_NULL && poolName[0] != '\0')
      +
      12676  {
      +
      12677  json.WriteString("Name");
      +
      12678  json.WriteString(poolName);
      +
      12679  }
      +
      12680 
      +
      12681  json.WriteString("MemoryTypeIndex");
      +
      12682  json.WriteNumber(m_MemoryTypeIndex);
      +
      12683 
      +
      12684  json.WriteString("BlockSize");
      +
      12685  json.WriteNumber(m_PreferredBlockSize);
      +
      12686 
      +
      12687  json.WriteString("BlockCount");
      +
      12688  json.BeginObject(true);
      +
      12689  if(m_MinBlockCount > 0)
      +
      12690  {
      +
      12691  json.WriteString("Min");
      +
      12692  json.WriteNumber((uint64_t)m_MinBlockCount);
      +
      12693  }
      +
      12694  if(m_MaxBlockCount < SIZE_MAX)
      +
      12695  {
      +
      12696  json.WriteString("Max");
      +
      12697  json.WriteNumber((uint64_t)m_MaxBlockCount);
      +
      12698  }
      +
      12699  json.WriteString("Cur");
      +
      12700  json.WriteNumber((uint64_t)m_Blocks.size());
      +
      12701  json.EndObject();
      +
      12702 
      +
      12703  if(m_FrameInUseCount > 0)
      +
      12704  {
      +
      12705  json.WriteString("FrameInUseCount");
      +
      12706  json.WriteNumber(m_FrameInUseCount);
      +
      12707  }
      +
      12708 
      +
      12709  if(m_Algorithm != 0)
      +
      12710  {
      +
      12711  json.WriteString("Algorithm");
      +
      12712  json.WriteString(VmaAlgorithmToStr(m_Algorithm));
      +
      12713  }
      +
      12714  }
      +
      12715  else
      +
      12716  {
      +
      12717  json.WriteString("PreferredBlockSize");
      +
      12718  json.WriteNumber(m_PreferredBlockSize);
      +
      12719  }
      +
      12720 
      +
      12721  json.WriteString("Blocks");
      +
      12722  json.BeginObject();
      +
      12723  for(size_t i = 0; i < m_Blocks.size(); ++i)
      +
      12724  {
      +
      12725  json.BeginString();
      +
      12726  json.ContinueString(m_Blocks[i]->GetId());
      +
      12727  json.EndString();
      +
      12728 
      +
      12729  m_Blocks[i]->m_pMetadata->PrintDetailedMap(json);
      +
      12730  }
      +
      12731  json.EndObject();
      +
      12732 
      +
      12733  json.EndObject();
      +
      12734 }
      +
      12735 
      +
      12736 #endif // #if VMA_STATS_STRING_ENABLED
      +
      12737 
      +
      12738 void VmaBlockVector::Defragment(
      +
      12739  class VmaBlockVectorDefragmentationContext* pCtx,
      +
      12740  VmaDefragmentationStats* pStats,
      +
      12741  VkDeviceSize& maxCpuBytesToMove, uint32_t& maxCpuAllocationsToMove,
      +
      12742  VkDeviceSize& maxGpuBytesToMove, uint32_t& maxGpuAllocationsToMove,
      +
      12743  VkCommandBuffer commandBuffer)
      +
      12744 {
      +
      12745  pCtx->res = VK_SUCCESS;
      +
      12746 
      +
      12747  const VkMemoryPropertyFlags memPropFlags =
      +
      12748  m_hAllocator->m_MemProps.memoryTypes[m_MemoryTypeIndex].propertyFlags;
      +
      12749  const bool isHostVisible = (memPropFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0;
      +
      12750 
      +
      12751  const bool canDefragmentOnCpu = maxCpuBytesToMove > 0 && maxCpuAllocationsToMove > 0 &&
      +
      12752  isHostVisible;
      +
      12753  const bool canDefragmentOnGpu = maxGpuBytesToMove > 0 && maxGpuAllocationsToMove > 0 &&
      +
      12754  !IsCorruptionDetectionEnabled() &&
      +
      12755  ((1u << m_MemoryTypeIndex) & m_hAllocator->GetGpuDefragmentationMemoryTypeBits()) != 0;
      12756 
      -
      12757  if(pCtx->res >= VK_SUCCESS)
      -
      12758  {
      -
      12759  FreeEmptyBlocks(pStats);
      -
      12760  }
      -
      12761 
      -
      12762  if(pCtx->mutexLocked)
      -
      12763  {
      -
      12764  VMA_ASSERT(m_hAllocator->m_UseMutex);
      -
      12765  m_Mutex.UnlockWrite();
      -
      12766  }
      -
      12767 }
      -
      12768 
      -
      12769 size_t VmaBlockVector::CalcAllocationCount() const
      -
      12770 {
      -
      12771  size_t result = 0;
      -
      12772  for(size_t i = 0; i < m_Blocks.size(); ++i)
      -
      12773  {
      -
      12774  result += m_Blocks[i]->m_pMetadata->GetAllocationCount();
      -
      12775  }
      -
      12776  return result;
      -
      12777 }
      -
      12778 
      -
      12779 bool VmaBlockVector::IsBufferImageGranularityConflictPossible() const
      -
      12780 {
      -
      12781  if(m_BufferImageGranularity == 1)
      -
      12782  {
      -
      12783  return false;
      -
      12784  }
      -
      12785  VmaSuballocationType lastSuballocType = VMA_SUBALLOCATION_TYPE_FREE;
      -
      12786  for(size_t i = 0, count = m_Blocks.size(); i < count; ++i)
      -
      12787  {
      -
      12788  VmaDeviceMemoryBlock* const pBlock = m_Blocks[i];
      -
      12789  VMA_ASSERT(m_Algorithm == 0);
      -
      12790  VmaBlockMetadata_Generic* const pMetadata = (VmaBlockMetadata_Generic*)pBlock->m_pMetadata;
      -
      12791  if(pMetadata->IsBufferImageGranularityConflictPossible(m_BufferImageGranularity, lastSuballocType))
      -
      12792  {
      -
      12793  return true;
      -
      12794  }
      -
      12795  }
      -
      12796  return false;
      -
      12797 }
      -
      12798 
      -
      12799 void VmaBlockVector::MakePoolAllocationsLost(
      -
      12800  uint32_t currentFrameIndex,
      -
      12801  size_t* pLostAllocationCount)
      -
      12802 {
      -
      12803  VmaMutexLockWrite lock(m_Mutex, m_hAllocator->m_UseMutex);
      -
      12804  size_t lostAllocationCount = 0;
      -
      12805  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
      -
      12806  {
      -
      12807  VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
      -
      12808  VMA_ASSERT(pBlock);
      -
      12809  lostAllocationCount += pBlock->m_pMetadata->MakeAllocationsLost(currentFrameIndex, m_FrameInUseCount);
      -
      12810  }
      -
      12811  if(pLostAllocationCount != VMA_NULL)
      -
      12812  {
      -
      12813  *pLostAllocationCount = lostAllocationCount;
      -
      12814  }
      -
      12815 }
      -
      12816 
      -
      12817 VkResult VmaBlockVector::CheckCorruption()
      -
      12818 {
      -
      12819  if(!IsCorruptionDetectionEnabled())
      -
      12820  {
      -
      12821  return VK_ERROR_FEATURE_NOT_PRESENT;
      -
      12822  }
      -
      12823 
      -
      12824  VmaMutexLockRead lock(m_Mutex, m_hAllocator->m_UseMutex);
      -
      12825  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
      -
      12826  {
      -
      12827  VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
      -
      12828  VMA_ASSERT(pBlock);
      -
      12829  VkResult res = pBlock->CheckCorruption(m_hAllocator);
      -
      12830  if(res != VK_SUCCESS)
      -
      12831  {
      -
      12832  return res;
      -
      12833  }
      -
      12834  }
      -
      12835  return VK_SUCCESS;
      -
      12836 }
      -
      12837 
      -
      12838 void VmaBlockVector::AddStats(VmaStats* pStats)
      -
      12839 {
      -
      12840  const uint32_t memTypeIndex = m_MemoryTypeIndex;
      -
      12841  const uint32_t memHeapIndex = m_hAllocator->MemoryTypeIndexToHeapIndex(memTypeIndex);
      -
      12842 
      -
      12843  VmaMutexLockRead lock(m_Mutex, m_hAllocator->m_UseMutex);
      -
      12844 
      -
      12845  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
      -
      12846  {
      -
      12847  const VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
      -
      12848  VMA_ASSERT(pBlock);
      -
      12849  VMA_HEAVY_ASSERT(pBlock->Validate());
      -
      12850  VmaStatInfo allocationStatInfo;
      -
      12851  pBlock->m_pMetadata->CalcAllocationStatInfo(allocationStatInfo);
      -
      12852  VmaAddStatInfo(pStats->total, allocationStatInfo);
      -
      12853  VmaAddStatInfo(pStats->memoryType[memTypeIndex], allocationStatInfo);
      -
      12854  VmaAddStatInfo(pStats->memoryHeap[memHeapIndex], allocationStatInfo);
      -
      12855  }
      -
      12856 }
      -
      12857 
      -
      12859 // VmaDefragmentationAlgorithm_Generic members definition
      -
      12860 
      -
      12861 VmaDefragmentationAlgorithm_Generic::VmaDefragmentationAlgorithm_Generic(
      -
      12862  VmaAllocator hAllocator,
      -
      12863  VmaBlockVector* pBlockVector,
      -
      12864  uint32_t currentFrameIndex,
      -
      12865  bool overlappingMoveSupported) :
      -
      12866  VmaDefragmentationAlgorithm(hAllocator, pBlockVector, currentFrameIndex),
      -
      12867  m_AllocationCount(0),
      -
      12868  m_AllAllocations(false),
      -
      12869  m_BytesMoved(0),
      -
      12870  m_AllocationsMoved(0),
      -
      12871  m_Blocks(VmaStlAllocator<BlockInfo*>(hAllocator->GetAllocationCallbacks()))
      -
      12872 {
      -
      12873  // Create block info for each block.
      -
      12874  const size_t blockCount = m_pBlockVector->m_Blocks.size();
      -
      12875  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
      -
      12876  {
      -
      12877  BlockInfo* pBlockInfo = vma_new(m_hAllocator, BlockInfo)(m_hAllocator->GetAllocationCallbacks());
      -
      12878  pBlockInfo->m_OriginalBlockIndex = blockIndex;
      -
      12879  pBlockInfo->m_pBlock = m_pBlockVector->m_Blocks[blockIndex];
      -
      12880  m_Blocks.push_back(pBlockInfo);
      -
      12881  }
      +
      12757  // There are options to defragment this memory type.
      +
      12758  if(canDefragmentOnCpu || canDefragmentOnGpu)
      +
      12759  {
      +
      12760  bool defragmentOnGpu;
      +
      12761  // There is only one option to defragment this memory type.
      +
      12762  if(canDefragmentOnGpu != canDefragmentOnCpu)
      +
      12763  {
      +
      12764  defragmentOnGpu = canDefragmentOnGpu;
      +
      12765  }
      +
      12766  // Both options are available: Heuristics to choose the best one.
      +
      12767  else
      +
      12768  {
      +
      12769  defragmentOnGpu = (memPropFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) != 0 ||
      +
      12770  m_hAllocator->IsIntegratedGpu();
      +
      12771  }
      +
      12772 
      +
      12773  bool overlappingMoveSupported = !defragmentOnGpu;
      +
      12774 
      +
      12775  if(m_hAllocator->m_UseMutex)
      +
      12776  {
      +
      12777  m_Mutex.LockWrite();
      +
      12778  pCtx->mutexLocked = true;
      +
      12779  }
      +
      12780 
      +
      12781  pCtx->Begin(overlappingMoveSupported);
      +
      12782 
      +
      12783  // Defragment.
      +
      12784 
      +
      12785  const VkDeviceSize maxBytesToMove = defragmentOnGpu ? maxGpuBytesToMove : maxCpuBytesToMove;
      +
      12786  const uint32_t maxAllocationsToMove = defragmentOnGpu ? maxGpuAllocationsToMove : maxCpuAllocationsToMove;
      +
      12787  VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> > moves =
      +
      12788  VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >(VmaStlAllocator<VmaDefragmentationMove>(m_hAllocator->GetAllocationCallbacks()));
      +
      12789  pCtx->res = pCtx->GetAlgorithm()->Defragment(moves, maxBytesToMove, maxAllocationsToMove);
      +
      12790 
      +
      12791  // Accumulate statistics.
      +
      12792  if(pStats != VMA_NULL)
      +
      12793  {
      +
      12794  const VkDeviceSize bytesMoved = pCtx->GetAlgorithm()->GetBytesMoved();
      +
      12795  const uint32_t allocationsMoved = pCtx->GetAlgorithm()->GetAllocationsMoved();
      +
      12796  pStats->bytesMoved += bytesMoved;
      +
      12797  pStats->allocationsMoved += allocationsMoved;
      +
      12798  VMA_ASSERT(bytesMoved <= maxBytesToMove);
      +
      12799  VMA_ASSERT(allocationsMoved <= maxAllocationsToMove);
      +
      12800  if(defragmentOnGpu)
      +
      12801  {
      +
      12802  maxGpuBytesToMove -= bytesMoved;
      +
      12803  maxGpuAllocationsToMove -= allocationsMoved;
      +
      12804  }
      +
      12805  else
      +
      12806  {
      +
      12807  maxCpuBytesToMove -= bytesMoved;
      +
      12808  maxCpuAllocationsToMove -= allocationsMoved;
      +
      12809  }
      +
      12810  }
      +
      12811 
      +
      12812  if(pCtx->res >= VK_SUCCESS)
      +
      12813  {
      +
      12814  if(defragmentOnGpu)
      +
      12815  {
      +
      12816  ApplyDefragmentationMovesGpu(pCtx, moves, commandBuffer);
      +
      12817  }
      +
      12818  else
      +
      12819  {
      +
      12820  ApplyDefragmentationMovesCpu(pCtx, moves);
      +
      12821  }
      +
      12822  }
      +
      12823  }
      +
      12824 }
      +
      12825 
      +
      12826 void VmaBlockVector::DefragmentationEnd(
      +
      12827  class VmaBlockVectorDefragmentationContext* pCtx,
      +
      12828  VmaDefragmentationStats* pStats)
      +
      12829 {
      +
      12830  // Destroy buffers.
      +
      12831  for(size_t blockIndex = pCtx->blockContexts.size(); blockIndex--; )
      +
      12832  {
      +
      12833  VmaBlockDefragmentationContext& blockCtx = pCtx->blockContexts[blockIndex];
      +
      12834  if(blockCtx.hBuffer)
      +
      12835  {
      +
      12836  (*m_hAllocator->GetVulkanFunctions().vkDestroyBuffer)(
      +
      12837  m_hAllocator->m_hDevice, blockCtx.hBuffer, m_hAllocator->GetAllocationCallbacks());
      +
      12838  }
      +
      12839  }
      +
      12840 
      +
      12841  if(pCtx->res >= VK_SUCCESS)
      +
      12842  {
      +
      12843  FreeEmptyBlocks(pStats);
      +
      12844  }
      +
      12845 
      +
      12846  if(pCtx->mutexLocked)
      +
      12847  {
      +
      12848  VMA_ASSERT(m_hAllocator->m_UseMutex);
      +
      12849  m_Mutex.UnlockWrite();
      +
      12850  }
      +
      12851 }
      +
      12852 
      +
      12853 size_t VmaBlockVector::CalcAllocationCount() const
      +
      12854 {
      +
      12855  size_t result = 0;
      +
      12856  for(size_t i = 0; i < m_Blocks.size(); ++i)
      +
      12857  {
      +
      12858  result += m_Blocks[i]->m_pMetadata->GetAllocationCount();
      +
      12859  }
      +
      12860  return result;
      +
      12861 }
      +
      12862 
      +
      12863 bool VmaBlockVector::IsBufferImageGranularityConflictPossible() const
      +
      12864 {
      +
      12865  if(m_BufferImageGranularity == 1)
      +
      12866  {
      +
      12867  return false;
      +
      12868  }
      +
      12869  VmaSuballocationType lastSuballocType = VMA_SUBALLOCATION_TYPE_FREE;
      +
      12870  for(size_t i = 0, count = m_Blocks.size(); i < count; ++i)
      +
      12871  {
      +
      12872  VmaDeviceMemoryBlock* const pBlock = m_Blocks[i];
      +
      12873  VMA_ASSERT(m_Algorithm == 0);
      +
      12874  VmaBlockMetadata_Generic* const pMetadata = (VmaBlockMetadata_Generic*)pBlock->m_pMetadata;
      +
      12875  if(pMetadata->IsBufferImageGranularityConflictPossible(m_BufferImageGranularity, lastSuballocType))
      +
      12876  {
      +
      12877  return true;
      +
      12878  }
      +
      12879  }
      +
      12880  return false;
      +
      12881 }
      12882 
      -
      12883  // Sort them by m_pBlock pointer value.
      -
      12884  VMA_SORT(m_Blocks.begin(), m_Blocks.end(), BlockPointerLess());
      -
      12885 }
      -
      12886 
      -
      12887 VmaDefragmentationAlgorithm_Generic::~VmaDefragmentationAlgorithm_Generic()
      -
      12888 {
      -
      12889  for(size_t i = m_Blocks.size(); i--; )
      +
      12883 void VmaBlockVector::MakePoolAllocationsLost(
      +
      12884  uint32_t currentFrameIndex,
      +
      12885  size_t* pLostAllocationCount)
      +
      12886 {
      +
      12887  VmaMutexLockWrite lock(m_Mutex, m_hAllocator->m_UseMutex);
      +
      12888  size_t lostAllocationCount = 0;
      +
      12889  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
      12890  {
      -
      12891  vma_delete(m_hAllocator, m_Blocks[i]);
      -
      12892  }
      -
      12893 }
      -
      12894 
      -
      12895 void VmaDefragmentationAlgorithm_Generic::AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged)
      -
      12896 {
      -
      12897  // Now as we are inside VmaBlockVector::m_Mutex, we can make final check if this allocation was not lost.
      -
      12898  if(hAlloc->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST)
      -
      12899  {
      -
      12900  VmaDeviceMemoryBlock* pBlock = hAlloc->GetBlock();
      -
      12901  BlockInfoVector::iterator it = VmaBinaryFindFirstNotLess(m_Blocks.begin(), m_Blocks.end(), pBlock, BlockPointerLess());
      -
      12902  if(it != m_Blocks.end() && (*it)->m_pBlock == pBlock)
      -
      12903  {
      -
      12904  AllocationInfo allocInfo = AllocationInfo(hAlloc, pChanged);
      -
      12905  (*it)->m_Allocations.push_back(allocInfo);
      -
      12906  }
      -
      12907  else
      -
      12908  {
      -
      12909  VMA_ASSERT(0);
      -
      12910  }
      -
      12911 
      -
      12912  ++m_AllocationCount;
      -
      12913  }
      -
      12914 }
      -
      12915 
      -
      12916 VkResult VmaDefragmentationAlgorithm_Generic::DefragmentRound(
      -
      12917  VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
      -
      12918  VkDeviceSize maxBytesToMove,
      -
      12919  uint32_t maxAllocationsToMove)
      -
      12920 {
      -
      12921  if(m_Blocks.empty())
      -
      12922  {
      -
      12923  return VK_SUCCESS;
      -
      12924  }
      -
      12925 
      -
      12926  // This is a choice based on research.
      -
      12927  // Option 1:
      -
      12928  uint32_t strategy = VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT;
      -
      12929  // Option 2:
      -
      12930  //uint32_t strategy = VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT;
      -
      12931  // Option 3:
      -
      12932  //uint32_t strategy = VMA_ALLOCATION_CREATE_STRATEGY_MIN_FRAGMENTATION_BIT;
      -
      12933 
      -
      12934  size_t srcBlockMinIndex = 0;
      -
      12935  // When FAST_ALGORITHM, move allocations from only last out of blocks that contain non-movable allocations.
      -
      12936  /*
      -
      12937  if(m_AlgorithmFlags & VMA_DEFRAGMENTATION_FAST_ALGORITHM_BIT)
      -
      12938  {
      -
      12939  const size_t blocksWithNonMovableCount = CalcBlocksWithNonMovableCount();
      -
      12940  if(blocksWithNonMovableCount > 0)
      -
      12941  {
      -
      12942  srcBlockMinIndex = blocksWithNonMovableCount - 1;
      -
      12943  }
      -
      12944  }
      -
      12945  */
      -
      12946 
      -
      12947  size_t srcBlockIndex = m_Blocks.size() - 1;
      -
      12948  size_t srcAllocIndex = SIZE_MAX;
      -
      12949  for(;;)
      -
      12950  {
      -
      12951  // 1. Find next allocation to move.
      -
      12952  // 1.1. Start from last to first m_Blocks - they are sorted from most "destination" to most "source".
      -
      12953  // 1.2. Then start from last to first m_Allocations.
      -
      12954  while(srcAllocIndex >= m_Blocks[srcBlockIndex]->m_Allocations.size())
      -
      12955  {
      -
      12956  if(m_Blocks[srcBlockIndex]->m_Allocations.empty())
      -
      12957  {
      -
      12958  // Finished: no more allocations to process.
      -
      12959  if(srcBlockIndex == srcBlockMinIndex)
      -
      12960  {
      -
      12961  return VK_SUCCESS;
      -
      12962  }
      -
      12963  else
      -
      12964  {
      -
      12965  --srcBlockIndex;
      -
      12966  srcAllocIndex = SIZE_MAX;
      -
      12967  }
      -
      12968  }
      -
      12969  else
      -
      12970  {
      -
      12971  srcAllocIndex = m_Blocks[srcBlockIndex]->m_Allocations.size() - 1;
      -
      12972  }
      -
      12973  }
      -
      12974 
      -
      12975  BlockInfo* pSrcBlockInfo = m_Blocks[srcBlockIndex];
      -
      12976  AllocationInfo& allocInfo = pSrcBlockInfo->m_Allocations[srcAllocIndex];
      -
      12977 
      -
      12978  const VkDeviceSize size = allocInfo.m_hAllocation->GetSize();
      -
      12979  const VkDeviceSize srcOffset = allocInfo.m_hAllocation->GetOffset();
      -
      12980  const VkDeviceSize alignment = allocInfo.m_hAllocation->GetAlignment();
      -
      12981  const VmaSuballocationType suballocType = allocInfo.m_hAllocation->GetSuballocationType();
      -
      12982 
      -
      12983  // 2. Try to find new place for this allocation in preceding or current block.
      -
      12984  for(size_t dstBlockIndex = 0; dstBlockIndex <= srcBlockIndex; ++dstBlockIndex)
      -
      12985  {
      -
      12986  BlockInfo* pDstBlockInfo = m_Blocks[dstBlockIndex];
      -
      12987  VmaAllocationRequest dstAllocRequest;
      -
      12988  if(pDstBlockInfo->m_pBlock->m_pMetadata->CreateAllocationRequest(
      -
      12989  m_CurrentFrameIndex,
      -
      12990  m_pBlockVector->GetFrameInUseCount(),
      -
      12991  m_pBlockVector->GetBufferImageGranularity(),
      -
      12992  size,
      -
      12993  alignment,
      -
      12994  false, // upperAddress
      -
      12995  suballocType,
      -
      12996  false, // canMakeOtherLost
      -
      12997  strategy,
      -
      12998  &dstAllocRequest) &&
      -
      12999  MoveMakesSense(
      -
      13000  dstBlockIndex, dstAllocRequest.offset, srcBlockIndex, srcOffset))
      -
      13001  {
      -
      13002  VMA_ASSERT(dstAllocRequest.itemsToMakeLostCount == 0);
      -
      13003 
      -
      13004  // Reached limit on number of allocations or bytes to move.
      -
      13005  if((m_AllocationsMoved + 1 > maxAllocationsToMove) ||
      -
      13006  (m_BytesMoved + size > maxBytesToMove))
      -
      13007  {
      -
      13008  return VK_SUCCESS;
      -
      13009  }
      -
      13010 
      -
      13011  VmaDefragmentationMove move;
      -
      13012  move.srcBlockIndex = pSrcBlockInfo->m_OriginalBlockIndex;
      -
      13013  move.dstBlockIndex = pDstBlockInfo->m_OriginalBlockIndex;
      -
      13014  move.srcOffset = srcOffset;
      -
      13015  move.dstOffset = dstAllocRequest.offset;
      -
      13016  move.size = size;
      -
      13017  moves.push_back(move);
      -
      13018 
      -
      13019  pDstBlockInfo->m_pBlock->m_pMetadata->Alloc(
      -
      13020  dstAllocRequest,
      -
      13021  suballocType,
      -
      13022  size,
      -
      13023  allocInfo.m_hAllocation);
      -
      13024  pSrcBlockInfo->m_pBlock->m_pMetadata->FreeAtOffset(srcOffset);
      -
      13025 
      -
      13026  allocInfo.m_hAllocation->ChangeBlockAllocation(m_hAllocator, pDstBlockInfo->m_pBlock, dstAllocRequest.offset);
      -
      13027 
      -
      13028  if(allocInfo.m_pChanged != VMA_NULL)
      -
      13029  {
      -
      13030  *allocInfo.m_pChanged = VK_TRUE;
      -
      13031  }
      -
      13032 
      -
      13033  ++m_AllocationsMoved;
      -
      13034  m_BytesMoved += size;
      -
      13035 
      -
      13036  VmaVectorRemove(pSrcBlockInfo->m_Allocations, srcAllocIndex);
      -
      13037 
      -
      13038  break;
      -
      13039  }
      -
      13040  }
      -
      13041 
      -
      13042  // If not processed, this allocInfo remains in pBlockInfo->m_Allocations for next round.
      -
      13043 
      -
      13044  if(srcAllocIndex > 0)
      -
      13045  {
      -
      13046  --srcAllocIndex;
      -
      13047  }
      -
      13048  else
      -
      13049  {
      -
      13050  if(srcBlockIndex > 0)
      -
      13051  {
      -
      13052  --srcBlockIndex;
      -
      13053  srcAllocIndex = SIZE_MAX;
      -
      13054  }
      -
      13055  else
      -
      13056  {
      -
      13057  return VK_SUCCESS;
      -
      13058  }
      -
      13059  }
      -
      13060  }
      -
      13061 }
      -
      13062 
      -
      13063 size_t VmaDefragmentationAlgorithm_Generic::CalcBlocksWithNonMovableCount() const
      -
      13064 {
      -
      13065  size_t result = 0;
      -
      13066  for(size_t i = 0; i < m_Blocks.size(); ++i)
      -
      13067  {
      -
      13068  if(m_Blocks[i]->m_HasNonMovableAllocations)
      +
      12891  VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
      +
      12892  VMA_ASSERT(pBlock);
      +
      12893  lostAllocationCount += pBlock->m_pMetadata->MakeAllocationsLost(currentFrameIndex, m_FrameInUseCount);
      +
      12894  }
      +
      12895  if(pLostAllocationCount != VMA_NULL)
      +
      12896  {
      +
      12897  *pLostAllocationCount = lostAllocationCount;
      +
      12898  }
      +
      12899 }
      +
      12900 
      +
      12901 VkResult VmaBlockVector::CheckCorruption()
      +
      12902 {
      +
      12903  if(!IsCorruptionDetectionEnabled())
      +
      12904  {
      +
      12905  return VK_ERROR_FEATURE_NOT_PRESENT;
      +
      12906  }
      +
      12907 
      +
      12908  VmaMutexLockRead lock(m_Mutex, m_hAllocator->m_UseMutex);
      +
      12909  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
      +
      12910  {
      +
      12911  VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
      +
      12912  VMA_ASSERT(pBlock);
      +
      12913  VkResult res = pBlock->CheckCorruption(m_hAllocator);
      +
      12914  if(res != VK_SUCCESS)
      +
      12915  {
      +
      12916  return res;
      +
      12917  }
      +
      12918  }
      +
      12919  return VK_SUCCESS;
      +
      12920 }
      +
      12921 
      +
      12922 void VmaBlockVector::AddStats(VmaStats* pStats)
      +
      12923 {
      +
      12924  const uint32_t memTypeIndex = m_MemoryTypeIndex;
      +
      12925  const uint32_t memHeapIndex = m_hAllocator->MemoryTypeIndexToHeapIndex(memTypeIndex);
      +
      12926 
      +
      12927  VmaMutexLockRead lock(m_Mutex, m_hAllocator->m_UseMutex);
      +
      12928 
      +
      12929  for(uint32_t blockIndex = 0; blockIndex < m_Blocks.size(); ++blockIndex)
      +
      12930  {
      +
      12931  const VmaDeviceMemoryBlock* const pBlock = m_Blocks[blockIndex];
      +
      12932  VMA_ASSERT(pBlock);
      +
      12933  VMA_HEAVY_ASSERT(pBlock->Validate());
      +
      12934  VmaStatInfo allocationStatInfo;
      +
      12935  pBlock->m_pMetadata->CalcAllocationStatInfo(allocationStatInfo);
      +
      12936  VmaAddStatInfo(pStats->total, allocationStatInfo);
      +
      12937  VmaAddStatInfo(pStats->memoryType[memTypeIndex], allocationStatInfo);
      +
      12938  VmaAddStatInfo(pStats->memoryHeap[memHeapIndex], allocationStatInfo);
      +
      12939  }
      +
      12940 }
      +
      12941 
      +
      12943 // VmaDefragmentationAlgorithm_Generic members definition
      +
      12944 
      +
      12945 VmaDefragmentationAlgorithm_Generic::VmaDefragmentationAlgorithm_Generic(
      +
      12946  VmaAllocator hAllocator,
      +
      12947  VmaBlockVector* pBlockVector,
      +
      12948  uint32_t currentFrameIndex,
      +
      12949  bool overlappingMoveSupported) :
      +
      12950  VmaDefragmentationAlgorithm(hAllocator, pBlockVector, currentFrameIndex),
      +
      12951  m_AllocationCount(0),
      +
      12952  m_AllAllocations(false),
      +
      12953  m_BytesMoved(0),
      +
      12954  m_AllocationsMoved(0),
      +
      12955  m_Blocks(VmaStlAllocator<BlockInfo*>(hAllocator->GetAllocationCallbacks()))
      +
      12956 {
      +
      12957  // Create block info for each block.
      +
      12958  const size_t blockCount = m_pBlockVector->m_Blocks.size();
      +
      12959  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
      +
      12960  {
      +
      12961  BlockInfo* pBlockInfo = vma_new(m_hAllocator, BlockInfo)(m_hAllocator->GetAllocationCallbacks());
      +
      12962  pBlockInfo->m_OriginalBlockIndex = blockIndex;
      +
      12963  pBlockInfo->m_pBlock = m_pBlockVector->m_Blocks[blockIndex];
      +
      12964  m_Blocks.push_back(pBlockInfo);
      +
      12965  }
      +
      12966 
      +
      12967  // Sort them by m_pBlock pointer value.
      +
      12968  VMA_SORT(m_Blocks.begin(), m_Blocks.end(), BlockPointerLess());
      +
      12969 }
      +
      12970 
      +
      12971 VmaDefragmentationAlgorithm_Generic::~VmaDefragmentationAlgorithm_Generic()
      +
      12972 {
      +
      12973  for(size_t i = m_Blocks.size(); i--; )
      +
      12974  {
      +
      12975  vma_delete(m_hAllocator, m_Blocks[i]);
      +
      12976  }
      +
      12977 }
      +
      12978 
      +
      12979 void VmaDefragmentationAlgorithm_Generic::AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged)
      +
      12980 {
      +
      12981  // Now as we are inside VmaBlockVector::m_Mutex, we can make final check if this allocation was not lost.
      +
      12982  if(hAlloc->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST)
      +
      12983  {
      +
      12984  VmaDeviceMemoryBlock* pBlock = hAlloc->GetBlock();
      +
      12985  BlockInfoVector::iterator it = VmaBinaryFindFirstNotLess(m_Blocks.begin(), m_Blocks.end(), pBlock, BlockPointerLess());
      +
      12986  if(it != m_Blocks.end() && (*it)->m_pBlock == pBlock)
      +
      12987  {
      +
      12988  AllocationInfo allocInfo = AllocationInfo(hAlloc, pChanged);
      +
      12989  (*it)->m_Allocations.push_back(allocInfo);
      +
      12990  }
      +
      12991  else
      +
      12992  {
      +
      12993  VMA_ASSERT(0);
      +
      12994  }
      +
      12995 
      +
      12996  ++m_AllocationCount;
      +
      12997  }
      +
      12998 }
      +
      12999 
      +
      13000 VkResult VmaDefragmentationAlgorithm_Generic::DefragmentRound(
      +
      13001  VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
      +
      13002  VkDeviceSize maxBytesToMove,
      +
      13003  uint32_t maxAllocationsToMove)
      +
      13004 {
      +
      13005  if(m_Blocks.empty())
      +
      13006  {
      +
      13007  return VK_SUCCESS;
      +
      13008  }
      +
      13009 
      +
      13010  // This is a choice based on research.
      +
      13011  // Option 1:
      +
      13012  uint32_t strategy = VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT;
      +
      13013  // Option 2:
      +
      13014  //uint32_t strategy = VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT;
      +
      13015  // Option 3:
      +
      13016  //uint32_t strategy = VMA_ALLOCATION_CREATE_STRATEGY_MIN_FRAGMENTATION_BIT;
      +
      13017 
      +
      13018  size_t srcBlockMinIndex = 0;
      +
      13019  // When FAST_ALGORITHM, move allocations from only last out of blocks that contain non-movable allocations.
      +
      13020  /*
      +
      13021  if(m_AlgorithmFlags & VMA_DEFRAGMENTATION_FAST_ALGORITHM_BIT)
      +
      13022  {
      +
      13023  const size_t blocksWithNonMovableCount = CalcBlocksWithNonMovableCount();
      +
      13024  if(blocksWithNonMovableCount > 0)
      +
      13025  {
      +
      13026  srcBlockMinIndex = blocksWithNonMovableCount - 1;
      +
      13027  }
      +
      13028  }
      +
      13029  */
      +
      13030 
      +
      13031  size_t srcBlockIndex = m_Blocks.size() - 1;
      +
      13032  size_t srcAllocIndex = SIZE_MAX;
      +
      13033  for(;;)
      +
      13034  {
      +
      13035  // 1. Find next allocation to move.
      +
      13036  // 1.1. Start from last to first m_Blocks - they are sorted from most "destination" to most "source".
      +
      13037  // 1.2. Then start from last to first m_Allocations.
      +
      13038  while(srcAllocIndex >= m_Blocks[srcBlockIndex]->m_Allocations.size())
      +
      13039  {
      +
      13040  if(m_Blocks[srcBlockIndex]->m_Allocations.empty())
      +
      13041  {
      +
      13042  // Finished: no more allocations to process.
      +
      13043  if(srcBlockIndex == srcBlockMinIndex)
      +
      13044  {
      +
      13045  return VK_SUCCESS;
      +
      13046  }
      +
      13047  else
      +
      13048  {
      +
      13049  --srcBlockIndex;
      +
      13050  srcAllocIndex = SIZE_MAX;
      +
      13051  }
      +
      13052  }
      +
      13053  else
      +
      13054  {
      +
      13055  srcAllocIndex = m_Blocks[srcBlockIndex]->m_Allocations.size() - 1;
      +
      13056  }
      +
      13057  }
      +
      13058 
      +
      13059  BlockInfo* pSrcBlockInfo = m_Blocks[srcBlockIndex];
      +
      13060  AllocationInfo& allocInfo = pSrcBlockInfo->m_Allocations[srcAllocIndex];
      +
      13061 
      +
      13062  const VkDeviceSize size = allocInfo.m_hAllocation->GetSize();
      +
      13063  const VkDeviceSize srcOffset = allocInfo.m_hAllocation->GetOffset();
      +
      13064  const VkDeviceSize alignment = allocInfo.m_hAllocation->GetAlignment();
      +
      13065  const VmaSuballocationType suballocType = allocInfo.m_hAllocation->GetSuballocationType();
      +
      13066 
      +
      13067  // 2. Try to find new place for this allocation in preceding or current block.
      +
      13068  for(size_t dstBlockIndex = 0; dstBlockIndex <= srcBlockIndex; ++dstBlockIndex)
      13069  {
      -
      13070  ++result;
      -
      13071  }
      -
      13072  }
      -
      13073  return result;
      -
      13074 }
      -
      13075 
      -
      13076 VkResult VmaDefragmentationAlgorithm_Generic::Defragment(
      -
      13077  VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
      -
      13078  VkDeviceSize maxBytesToMove,
      -
      13079  uint32_t maxAllocationsToMove)
      -
      13080 {
      -
      13081  if(!m_AllAllocations && m_AllocationCount == 0)
      -
      13082  {
      -
      13083  return VK_SUCCESS;
      -
      13084  }
      -
      13085 
      -
      13086  const size_t blockCount = m_Blocks.size();
      -
      13087  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
      -
      13088  {
      -
      13089  BlockInfo* pBlockInfo = m_Blocks[blockIndex];
      -
      13090 
      -
      13091  if(m_AllAllocations)
      -
      13092  {
      -
      13093  VmaBlockMetadata_Generic* pMetadata = (VmaBlockMetadata_Generic*)pBlockInfo->m_pBlock->m_pMetadata;
      -
      13094  for(VmaSuballocationList::const_iterator it = pMetadata->m_Suballocations.begin();
      -
      13095  it != pMetadata->m_Suballocations.end();
      -
      13096  ++it)
      -
      13097  {
      -
      13098  if(it->type != VMA_SUBALLOCATION_TYPE_FREE)
      -
      13099  {
      -
      13100  AllocationInfo allocInfo = AllocationInfo(it->hAllocation, VMA_NULL);
      -
      13101  pBlockInfo->m_Allocations.push_back(allocInfo);
      -
      13102  }
      -
      13103  }
      -
      13104  }
      -
      13105 
      -
      13106  pBlockInfo->CalcHasNonMovableAllocations();
      -
      13107 
      -
      13108  // This is a choice based on research.
      -
      13109  // Option 1:
      -
      13110  pBlockInfo->SortAllocationsByOffsetDescending();
      -
      13111  // Option 2:
      -
      13112  //pBlockInfo->SortAllocationsBySizeDescending();
      -
      13113  }
      -
      13114 
      -
      13115  // Sort m_Blocks this time by the main criterium, from most "destination" to most "source" blocks.
      -
      13116  VMA_SORT(m_Blocks.begin(), m_Blocks.end(), BlockInfoCompareMoveDestination());
      -
      13117 
      -
      13118  // This is a choice based on research.
      -
      13119  const uint32_t roundCount = 2;
      -
      13120 
      -
      13121  // Execute defragmentation rounds (the main part).
      -
      13122  VkResult result = VK_SUCCESS;
      -
      13123  for(uint32_t round = 0; (round < roundCount) && (result == VK_SUCCESS); ++round)
      -
      13124  {
      -
      13125  result = DefragmentRound(moves, maxBytesToMove, maxAllocationsToMove);
      -
      13126  }
      +
      13070  BlockInfo* pDstBlockInfo = m_Blocks[dstBlockIndex];
      +
      13071  VmaAllocationRequest dstAllocRequest;
      +
      13072  if(pDstBlockInfo->m_pBlock->m_pMetadata->CreateAllocationRequest(
      +
      13073  m_CurrentFrameIndex,
      +
      13074  m_pBlockVector->GetFrameInUseCount(),
      +
      13075  m_pBlockVector->GetBufferImageGranularity(),
      +
      13076  size,
      +
      13077  alignment,
      +
      13078  false, // upperAddress
      +
      13079  suballocType,
      +
      13080  false, // canMakeOtherLost
      +
      13081  strategy,
      +
      13082  &dstAllocRequest) &&
      +
      13083  MoveMakesSense(
      +
      13084  dstBlockIndex, dstAllocRequest.offset, srcBlockIndex, srcOffset))
      +
      13085  {
      +
      13086  VMA_ASSERT(dstAllocRequest.itemsToMakeLostCount == 0);
      +
      13087 
      +
      13088  // Reached limit on number of allocations or bytes to move.
      +
      13089  if((m_AllocationsMoved + 1 > maxAllocationsToMove) ||
      +
      13090  (m_BytesMoved + size > maxBytesToMove))
      +
      13091  {
      +
      13092  return VK_SUCCESS;
      +
      13093  }
      +
      13094 
      +
      13095  VmaDefragmentationMove move;
      +
      13096  move.srcBlockIndex = pSrcBlockInfo->m_OriginalBlockIndex;
      +
      13097  move.dstBlockIndex = pDstBlockInfo->m_OriginalBlockIndex;
      +
      13098  move.srcOffset = srcOffset;
      +
      13099  move.dstOffset = dstAllocRequest.offset;
      +
      13100  move.size = size;
      +
      13101  moves.push_back(move);
      +
      13102 
      +
      13103  pDstBlockInfo->m_pBlock->m_pMetadata->Alloc(
      +
      13104  dstAllocRequest,
      +
      13105  suballocType,
      +
      13106  size,
      +
      13107  allocInfo.m_hAllocation);
      +
      13108  pSrcBlockInfo->m_pBlock->m_pMetadata->FreeAtOffset(srcOffset);
      +
      13109 
      +
      13110  allocInfo.m_hAllocation->ChangeBlockAllocation(m_hAllocator, pDstBlockInfo->m_pBlock, dstAllocRequest.offset);
      +
      13111 
      +
      13112  if(allocInfo.m_pChanged != VMA_NULL)
      +
      13113  {
      +
      13114  *allocInfo.m_pChanged = VK_TRUE;
      +
      13115  }
      +
      13116 
      +
      13117  ++m_AllocationsMoved;
      +
      13118  m_BytesMoved += size;
      +
      13119 
      +
      13120  VmaVectorRemove(pSrcBlockInfo->m_Allocations, srcAllocIndex);
      +
      13121 
      +
      13122  break;
      +
      13123  }
      +
      13124  }
      +
      13125 
      +
      13126  // If not processed, this allocInfo remains in pBlockInfo->m_Allocations for next round.
      13127 
      -
      13128  return result;
      -
      13129 }
      -
      13130 
      -
      13131 bool VmaDefragmentationAlgorithm_Generic::MoveMakesSense(
      -
      13132  size_t dstBlockIndex, VkDeviceSize dstOffset,
      -
      13133  size_t srcBlockIndex, VkDeviceSize srcOffset)
      -
      13134 {
      -
      13135  if(dstBlockIndex < srcBlockIndex)
      -
      13136  {
      -
      13137  return true;
      -
      13138  }
      -
      13139  if(dstBlockIndex > srcBlockIndex)
      -
      13140  {
      -
      13141  return false;
      -
      13142  }
      -
      13143  if(dstOffset < srcOffset)
      -
      13144  {
      -
      13145  return true;
      -
      13146  }
      -
      13147  return false;
      -
      13148 }
      -
      13149 
      -
      13151 // VmaDefragmentationAlgorithm_Fast
      -
      13152 
      -
      13153 VmaDefragmentationAlgorithm_Fast::VmaDefragmentationAlgorithm_Fast(
      -
      13154  VmaAllocator hAllocator,
      -
      13155  VmaBlockVector* pBlockVector,
      -
      13156  uint32_t currentFrameIndex,
      -
      13157  bool overlappingMoveSupported) :
      -
      13158  VmaDefragmentationAlgorithm(hAllocator, pBlockVector, currentFrameIndex),
      -
      13159  m_OverlappingMoveSupported(overlappingMoveSupported),
      -
      13160  m_AllocationCount(0),
      -
      13161  m_AllAllocations(false),
      -
      13162  m_BytesMoved(0),
      -
      13163  m_AllocationsMoved(0),
      -
      13164  m_BlockInfos(VmaStlAllocator<BlockInfo>(hAllocator->GetAllocationCallbacks()))
      -
      13165 {
      -
      13166  VMA_ASSERT(VMA_DEBUG_MARGIN == 0);
      -
      13167 
      -
      13168 }
      +
      13128  if(srcAllocIndex > 0)
      +
      13129  {
      +
      13130  --srcAllocIndex;
      +
      13131  }
      +
      13132  else
      +
      13133  {
      +
      13134  if(srcBlockIndex > 0)
      +
      13135  {
      +
      13136  --srcBlockIndex;
      +
      13137  srcAllocIndex = SIZE_MAX;
      +
      13138  }
      +
      13139  else
      +
      13140  {
      +
      13141  return VK_SUCCESS;
      +
      13142  }
      +
      13143  }
      +
      13144  }
      +
      13145 }
      +
      13146 
      +
      13147 size_t VmaDefragmentationAlgorithm_Generic::CalcBlocksWithNonMovableCount() const
      +
      13148 {
      +
      13149  size_t result = 0;
      +
      13150  for(size_t i = 0; i < m_Blocks.size(); ++i)
      +
      13151  {
      +
      13152  if(m_Blocks[i]->m_HasNonMovableAllocations)
      +
      13153  {
      +
      13154  ++result;
      +
      13155  }
      +
      13156  }
      +
      13157  return result;
      +
      13158 }
      +
      13159 
      +
      13160 VkResult VmaDefragmentationAlgorithm_Generic::Defragment(
      +
      13161  VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
      +
      13162  VkDeviceSize maxBytesToMove,
      +
      13163  uint32_t maxAllocationsToMove)
      +
      13164 {
      +
      13165  if(!m_AllAllocations && m_AllocationCount == 0)
      +
      13166  {
      +
      13167  return VK_SUCCESS;
      +
      13168  }
      13169 
      -
      13170 VmaDefragmentationAlgorithm_Fast::~VmaDefragmentationAlgorithm_Fast()
      -
      13171 {
      -
      13172 }
      -
      13173 
      -
      13174 VkResult VmaDefragmentationAlgorithm_Fast::Defragment(
      -
      13175  VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
      -
      13176  VkDeviceSize maxBytesToMove,
      -
      13177  uint32_t maxAllocationsToMove)
      -
      13178 {
      -
      13179  VMA_ASSERT(m_AllAllocations || m_pBlockVector->CalcAllocationCount() == m_AllocationCount);
      -
      13180 
      -
      13181  const size_t blockCount = m_pBlockVector->GetBlockCount();
      -
      13182  if(blockCount == 0 || maxBytesToMove == 0 || maxAllocationsToMove == 0)
      -
      13183  {
      -
      13184  return VK_SUCCESS;
      -
      13185  }
      -
      13186 
      -
      13187  PreprocessMetadata();
      -
      13188 
      -
      13189  // Sort blocks in order from most destination.
      -
      13190 
      -
      13191  m_BlockInfos.resize(blockCount);
      -
      13192  for(size_t i = 0; i < blockCount; ++i)
      -
      13193  {
      -
      13194  m_BlockInfos[i].origBlockIndex = i;
      -
      13195  }
      -
      13196 
      -
      13197  VMA_SORT(m_BlockInfos.begin(), m_BlockInfos.end(), [this](const BlockInfo& lhs, const BlockInfo& rhs) -> bool {
      -
      13198  return m_pBlockVector->GetBlock(lhs.origBlockIndex)->m_pMetadata->GetSumFreeSize() <
      -
      13199  m_pBlockVector->GetBlock(rhs.origBlockIndex)->m_pMetadata->GetSumFreeSize();
      -
      13200  });
      +
      13170  const size_t blockCount = m_Blocks.size();
      +
      13171  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
      +
      13172  {
      +
      13173  BlockInfo* pBlockInfo = m_Blocks[blockIndex];
      +
      13174 
      +
      13175  if(m_AllAllocations)
      +
      13176  {
      +
      13177  VmaBlockMetadata_Generic* pMetadata = (VmaBlockMetadata_Generic*)pBlockInfo->m_pBlock->m_pMetadata;
      +
      13178  for(VmaSuballocationList::const_iterator it = pMetadata->m_Suballocations.begin();
      +
      13179  it != pMetadata->m_Suballocations.end();
      +
      13180  ++it)
      +
      13181  {
      +
      13182  if(it->type != VMA_SUBALLOCATION_TYPE_FREE)
      +
      13183  {
      +
      13184  AllocationInfo allocInfo = AllocationInfo(it->hAllocation, VMA_NULL);
      +
      13185  pBlockInfo->m_Allocations.push_back(allocInfo);
      +
      13186  }
      +
      13187  }
      +
      13188  }
      +
      13189 
      +
      13190  pBlockInfo->CalcHasNonMovableAllocations();
      +
      13191 
      +
      13192  // This is a choice based on research.
      +
      13193  // Option 1:
      +
      13194  pBlockInfo->SortAllocationsByOffsetDescending();
      +
      13195  // Option 2:
      +
      13196  //pBlockInfo->SortAllocationsBySizeDescending();
      +
      13197  }
      +
      13198 
      +
      13199  // Sort m_Blocks this time by the main criterium, from most "destination" to most "source" blocks.
      +
      13200  VMA_SORT(m_Blocks.begin(), m_Blocks.end(), BlockInfoCompareMoveDestination());
      13201 
      -
      13202  // THE MAIN ALGORITHM
      -
      13203 
      -
      13204  FreeSpaceDatabase freeSpaceDb;
      -
      13205 
      -
      13206  size_t dstBlockInfoIndex = 0;
      -
      13207  size_t dstOrigBlockIndex = m_BlockInfos[dstBlockInfoIndex].origBlockIndex;
      -
      13208  VmaDeviceMemoryBlock* pDstBlock = m_pBlockVector->GetBlock(dstOrigBlockIndex);
      -
      13209  VmaBlockMetadata_Generic* pDstMetadata = (VmaBlockMetadata_Generic*)pDstBlock->m_pMetadata;
      -
      13210  VkDeviceSize dstBlockSize = pDstMetadata->GetSize();
      -
      13211  VkDeviceSize dstOffset = 0;
      -
      13212 
      -
      13213  bool end = false;
      -
      13214  for(size_t srcBlockInfoIndex = 0; !end && srcBlockInfoIndex < blockCount; ++srcBlockInfoIndex)
      -
      13215  {
      -
      13216  const size_t srcOrigBlockIndex = m_BlockInfos[srcBlockInfoIndex].origBlockIndex;
      -
      13217  VmaDeviceMemoryBlock* const pSrcBlock = m_pBlockVector->GetBlock(srcOrigBlockIndex);
      -
      13218  VmaBlockMetadata_Generic* const pSrcMetadata = (VmaBlockMetadata_Generic*)pSrcBlock->m_pMetadata;
      -
      13219  for(VmaSuballocationList::iterator srcSuballocIt = pSrcMetadata->m_Suballocations.begin();
      -
      13220  !end && srcSuballocIt != pSrcMetadata->m_Suballocations.end(); )
      -
      13221  {
      -
      13222  VmaAllocation_T* const pAlloc = srcSuballocIt->hAllocation;
      -
      13223  const VkDeviceSize srcAllocAlignment = pAlloc->GetAlignment();
      -
      13224  const VkDeviceSize srcAllocSize = srcSuballocIt->size;
      -
      13225  if(m_AllocationsMoved == maxAllocationsToMove ||
      -
      13226  m_BytesMoved + srcAllocSize > maxBytesToMove)
      -
      13227  {
      -
      13228  end = true;
      -
      13229  break;
      -
      13230  }
      -
      13231  const VkDeviceSize srcAllocOffset = srcSuballocIt->offset;
      -
      13232 
      -
      13233  // Try to place it in one of free spaces from the database.
      -
      13234  size_t freeSpaceInfoIndex;
      -
      13235  VkDeviceSize dstAllocOffset;
      -
      13236  if(freeSpaceDb.Fetch(srcAllocAlignment, srcAllocSize,
      -
      13237  freeSpaceInfoIndex, dstAllocOffset))
      -
      13238  {
      -
      13239  size_t freeSpaceOrigBlockIndex = m_BlockInfos[freeSpaceInfoIndex].origBlockIndex;
      -
      13240  VmaDeviceMemoryBlock* pFreeSpaceBlock = m_pBlockVector->GetBlock(freeSpaceOrigBlockIndex);
      -
      13241  VmaBlockMetadata_Generic* pFreeSpaceMetadata = (VmaBlockMetadata_Generic*)pFreeSpaceBlock->m_pMetadata;
      -
      13242 
      -
      13243  // Same block
      -
      13244  if(freeSpaceInfoIndex == srcBlockInfoIndex)
      -
      13245  {
      -
      13246  VMA_ASSERT(dstAllocOffset <= srcAllocOffset);
      -
      13247 
      -
      13248  // MOVE OPTION 1: Move the allocation inside the same block by decreasing offset.
      -
      13249 
      -
      13250  VmaSuballocation suballoc = *srcSuballocIt;
      -
      13251  suballoc.offset = dstAllocOffset;
      -
      13252  suballoc.hAllocation->ChangeOffset(dstAllocOffset);
      -
      13253  m_BytesMoved += srcAllocSize;
      -
      13254  ++m_AllocationsMoved;
      -
      13255 
      -
      13256  VmaSuballocationList::iterator nextSuballocIt = srcSuballocIt;
      -
      13257  ++nextSuballocIt;
      -
      13258  pSrcMetadata->m_Suballocations.erase(srcSuballocIt);
      -
      13259  srcSuballocIt = nextSuballocIt;
      -
      13260 
      -
      13261  InsertSuballoc(pFreeSpaceMetadata, suballoc);
      -
      13262 
      -
      13263  VmaDefragmentationMove move = {
      -
      13264  srcOrigBlockIndex, freeSpaceOrigBlockIndex,
      -
      13265  srcAllocOffset, dstAllocOffset,
      -
      13266  srcAllocSize };
      -
      13267  moves.push_back(move);
      -
      13268  }
      -
      13269  // Different block
      -
      13270  else
      -
      13271  {
      -
      13272  // MOVE OPTION 2: Move the allocation to a different block.
      -
      13273 
      -
      13274  VMA_ASSERT(freeSpaceInfoIndex < srcBlockInfoIndex);
      -
      13275 
      -
      13276  VmaSuballocation suballoc = *srcSuballocIt;
      -
      13277  suballoc.offset = dstAllocOffset;
      -
      13278  suballoc.hAllocation->ChangeBlockAllocation(m_hAllocator, pFreeSpaceBlock, dstAllocOffset);
      -
      13279  m_BytesMoved += srcAllocSize;
      -
      13280  ++m_AllocationsMoved;
      -
      13281 
      -
      13282  VmaSuballocationList::iterator nextSuballocIt = srcSuballocIt;
      -
      13283  ++nextSuballocIt;
      -
      13284  pSrcMetadata->m_Suballocations.erase(srcSuballocIt);
      -
      13285  srcSuballocIt = nextSuballocIt;
      -
      13286 
      -
      13287  InsertSuballoc(pFreeSpaceMetadata, suballoc);
      -
      13288 
      -
      13289  VmaDefragmentationMove move = {
      -
      13290  srcOrigBlockIndex, freeSpaceOrigBlockIndex,
      -
      13291  srcAllocOffset, dstAllocOffset,
      -
      13292  srcAllocSize };
      -
      13293  moves.push_back(move);
      -
      13294  }
      -
      13295  }
      -
      13296  else
      -
      13297  {
      -
      13298  dstAllocOffset = VmaAlignUp(dstOffset, srcAllocAlignment);
      -
      13299 
      -
      13300  // If the allocation doesn't fit before the end of dstBlock, forward to next block.
      -
      13301  while(dstBlockInfoIndex < srcBlockInfoIndex &&
      -
      13302  dstAllocOffset + srcAllocSize > dstBlockSize)
      -
      13303  {
      -
      13304  // But before that, register remaining free space at the end of dst block.
      -
      13305  freeSpaceDb.Register(dstBlockInfoIndex, dstOffset, dstBlockSize - dstOffset);
      -
      13306 
      -
      13307  ++dstBlockInfoIndex;
      -
      13308  dstOrigBlockIndex = m_BlockInfos[dstBlockInfoIndex].origBlockIndex;
      -
      13309  pDstBlock = m_pBlockVector->GetBlock(dstOrigBlockIndex);
      -
      13310  pDstMetadata = (VmaBlockMetadata_Generic*)pDstBlock->m_pMetadata;
      -
      13311  dstBlockSize = pDstMetadata->GetSize();
      -
      13312  dstOffset = 0;
      -
      13313  dstAllocOffset = 0;
      -
      13314  }
      -
      13315 
      -
      13316  // Same block
      -
      13317  if(dstBlockInfoIndex == srcBlockInfoIndex)
      -
      13318  {
      -
      13319  VMA_ASSERT(dstAllocOffset <= srcAllocOffset);
      -
      13320 
      -
      13321  const bool overlap = dstAllocOffset + srcAllocSize > srcAllocOffset;
      -
      13322 
      -
      13323  bool skipOver = overlap;
      -
      13324  if(overlap && m_OverlappingMoveSupported && dstAllocOffset < srcAllocOffset)
      -
      13325  {
      -
      13326  // If destination and source place overlap, skip if it would move it
      -
      13327  // by only < 1/64 of its size.
      -
      13328  skipOver = (srcAllocOffset - dstAllocOffset) * 64 < srcAllocSize;
      -
      13329  }
      -
      13330 
      -
      13331  if(skipOver)
      -
      13332  {
      -
      13333  freeSpaceDb.Register(dstBlockInfoIndex, dstOffset, srcAllocOffset - dstOffset);
      -
      13334 
      -
      13335  dstOffset = srcAllocOffset + srcAllocSize;
      -
      13336  ++srcSuballocIt;
      -
      13337  }
      -
      13338  // MOVE OPTION 1: Move the allocation inside the same block by decreasing offset.
      -
      13339  else
      -
      13340  {
      -
      13341  srcSuballocIt->offset = dstAllocOffset;
      -
      13342  srcSuballocIt->hAllocation->ChangeOffset(dstAllocOffset);
      -
      13343  dstOffset = dstAllocOffset + srcAllocSize;
      -
      13344  m_BytesMoved += srcAllocSize;
      -
      13345  ++m_AllocationsMoved;
      -
      13346  ++srcSuballocIt;
      -
      13347  VmaDefragmentationMove move = {
      -
      13348  srcOrigBlockIndex, dstOrigBlockIndex,
      -
      13349  srcAllocOffset, dstAllocOffset,
      -
      13350  srcAllocSize };
      -
      13351  moves.push_back(move);
      -
      13352  }
      -
      13353  }
      -
      13354  // Different block
      -
      13355  else
      -
      13356  {
      -
      13357  // MOVE OPTION 2: Move the allocation to a different block.
      -
      13358 
      -
      13359  VMA_ASSERT(dstBlockInfoIndex < srcBlockInfoIndex);
      -
      13360  VMA_ASSERT(dstAllocOffset + srcAllocSize <= dstBlockSize);
      -
      13361 
      -
      13362  VmaSuballocation suballoc = *srcSuballocIt;
      -
      13363  suballoc.offset = dstAllocOffset;
      -
      13364  suballoc.hAllocation->ChangeBlockAllocation(m_hAllocator, pDstBlock, dstAllocOffset);
      -
      13365  dstOffset = dstAllocOffset + srcAllocSize;
      -
      13366  m_BytesMoved += srcAllocSize;
      -
      13367  ++m_AllocationsMoved;
      -
      13368 
      -
      13369  VmaSuballocationList::iterator nextSuballocIt = srcSuballocIt;
      -
      13370  ++nextSuballocIt;
      -
      13371  pSrcMetadata->m_Suballocations.erase(srcSuballocIt);
      -
      13372  srcSuballocIt = nextSuballocIt;
      -
      13373 
      -
      13374  pDstMetadata->m_Suballocations.push_back(suballoc);
      -
      13375 
      -
      13376  VmaDefragmentationMove move = {
      -
      13377  srcOrigBlockIndex, dstOrigBlockIndex,
      -
      13378  srcAllocOffset, dstAllocOffset,
      -
      13379  srcAllocSize };
      -
      13380  moves.push_back(move);
      -
      13381  }
      -
      13382  }
      -
      13383  }
      -
      13384  }
      -
      13385 
      -
      13386  m_BlockInfos.clear();
      -
      13387 
      -
      13388  PostprocessMetadata();
      -
      13389 
      -
      13390  return VK_SUCCESS;
      -
      13391 }
      -
      13392 
      -
      13393 void VmaDefragmentationAlgorithm_Fast::PreprocessMetadata()
      -
      13394 {
      -
      13395  const size_t blockCount = m_pBlockVector->GetBlockCount();
      -
      13396  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
      -
      13397  {
      -
      13398  VmaBlockMetadata_Generic* const pMetadata =
      -
      13399  (VmaBlockMetadata_Generic*)m_pBlockVector->GetBlock(blockIndex)->m_pMetadata;
      -
      13400  pMetadata->m_FreeCount = 0;
      -
      13401  pMetadata->m_SumFreeSize = pMetadata->GetSize();
      -
      13402  pMetadata->m_FreeSuballocationsBySize.clear();
      -
      13403  for(VmaSuballocationList::iterator it = pMetadata->m_Suballocations.begin();
      -
      13404  it != pMetadata->m_Suballocations.end(); )
      -
      13405  {
      -
      13406  if(it->type == VMA_SUBALLOCATION_TYPE_FREE)
      -
      13407  {
      -
      13408  VmaSuballocationList::iterator nextIt = it;
      -
      13409  ++nextIt;
      -
      13410  pMetadata->m_Suballocations.erase(it);
      -
      13411  it = nextIt;
      -
      13412  }
      -
      13413  else
      -
      13414  {
      -
      13415  ++it;
      -
      13416  }
      -
      13417  }
      -
      13418  }
      -
      13419 }
      -
      13420 
      -
      13421 void VmaDefragmentationAlgorithm_Fast::PostprocessMetadata()
      -
      13422 {
      -
      13423  const size_t blockCount = m_pBlockVector->GetBlockCount();
      -
      13424  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
      -
      13425  {
      -
      13426  VmaBlockMetadata_Generic* const pMetadata =
      -
      13427  (VmaBlockMetadata_Generic*)m_pBlockVector->GetBlock(blockIndex)->m_pMetadata;
      -
      13428  const VkDeviceSize blockSize = pMetadata->GetSize();
      -
      13429 
      -
      13430  // No allocations in this block - entire area is free.
      -
      13431  if(pMetadata->m_Suballocations.empty())
      -
      13432  {
      -
      13433  pMetadata->m_FreeCount = 1;
      -
      13434  //pMetadata->m_SumFreeSize is already set to blockSize.
      -
      13435  VmaSuballocation suballoc = {
      -
      13436  0, // offset
      -
      13437  blockSize, // size
      -
      13438  VMA_NULL, // hAllocation
      -
      13439  VMA_SUBALLOCATION_TYPE_FREE };
      -
      13440  pMetadata->m_Suballocations.push_back(suballoc);
      -
      13441  pMetadata->RegisterFreeSuballocation(pMetadata->m_Suballocations.begin());
      -
      13442  }
      -
      13443  // There are some allocations in this block.
      -
      13444  else
      -
      13445  {
      -
      13446  VkDeviceSize offset = 0;
      -
      13447  VmaSuballocationList::iterator it;
      -
      13448  for(it = pMetadata->m_Suballocations.begin();
      -
      13449  it != pMetadata->m_Suballocations.end();
      -
      13450  ++it)
      -
      13451  {
      -
      13452  VMA_ASSERT(it->type != VMA_SUBALLOCATION_TYPE_FREE);
      -
      13453  VMA_ASSERT(it->offset >= offset);
      -
      13454 
      -
      13455  // Need to insert preceding free space.
      -
      13456  if(it->offset > offset)
      -
      13457  {
      -
      13458  ++pMetadata->m_FreeCount;
      -
      13459  const VkDeviceSize freeSize = it->offset - offset;
      -
      13460  VmaSuballocation suballoc = {
      -
      13461  offset, // offset
      -
      13462  freeSize, // size
      -
      13463  VMA_NULL, // hAllocation
      -
      13464  VMA_SUBALLOCATION_TYPE_FREE };
      -
      13465  VmaSuballocationList::iterator precedingFreeIt = pMetadata->m_Suballocations.insert(it, suballoc);
      -
      13466  if(freeSize >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
      -
      13467  {
      -
      13468  pMetadata->m_FreeSuballocationsBySize.push_back(precedingFreeIt);
      -
      13469  }
      -
      13470  }
      -
      13471 
      -
      13472  pMetadata->m_SumFreeSize -= it->size;
      -
      13473  offset = it->offset + it->size;
      -
      13474  }
      -
      13475 
      -
      13476  // Need to insert trailing free space.
      -
      13477  if(offset < blockSize)
      -
      13478  {
      -
      13479  ++pMetadata->m_FreeCount;
      -
      13480  const VkDeviceSize freeSize = blockSize - offset;
      -
      13481  VmaSuballocation suballoc = {
      -
      13482  offset, // offset
      -
      13483  freeSize, // size
      -
      13484  VMA_NULL, // hAllocation
      -
      13485  VMA_SUBALLOCATION_TYPE_FREE };
      -
      13486  VMA_ASSERT(it == pMetadata->m_Suballocations.end());
      -
      13487  VmaSuballocationList::iterator trailingFreeIt = pMetadata->m_Suballocations.insert(it, suballoc);
      -
      13488  if(freeSize > VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
      -
      13489  {
      -
      13490  pMetadata->m_FreeSuballocationsBySize.push_back(trailingFreeIt);
      -
      13491  }
      -
      13492  }
      -
      13493 
      -
      13494  VMA_SORT(
      -
      13495  pMetadata->m_FreeSuballocationsBySize.begin(),
      -
      13496  pMetadata->m_FreeSuballocationsBySize.end(),
      -
      13497  VmaSuballocationItemSizeLess());
      -
      13498  }
      -
      13499 
      -
      13500  VMA_HEAVY_ASSERT(pMetadata->Validate());
      -
      13501  }
      -
      13502 }
      -
      13503 
      -
      13504 void VmaDefragmentationAlgorithm_Fast::InsertSuballoc(VmaBlockMetadata_Generic* pMetadata, const VmaSuballocation& suballoc)
      -
      13505 {
      -
      13506  // TODO: Optimize somehow. Remember iterator instead of searching for it linearly.
      -
      13507  VmaSuballocationList::iterator it = pMetadata->m_Suballocations.begin();
      -
      13508  while(it != pMetadata->m_Suballocations.end())
      +
      13202  // This is a choice based on research.
      +
      13203  const uint32_t roundCount = 2;
      +
      13204 
      +
      13205  // Execute defragmentation rounds (the main part).
      +
      13206  VkResult result = VK_SUCCESS;
      +
      13207  for(uint32_t round = 0; (round < roundCount) && (result == VK_SUCCESS); ++round)
      +
      13208  {
      +
      13209  result = DefragmentRound(moves, maxBytesToMove, maxAllocationsToMove);
      +
      13210  }
      +
      13211 
      +
      13212  return result;
      +
      13213 }
      +
      13214 
      +
      13215 bool VmaDefragmentationAlgorithm_Generic::MoveMakesSense(
      +
      13216  size_t dstBlockIndex, VkDeviceSize dstOffset,
      +
      13217  size_t srcBlockIndex, VkDeviceSize srcOffset)
      +
      13218 {
      +
      13219  if(dstBlockIndex < srcBlockIndex)
      +
      13220  {
      +
      13221  return true;
      +
      13222  }
      +
      13223  if(dstBlockIndex > srcBlockIndex)
      +
      13224  {
      +
      13225  return false;
      +
      13226  }
      +
      13227  if(dstOffset < srcOffset)
      +
      13228  {
      +
      13229  return true;
      +
      13230  }
      +
      13231  return false;
      +
      13232 }
      +
      13233 
      +
      13235 // VmaDefragmentationAlgorithm_Fast
      +
      13236 
      +
      13237 VmaDefragmentationAlgorithm_Fast::VmaDefragmentationAlgorithm_Fast(
      +
      13238  VmaAllocator hAllocator,
      +
      13239  VmaBlockVector* pBlockVector,
      +
      13240  uint32_t currentFrameIndex,
      +
      13241  bool overlappingMoveSupported) :
      +
      13242  VmaDefragmentationAlgorithm(hAllocator, pBlockVector, currentFrameIndex),
      +
      13243  m_OverlappingMoveSupported(overlappingMoveSupported),
      +
      13244  m_AllocationCount(0),
      +
      13245  m_AllAllocations(false),
      +
      13246  m_BytesMoved(0),
      +
      13247  m_AllocationsMoved(0),
      +
      13248  m_BlockInfos(VmaStlAllocator<BlockInfo>(hAllocator->GetAllocationCallbacks()))
      +
      13249 {
      +
      13250  VMA_ASSERT(VMA_DEBUG_MARGIN == 0);
      +
      13251 
      +
      13252 }
      +
      13253 
      +
      13254 VmaDefragmentationAlgorithm_Fast::~VmaDefragmentationAlgorithm_Fast()
      +
      13255 {
      +
      13256 }
      +
      13257 
      +
      13258 VkResult VmaDefragmentationAlgorithm_Fast::Defragment(
      +
      13259  VmaVector< VmaDefragmentationMove, VmaStlAllocator<VmaDefragmentationMove> >& moves,
      +
      13260  VkDeviceSize maxBytesToMove,
      +
      13261  uint32_t maxAllocationsToMove)
      +
      13262 {
      +
      13263  VMA_ASSERT(m_AllAllocations || m_pBlockVector->CalcAllocationCount() == m_AllocationCount);
      +
      13264 
      +
      13265  const size_t blockCount = m_pBlockVector->GetBlockCount();
      +
      13266  if(blockCount == 0 || maxBytesToMove == 0 || maxAllocationsToMove == 0)
      +
      13267  {
      +
      13268  return VK_SUCCESS;
      +
      13269  }
      +
      13270 
      +
      13271  PreprocessMetadata();
      +
      13272 
      +
      13273  // Sort blocks in order from most destination.
      +
      13274 
      +
      13275  m_BlockInfos.resize(blockCount);
      +
      13276  for(size_t i = 0; i < blockCount; ++i)
      +
      13277  {
      +
      13278  m_BlockInfos[i].origBlockIndex = i;
      +
      13279  }
      +
      13280 
      +
      13281  VMA_SORT(m_BlockInfos.begin(), m_BlockInfos.end(), [this](const BlockInfo& lhs, const BlockInfo& rhs) -> bool {
      +
      13282  return m_pBlockVector->GetBlock(lhs.origBlockIndex)->m_pMetadata->GetSumFreeSize() <
      +
      13283  m_pBlockVector->GetBlock(rhs.origBlockIndex)->m_pMetadata->GetSumFreeSize();
      +
      13284  });
      +
      13285 
      +
      13286  // THE MAIN ALGORITHM
      +
      13287 
      +
      13288  FreeSpaceDatabase freeSpaceDb;
      +
      13289 
      +
      13290  size_t dstBlockInfoIndex = 0;
      +
      13291  size_t dstOrigBlockIndex = m_BlockInfos[dstBlockInfoIndex].origBlockIndex;
      +
      13292  VmaDeviceMemoryBlock* pDstBlock = m_pBlockVector->GetBlock(dstOrigBlockIndex);
      +
      13293  VmaBlockMetadata_Generic* pDstMetadata = (VmaBlockMetadata_Generic*)pDstBlock->m_pMetadata;
      +
      13294  VkDeviceSize dstBlockSize = pDstMetadata->GetSize();
      +
      13295  VkDeviceSize dstOffset = 0;
      +
      13296 
      +
      13297  bool end = false;
      +
      13298  for(size_t srcBlockInfoIndex = 0; !end && srcBlockInfoIndex < blockCount; ++srcBlockInfoIndex)
      +
      13299  {
      +
      13300  const size_t srcOrigBlockIndex = m_BlockInfos[srcBlockInfoIndex].origBlockIndex;
      +
      13301  VmaDeviceMemoryBlock* const pSrcBlock = m_pBlockVector->GetBlock(srcOrigBlockIndex);
      +
      13302  VmaBlockMetadata_Generic* const pSrcMetadata = (VmaBlockMetadata_Generic*)pSrcBlock->m_pMetadata;
      +
      13303  for(VmaSuballocationList::iterator srcSuballocIt = pSrcMetadata->m_Suballocations.begin();
      +
      13304  !end && srcSuballocIt != pSrcMetadata->m_Suballocations.end(); )
      +
      13305  {
      +
      13306  VmaAllocation_T* const pAlloc = srcSuballocIt->hAllocation;
      +
      13307  const VkDeviceSize srcAllocAlignment = pAlloc->GetAlignment();
      +
      13308  const VkDeviceSize srcAllocSize = srcSuballocIt->size;
      +
      13309  if(m_AllocationsMoved == maxAllocationsToMove ||
      +
      13310  m_BytesMoved + srcAllocSize > maxBytesToMove)
      +
      13311  {
      +
      13312  end = true;
      +
      13313  break;
      +
      13314  }
      +
      13315  const VkDeviceSize srcAllocOffset = srcSuballocIt->offset;
      +
      13316 
      +
      13317  // Try to place it in one of free spaces from the database.
      +
      13318  size_t freeSpaceInfoIndex;
      +
      13319  VkDeviceSize dstAllocOffset;
      +
      13320  if(freeSpaceDb.Fetch(srcAllocAlignment, srcAllocSize,
      +
      13321  freeSpaceInfoIndex, dstAllocOffset))
      +
      13322  {
      +
      13323  size_t freeSpaceOrigBlockIndex = m_BlockInfos[freeSpaceInfoIndex].origBlockIndex;
      +
      13324  VmaDeviceMemoryBlock* pFreeSpaceBlock = m_pBlockVector->GetBlock(freeSpaceOrigBlockIndex);
      +
      13325  VmaBlockMetadata_Generic* pFreeSpaceMetadata = (VmaBlockMetadata_Generic*)pFreeSpaceBlock->m_pMetadata;
      +
      13326 
      +
      13327  // Same block
      +
      13328  if(freeSpaceInfoIndex == srcBlockInfoIndex)
      +
      13329  {
      +
      13330  VMA_ASSERT(dstAllocOffset <= srcAllocOffset);
      +
      13331 
      +
      13332  // MOVE OPTION 1: Move the allocation inside the same block by decreasing offset.
      +
      13333 
      +
      13334  VmaSuballocation suballoc = *srcSuballocIt;
      +
      13335  suballoc.offset = dstAllocOffset;
      +
      13336  suballoc.hAllocation->ChangeOffset(dstAllocOffset);
      +
      13337  m_BytesMoved += srcAllocSize;
      +
      13338  ++m_AllocationsMoved;
      +
      13339 
      +
      13340  VmaSuballocationList::iterator nextSuballocIt = srcSuballocIt;
      +
      13341  ++nextSuballocIt;
      +
      13342  pSrcMetadata->m_Suballocations.erase(srcSuballocIt);
      +
      13343  srcSuballocIt = nextSuballocIt;
      +
      13344 
      +
      13345  InsertSuballoc(pFreeSpaceMetadata, suballoc);
      +
      13346 
      +
      13347  VmaDefragmentationMove move = {
      +
      13348  srcOrigBlockIndex, freeSpaceOrigBlockIndex,
      +
      13349  srcAllocOffset, dstAllocOffset,
      +
      13350  srcAllocSize };
      +
      13351  moves.push_back(move);
      +
      13352  }
      +
      13353  // Different block
      +
      13354  else
      +
      13355  {
      +
      13356  // MOVE OPTION 2: Move the allocation to a different block.
      +
      13357 
      +
      13358  VMA_ASSERT(freeSpaceInfoIndex < srcBlockInfoIndex);
      +
      13359 
      +
      13360  VmaSuballocation suballoc = *srcSuballocIt;
      +
      13361  suballoc.offset = dstAllocOffset;
      +
      13362  suballoc.hAllocation->ChangeBlockAllocation(m_hAllocator, pFreeSpaceBlock, dstAllocOffset);
      +
      13363  m_BytesMoved += srcAllocSize;
      +
      13364  ++m_AllocationsMoved;
      +
      13365 
      +
      13366  VmaSuballocationList::iterator nextSuballocIt = srcSuballocIt;
      +
      13367  ++nextSuballocIt;
      +
      13368  pSrcMetadata->m_Suballocations.erase(srcSuballocIt);
      +
      13369  srcSuballocIt = nextSuballocIt;
      +
      13370 
      +
      13371  InsertSuballoc(pFreeSpaceMetadata, suballoc);
      +
      13372 
      +
      13373  VmaDefragmentationMove move = {
      +
      13374  srcOrigBlockIndex, freeSpaceOrigBlockIndex,
      +
      13375  srcAllocOffset, dstAllocOffset,
      +
      13376  srcAllocSize };
      +
      13377  moves.push_back(move);
      +
      13378  }
      +
      13379  }
      +
      13380  else
      +
      13381  {
      +
      13382  dstAllocOffset = VmaAlignUp(dstOffset, srcAllocAlignment);
      +
      13383 
      +
      13384  // If the allocation doesn't fit before the end of dstBlock, forward to next block.
      +
      13385  while(dstBlockInfoIndex < srcBlockInfoIndex &&
      +
      13386  dstAllocOffset + srcAllocSize > dstBlockSize)
      +
      13387  {
      +
      13388  // But before that, register remaining free space at the end of dst block.
      +
      13389  freeSpaceDb.Register(dstBlockInfoIndex, dstOffset, dstBlockSize - dstOffset);
      +
      13390 
      +
      13391  ++dstBlockInfoIndex;
      +
      13392  dstOrigBlockIndex = m_BlockInfos[dstBlockInfoIndex].origBlockIndex;
      +
      13393  pDstBlock = m_pBlockVector->GetBlock(dstOrigBlockIndex);
      +
      13394  pDstMetadata = (VmaBlockMetadata_Generic*)pDstBlock->m_pMetadata;
      +
      13395  dstBlockSize = pDstMetadata->GetSize();
      +
      13396  dstOffset = 0;
      +
      13397  dstAllocOffset = 0;
      +
      13398  }
      +
      13399 
      +
      13400  // Same block
      +
      13401  if(dstBlockInfoIndex == srcBlockInfoIndex)
      +
      13402  {
      +
      13403  VMA_ASSERT(dstAllocOffset <= srcAllocOffset);
      +
      13404 
      +
      13405  const bool overlap = dstAllocOffset + srcAllocSize > srcAllocOffset;
      +
      13406 
      +
      13407  bool skipOver = overlap;
      +
      13408  if(overlap && m_OverlappingMoveSupported && dstAllocOffset < srcAllocOffset)
      +
      13409  {
      +
      13410  // If destination and source place overlap, skip if it would move it
      +
      13411  // by only < 1/64 of its size.
      +
      13412  skipOver = (srcAllocOffset - dstAllocOffset) * 64 < srcAllocSize;
      +
      13413  }
      +
      13414 
      +
      13415  if(skipOver)
      +
      13416  {
      +
      13417  freeSpaceDb.Register(dstBlockInfoIndex, dstOffset, srcAllocOffset - dstOffset);
      +
      13418 
      +
      13419  dstOffset = srcAllocOffset + srcAllocSize;
      +
      13420  ++srcSuballocIt;
      +
      13421  }
      +
      13422  // MOVE OPTION 1: Move the allocation inside the same block by decreasing offset.
      +
      13423  else
      +
      13424  {
      +
      13425  srcSuballocIt->offset = dstAllocOffset;
      +
      13426  srcSuballocIt->hAllocation->ChangeOffset(dstAllocOffset);
      +
      13427  dstOffset = dstAllocOffset + srcAllocSize;
      +
      13428  m_BytesMoved += srcAllocSize;
      +
      13429  ++m_AllocationsMoved;
      +
      13430  ++srcSuballocIt;
      +
      13431  VmaDefragmentationMove move = {
      +
      13432  srcOrigBlockIndex, dstOrigBlockIndex,
      +
      13433  srcAllocOffset, dstAllocOffset,
      +
      13434  srcAllocSize };
      +
      13435  moves.push_back(move);
      +
      13436  }
      +
      13437  }
      +
      13438  // Different block
      +
      13439  else
      +
      13440  {
      +
      13441  // MOVE OPTION 2: Move the allocation to a different block.
      +
      13442 
      +
      13443  VMA_ASSERT(dstBlockInfoIndex < srcBlockInfoIndex);
      +
      13444  VMA_ASSERT(dstAllocOffset + srcAllocSize <= dstBlockSize);
      +
      13445 
      +
      13446  VmaSuballocation suballoc = *srcSuballocIt;
      +
      13447  suballoc.offset = dstAllocOffset;
      +
      13448  suballoc.hAllocation->ChangeBlockAllocation(m_hAllocator, pDstBlock, dstAllocOffset);
      +
      13449  dstOffset = dstAllocOffset + srcAllocSize;
      +
      13450  m_BytesMoved += srcAllocSize;
      +
      13451  ++m_AllocationsMoved;
      +
      13452 
      +
      13453  VmaSuballocationList::iterator nextSuballocIt = srcSuballocIt;
      +
      13454  ++nextSuballocIt;
      +
      13455  pSrcMetadata->m_Suballocations.erase(srcSuballocIt);
      +
      13456  srcSuballocIt = nextSuballocIt;
      +
      13457 
      +
      13458  pDstMetadata->m_Suballocations.push_back(suballoc);
      +
      13459 
      +
      13460  VmaDefragmentationMove move = {
      +
      13461  srcOrigBlockIndex, dstOrigBlockIndex,
      +
      13462  srcAllocOffset, dstAllocOffset,
      +
      13463  srcAllocSize };
      +
      13464  moves.push_back(move);
      +
      13465  }
      +
      13466  }
      +
      13467  }
      +
      13468  }
      +
      13469 
      +
      13470  m_BlockInfos.clear();
      +
      13471 
      +
      13472  PostprocessMetadata();
      +
      13473 
      +
      13474  return VK_SUCCESS;
      +
      13475 }
      +
      13476 
      +
      13477 void VmaDefragmentationAlgorithm_Fast::PreprocessMetadata()
      +
      13478 {
      +
      13479  const size_t blockCount = m_pBlockVector->GetBlockCount();
      +
      13480  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
      +
      13481  {
      +
      13482  VmaBlockMetadata_Generic* const pMetadata =
      +
      13483  (VmaBlockMetadata_Generic*)m_pBlockVector->GetBlock(blockIndex)->m_pMetadata;
      +
      13484  pMetadata->m_FreeCount = 0;
      +
      13485  pMetadata->m_SumFreeSize = pMetadata->GetSize();
      +
      13486  pMetadata->m_FreeSuballocationsBySize.clear();
      +
      13487  for(VmaSuballocationList::iterator it = pMetadata->m_Suballocations.begin();
      +
      13488  it != pMetadata->m_Suballocations.end(); )
      +
      13489  {
      +
      13490  if(it->type == VMA_SUBALLOCATION_TYPE_FREE)
      +
      13491  {
      +
      13492  VmaSuballocationList::iterator nextIt = it;
      +
      13493  ++nextIt;
      +
      13494  pMetadata->m_Suballocations.erase(it);
      +
      13495  it = nextIt;
      +
      13496  }
      +
      13497  else
      +
      13498  {
      +
      13499  ++it;
      +
      13500  }
      +
      13501  }
      +
      13502  }
      +
      13503 }
      +
      13504 
      +
      13505 void VmaDefragmentationAlgorithm_Fast::PostprocessMetadata()
      +
      13506 {
      +
      13507  const size_t blockCount = m_pBlockVector->GetBlockCount();
      +
      13508  for(size_t blockIndex = 0; blockIndex < blockCount; ++blockIndex)
      13509  {
      -
      13510  if(it->offset < suballoc.offset)
      -
      13511  {
      -
      13512  ++it;
      -
      13513  }
      -
      13514  }
      -
      13515  pMetadata->m_Suballocations.insert(it, suballoc);
      -
      13516 }
      -
      13517 
      -
      13519 // VmaBlockVectorDefragmentationContext
      -
      13520 
      -
      13521 VmaBlockVectorDefragmentationContext::VmaBlockVectorDefragmentationContext(
      -
      13522  VmaAllocator hAllocator,
      -
      13523  VmaPool hCustomPool,
      -
      13524  VmaBlockVector* pBlockVector,
      -
      13525  uint32_t currFrameIndex) :
      -
      13526  res(VK_SUCCESS),
      -
      13527  mutexLocked(false),
      -
      13528  blockContexts(VmaStlAllocator<VmaBlockDefragmentationContext>(hAllocator->GetAllocationCallbacks())),
      -
      13529  m_hAllocator(hAllocator),
      -
      13530  m_hCustomPool(hCustomPool),
      -
      13531  m_pBlockVector(pBlockVector),
      -
      13532  m_CurrFrameIndex(currFrameIndex),
      -
      13533  m_pAlgorithm(VMA_NULL),
      -
      13534  m_Allocations(VmaStlAllocator<AllocInfo>(hAllocator->GetAllocationCallbacks())),
      -
      13535  m_AllAllocations(false)
      -
      13536 {
      -
      13537 }
      +
      13510  VmaBlockMetadata_Generic* const pMetadata =
      +
      13511  (VmaBlockMetadata_Generic*)m_pBlockVector->GetBlock(blockIndex)->m_pMetadata;
      +
      13512  const VkDeviceSize blockSize = pMetadata->GetSize();
      +
      13513 
      +
      13514  // No allocations in this block - entire area is free.
      +
      13515  if(pMetadata->m_Suballocations.empty())
      +
      13516  {
      +
      13517  pMetadata->m_FreeCount = 1;
      +
      13518  //pMetadata->m_SumFreeSize is already set to blockSize.
      +
      13519  VmaSuballocation suballoc = {
      +
      13520  0, // offset
      +
      13521  blockSize, // size
      +
      13522  VMA_NULL, // hAllocation
      +
      13523  VMA_SUBALLOCATION_TYPE_FREE };
      +
      13524  pMetadata->m_Suballocations.push_back(suballoc);
      +
      13525  pMetadata->RegisterFreeSuballocation(pMetadata->m_Suballocations.begin());
      +
      13526  }
      +
      13527  // There are some allocations in this block.
      +
      13528  else
      +
      13529  {
      +
      13530  VkDeviceSize offset = 0;
      +
      13531  VmaSuballocationList::iterator it;
      +
      13532  for(it = pMetadata->m_Suballocations.begin();
      +
      13533  it != pMetadata->m_Suballocations.end();
      +
      13534  ++it)
      +
      13535  {
      +
      13536  VMA_ASSERT(it->type != VMA_SUBALLOCATION_TYPE_FREE);
      +
      13537  VMA_ASSERT(it->offset >= offset);
      13538 
      -
      13539 VmaBlockVectorDefragmentationContext::~VmaBlockVectorDefragmentationContext()
      -
      13540 {
      -
      13541  vma_delete(m_hAllocator, m_pAlgorithm);
      -
      13542 }
      -
      13543 
      -
      13544 void VmaBlockVectorDefragmentationContext::AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged)
      -
      13545 {
      -
      13546  AllocInfo info = { hAlloc, pChanged };
      -
      13547  m_Allocations.push_back(info);
      -
      13548 }
      -
      13549 
      -
      13550 void VmaBlockVectorDefragmentationContext::Begin(bool overlappingMoveSupported)
      -
      13551 {
      -
      13552  const bool allAllocations = m_AllAllocations ||
      -
      13553  m_Allocations.size() == m_pBlockVector->CalcAllocationCount();
      -
      13554 
      -
      13555  /********************************
      -
      13556  HERE IS THE CHOICE OF DEFRAGMENTATION ALGORITHM.
      -
      13557  ********************************/
      -
      13558 
      -
      13559  /*
      -
      13560  Fast algorithm is supported only when certain criteria are met:
      -
      13561  - VMA_DEBUG_MARGIN is 0.
      -
      13562  - All allocations in this block vector are moveable.
      -
      13563  - There is no possibility of image/buffer granularity conflict.
      -
      13564  */
      -
      13565  if(VMA_DEBUG_MARGIN == 0 &&
      -
      13566  allAllocations &&
      -
      13567  !m_pBlockVector->IsBufferImageGranularityConflictPossible())
      -
      13568  {
      -
      13569  m_pAlgorithm = vma_new(m_hAllocator, VmaDefragmentationAlgorithm_Fast)(
      -
      13570  m_hAllocator, m_pBlockVector, m_CurrFrameIndex, overlappingMoveSupported);
      -
      13571  }
      -
      13572  else
      -
      13573  {
      -
      13574  m_pAlgorithm = vma_new(m_hAllocator, VmaDefragmentationAlgorithm_Generic)(
      -
      13575  m_hAllocator, m_pBlockVector, m_CurrFrameIndex, overlappingMoveSupported);
      -
      13576  }
      +
      13539  // Need to insert preceding free space.
      +
      13540  if(it->offset > offset)
      +
      13541  {
      +
      13542  ++pMetadata->m_FreeCount;
      +
      13543  const VkDeviceSize freeSize = it->offset - offset;
      +
      13544  VmaSuballocation suballoc = {
      +
      13545  offset, // offset
      +
      13546  freeSize, // size
      +
      13547  VMA_NULL, // hAllocation
      +
      13548  VMA_SUBALLOCATION_TYPE_FREE };
      +
      13549  VmaSuballocationList::iterator precedingFreeIt = pMetadata->m_Suballocations.insert(it, suballoc);
      +
      13550  if(freeSize >= VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
      +
      13551  {
      +
      13552  pMetadata->m_FreeSuballocationsBySize.push_back(precedingFreeIt);
      +
      13553  }
      +
      13554  }
      +
      13555 
      +
      13556  pMetadata->m_SumFreeSize -= it->size;
      +
      13557  offset = it->offset + it->size;
      +
      13558  }
      +
      13559 
      +
      13560  // Need to insert trailing free space.
      +
      13561  if(offset < blockSize)
      +
      13562  {
      +
      13563  ++pMetadata->m_FreeCount;
      +
      13564  const VkDeviceSize freeSize = blockSize - offset;
      +
      13565  VmaSuballocation suballoc = {
      +
      13566  offset, // offset
      +
      13567  freeSize, // size
      +
      13568  VMA_NULL, // hAllocation
      +
      13569  VMA_SUBALLOCATION_TYPE_FREE };
      +
      13570  VMA_ASSERT(it == pMetadata->m_Suballocations.end());
      +
      13571  VmaSuballocationList::iterator trailingFreeIt = pMetadata->m_Suballocations.insert(it, suballoc);
      +
      13572  if(freeSize > VMA_MIN_FREE_SUBALLOCATION_SIZE_TO_REGISTER)
      +
      13573  {
      +
      13574  pMetadata->m_FreeSuballocationsBySize.push_back(trailingFreeIt);
      +
      13575  }
      +
      13576  }
      13577 
      -
      13578  if(allAllocations)
      -
      13579  {
      -
      13580  m_pAlgorithm->AddAll();
      -
      13581  }
      -
      13582  else
      -
      13583  {
      -
      13584  for(size_t i = 0, count = m_Allocations.size(); i < count; ++i)
      -
      13585  {
      -
      13586  m_pAlgorithm->AddAllocation(m_Allocations[i].hAlloc, m_Allocations[i].pChanged);
      -
      13587  }
      -
      13588  }
      -
      13589 }
      -
      13590 
      -
      13592 // VmaDefragmentationContext
      -
      13593 
      -
      13594 VmaDefragmentationContext_T::VmaDefragmentationContext_T(
      -
      13595  VmaAllocator hAllocator,
      -
      13596  uint32_t currFrameIndex,
      -
      13597  uint32_t flags,
      -
      13598  VmaDefragmentationStats* pStats) :
      -
      13599  m_hAllocator(hAllocator),
      -
      13600  m_CurrFrameIndex(currFrameIndex),
      -
      13601  m_Flags(flags),
      -
      13602  m_pStats(pStats),
      -
      13603  m_CustomPoolContexts(VmaStlAllocator<VmaBlockVectorDefragmentationContext*>(hAllocator->GetAllocationCallbacks()))
      -
      13604 {
      -
      13605  memset(m_DefaultPoolContexts, 0, sizeof(m_DefaultPoolContexts));
      -
      13606 }
      -
      13607 
      -
      13608 VmaDefragmentationContext_T::~VmaDefragmentationContext_T()
      -
      13609 {
      -
      13610  for(size_t i = m_CustomPoolContexts.size(); i--; )
      -
      13611  {
      -
      13612  VmaBlockVectorDefragmentationContext* pBlockVectorCtx = m_CustomPoolContexts[i];
      -
      13613  pBlockVectorCtx->GetBlockVector()->DefragmentationEnd(pBlockVectorCtx, m_pStats);
      -
      13614  vma_delete(m_hAllocator, pBlockVectorCtx);
      -
      13615  }
      -
      13616  for(size_t i = m_hAllocator->m_MemProps.memoryTypeCount; i--; )
      -
      13617  {
      -
      13618  VmaBlockVectorDefragmentationContext* pBlockVectorCtx = m_DefaultPoolContexts[i];
      -
      13619  if(pBlockVectorCtx)
      -
      13620  {
      -
      13621  pBlockVectorCtx->GetBlockVector()->DefragmentationEnd(pBlockVectorCtx, m_pStats);
      -
      13622  vma_delete(m_hAllocator, pBlockVectorCtx);
      -
      13623  }
      -
      13624  }
      -
      13625 }
      -
      13626 
      -
      13627 void VmaDefragmentationContext_T::AddPools(uint32_t poolCount, VmaPool* pPools)
      -
      13628 {
      -
      13629  for(uint32_t poolIndex = 0; poolIndex < poolCount; ++poolIndex)
      -
      13630  {
      -
      13631  VmaPool pool = pPools[poolIndex];
      -
      13632  VMA_ASSERT(pool);
      -
      13633  // Pools with algorithm other than default are not defragmented.
      -
      13634  if(pool->m_BlockVector.GetAlgorithm() == 0)
      -
      13635  {
      -
      13636  VmaBlockVectorDefragmentationContext* pBlockVectorDefragCtx = VMA_NULL;
      -
      13637 
      -
      13638  for(size_t i = m_CustomPoolContexts.size(); i--; )
      -
      13639  {
      -
      13640  if(m_CustomPoolContexts[i]->GetCustomPool() == pool)
      -
      13641  {
      -
      13642  pBlockVectorDefragCtx = m_CustomPoolContexts[i];
      -
      13643  break;
      -
      13644  }
      -
      13645  }
      -
      13646 
      -
      13647  if(!pBlockVectorDefragCtx)
      -
      13648  {
      -
      13649  pBlockVectorDefragCtx = vma_new(m_hAllocator, VmaBlockVectorDefragmentationContext)(
      -
      13650  m_hAllocator,
      -
      13651  pool,
      -
      13652  &pool->m_BlockVector,
      -
      13653  m_CurrFrameIndex);
      -
      13654  m_CustomPoolContexts.push_back(pBlockVectorDefragCtx);
      -
      13655  }
      -
      13656 
      -
      13657  pBlockVectorDefragCtx->AddAll();
      -
      13658  }
      -
      13659  }
      -
      13660 }
      +
      13578  VMA_SORT(
      +
      13579  pMetadata->m_FreeSuballocationsBySize.begin(),
      +
      13580  pMetadata->m_FreeSuballocationsBySize.end(),
      +
      13581  VmaSuballocationItemSizeLess());
      +
      13582  }
      +
      13583 
      +
      13584  VMA_HEAVY_ASSERT(pMetadata->Validate());
      +
      13585  }
      +
      13586 }
      +
      13587 
      +
      13588 void VmaDefragmentationAlgorithm_Fast::InsertSuballoc(VmaBlockMetadata_Generic* pMetadata, const VmaSuballocation& suballoc)
      +
      13589 {
      +
      13590  // TODO: Optimize somehow. Remember iterator instead of searching for it linearly.
      +
      13591  VmaSuballocationList::iterator it = pMetadata->m_Suballocations.begin();
      +
      13592  while(it != pMetadata->m_Suballocations.end())
      +
      13593  {
      +
      13594  if(it->offset < suballoc.offset)
      +
      13595  {
      +
      13596  ++it;
      +
      13597  }
      +
      13598  }
      +
      13599  pMetadata->m_Suballocations.insert(it, suballoc);
      +
      13600 }
      +
      13601 
      +
      13603 // VmaBlockVectorDefragmentationContext
      +
      13604 
      +
      13605 VmaBlockVectorDefragmentationContext::VmaBlockVectorDefragmentationContext(
      +
      13606  VmaAllocator hAllocator,
      +
      13607  VmaPool hCustomPool,
      +
      13608  VmaBlockVector* pBlockVector,
      +
      13609  uint32_t currFrameIndex) :
      +
      13610  res(VK_SUCCESS),
      +
      13611  mutexLocked(false),
      +
      13612  blockContexts(VmaStlAllocator<VmaBlockDefragmentationContext>(hAllocator->GetAllocationCallbacks())),
      +
      13613  m_hAllocator(hAllocator),
      +
      13614  m_hCustomPool(hCustomPool),
      +
      13615  m_pBlockVector(pBlockVector),
      +
      13616  m_CurrFrameIndex(currFrameIndex),
      +
      13617  m_pAlgorithm(VMA_NULL),
      +
      13618  m_Allocations(VmaStlAllocator<AllocInfo>(hAllocator->GetAllocationCallbacks())),
      +
      13619  m_AllAllocations(false)
      +
      13620 {
      +
      13621 }
      +
      13622 
      +
      13623 VmaBlockVectorDefragmentationContext::~VmaBlockVectorDefragmentationContext()
      +
      13624 {
      +
      13625  vma_delete(m_hAllocator, m_pAlgorithm);
      +
      13626 }
      +
      13627 
      +
      13628 void VmaBlockVectorDefragmentationContext::AddAllocation(VmaAllocation hAlloc, VkBool32* pChanged)
      +
      13629 {
      +
      13630  AllocInfo info = { hAlloc, pChanged };
      +
      13631  m_Allocations.push_back(info);
      +
      13632 }
      +
      13633 
      +
      13634 void VmaBlockVectorDefragmentationContext::Begin(bool overlappingMoveSupported)
      +
      13635 {
      +
      13636  const bool allAllocations = m_AllAllocations ||
      +
      13637  m_Allocations.size() == m_pBlockVector->CalcAllocationCount();
      +
      13638 
      +
      13639  /********************************
      +
      13640  HERE IS THE CHOICE OF DEFRAGMENTATION ALGORITHM.
      +
      13641  ********************************/
      +
      13642 
      +
      13643  /*
      +
      13644  Fast algorithm is supported only when certain criteria are met:
      +
      13645  - VMA_DEBUG_MARGIN is 0.
      +
      13646  - All allocations in this block vector are moveable.
      +
      13647  - There is no possibility of image/buffer granularity conflict.
      +
      13648  */
      +
      13649  if(VMA_DEBUG_MARGIN == 0 &&
      +
      13650  allAllocations &&
      +
      13651  !m_pBlockVector->IsBufferImageGranularityConflictPossible())
      +
      13652  {
      +
      13653  m_pAlgorithm = vma_new(m_hAllocator, VmaDefragmentationAlgorithm_Fast)(
      +
      13654  m_hAllocator, m_pBlockVector, m_CurrFrameIndex, overlappingMoveSupported);
      +
      13655  }
      +
      13656  else
      +
      13657  {
      +
      13658  m_pAlgorithm = vma_new(m_hAllocator, VmaDefragmentationAlgorithm_Generic)(
      +
      13659  m_hAllocator, m_pBlockVector, m_CurrFrameIndex, overlappingMoveSupported);
      +
      13660  }
      13661 
      -
      13662 void VmaDefragmentationContext_T::AddAllocations(
      -
      13663  uint32_t allocationCount,
      -
      13664  VmaAllocation* pAllocations,
      -
      13665  VkBool32* pAllocationsChanged)
      -
      13666 {
      -
      13667  // Dispatch pAllocations among defragmentators. Create them when necessary.
      -
      13668  for(uint32_t allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
      -
      13669  {
      -
      13670  const VmaAllocation hAlloc = pAllocations[allocIndex];
      -
      13671  VMA_ASSERT(hAlloc);
      -
      13672  // DedicatedAlloc cannot be defragmented.
      -
      13673  if((hAlloc->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK) &&
      -
      13674  // Lost allocation cannot be defragmented.
      -
      13675  (hAlloc->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST))
      -
      13676  {
      -
      13677  VmaBlockVectorDefragmentationContext* pBlockVectorDefragCtx = VMA_NULL;
      -
      13678 
      -
      13679  const VmaPool hAllocPool = hAlloc->GetBlock()->GetParentPool();
      -
      13680  // This allocation belongs to custom pool.
      -
      13681  if(hAllocPool != VK_NULL_HANDLE)
      -
      13682  {
      -
      13683  // Pools with algorithm other than default are not defragmented.
      -
      13684  if(hAllocPool->m_BlockVector.GetAlgorithm() == 0)
      -
      13685  {
      -
      13686  for(size_t i = m_CustomPoolContexts.size(); i--; )
      -
      13687  {
      -
      13688  if(m_CustomPoolContexts[i]->GetCustomPool() == hAllocPool)
      -
      13689  {
      -
      13690  pBlockVectorDefragCtx = m_CustomPoolContexts[i];
      -
      13691  break;
      -
      13692  }
      -
      13693  }
      -
      13694  if(!pBlockVectorDefragCtx)
      -
      13695  {
      -
      13696  pBlockVectorDefragCtx = vma_new(m_hAllocator, VmaBlockVectorDefragmentationContext)(
      -
      13697  m_hAllocator,
      -
      13698  hAllocPool,
      -
      13699  &hAllocPool->m_BlockVector,
      -
      13700  m_CurrFrameIndex);
      -
      13701  m_CustomPoolContexts.push_back(pBlockVectorDefragCtx);
      -
      13702  }
      -
      13703  }
      -
      13704  }
      -
      13705  // This allocation belongs to default pool.
      -
      13706  else
      -
      13707  {
      -
      13708  const uint32_t memTypeIndex = hAlloc->GetMemoryTypeIndex();
      -
      13709  pBlockVectorDefragCtx = m_DefaultPoolContexts[memTypeIndex];
      -
      13710  if(!pBlockVectorDefragCtx)
      -
      13711  {
      -
      13712  pBlockVectorDefragCtx = vma_new(m_hAllocator, VmaBlockVectorDefragmentationContext)(
      -
      13713  m_hAllocator,
      -
      13714  VMA_NULL, // hCustomPool
      -
      13715  m_hAllocator->m_pBlockVectors[memTypeIndex],
      -
      13716  m_CurrFrameIndex);
      -
      13717  m_DefaultPoolContexts[memTypeIndex] = pBlockVectorDefragCtx;
      -
      13718  }
      -
      13719  }
      -
      13720 
      -
      13721  if(pBlockVectorDefragCtx)
      -
      13722  {
      -
      13723  VkBool32* const pChanged = (pAllocationsChanged != VMA_NULL) ?
      -
      13724  &pAllocationsChanged[allocIndex] : VMA_NULL;
      -
      13725  pBlockVectorDefragCtx->AddAllocation(hAlloc, pChanged);
      -
      13726  }
      -
      13727  }
      -
      13728  }
      -
      13729 }
      -
      13730 
      -
      13731 VkResult VmaDefragmentationContext_T::Defragment(
      -
      13732  VkDeviceSize maxCpuBytesToMove, uint32_t maxCpuAllocationsToMove,
      -
      13733  VkDeviceSize maxGpuBytesToMove, uint32_t maxGpuAllocationsToMove,
      -
      13734  VkCommandBuffer commandBuffer, VmaDefragmentationStats* pStats)
      -
      13735 {
      -
      13736  if(pStats)
      -
      13737  {
      -
      13738  memset(pStats, 0, sizeof(VmaDefragmentationStats));
      -
      13739  }
      +
      13662  if(allAllocations)
      +
      13663  {
      +
      13664  m_pAlgorithm->AddAll();
      +
      13665  }
      +
      13666  else
      +
      13667  {
      +
      13668  for(size_t i = 0, count = m_Allocations.size(); i < count; ++i)
      +
      13669  {
      +
      13670  m_pAlgorithm->AddAllocation(m_Allocations[i].hAlloc, m_Allocations[i].pChanged);
      +
      13671  }
      +
      13672  }
      +
      13673 }
      +
      13674 
      +
      13676 // VmaDefragmentationContext
      +
      13677 
      +
      13678 VmaDefragmentationContext_T::VmaDefragmentationContext_T(
      +
      13679  VmaAllocator hAllocator,
      +
      13680  uint32_t currFrameIndex,
      +
      13681  uint32_t flags,
      +
      13682  VmaDefragmentationStats* pStats) :
      +
      13683  m_hAllocator(hAllocator),
      +
      13684  m_CurrFrameIndex(currFrameIndex),
      +
      13685  m_Flags(flags),
      +
      13686  m_pStats(pStats),
      +
      13687  m_CustomPoolContexts(VmaStlAllocator<VmaBlockVectorDefragmentationContext*>(hAllocator->GetAllocationCallbacks()))
      +
      13688 {
      +
      13689  memset(m_DefaultPoolContexts, 0, sizeof(m_DefaultPoolContexts));
      +
      13690 }
      +
      13691 
      +
      13692 VmaDefragmentationContext_T::~VmaDefragmentationContext_T()
      +
      13693 {
      +
      13694  for(size_t i = m_CustomPoolContexts.size(); i--; )
      +
      13695  {
      +
      13696  VmaBlockVectorDefragmentationContext* pBlockVectorCtx = m_CustomPoolContexts[i];
      +
      13697  pBlockVectorCtx->GetBlockVector()->DefragmentationEnd(pBlockVectorCtx, m_pStats);
      +
      13698  vma_delete(m_hAllocator, pBlockVectorCtx);
      +
      13699  }
      +
      13700  for(size_t i = m_hAllocator->m_MemProps.memoryTypeCount; i--; )
      +
      13701  {
      +
      13702  VmaBlockVectorDefragmentationContext* pBlockVectorCtx = m_DefaultPoolContexts[i];
      +
      13703  if(pBlockVectorCtx)
      +
      13704  {
      +
      13705  pBlockVectorCtx->GetBlockVector()->DefragmentationEnd(pBlockVectorCtx, m_pStats);
      +
      13706  vma_delete(m_hAllocator, pBlockVectorCtx);
      +
      13707  }
      +
      13708  }
      +
      13709 }
      +
      13710 
      +
      13711 void VmaDefragmentationContext_T::AddPools(uint32_t poolCount, VmaPool* pPools)
      +
      13712 {
      +
      13713  for(uint32_t poolIndex = 0; poolIndex < poolCount; ++poolIndex)
      +
      13714  {
      +
      13715  VmaPool pool = pPools[poolIndex];
      +
      13716  VMA_ASSERT(pool);
      +
      13717  // Pools with algorithm other than default are not defragmented.
      +
      13718  if(pool->m_BlockVector.GetAlgorithm() == 0)
      +
      13719  {
      +
      13720  VmaBlockVectorDefragmentationContext* pBlockVectorDefragCtx = VMA_NULL;
      +
      13721 
      +
      13722  for(size_t i = m_CustomPoolContexts.size(); i--; )
      +
      13723  {
      +
      13724  if(m_CustomPoolContexts[i]->GetCustomPool() == pool)
      +
      13725  {
      +
      13726  pBlockVectorDefragCtx = m_CustomPoolContexts[i];
      +
      13727  break;
      +
      13728  }
      +
      13729  }
      +
      13730 
      +
      13731  if(!pBlockVectorDefragCtx)
      +
      13732  {
      +
      13733  pBlockVectorDefragCtx = vma_new(m_hAllocator, VmaBlockVectorDefragmentationContext)(
      +
      13734  m_hAllocator,
      +
      13735  pool,
      +
      13736  &pool->m_BlockVector,
      +
      13737  m_CurrFrameIndex);
      +
      13738  m_CustomPoolContexts.push_back(pBlockVectorDefragCtx);
      +
      13739  }
      13740 
      -
      13741  if(commandBuffer == VK_NULL_HANDLE)
      -
      13742  {
      -
      13743  maxGpuBytesToMove = 0;
      -
      13744  maxGpuAllocationsToMove = 0;
      -
      13745  }
      -
      13746 
      -
      13747  VkResult res = VK_SUCCESS;
      -
      13748 
      -
      13749  // Process default pools.
      -
      13750  for(uint32_t memTypeIndex = 0;
      -
      13751  memTypeIndex < m_hAllocator->GetMemoryTypeCount() && res >= VK_SUCCESS;
      -
      13752  ++memTypeIndex)
      +
      13741  pBlockVectorDefragCtx->AddAll();
      +
      13742  }
      +
      13743  }
      +
      13744 }
      +
      13745 
      +
      13746 void VmaDefragmentationContext_T::AddAllocations(
      +
      13747  uint32_t allocationCount,
      +
      13748  VmaAllocation* pAllocations,
      +
      13749  VkBool32* pAllocationsChanged)
      +
      13750 {
      +
      13751  // Dispatch pAllocations among defragmentators. Create them when necessary.
      +
      13752  for(uint32_t allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
      13753  {
      -
      13754  VmaBlockVectorDefragmentationContext* pBlockVectorCtx = m_DefaultPoolContexts[memTypeIndex];
      -
      13755  if(pBlockVectorCtx)
      -
      13756  {
      -
      13757  VMA_ASSERT(pBlockVectorCtx->GetBlockVector());
      -
      13758  pBlockVectorCtx->GetBlockVector()->Defragment(
      -
      13759  pBlockVectorCtx,
      -
      13760  pStats,
      -
      13761  maxCpuBytesToMove, maxCpuAllocationsToMove,
      -
      13762  maxGpuBytesToMove, maxGpuAllocationsToMove,
      -
      13763  commandBuffer);
      -
      13764  if(pBlockVectorCtx->res != VK_SUCCESS)
      -
      13765  {
      -
      13766  res = pBlockVectorCtx->res;
      -
      13767  }
      -
      13768  }
      -
      13769  }
      -
      13770 
      -
      13771  // Process custom pools.
      -
      13772  for(size_t customCtxIndex = 0, customCtxCount = m_CustomPoolContexts.size();
      -
      13773  customCtxIndex < customCtxCount && res >= VK_SUCCESS;
      -
      13774  ++customCtxIndex)
      -
      13775  {
      -
      13776  VmaBlockVectorDefragmentationContext* pBlockVectorCtx = m_CustomPoolContexts[customCtxIndex];
      -
      13777  VMA_ASSERT(pBlockVectorCtx && pBlockVectorCtx->GetBlockVector());
      -
      13778  pBlockVectorCtx->GetBlockVector()->Defragment(
      -
      13779  pBlockVectorCtx,
      -
      13780  pStats,
      -
      13781  maxCpuBytesToMove, maxCpuAllocationsToMove,
      -
      13782  maxGpuBytesToMove, maxGpuAllocationsToMove,
      -
      13783  commandBuffer);
      -
      13784  if(pBlockVectorCtx->res != VK_SUCCESS)
      -
      13785  {
      -
      13786  res = pBlockVectorCtx->res;
      -
      13787  }
      -
      13788  }
      -
      13789 
      -
      13790  return res;
      -
      13791 }
      -
      13792 
      -
      13794 // VmaRecorder
      -
      13795 
      -
      13796 #if VMA_RECORDING_ENABLED
      -
      13797 
      -
      13798 VmaRecorder::VmaRecorder() :
      -
      13799  m_UseMutex(true),
      -
      13800  m_Flags(0),
      -
      13801  m_File(VMA_NULL),
      -
      13802  m_Freq(INT64_MAX),
      -
      13803  m_StartCounter(INT64_MAX)
      -
      13804 {
      -
      13805 }
      -
      13806 
      -
      13807 VkResult VmaRecorder::Init(const VmaRecordSettings& settings, bool useMutex)
      -
      13808 {
      -
      13809  m_UseMutex = useMutex;
      -
      13810  m_Flags = settings.flags;
      -
      13811 
      -
      13812  QueryPerformanceFrequency((LARGE_INTEGER*)&m_Freq);
      -
      13813  QueryPerformanceCounter((LARGE_INTEGER*)&m_StartCounter);
      +
      13754  const VmaAllocation hAlloc = pAllocations[allocIndex];
      +
      13755  VMA_ASSERT(hAlloc);
      +
      13756  // DedicatedAlloc cannot be defragmented.
      +
      13757  if((hAlloc->GetType() == VmaAllocation_T::ALLOCATION_TYPE_BLOCK) &&
      +
      13758  // Lost allocation cannot be defragmented.
      +
      13759  (hAlloc->GetLastUseFrameIndex() != VMA_FRAME_INDEX_LOST))
      +
      13760  {
      +
      13761  VmaBlockVectorDefragmentationContext* pBlockVectorDefragCtx = VMA_NULL;
      +
      13762 
      +
      13763  const VmaPool hAllocPool = hAlloc->GetBlock()->GetParentPool();
      +
      13764  // This allocation belongs to custom pool.
      +
      13765  if(hAllocPool != VK_NULL_HANDLE)
      +
      13766  {
      +
      13767  // Pools with algorithm other than default are not defragmented.
      +
      13768  if(hAllocPool->m_BlockVector.GetAlgorithm() == 0)
      +
      13769  {
      +
      13770  for(size_t i = m_CustomPoolContexts.size(); i--; )
      +
      13771  {
      +
      13772  if(m_CustomPoolContexts[i]->GetCustomPool() == hAllocPool)
      +
      13773  {
      +
      13774  pBlockVectorDefragCtx = m_CustomPoolContexts[i];
      +
      13775  break;
      +
      13776  }
      +
      13777  }
      +
      13778  if(!pBlockVectorDefragCtx)
      +
      13779  {
      +
      13780  pBlockVectorDefragCtx = vma_new(m_hAllocator, VmaBlockVectorDefragmentationContext)(
      +
      13781  m_hAllocator,
      +
      13782  hAllocPool,
      +
      13783  &hAllocPool->m_BlockVector,
      +
      13784  m_CurrFrameIndex);
      +
      13785  m_CustomPoolContexts.push_back(pBlockVectorDefragCtx);
      +
      13786  }
      +
      13787  }
      +
      13788  }
      +
      13789  // This allocation belongs to default pool.
      +
      13790  else
      +
      13791  {
      +
      13792  const uint32_t memTypeIndex = hAlloc->GetMemoryTypeIndex();
      +
      13793  pBlockVectorDefragCtx = m_DefaultPoolContexts[memTypeIndex];
      +
      13794  if(!pBlockVectorDefragCtx)
      +
      13795  {
      +
      13796  pBlockVectorDefragCtx = vma_new(m_hAllocator, VmaBlockVectorDefragmentationContext)(
      +
      13797  m_hAllocator,
      +
      13798  VMA_NULL, // hCustomPool
      +
      13799  m_hAllocator->m_pBlockVectors[memTypeIndex],
      +
      13800  m_CurrFrameIndex);
      +
      13801  m_DefaultPoolContexts[memTypeIndex] = pBlockVectorDefragCtx;
      +
      13802  }
      +
      13803  }
      +
      13804 
      +
      13805  if(pBlockVectorDefragCtx)
      +
      13806  {
      +
      13807  VkBool32* const pChanged = (pAllocationsChanged != VMA_NULL) ?
      +
      13808  &pAllocationsChanged[allocIndex] : VMA_NULL;
      +
      13809  pBlockVectorDefragCtx->AddAllocation(hAlloc, pChanged);
      +
      13810  }
      +
      13811  }
      +
      13812  }
      +
      13813 }
      13814 
      -
      13815  // Open file for writing.
      -
      13816  errno_t err = fopen_s(&m_File, settings.pFilePath, "wb");
      -
      13817  if(err != 0)
      -
      13818  {
      -
      13819  return VK_ERROR_INITIALIZATION_FAILED;
      -
      13820  }
      -
      13821 
      -
      13822  // Write header.
      -
      13823  fprintf(m_File, "%s\n", "Vulkan Memory Allocator,Calls recording");
      -
      13824  fprintf(m_File, "%s\n", "1,6");
      -
      13825 
      -
      13826  return VK_SUCCESS;
      -
      13827 }
      -
      13828 
      -
      13829 VmaRecorder::~VmaRecorder()
      -
      13830 {
      -
      13831  if(m_File != VMA_NULL)
      -
      13832  {
      -
      13833  fclose(m_File);
      -
      13834  }
      -
      13835 }
      -
      13836 
      -
      13837 void VmaRecorder::RecordCreateAllocator(uint32_t frameIndex)
      -
      13838 {
      -
      13839  CallParams callParams;
      -
      13840  GetBasicParams(callParams);
      -
      13841 
      -
      13842  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      -
      13843  fprintf(m_File, "%u,%.3f,%u,vmaCreateAllocator\n", callParams.threadId, callParams.time, frameIndex);
      -
      13844  Flush();
      -
      13845 }
      -
      13846 
      -
      13847 void VmaRecorder::RecordDestroyAllocator(uint32_t frameIndex)
      -
      13848 {
      -
      13849  CallParams callParams;
      -
      13850  GetBasicParams(callParams);
      -
      13851 
      -
      13852  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      -
      13853  fprintf(m_File, "%u,%.3f,%u,vmaDestroyAllocator\n", callParams.threadId, callParams.time, frameIndex);
      -
      13854  Flush();
      -
      13855 }
      -
      13856 
      -
      13857 void VmaRecorder::RecordCreatePool(uint32_t frameIndex, const VmaPoolCreateInfo& createInfo, VmaPool pool)
      -
      13858 {
      -
      13859  CallParams callParams;
      -
      13860  GetBasicParams(callParams);
      -
      13861 
      -
      13862  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      -
      13863  fprintf(m_File, "%u,%.3f,%u,vmaCreatePool,%u,%u,%llu,%llu,%llu,%u,%p\n", callParams.threadId, callParams.time, frameIndex,
      -
      13864  createInfo.memoryTypeIndex,
      -
      13865  createInfo.flags,
      -
      13866  createInfo.blockSize,
      -
      13867  (uint64_t)createInfo.minBlockCount,
      -
      13868  (uint64_t)createInfo.maxBlockCount,
      -
      13869  createInfo.frameInUseCount,
      -
      13870  pool);
      -
      13871  Flush();
      -
      13872 }
      +
      13815 VkResult VmaDefragmentationContext_T::Defragment(
      +
      13816  VkDeviceSize maxCpuBytesToMove, uint32_t maxCpuAllocationsToMove,
      +
      13817  VkDeviceSize maxGpuBytesToMove, uint32_t maxGpuAllocationsToMove,
      +
      13818  VkCommandBuffer commandBuffer, VmaDefragmentationStats* pStats)
      +
      13819 {
      +
      13820  if(pStats)
      +
      13821  {
      +
      13822  memset(pStats, 0, sizeof(VmaDefragmentationStats));
      +
      13823  }
      +
      13824 
      +
      13825  if(commandBuffer == VK_NULL_HANDLE)
      +
      13826  {
      +
      13827  maxGpuBytesToMove = 0;
      +
      13828  maxGpuAllocationsToMove = 0;
      +
      13829  }
      +
      13830 
      +
      13831  VkResult res = VK_SUCCESS;
      +
      13832 
      +
      13833  // Process default pools.
      +
      13834  for(uint32_t memTypeIndex = 0;
      +
      13835  memTypeIndex < m_hAllocator->GetMemoryTypeCount() && res >= VK_SUCCESS;
      +
      13836  ++memTypeIndex)
      +
      13837  {
      +
      13838  VmaBlockVectorDefragmentationContext* pBlockVectorCtx = m_DefaultPoolContexts[memTypeIndex];
      +
      13839  if(pBlockVectorCtx)
      +
      13840  {
      +
      13841  VMA_ASSERT(pBlockVectorCtx->GetBlockVector());
      +
      13842  pBlockVectorCtx->GetBlockVector()->Defragment(
      +
      13843  pBlockVectorCtx,
      +
      13844  pStats,
      +
      13845  maxCpuBytesToMove, maxCpuAllocationsToMove,
      +
      13846  maxGpuBytesToMove, maxGpuAllocationsToMove,
      +
      13847  commandBuffer);
      +
      13848  if(pBlockVectorCtx->res != VK_SUCCESS)
      +
      13849  {
      +
      13850  res = pBlockVectorCtx->res;
      +
      13851  }
      +
      13852  }
      +
      13853  }
      +
      13854 
      +
      13855  // Process custom pools.
      +
      13856  for(size_t customCtxIndex = 0, customCtxCount = m_CustomPoolContexts.size();
      +
      13857  customCtxIndex < customCtxCount && res >= VK_SUCCESS;
      +
      13858  ++customCtxIndex)
      +
      13859  {
      +
      13860  VmaBlockVectorDefragmentationContext* pBlockVectorCtx = m_CustomPoolContexts[customCtxIndex];
      +
      13861  VMA_ASSERT(pBlockVectorCtx && pBlockVectorCtx->GetBlockVector());
      +
      13862  pBlockVectorCtx->GetBlockVector()->Defragment(
      +
      13863  pBlockVectorCtx,
      +
      13864  pStats,
      +
      13865  maxCpuBytesToMove, maxCpuAllocationsToMove,
      +
      13866  maxGpuBytesToMove, maxGpuAllocationsToMove,
      +
      13867  commandBuffer);
      +
      13868  if(pBlockVectorCtx->res != VK_SUCCESS)
      +
      13869  {
      +
      13870  res = pBlockVectorCtx->res;
      +
      13871  }
      +
      13872  }
      13873 
      -
      13874 void VmaRecorder::RecordDestroyPool(uint32_t frameIndex, VmaPool pool)
      -
      13875 {
      -
      13876  CallParams callParams;
      -
      13877  GetBasicParams(callParams);
      -
      13878 
      -
      13879  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      -
      13880  fprintf(m_File, "%u,%.3f,%u,vmaDestroyPool,%p\n", callParams.threadId, callParams.time, frameIndex,
      -
      13881  pool);
      -
      13882  Flush();
      -
      13883 }
      -
      13884 
      -
      13885 void VmaRecorder::RecordAllocateMemory(uint32_t frameIndex,
      -
      13886  const VkMemoryRequirements& vkMemReq,
      -
      13887  const VmaAllocationCreateInfo& createInfo,
      -
      13888  VmaAllocation allocation)
      -
      13889 {
      -
      13890  CallParams callParams;
      -
      13891  GetBasicParams(callParams);
      -
      13892 
      -
      13893  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      -
      13894  UserDataString userDataStr(createInfo.flags, createInfo.pUserData);
      -
      13895  fprintf(m_File, "%u,%.3f,%u,vmaAllocateMemory,%llu,%llu,%u,%u,%u,%u,%u,%u,%p,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
      -
      13896  vkMemReq.size,
      -
      13897  vkMemReq.alignment,
      -
      13898  vkMemReq.memoryTypeBits,
      -
      13899  createInfo.flags,
      -
      13900  createInfo.usage,
      -
      13901  createInfo.requiredFlags,
      -
      13902  createInfo.preferredFlags,
      -
      13903  createInfo.memoryTypeBits,
      -
      13904  createInfo.pool,
      -
      13905  allocation,
      -
      13906  userDataStr.GetString());
      -
      13907  Flush();
      -
      13908 }
      +
      13874  return res;
      +
      13875 }
      +
      13876 
      +
      13878 // VmaRecorder
      +
      13879 
      +
      13880 #if VMA_RECORDING_ENABLED
      +
      13881 
      +
      13882 VmaRecorder::VmaRecorder() :
      +
      13883  m_UseMutex(true),
      +
      13884  m_Flags(0),
      +
      13885  m_File(VMA_NULL),
      +
      13886  m_Freq(INT64_MAX),
      +
      13887  m_StartCounter(INT64_MAX)
      +
      13888 {
      +
      13889 }
      +
      13890 
      +
      13891 VkResult VmaRecorder::Init(const VmaRecordSettings& settings, bool useMutex)
      +
      13892 {
      +
      13893  m_UseMutex = useMutex;
      +
      13894  m_Flags = settings.flags;
      +
      13895 
      +
      13896  QueryPerformanceFrequency((LARGE_INTEGER*)&m_Freq);
      +
      13897  QueryPerformanceCounter((LARGE_INTEGER*)&m_StartCounter);
      +
      13898 
      +
      13899  // Open file for writing.
      +
      13900  errno_t err = fopen_s(&m_File, settings.pFilePath, "wb");
      +
      13901  if(err != 0)
      +
      13902  {
      +
      13903  return VK_ERROR_INITIALIZATION_FAILED;
      +
      13904  }
      +
      13905 
      +
      13906  // Write header.
      +
      13907  fprintf(m_File, "%s\n", "Vulkan Memory Allocator,Calls recording");
      +
      13908  fprintf(m_File, "%s\n", "1,7");
      13909 
      -
      13910 void VmaRecorder::RecordAllocateMemoryPages(uint32_t frameIndex,
      -
      13911  const VkMemoryRequirements& vkMemReq,
      -
      13912  const VmaAllocationCreateInfo& createInfo,
      -
      13913  uint64_t allocationCount,
      -
      13914  const VmaAllocation* pAllocations)
      -
      13915 {
      -
      13916  CallParams callParams;
      -
      13917  GetBasicParams(callParams);
      -
      13918 
      -
      13919  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      -
      13920  UserDataString userDataStr(createInfo.flags, createInfo.pUserData);
      -
      13921  fprintf(m_File, "%u,%.3f,%u,vmaAllocateMemoryPages,%llu,%llu,%u,%u,%u,%u,%u,%u,%p,", callParams.threadId, callParams.time, frameIndex,
      -
      13922  vkMemReq.size,
      -
      13923  vkMemReq.alignment,
      -
      13924  vkMemReq.memoryTypeBits,
      -
      13925  createInfo.flags,
      -
      13926  createInfo.usage,
      -
      13927  createInfo.requiredFlags,
      -
      13928  createInfo.preferredFlags,
      -
      13929  createInfo.memoryTypeBits,
      -
      13930  createInfo.pool);
      -
      13931  PrintPointerList(allocationCount, pAllocations);
      -
      13932  fprintf(m_File, ",%s\n", userDataStr.GetString());
      -
      13933  Flush();
      -
      13934 }
      +
      13910  return VK_SUCCESS;
      +
      13911 }
      +
      13912 
      +
      13913 VmaRecorder::~VmaRecorder()
      +
      13914 {
      +
      13915  if(m_File != VMA_NULL)
      +
      13916  {
      +
      13917  fclose(m_File);
      +
      13918  }
      +
      13919 }
      +
      13920 
      +
      13921 void VmaRecorder::RecordCreateAllocator(uint32_t frameIndex)
      +
      13922 {
      +
      13923  CallParams callParams;
      +
      13924  GetBasicParams(callParams);
      +
      13925 
      +
      13926  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      +
      13927  fprintf(m_File, "%u,%.3f,%u,vmaCreateAllocator\n", callParams.threadId, callParams.time, frameIndex);
      +
      13928  Flush();
      +
      13929 }
      +
      13930 
      +
      13931 void VmaRecorder::RecordDestroyAllocator(uint32_t frameIndex)
      +
      13932 {
      +
      13933  CallParams callParams;
      +
      13934  GetBasicParams(callParams);
      13935 
      -
      13936 void VmaRecorder::RecordAllocateMemoryForBuffer(uint32_t frameIndex,
      -
      13937  const VkMemoryRequirements& vkMemReq,
      -
      13938  bool requiresDedicatedAllocation,
      -
      13939  bool prefersDedicatedAllocation,
      -
      13940  const VmaAllocationCreateInfo& createInfo,
      -
      13941  VmaAllocation allocation)
      +
      13936  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      +
      13937  fprintf(m_File, "%u,%.3f,%u,vmaDestroyAllocator\n", callParams.threadId, callParams.time, frameIndex);
      +
      13938  Flush();
      +
      13939 }
      +
      13940 
      +
      13941 void VmaRecorder::RecordCreatePool(uint32_t frameIndex, const VmaPoolCreateInfo& createInfo, VmaPool pool)
      13942 {
      13943  CallParams callParams;
      13944  GetBasicParams(callParams);
      13945 
      13946  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      -
      13947  UserDataString userDataStr(createInfo.flags, createInfo.pUserData);
      -
      13948  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,
      -
      13949  vkMemReq.size,
      -
      13950  vkMemReq.alignment,
      -
      13951  vkMemReq.memoryTypeBits,
      -
      13952  requiresDedicatedAllocation ? 1 : 0,
      -
      13953  prefersDedicatedAllocation ? 1 : 0,
      -
      13954  createInfo.flags,
      -
      13955  createInfo.usage,
      -
      13956  createInfo.requiredFlags,
      -
      13957  createInfo.preferredFlags,
      -
      13958  createInfo.memoryTypeBits,
      -
      13959  createInfo.pool,
      -
      13960  allocation,
      -
      13961  userDataStr.GetString());
      -
      13962  Flush();
      -
      13963 }
      -
      13964 
      -
      13965 void VmaRecorder::RecordAllocateMemoryForImage(uint32_t frameIndex,
      -
      13966  const VkMemoryRequirements& vkMemReq,
      -
      13967  bool requiresDedicatedAllocation,
      -
      13968  bool prefersDedicatedAllocation,
      -
      13969  const VmaAllocationCreateInfo& createInfo,
      -
      13970  VmaAllocation allocation)
      -
      13971 {
      -
      13972  CallParams callParams;
      -
      13973  GetBasicParams(callParams);
      -
      13974 
      -
      13975  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      -
      13976  UserDataString userDataStr(createInfo.flags, createInfo.pUserData);
      -
      13977  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,
      -
      13978  vkMemReq.size,
      -
      13979  vkMemReq.alignment,
      -
      13980  vkMemReq.memoryTypeBits,
      -
      13981  requiresDedicatedAllocation ? 1 : 0,
      -
      13982  prefersDedicatedAllocation ? 1 : 0,
      +
      13947  fprintf(m_File, "%u,%.3f,%u,vmaCreatePool,%u,%u,%llu,%llu,%llu,%u,%p\n", callParams.threadId, callParams.time, frameIndex,
      +
      13948  createInfo.memoryTypeIndex,
      +
      13949  createInfo.flags,
      +
      13950  createInfo.blockSize,
      +
      13951  (uint64_t)createInfo.minBlockCount,
      +
      13952  (uint64_t)createInfo.maxBlockCount,
      +
      13953  createInfo.frameInUseCount,
      +
      13954  pool);
      +
      13955  Flush();
      +
      13956 }
      +
      13957 
      +
      13958 void VmaRecorder::RecordDestroyPool(uint32_t frameIndex, VmaPool pool)
      +
      13959 {
      +
      13960  CallParams callParams;
      +
      13961  GetBasicParams(callParams);
      +
      13962 
      +
      13963  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      +
      13964  fprintf(m_File, "%u,%.3f,%u,vmaDestroyPool,%p\n", callParams.threadId, callParams.time, frameIndex,
      +
      13965  pool);
      +
      13966  Flush();
      +
      13967 }
      +
      13968 
      +
      13969 void VmaRecorder::RecordAllocateMemory(uint32_t frameIndex,
      +
      13970  const VkMemoryRequirements& vkMemReq,
      +
      13971  const VmaAllocationCreateInfo& createInfo,
      +
      13972  VmaAllocation allocation)
      +
      13973 {
      +
      13974  CallParams callParams;
      +
      13975  GetBasicParams(callParams);
      +
      13976 
      +
      13977  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      +
      13978  UserDataString userDataStr(createInfo.flags, createInfo.pUserData);
      +
      13979  fprintf(m_File, "%u,%.3f,%u,vmaAllocateMemory,%llu,%llu,%u,%u,%u,%u,%u,%u,%p,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
      +
      13980  vkMemReq.size,
      +
      13981  vkMemReq.alignment,
      +
      13982  vkMemReq.memoryTypeBits,
      13983  createInfo.flags,
      13984  createInfo.usage,
      13985  createInfo.requiredFlags,
      @@ -11207,3729 +11193,3876 @@ $(function() {
      13991  Flush();
      13992 }
      13993 
      -
      13994 void VmaRecorder::RecordFreeMemory(uint32_t frameIndex,
      -
      13995  VmaAllocation allocation)
      -
      13996 {
      -
      13997  CallParams callParams;
      -
      13998  GetBasicParams(callParams);
      -
      13999 
      -
      14000  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      -
      14001  fprintf(m_File, "%u,%.3f,%u,vmaFreeMemory,%p\n", callParams.threadId, callParams.time, frameIndex,
      -
      14002  allocation);
      -
      14003  Flush();
      -
      14004 }
      -
      14005 
      -
      14006 void VmaRecorder::RecordFreeMemoryPages(uint32_t frameIndex,
      -
      14007  uint64_t allocationCount,
      -
      14008  const VmaAllocation* pAllocations)
      -
      14009 {
      -
      14010  CallParams callParams;
      -
      14011  GetBasicParams(callParams);
      -
      14012 
      -
      14013  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      -
      14014  fprintf(m_File, "%u,%.3f,%u,vmaFreeMemoryPages,", callParams.threadId, callParams.time, frameIndex);
      +
      13994 void VmaRecorder::RecordAllocateMemoryPages(uint32_t frameIndex,
      +
      13995  const VkMemoryRequirements& vkMemReq,
      +
      13996  const VmaAllocationCreateInfo& createInfo,
      +
      13997  uint64_t allocationCount,
      +
      13998  const VmaAllocation* pAllocations)
      +
      13999 {
      +
      14000  CallParams callParams;
      +
      14001  GetBasicParams(callParams);
      +
      14002 
      +
      14003  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      +
      14004  UserDataString userDataStr(createInfo.flags, createInfo.pUserData);
      +
      14005  fprintf(m_File, "%u,%.3f,%u,vmaAllocateMemoryPages,%llu,%llu,%u,%u,%u,%u,%u,%u,%p,", callParams.threadId, callParams.time, frameIndex,
      +
      14006  vkMemReq.size,
      +
      14007  vkMemReq.alignment,
      +
      14008  vkMemReq.memoryTypeBits,
      +
      14009  createInfo.flags,
      +
      14010  createInfo.usage,
      +
      14011  createInfo.requiredFlags,
      +
      14012  createInfo.preferredFlags,
      +
      14013  createInfo.memoryTypeBits,
      +
      14014  createInfo.pool);
      14015  PrintPointerList(allocationCount, pAllocations);
      -
      14016  fprintf(m_File, "\n");
      +
      14016  fprintf(m_File, ",%s\n", userDataStr.GetString());
      14017  Flush();
      14018 }
      14019 
      -
      14020 void VmaRecorder::RecordSetAllocationUserData(uint32_t frameIndex,
      -
      14021  VmaAllocation allocation,
      -
      14022  const void* pUserData)
      -
      14023 {
      -
      14024  CallParams callParams;
      -
      14025  GetBasicParams(callParams);
      -
      14026 
      -
      14027  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      -
      14028  UserDataString userDataStr(
      -
      14029  allocation->IsUserDataString() ? VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT : 0,
      -
      14030  pUserData);
      -
      14031  fprintf(m_File, "%u,%.3f,%u,vmaSetAllocationUserData,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
      -
      14032  allocation,
      -
      14033  userDataStr.GetString());
      -
      14034  Flush();
      -
      14035 }
      -
      14036 
      -
      14037 void VmaRecorder::RecordCreateLostAllocation(uint32_t frameIndex,
      -
      14038  VmaAllocation allocation)
      -
      14039 {
      -
      14040  CallParams callParams;
      -
      14041  GetBasicParams(callParams);
      -
      14042 
      -
      14043  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      -
      14044  fprintf(m_File, "%u,%.3f,%u,vmaCreateLostAllocation,%p\n", callParams.threadId, callParams.time, frameIndex,
      -
      14045  allocation);
      +
      14020 void VmaRecorder::RecordAllocateMemoryForBuffer(uint32_t frameIndex,
      +
      14021  const VkMemoryRequirements& vkMemReq,
      +
      14022  bool requiresDedicatedAllocation,
      +
      14023  bool prefersDedicatedAllocation,
      +
      14024  const VmaAllocationCreateInfo& createInfo,
      +
      14025  VmaAllocation allocation)
      +
      14026 {
      +
      14027  CallParams callParams;
      +
      14028  GetBasicParams(callParams);
      +
      14029 
      +
      14030  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      +
      14031  UserDataString userDataStr(createInfo.flags, createInfo.pUserData);
      +
      14032  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,
      +
      14033  vkMemReq.size,
      +
      14034  vkMemReq.alignment,
      +
      14035  vkMemReq.memoryTypeBits,
      +
      14036  requiresDedicatedAllocation ? 1 : 0,
      +
      14037  prefersDedicatedAllocation ? 1 : 0,
      +
      14038  createInfo.flags,
      +
      14039  createInfo.usage,
      +
      14040  createInfo.requiredFlags,
      +
      14041  createInfo.preferredFlags,
      +
      14042  createInfo.memoryTypeBits,
      +
      14043  createInfo.pool,
      +
      14044  allocation,
      +
      14045  userDataStr.GetString());
      14046  Flush();
      14047 }
      14048 
      -
      14049 void VmaRecorder::RecordMapMemory(uint32_t frameIndex,
      -
      14050  VmaAllocation allocation)
      -
      14051 {
      -
      14052  CallParams callParams;
      -
      14053  GetBasicParams(callParams);
      -
      14054 
      -
      14055  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      -
      14056  fprintf(m_File, "%u,%.3f,%u,vmaMapMemory,%p\n", callParams.threadId, callParams.time, frameIndex,
      -
      14057  allocation);
      -
      14058  Flush();
      -
      14059 }
      -
      14060 
      -
      14061 void VmaRecorder::RecordUnmapMemory(uint32_t frameIndex,
      -
      14062  VmaAllocation allocation)
      -
      14063 {
      -
      14064  CallParams callParams;
      -
      14065  GetBasicParams(callParams);
      -
      14066 
      -
      14067  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      -
      14068  fprintf(m_File, "%u,%.3f,%u,vmaUnmapMemory,%p\n", callParams.threadId, callParams.time, frameIndex,
      -
      14069  allocation);
      -
      14070  Flush();
      -
      14071 }
      -
      14072 
      -
      14073 void VmaRecorder::RecordFlushAllocation(uint32_t frameIndex,
      -
      14074  VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
      -
      14075 {
      -
      14076  CallParams callParams;
      -
      14077  GetBasicParams(callParams);
      -
      14078 
      -
      14079  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      -
      14080  fprintf(m_File, "%u,%.3f,%u,vmaFlushAllocation,%p,%llu,%llu\n", callParams.threadId, callParams.time, frameIndex,
      -
      14081  allocation,
      -
      14082  offset,
      -
      14083  size);
      -
      14084  Flush();
      -
      14085 }
      -
      14086 
      -
      14087 void VmaRecorder::RecordInvalidateAllocation(uint32_t frameIndex,
      -
      14088  VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
      -
      14089 {
      -
      14090  CallParams callParams;
      -
      14091  GetBasicParams(callParams);
      -
      14092 
      -
      14093  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      -
      14094  fprintf(m_File, "%u,%.3f,%u,vmaInvalidateAllocation,%p,%llu,%llu\n", callParams.threadId, callParams.time, frameIndex,
      -
      14095  allocation,
      -
      14096  offset,
      -
      14097  size);
      -
      14098  Flush();
      -
      14099 }
      -
      14100 
      -
      14101 void VmaRecorder::RecordCreateBuffer(uint32_t frameIndex,
      -
      14102  const VkBufferCreateInfo& bufCreateInfo,
      -
      14103  const VmaAllocationCreateInfo& allocCreateInfo,
      -
      14104  VmaAllocation allocation)
      -
      14105 {
      -
      14106  CallParams callParams;
      -
      14107  GetBasicParams(callParams);
      -
      14108 
      -
      14109  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      -
      14110  UserDataString userDataStr(allocCreateInfo.flags, allocCreateInfo.pUserData);
      -
      14111  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,
      -
      14112  bufCreateInfo.flags,
      -
      14113  bufCreateInfo.size,
      -
      14114  bufCreateInfo.usage,
      -
      14115  bufCreateInfo.sharingMode,
      -
      14116  allocCreateInfo.flags,
      -
      14117  allocCreateInfo.usage,
      -
      14118  allocCreateInfo.requiredFlags,
      -
      14119  allocCreateInfo.preferredFlags,
      -
      14120  allocCreateInfo.memoryTypeBits,
      -
      14121  allocCreateInfo.pool,
      -
      14122  allocation,
      -
      14123  userDataStr.GetString());
      -
      14124  Flush();
      -
      14125 }
      +
      14049 void VmaRecorder::RecordAllocateMemoryForImage(uint32_t frameIndex,
      +
      14050  const VkMemoryRequirements& vkMemReq,
      +
      14051  bool requiresDedicatedAllocation,
      +
      14052  bool prefersDedicatedAllocation,
      +
      14053  const VmaAllocationCreateInfo& createInfo,
      +
      14054  VmaAllocation allocation)
      +
      14055 {
      +
      14056  CallParams callParams;
      +
      14057  GetBasicParams(callParams);
      +
      14058 
      +
      14059  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      +
      14060  UserDataString userDataStr(createInfo.flags, createInfo.pUserData);
      +
      14061  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,
      +
      14062  vkMemReq.size,
      +
      14063  vkMemReq.alignment,
      +
      14064  vkMemReq.memoryTypeBits,
      +
      14065  requiresDedicatedAllocation ? 1 : 0,
      +
      14066  prefersDedicatedAllocation ? 1 : 0,
      +
      14067  createInfo.flags,
      +
      14068  createInfo.usage,
      +
      14069  createInfo.requiredFlags,
      +
      14070  createInfo.preferredFlags,
      +
      14071  createInfo.memoryTypeBits,
      +
      14072  createInfo.pool,
      +
      14073  allocation,
      +
      14074  userDataStr.GetString());
      +
      14075  Flush();
      +
      14076 }
      +
      14077 
      +
      14078 void VmaRecorder::RecordFreeMemory(uint32_t frameIndex,
      +
      14079  VmaAllocation allocation)
      +
      14080 {
      +
      14081  CallParams callParams;
      +
      14082  GetBasicParams(callParams);
      +
      14083 
      +
      14084  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      +
      14085  fprintf(m_File, "%u,%.3f,%u,vmaFreeMemory,%p\n", callParams.threadId, callParams.time, frameIndex,
      +
      14086  allocation);
      +
      14087  Flush();
      +
      14088 }
      +
      14089 
      +
      14090 void VmaRecorder::RecordFreeMemoryPages(uint32_t frameIndex,
      +
      14091  uint64_t allocationCount,
      +
      14092  const VmaAllocation* pAllocations)
      +
      14093 {
      +
      14094  CallParams callParams;
      +
      14095  GetBasicParams(callParams);
      +
      14096 
      +
      14097  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      +
      14098  fprintf(m_File, "%u,%.3f,%u,vmaFreeMemoryPages,", callParams.threadId, callParams.time, frameIndex);
      +
      14099  PrintPointerList(allocationCount, pAllocations);
      +
      14100  fprintf(m_File, "\n");
      +
      14101  Flush();
      +
      14102 }
      +
      14103 
      +
      14104 void VmaRecorder::RecordSetAllocationUserData(uint32_t frameIndex,
      +
      14105  VmaAllocation allocation,
      +
      14106  const void* pUserData)
      +
      14107 {
      +
      14108  CallParams callParams;
      +
      14109  GetBasicParams(callParams);
      +
      14110 
      +
      14111  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      +
      14112  UserDataString userDataStr(
      +
      14113  allocation->IsUserDataString() ? VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT : 0,
      +
      14114  pUserData);
      +
      14115  fprintf(m_File, "%u,%.3f,%u,vmaSetAllocationUserData,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
      +
      14116  allocation,
      +
      14117  userDataStr.GetString());
      +
      14118  Flush();
      +
      14119 }
      +
      14120 
      +
      14121 void VmaRecorder::RecordCreateLostAllocation(uint32_t frameIndex,
      +
      14122  VmaAllocation allocation)
      +
      14123 {
      +
      14124  CallParams callParams;
      +
      14125  GetBasicParams(callParams);
      14126 
      -
      14127 void VmaRecorder::RecordCreateImage(uint32_t frameIndex,
      -
      14128  const VkImageCreateInfo& imageCreateInfo,
      -
      14129  const VmaAllocationCreateInfo& allocCreateInfo,
      -
      14130  VmaAllocation allocation)
      -
      14131 {
      -
      14132  CallParams callParams;
      -
      14133  GetBasicParams(callParams);
      -
      14134 
      -
      14135  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      -
      14136  UserDataString userDataStr(allocCreateInfo.flags, allocCreateInfo.pUserData);
      -
      14137  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,
      -
      14138  imageCreateInfo.flags,
      -
      14139  imageCreateInfo.imageType,
      -
      14140  imageCreateInfo.format,
      -
      14141  imageCreateInfo.extent.width,
      -
      14142  imageCreateInfo.extent.height,
      -
      14143  imageCreateInfo.extent.depth,
      -
      14144  imageCreateInfo.mipLevels,
      -
      14145  imageCreateInfo.arrayLayers,
      -
      14146  imageCreateInfo.samples,
      -
      14147  imageCreateInfo.tiling,
      -
      14148  imageCreateInfo.usage,
      -
      14149  imageCreateInfo.sharingMode,
      -
      14150  imageCreateInfo.initialLayout,
      -
      14151  allocCreateInfo.flags,
      -
      14152  allocCreateInfo.usage,
      -
      14153  allocCreateInfo.requiredFlags,
      -
      14154  allocCreateInfo.preferredFlags,
      -
      14155  allocCreateInfo.memoryTypeBits,
      -
      14156  allocCreateInfo.pool,
      -
      14157  allocation,
      -
      14158  userDataStr.GetString());
      -
      14159  Flush();
      -
      14160 }
      -
      14161 
      -
      14162 void VmaRecorder::RecordDestroyBuffer(uint32_t frameIndex,
      -
      14163  VmaAllocation allocation)
      -
      14164 {
      -
      14165  CallParams callParams;
      -
      14166  GetBasicParams(callParams);
      -
      14167 
      -
      14168  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      -
      14169  fprintf(m_File, "%u,%.3f,%u,vmaDestroyBuffer,%p\n", callParams.threadId, callParams.time, frameIndex,
      -
      14170  allocation);
      -
      14171  Flush();
      -
      14172 }
      -
      14173 
      -
      14174 void VmaRecorder::RecordDestroyImage(uint32_t frameIndex,
      -
      14175  VmaAllocation allocation)
      -
      14176 {
      -
      14177  CallParams callParams;
      -
      14178  GetBasicParams(callParams);
      -
      14179 
      -
      14180  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      -
      14181  fprintf(m_File, "%u,%.3f,%u,vmaDestroyImage,%p\n", callParams.threadId, callParams.time, frameIndex,
      -
      14182  allocation);
      -
      14183  Flush();
      -
      14184 }
      -
      14185 
      -
      14186 void VmaRecorder::RecordTouchAllocation(uint32_t frameIndex,
      -
      14187  VmaAllocation allocation)
      -
      14188 {
      -
      14189  CallParams callParams;
      -
      14190  GetBasicParams(callParams);
      -
      14191 
      -
      14192  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      -
      14193  fprintf(m_File, "%u,%.3f,%u,vmaTouchAllocation,%p\n", callParams.threadId, callParams.time, frameIndex,
      -
      14194  allocation);
      -
      14195  Flush();
      -
      14196 }
      -
      14197 
      -
      14198 void VmaRecorder::RecordGetAllocationInfo(uint32_t frameIndex,
      -
      14199  VmaAllocation allocation)
      -
      14200 {
      -
      14201  CallParams callParams;
      -
      14202  GetBasicParams(callParams);
      -
      14203 
      -
      14204  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      -
      14205  fprintf(m_File, "%u,%.3f,%u,vmaGetAllocationInfo,%p\n", callParams.threadId, callParams.time, frameIndex,
      -
      14206  allocation);
      -
      14207  Flush();
      -
      14208 }
      -
      14209 
      -
      14210 void VmaRecorder::RecordMakePoolAllocationsLost(uint32_t frameIndex,
      -
      14211  VmaPool pool)
      -
      14212 {
      -
      14213  CallParams callParams;
      -
      14214  GetBasicParams(callParams);
      -
      14215 
      -
      14216  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      -
      14217  fprintf(m_File, "%u,%.3f,%u,vmaMakePoolAllocationsLost,%p\n", callParams.threadId, callParams.time, frameIndex,
      -
      14218  pool);
      -
      14219  Flush();
      -
      14220 }
      -
      14221 
      -
      14222 void VmaRecorder::RecordDefragmentationBegin(uint32_t frameIndex,
      -
      14223  const VmaDefragmentationInfo2& info,
      -
      14224  VmaDefragmentationContext ctx)
      -
      14225 {
      -
      14226  CallParams callParams;
      -
      14227  GetBasicParams(callParams);
      -
      14228 
      -
      14229  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      -
      14230  fprintf(m_File, "%u,%.3f,%u,vmaDefragmentationBegin,%u,", callParams.threadId, callParams.time, frameIndex,
      -
      14231  info.flags);
      -
      14232  PrintPointerList(info.allocationCount, info.pAllocations);
      -
      14233  fprintf(m_File, ",");
      -
      14234  PrintPointerList(info.poolCount, info.pPools);
      -
      14235  fprintf(m_File, ",%llu,%u,%llu,%u,%p,%p\n",
      -
      14236  info.maxCpuBytesToMove,
      -
      14237  info.maxCpuAllocationsToMove,
      -
      14238  info.maxGpuBytesToMove,
      -
      14239  info.maxGpuAllocationsToMove,
      -
      14240  info.commandBuffer,
      -
      14241  ctx);
      -
      14242  Flush();
      -
      14243 }
      -
      14244 
      -
      14245 void VmaRecorder::RecordDefragmentationEnd(uint32_t frameIndex,
      -
      14246  VmaDefragmentationContext ctx)
      -
      14247 {
      -
      14248  CallParams callParams;
      -
      14249  GetBasicParams(callParams);
      -
      14250 
      -
      14251  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      -
      14252  fprintf(m_File, "%u,%.3f,%u,vmaDefragmentationEnd,%p\n", callParams.threadId, callParams.time, frameIndex,
      -
      14253  ctx);
      -
      14254  Flush();
      -
      14255 }
      -
      14256 
      -
      14257 VmaRecorder::UserDataString::UserDataString(VmaAllocationCreateFlags allocFlags, const void* pUserData)
      -
      14258 {
      -
      14259  if(pUserData != VMA_NULL)
      -
      14260  {
      -
      14261  if((allocFlags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0)
      -
      14262  {
      -
      14263  m_Str = (const char*)pUserData;
      -
      14264  }
      -
      14265  else
      -
      14266  {
      -
      14267  sprintf_s(m_PtrStr, "%p", pUserData);
      -
      14268  m_Str = m_PtrStr;
      -
      14269  }
      -
      14270  }
      -
      14271  else
      -
      14272  {
      -
      14273  m_Str = "";
      -
      14274  }
      -
      14275 }
      -
      14276 
      -
      14277 void VmaRecorder::WriteConfiguration(
      -
      14278  const VkPhysicalDeviceProperties& devProps,
      -
      14279  const VkPhysicalDeviceMemoryProperties& memProps,
      -
      14280  bool dedicatedAllocationExtensionEnabled,
      -
      14281  bool bindMemory2ExtensionEnabled)
      -
      14282 {
      -
      14283  fprintf(m_File, "Config,Begin\n");
      -
      14284 
      -
      14285  fprintf(m_File, "PhysicalDevice,apiVersion,%u\n", devProps.apiVersion);
      -
      14286  fprintf(m_File, "PhysicalDevice,driverVersion,%u\n", devProps.driverVersion);
      -
      14287  fprintf(m_File, "PhysicalDevice,vendorID,%u\n", devProps.vendorID);
      -
      14288  fprintf(m_File, "PhysicalDevice,deviceID,%u\n", devProps.deviceID);
      -
      14289  fprintf(m_File, "PhysicalDevice,deviceType,%u\n", devProps.deviceType);
      -
      14290  fprintf(m_File, "PhysicalDevice,deviceName,%s\n", devProps.deviceName);
      -
      14291 
      -
      14292  fprintf(m_File, "PhysicalDeviceLimits,maxMemoryAllocationCount,%u\n", devProps.limits.maxMemoryAllocationCount);
      -
      14293  fprintf(m_File, "PhysicalDeviceLimits,bufferImageGranularity,%llu\n", devProps.limits.bufferImageGranularity);
      -
      14294  fprintf(m_File, "PhysicalDeviceLimits,nonCoherentAtomSize,%llu\n", devProps.limits.nonCoherentAtomSize);
      -
      14295 
      -
      14296  fprintf(m_File, "PhysicalDeviceMemory,HeapCount,%u\n", memProps.memoryHeapCount);
      -
      14297  for(uint32_t i = 0; i < memProps.memoryHeapCount; ++i)
      -
      14298  {
      -
      14299  fprintf(m_File, "PhysicalDeviceMemory,Heap,%u,size,%llu\n", i, memProps.memoryHeaps[i].size);
      -
      14300  fprintf(m_File, "PhysicalDeviceMemory,Heap,%u,flags,%u\n", i, memProps.memoryHeaps[i].flags);
      -
      14301  }
      -
      14302  fprintf(m_File, "PhysicalDeviceMemory,TypeCount,%u\n", memProps.memoryTypeCount);
      -
      14303  for(uint32_t i = 0; i < memProps.memoryTypeCount; ++i)
      -
      14304  {
      -
      14305  fprintf(m_File, "PhysicalDeviceMemory,Type,%u,heapIndex,%u\n", i, memProps.memoryTypes[i].heapIndex);
      -
      14306  fprintf(m_File, "PhysicalDeviceMemory,Type,%u,propertyFlags,%u\n", i, memProps.memoryTypes[i].propertyFlags);
      -
      14307  }
      -
      14308 
      -
      14309  fprintf(m_File, "Extension,VK_KHR_dedicated_allocation,%u\n", dedicatedAllocationExtensionEnabled ? 1 : 0);
      -
      14310  fprintf(m_File, "Extension,VK_KHR_bind_memory2,%u\n", bindMemory2ExtensionEnabled ? 1 : 0);
      -
      14311 
      -
      14312  fprintf(m_File, "Macro,VMA_DEBUG_ALWAYS_DEDICATED_MEMORY,%u\n", VMA_DEBUG_ALWAYS_DEDICATED_MEMORY ? 1 : 0);
      -
      14313  fprintf(m_File, "Macro,VMA_DEBUG_ALIGNMENT,%llu\n", (VkDeviceSize)VMA_DEBUG_ALIGNMENT);
      -
      14314  fprintf(m_File, "Macro,VMA_DEBUG_MARGIN,%llu\n", (VkDeviceSize)VMA_DEBUG_MARGIN);
      -
      14315  fprintf(m_File, "Macro,VMA_DEBUG_INITIALIZE_ALLOCATIONS,%u\n", VMA_DEBUG_INITIALIZE_ALLOCATIONS ? 1 : 0);
      -
      14316  fprintf(m_File, "Macro,VMA_DEBUG_DETECT_CORRUPTION,%u\n", VMA_DEBUG_DETECT_CORRUPTION ? 1 : 0);
      -
      14317  fprintf(m_File, "Macro,VMA_DEBUG_GLOBAL_MUTEX,%u\n", VMA_DEBUG_GLOBAL_MUTEX ? 1 : 0);
      -
      14318  fprintf(m_File, "Macro,VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY,%llu\n", (VkDeviceSize)VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY);
      -
      14319  fprintf(m_File, "Macro,VMA_SMALL_HEAP_MAX_SIZE,%llu\n", (VkDeviceSize)VMA_SMALL_HEAP_MAX_SIZE);
      -
      14320  fprintf(m_File, "Macro,VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE,%llu\n", (VkDeviceSize)VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE);
      -
      14321 
      -
      14322  fprintf(m_File, "Config,End\n");
      -
      14323 }
      -
      14324 
      -
      14325 void VmaRecorder::GetBasicParams(CallParams& outParams)
      -
      14326 {
      -
      14327  outParams.threadId = GetCurrentThreadId();
      +
      14127  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      +
      14128  fprintf(m_File, "%u,%.3f,%u,vmaCreateLostAllocation,%p\n", callParams.threadId, callParams.time, frameIndex,
      +
      14129  allocation);
      +
      14130  Flush();
      +
      14131 }
      +
      14132 
      +
      14133 void VmaRecorder::RecordMapMemory(uint32_t frameIndex,
      +
      14134  VmaAllocation allocation)
      +
      14135 {
      +
      14136  CallParams callParams;
      +
      14137  GetBasicParams(callParams);
      +
      14138 
      +
      14139  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      +
      14140  fprintf(m_File, "%u,%.3f,%u,vmaMapMemory,%p\n", callParams.threadId, callParams.time, frameIndex,
      +
      14141  allocation);
      +
      14142  Flush();
      +
      14143 }
      +
      14144 
      +
      14145 void VmaRecorder::RecordUnmapMemory(uint32_t frameIndex,
      +
      14146  VmaAllocation allocation)
      +
      14147 {
      +
      14148  CallParams callParams;
      +
      14149  GetBasicParams(callParams);
      +
      14150 
      +
      14151  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      +
      14152  fprintf(m_File, "%u,%.3f,%u,vmaUnmapMemory,%p\n", callParams.threadId, callParams.time, frameIndex,
      +
      14153  allocation);
      +
      14154  Flush();
      +
      14155 }
      +
      14156 
      +
      14157 void VmaRecorder::RecordFlushAllocation(uint32_t frameIndex,
      +
      14158  VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
      +
      14159 {
      +
      14160  CallParams callParams;
      +
      14161  GetBasicParams(callParams);
      +
      14162 
      +
      14163  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      +
      14164  fprintf(m_File, "%u,%.3f,%u,vmaFlushAllocation,%p,%llu,%llu\n", callParams.threadId, callParams.time, frameIndex,
      +
      14165  allocation,
      +
      14166  offset,
      +
      14167  size);
      +
      14168  Flush();
      +
      14169 }
      +
      14170 
      +
      14171 void VmaRecorder::RecordInvalidateAllocation(uint32_t frameIndex,
      +
      14172  VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
      +
      14173 {
      +
      14174  CallParams callParams;
      +
      14175  GetBasicParams(callParams);
      +
      14176 
      +
      14177  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      +
      14178  fprintf(m_File, "%u,%.3f,%u,vmaInvalidateAllocation,%p,%llu,%llu\n", callParams.threadId, callParams.time, frameIndex,
      +
      14179  allocation,
      +
      14180  offset,
      +
      14181  size);
      +
      14182  Flush();
      +
      14183 }
      +
      14184 
      +
      14185 void VmaRecorder::RecordCreateBuffer(uint32_t frameIndex,
      +
      14186  const VkBufferCreateInfo& bufCreateInfo,
      +
      14187  const VmaAllocationCreateInfo& allocCreateInfo,
      +
      14188  VmaAllocation allocation)
      +
      14189 {
      +
      14190  CallParams callParams;
      +
      14191  GetBasicParams(callParams);
      +
      14192 
      +
      14193  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      +
      14194  UserDataString userDataStr(allocCreateInfo.flags, allocCreateInfo.pUserData);
      +
      14195  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,
      +
      14196  bufCreateInfo.flags,
      +
      14197  bufCreateInfo.size,
      +
      14198  bufCreateInfo.usage,
      +
      14199  bufCreateInfo.sharingMode,
      +
      14200  allocCreateInfo.flags,
      +
      14201  allocCreateInfo.usage,
      +
      14202  allocCreateInfo.requiredFlags,
      +
      14203  allocCreateInfo.preferredFlags,
      +
      14204  allocCreateInfo.memoryTypeBits,
      +
      14205  allocCreateInfo.pool,
      +
      14206  allocation,
      +
      14207  userDataStr.GetString());
      +
      14208  Flush();
      +
      14209 }
      +
      14210 
      +
      14211 void VmaRecorder::RecordCreateImage(uint32_t frameIndex,
      +
      14212  const VkImageCreateInfo& imageCreateInfo,
      +
      14213  const VmaAllocationCreateInfo& allocCreateInfo,
      +
      14214  VmaAllocation allocation)
      +
      14215 {
      +
      14216  CallParams callParams;
      +
      14217  GetBasicParams(callParams);
      +
      14218 
      +
      14219  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      +
      14220  UserDataString userDataStr(allocCreateInfo.flags, allocCreateInfo.pUserData);
      +
      14221  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,
      +
      14222  imageCreateInfo.flags,
      +
      14223  imageCreateInfo.imageType,
      +
      14224  imageCreateInfo.format,
      +
      14225  imageCreateInfo.extent.width,
      +
      14226  imageCreateInfo.extent.height,
      +
      14227  imageCreateInfo.extent.depth,
      +
      14228  imageCreateInfo.mipLevels,
      +
      14229  imageCreateInfo.arrayLayers,
      +
      14230  imageCreateInfo.samples,
      +
      14231  imageCreateInfo.tiling,
      +
      14232  imageCreateInfo.usage,
      +
      14233  imageCreateInfo.sharingMode,
      +
      14234  imageCreateInfo.initialLayout,
      +
      14235  allocCreateInfo.flags,
      +
      14236  allocCreateInfo.usage,
      +
      14237  allocCreateInfo.requiredFlags,
      +
      14238  allocCreateInfo.preferredFlags,
      +
      14239  allocCreateInfo.memoryTypeBits,
      +
      14240  allocCreateInfo.pool,
      +
      14241  allocation,
      +
      14242  userDataStr.GetString());
      +
      14243  Flush();
      +
      14244 }
      +
      14245 
      +
      14246 void VmaRecorder::RecordDestroyBuffer(uint32_t frameIndex,
      +
      14247  VmaAllocation allocation)
      +
      14248 {
      +
      14249  CallParams callParams;
      +
      14250  GetBasicParams(callParams);
      +
      14251 
      +
      14252  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      +
      14253  fprintf(m_File, "%u,%.3f,%u,vmaDestroyBuffer,%p\n", callParams.threadId, callParams.time, frameIndex,
      +
      14254  allocation);
      +
      14255  Flush();
      +
      14256 }
      +
      14257 
      +
      14258 void VmaRecorder::RecordDestroyImage(uint32_t frameIndex,
      +
      14259  VmaAllocation allocation)
      +
      14260 {
      +
      14261  CallParams callParams;
      +
      14262  GetBasicParams(callParams);
      +
      14263 
      +
      14264  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      +
      14265  fprintf(m_File, "%u,%.3f,%u,vmaDestroyImage,%p\n", callParams.threadId, callParams.time, frameIndex,
      +
      14266  allocation);
      +
      14267  Flush();
      +
      14268 }
      +
      14269 
      +
      14270 void VmaRecorder::RecordTouchAllocation(uint32_t frameIndex,
      +
      14271  VmaAllocation allocation)
      +
      14272 {
      +
      14273  CallParams callParams;
      +
      14274  GetBasicParams(callParams);
      +
      14275 
      +
      14276  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      +
      14277  fprintf(m_File, "%u,%.3f,%u,vmaTouchAllocation,%p\n", callParams.threadId, callParams.time, frameIndex,
      +
      14278  allocation);
      +
      14279  Flush();
      +
      14280 }
      +
      14281 
      +
      14282 void VmaRecorder::RecordGetAllocationInfo(uint32_t frameIndex,
      +
      14283  VmaAllocation allocation)
      +
      14284 {
      +
      14285  CallParams callParams;
      +
      14286  GetBasicParams(callParams);
      +
      14287 
      +
      14288  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      +
      14289  fprintf(m_File, "%u,%.3f,%u,vmaGetAllocationInfo,%p\n", callParams.threadId, callParams.time, frameIndex,
      +
      14290  allocation);
      +
      14291  Flush();
      +
      14292 }
      +
      14293 
      +
      14294 void VmaRecorder::RecordMakePoolAllocationsLost(uint32_t frameIndex,
      +
      14295  VmaPool pool)
      +
      14296 {
      +
      14297  CallParams callParams;
      +
      14298  GetBasicParams(callParams);
      +
      14299 
      +
      14300  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      +
      14301  fprintf(m_File, "%u,%.3f,%u,vmaMakePoolAllocationsLost,%p\n", callParams.threadId, callParams.time, frameIndex,
      +
      14302  pool);
      +
      14303  Flush();
      +
      14304 }
      +
      14305 
      +
      14306 void VmaRecorder::RecordDefragmentationBegin(uint32_t frameIndex,
      +
      14307  const VmaDefragmentationInfo2& info,
      +
      14308  VmaDefragmentationContext ctx)
      +
      14309 {
      +
      14310  CallParams callParams;
      +
      14311  GetBasicParams(callParams);
      +
      14312 
      +
      14313  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      +
      14314  fprintf(m_File, "%u,%.3f,%u,vmaDefragmentationBegin,%u,", callParams.threadId, callParams.time, frameIndex,
      +
      14315  info.flags);
      +
      14316  PrintPointerList(info.allocationCount, info.pAllocations);
      +
      14317  fprintf(m_File, ",");
      +
      14318  PrintPointerList(info.poolCount, info.pPools);
      +
      14319  fprintf(m_File, ",%llu,%u,%llu,%u,%p,%p\n",
      +
      14320  info.maxCpuBytesToMove,
      +
      14321  info.maxCpuAllocationsToMove,
      +
      14322  info.maxGpuBytesToMove,
      +
      14323  info.maxGpuAllocationsToMove,
      +
      14324  info.commandBuffer,
      +
      14325  ctx);
      +
      14326  Flush();
      +
      14327 }
      14328 
      -
      14329  LARGE_INTEGER counter;
      -
      14330  QueryPerformanceCounter(&counter);
      -
      14331  outParams.time = (double)(counter.QuadPart - m_StartCounter) / (double)m_Freq;
      -
      14332 }
      -
      14333 
      -
      14334 void VmaRecorder::PrintPointerList(uint64_t count, const VmaAllocation* pItems)
      -
      14335 {
      -
      14336  if(count)
      -
      14337  {
      -
      14338  fprintf(m_File, "%p", pItems[0]);
      -
      14339  for(uint64_t i = 1; i < count; ++i)
      -
      14340  {
      -
      14341  fprintf(m_File, " %p", pItems[i]);
      -
      14342  }
      -
      14343  }
      -
      14344 }
      -
      14345 
      -
      14346 void VmaRecorder::Flush()
      -
      14347 {
      -
      14348  if((m_Flags & VMA_RECORD_FLUSH_AFTER_CALL_BIT) != 0)
      -
      14349  {
      -
      14350  fflush(m_File);
      -
      14351  }
      +
      14329 void VmaRecorder::RecordDefragmentationEnd(uint32_t frameIndex,
      +
      14330  VmaDefragmentationContext ctx)
      +
      14331 {
      +
      14332  CallParams callParams;
      +
      14333  GetBasicParams(callParams);
      +
      14334 
      +
      14335  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      +
      14336  fprintf(m_File, "%u,%.3f,%u,vmaDefragmentationEnd,%p\n", callParams.threadId, callParams.time, frameIndex,
      +
      14337  ctx);
      +
      14338  Flush();
      +
      14339 }
      +
      14340 
      +
      14341 void VmaRecorder::RecordSetPoolName(uint32_t frameIndex,
      +
      14342  VmaPool pool,
      +
      14343  const char* name)
      +
      14344 {
      +
      14345  CallParams callParams;
      +
      14346  GetBasicParams(callParams);
      +
      14347 
      +
      14348  VmaMutexLock lock(m_FileMutex, m_UseMutex);
      +
      14349  fprintf(m_File, "%u,%.3f,%u,vmaSetPoolName,%p,%s\n", callParams.threadId, callParams.time, frameIndex,
      +
      14350  pool, name != VMA_NULL ? name : "");
      +
      14351  Flush();
      14352 }
      14353 
      -
      14354 #endif // #if VMA_RECORDING_ENABLED
      -
      14355 
      -
      14357 // VmaAllocationObjectAllocator
      -
      14358 
      -
      14359 VmaAllocationObjectAllocator::VmaAllocationObjectAllocator(const VkAllocationCallbacks* pAllocationCallbacks) :
      -
      14360  m_Allocator(pAllocationCallbacks, 1024)
      -
      14361 {
      -
      14362 }
      -
      14363 
      -
      14364 VmaAllocation VmaAllocationObjectAllocator::Allocate()
      -
      14365 {
      -
      14366  VmaMutexLock mutexLock(m_Mutex);
      -
      14367  return m_Allocator.Alloc();
      -
      14368 }
      -
      14369 
      -
      14370 void VmaAllocationObjectAllocator::Free(VmaAllocation hAlloc)
      -
      14371 {
      -
      14372  VmaMutexLock mutexLock(m_Mutex);
      -
      14373  m_Allocator.Free(hAlloc);
      -
      14374 }
      -
      14375 
      -
      14377 // VmaAllocator_T
      -
      14378 
      -
      14379 VmaAllocator_T::VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo) :
      -
      14380  m_UseMutex((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT) == 0),
      -
      14381  m_UseKhrDedicatedAllocation((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT) != 0),
      -
      14382  m_UseKhrBindMemory2((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT) != 0),
      -
      14383  m_UseExtMemoryBudget((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT) != 0),
      -
      14384  m_hDevice(pCreateInfo->device),
      -
      14385  m_hInstance(pCreateInfo->instance),
      -
      14386  m_AllocationCallbacksSpecified(pCreateInfo->pAllocationCallbacks != VMA_NULL),
      -
      14387  m_AllocationCallbacks(pCreateInfo->pAllocationCallbacks ?
      -
      14388  *pCreateInfo->pAllocationCallbacks : VmaEmptyAllocationCallbacks),
      -
      14389  m_AllocationObjectAllocator(&m_AllocationCallbacks),
      -
      14390  m_HeapSizeLimitMask(0),
      -
      14391  m_PreferredLargeHeapBlockSize(0),
      -
      14392  m_PhysicalDevice(pCreateInfo->physicalDevice),
      -
      14393  m_CurrentFrameIndex(0),
      -
      14394  m_GpuDefragmentationMemoryTypeBits(UINT32_MAX),
      -
      14395  m_Pools(VmaStlAllocator<VmaPool>(GetAllocationCallbacks())),
      -
      14396  m_NextPoolId(0)
      -
      14397 #if VMA_RECORDING_ENABLED
      -
      14398  ,m_pRecorder(VMA_NULL)
      -
      14399 #endif
      -
      14400 {
      -
      14401  if(VMA_DEBUG_DETECT_CORRUPTION)
      +
      14354 VmaRecorder::UserDataString::UserDataString(VmaAllocationCreateFlags allocFlags, const void* pUserData)
      +
      14355 {
      +
      14356  if(pUserData != VMA_NULL)
      +
      14357  {
      +
      14358  if((allocFlags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0)
      +
      14359  {
      +
      14360  m_Str = (const char*)pUserData;
      +
      14361  }
      +
      14362  else
      +
      14363  {
      +
      14364  sprintf_s(m_PtrStr, "%p", pUserData);
      +
      14365  m_Str = m_PtrStr;
      +
      14366  }
      +
      14367  }
      +
      14368  else
      +
      14369  {
      +
      14370  m_Str = "";
      +
      14371  }
      +
      14372 }
      +
      14373 
      +
      14374 void VmaRecorder::WriteConfiguration(
      +
      14375  const VkPhysicalDeviceProperties& devProps,
      +
      14376  const VkPhysicalDeviceMemoryProperties& memProps,
      +
      14377  bool dedicatedAllocationExtensionEnabled,
      +
      14378  bool bindMemory2ExtensionEnabled,
      +
      14379  bool memoryBudgetExtensionEnabled)
      +
      14380 {
      +
      14381  fprintf(m_File, "Config,Begin\n");
      +
      14382 
      +
      14383  fprintf(m_File, "PhysicalDevice,apiVersion,%u\n", devProps.apiVersion);
      +
      14384  fprintf(m_File, "PhysicalDevice,driverVersion,%u\n", devProps.driverVersion);
      +
      14385  fprintf(m_File, "PhysicalDevice,vendorID,%u\n", devProps.vendorID);
      +
      14386  fprintf(m_File, "PhysicalDevice,deviceID,%u\n", devProps.deviceID);
      +
      14387  fprintf(m_File, "PhysicalDevice,deviceType,%u\n", devProps.deviceType);
      +
      14388  fprintf(m_File, "PhysicalDevice,deviceName,%s\n", devProps.deviceName);
      +
      14389 
      +
      14390  fprintf(m_File, "PhysicalDeviceLimits,maxMemoryAllocationCount,%u\n", devProps.limits.maxMemoryAllocationCount);
      +
      14391  fprintf(m_File, "PhysicalDeviceLimits,bufferImageGranularity,%llu\n", devProps.limits.bufferImageGranularity);
      +
      14392  fprintf(m_File, "PhysicalDeviceLimits,nonCoherentAtomSize,%llu\n", devProps.limits.nonCoherentAtomSize);
      +
      14393 
      +
      14394  fprintf(m_File, "PhysicalDeviceMemory,HeapCount,%u\n", memProps.memoryHeapCount);
      +
      14395  for(uint32_t i = 0; i < memProps.memoryHeapCount; ++i)
      +
      14396  {
      +
      14397  fprintf(m_File, "PhysicalDeviceMemory,Heap,%u,size,%llu\n", i, memProps.memoryHeaps[i].size);
      +
      14398  fprintf(m_File, "PhysicalDeviceMemory,Heap,%u,flags,%u\n", i, memProps.memoryHeaps[i].flags);
      +
      14399  }
      +
      14400  fprintf(m_File, "PhysicalDeviceMemory,TypeCount,%u\n", memProps.memoryTypeCount);
      +
      14401  for(uint32_t i = 0; i < memProps.memoryTypeCount; ++i)
      14402  {
      -
      14403  // Needs to be multiply of uint32_t size because we are going to write VMA_CORRUPTION_DETECTION_MAGIC_VALUE to it.
      -
      14404  VMA_ASSERT(VMA_DEBUG_MARGIN % sizeof(uint32_t) == 0);
      +
      14403  fprintf(m_File, "PhysicalDeviceMemory,Type,%u,heapIndex,%u\n", i, memProps.memoryTypes[i].heapIndex);
      +
      14404  fprintf(m_File, "PhysicalDeviceMemory,Type,%u,propertyFlags,%u\n", i, memProps.memoryTypes[i].propertyFlags);
      14405  }
      14406 
      -
      14407  VMA_ASSERT(pCreateInfo->physicalDevice && pCreateInfo->device);
      -
      14408 
      -
      14409 #if !(VMA_DEDICATED_ALLOCATION)
      -
      14410  if((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT) != 0)
      -
      14411  {
      -
      14412  VMA_ASSERT(0 && "VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT set but required extensions are disabled by preprocessor macros.");
      -
      14413  }
      -
      14414 #endif
      -
      14415 #if !(VMA_BIND_MEMORY2)
      -
      14416  if((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT) != 0)
      -
      14417  {
      -
      14418  VMA_ASSERT(0 && "VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT set but required extension is disabled by preprocessor macros.");
      -
      14419  }
      -
      14420 #endif
      -
      14421 #if !(VMA_MEMORY_BUDGET)
      -
      14422  if((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT) != 0)
      -
      14423  {
      -
      14424  VMA_ASSERT(0 && "VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT set but required extension is disabled by preprocessor macros.");
      -
      14425  }
      -
      14426 #endif
      +
      14407  fprintf(m_File, "Extension,VK_KHR_dedicated_allocation,%u\n", dedicatedAllocationExtensionEnabled ? 1 : 0);
      +
      14408  fprintf(m_File, "Extension,VK_KHR_bind_memory2,%u\n", bindMemory2ExtensionEnabled ? 1 : 0);
      +
      14409  fprintf(m_File, "Extension,VK_EXT_memory_budget,%u\n", memoryBudgetExtensionEnabled ? 1 : 0);
      +
      14410 
      +
      14411  fprintf(m_File, "Macro,VMA_DEBUG_ALWAYS_DEDICATED_MEMORY,%u\n", VMA_DEBUG_ALWAYS_DEDICATED_MEMORY ? 1 : 0);
      +
      14412  fprintf(m_File, "Macro,VMA_DEBUG_ALIGNMENT,%llu\n", (VkDeviceSize)VMA_DEBUG_ALIGNMENT);
      +
      14413  fprintf(m_File, "Macro,VMA_DEBUG_MARGIN,%llu\n", (VkDeviceSize)VMA_DEBUG_MARGIN);
      +
      14414  fprintf(m_File, "Macro,VMA_DEBUG_INITIALIZE_ALLOCATIONS,%u\n", VMA_DEBUG_INITIALIZE_ALLOCATIONS ? 1 : 0);
      +
      14415  fprintf(m_File, "Macro,VMA_DEBUG_DETECT_CORRUPTION,%u\n", VMA_DEBUG_DETECT_CORRUPTION ? 1 : 0);
      +
      14416  fprintf(m_File, "Macro,VMA_DEBUG_GLOBAL_MUTEX,%u\n", VMA_DEBUG_GLOBAL_MUTEX ? 1 : 0);
      +
      14417  fprintf(m_File, "Macro,VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY,%llu\n", (VkDeviceSize)VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY);
      +
      14418  fprintf(m_File, "Macro,VMA_SMALL_HEAP_MAX_SIZE,%llu\n", (VkDeviceSize)VMA_SMALL_HEAP_MAX_SIZE);
      +
      14419  fprintf(m_File, "Macro,VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE,%llu\n", (VkDeviceSize)VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE);
      +
      14420 
      +
      14421  fprintf(m_File, "Config,End\n");
      +
      14422 }
      +
      14423 
      +
      14424 void VmaRecorder::GetBasicParams(CallParams& outParams)
      +
      14425 {
      +
      14426  outParams.threadId = GetCurrentThreadId();
      14427 
      -
      14428  memset(&m_DeviceMemoryCallbacks, 0 ,sizeof(m_DeviceMemoryCallbacks));
      -
      14429  memset(&m_PhysicalDeviceProperties, 0, sizeof(m_PhysicalDeviceProperties));
      -
      14430  memset(&m_MemProps, 0, sizeof(m_MemProps));
      -
      14431 
      -
      14432  memset(&m_pBlockVectors, 0, sizeof(m_pBlockVectors));
      -
      14433  memset(&m_pDedicatedAllocations, 0, sizeof(m_pDedicatedAllocations));
      -
      14434  memset(&m_VulkanFunctions, 0, sizeof(m_VulkanFunctions));
      -
      14435 
      -
      14436  if(pCreateInfo->pDeviceMemoryCallbacks != VMA_NULL)
      -
      14437  {
      -
      14438  m_DeviceMemoryCallbacks.pfnAllocate = pCreateInfo->pDeviceMemoryCallbacks->pfnAllocate;
      -
      14439  m_DeviceMemoryCallbacks.pfnFree = pCreateInfo->pDeviceMemoryCallbacks->pfnFree;
      -
      14440  }
      -
      14441 
      -
      14442  ImportVulkanFunctions(pCreateInfo->pVulkanFunctions);
      -
      14443 
      -
      14444  (*m_VulkanFunctions.vkGetPhysicalDeviceProperties)(m_PhysicalDevice, &m_PhysicalDeviceProperties);
      -
      14445  (*m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties)(m_PhysicalDevice, &m_MemProps);
      -
      14446 
      -
      14447  VMA_ASSERT(VmaIsPow2(VMA_DEBUG_ALIGNMENT));
      -
      14448  VMA_ASSERT(VmaIsPow2(VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY));
      -
      14449  VMA_ASSERT(VmaIsPow2(m_PhysicalDeviceProperties.limits.bufferImageGranularity));
      -
      14450  VMA_ASSERT(VmaIsPow2(m_PhysicalDeviceProperties.limits.nonCoherentAtomSize));
      -
      14451 
      -
      14452  m_PreferredLargeHeapBlockSize = (pCreateInfo->preferredLargeHeapBlockSize != 0) ?
      -
      14453  pCreateInfo->preferredLargeHeapBlockSize : static_cast<VkDeviceSize>(VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE);
      +
      14428  LARGE_INTEGER counter;
      +
      14429  QueryPerformanceCounter(&counter);
      +
      14430  outParams.time = (double)(counter.QuadPart - m_StartCounter) / (double)m_Freq;
      +
      14431 }
      +
      14432 
      +
      14433 void VmaRecorder::PrintPointerList(uint64_t count, const VmaAllocation* pItems)
      +
      14434 {
      +
      14435  if(count)
      +
      14436  {
      +
      14437  fprintf(m_File, "%p", pItems[0]);
      +
      14438  for(uint64_t i = 1; i < count; ++i)
      +
      14439  {
      +
      14440  fprintf(m_File, " %p", pItems[i]);
      +
      14441  }
      +
      14442  }
      +
      14443 }
      +
      14444 
      +
      14445 void VmaRecorder::Flush()
      +
      14446 {
      +
      14447  if((m_Flags & VMA_RECORD_FLUSH_AFTER_CALL_BIT) != 0)
      +
      14448  {
      +
      14449  fflush(m_File);
      +
      14450  }
      +
      14451 }
      +
      14452 
      +
      14453 #endif // #if VMA_RECORDING_ENABLED
      14454 
      -
      14455  if(pCreateInfo->pHeapSizeLimit != VMA_NULL)
      -
      14456  {
      -
      14457  for(uint32_t heapIndex = 0; heapIndex < GetMemoryHeapCount(); ++heapIndex)
      -
      14458  {
      -
      14459  const VkDeviceSize limit = pCreateInfo->pHeapSizeLimit[heapIndex];
      -
      14460  if(limit != VK_WHOLE_SIZE)
      -
      14461  {
      -
      14462  m_HeapSizeLimitMask |= 1u << heapIndex;
      -
      14463  if(limit < m_MemProps.memoryHeaps[heapIndex].size)
      -
      14464  {
      -
      14465  m_MemProps.memoryHeaps[heapIndex].size = limit;
      -
      14466  }
      -
      14467  }
      -
      14468  }
      -
      14469  }
      -
      14470 
      -
      14471  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
      -
      14472  {
      -
      14473  const VkDeviceSize preferredBlockSize = CalcPreferredBlockSize(memTypeIndex);
      +
      14456 // VmaAllocationObjectAllocator
      +
      14457 
      +
      14458 VmaAllocationObjectAllocator::VmaAllocationObjectAllocator(const VkAllocationCallbacks* pAllocationCallbacks) :
      +
      14459  m_Allocator(pAllocationCallbacks, 1024)
      +
      14460 {
      +
      14461 }
      +
      14462 
      +
      14463 VmaAllocation VmaAllocationObjectAllocator::Allocate()
      +
      14464 {
      +
      14465  VmaMutexLock mutexLock(m_Mutex);
      +
      14466  return m_Allocator.Alloc();
      +
      14467 }
      +
      14468 
      +
      14469 void VmaAllocationObjectAllocator::Free(VmaAllocation hAlloc)
      +
      14470 {
      +
      14471  VmaMutexLock mutexLock(m_Mutex);
      +
      14472  m_Allocator.Free(hAlloc);
      +
      14473 }
      14474 
      -
      14475  m_pBlockVectors[memTypeIndex] = vma_new(this, VmaBlockVector)(
      -
      14476  this,
      -
      14477  VK_NULL_HANDLE, // hParentPool
      -
      14478  memTypeIndex,
      -
      14479  preferredBlockSize,
      -
      14480  0,
      -
      14481  SIZE_MAX,
      -
      14482  GetBufferImageGranularity(),
      -
      14483  pCreateInfo->frameInUseCount,
      -
      14484  false, // isCustomPool
      -
      14485  false, // explicitBlockSize
      -
      14486  false); // linearAlgorithm
      -
      14487  // No need to call m_pBlockVectors[memTypeIndex][blockVectorTypeIndex]->CreateMinBlocks here,
      -
      14488  // becase minBlockCount is 0.
      -
      14489  m_pDedicatedAllocations[memTypeIndex] = vma_new(this, AllocationVectorType)(VmaStlAllocator<VmaAllocation>(GetAllocationCallbacks()));
      -
      14490 
      -
      14491  }
      -
      14492 }
      -
      14493 
      -
      14494 VkResult VmaAllocator_T::Init(const VmaAllocatorCreateInfo* pCreateInfo)
      -
      14495 {
      -
      14496  VkResult res = VK_SUCCESS;
      -
      14497 
      -
      14498  if(pCreateInfo->pRecordSettings != VMA_NULL &&
      -
      14499  !VmaStrIsEmpty(pCreateInfo->pRecordSettings->pFilePath))
      -
      14500  {
      -
      14501 #if VMA_RECORDING_ENABLED
      -
      14502  m_pRecorder = vma_new(this, VmaRecorder)();
      -
      14503  res = m_pRecorder->Init(*pCreateInfo->pRecordSettings, m_UseMutex);
      -
      14504  if(res != VK_SUCCESS)
      -
      14505  {
      -
      14506  return res;
      -
      14507  }
      -
      14508  m_pRecorder->WriteConfiguration(
      -
      14509  m_PhysicalDeviceProperties,
      -
      14510  m_MemProps,
      -
      14511  m_UseKhrDedicatedAllocation,
      -
      14512  m_UseKhrBindMemory2);
      -
      14513  m_pRecorder->RecordCreateAllocator(GetCurrentFrameIndex());
      -
      14514 #else
      -
      14515  VMA_ASSERT(0 && "VmaAllocatorCreateInfo::pRecordSettings used, but not supported due to VMA_RECORDING_ENABLED not defined to 1.");
      -
      14516  return VK_ERROR_FEATURE_NOT_PRESENT;
      -
      14517 #endif
      +
      14476 // VmaAllocator_T
      +
      14477 
      +
      14478 VmaAllocator_T::VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo) :
      +
      14479  m_UseMutex((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_EXTERNALLY_SYNCHRONIZED_BIT) == 0),
      +
      14480  m_UseKhrDedicatedAllocation((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT) != 0),
      +
      14481  m_UseKhrBindMemory2((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT) != 0),
      +
      14482  m_UseExtMemoryBudget((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT) != 0),
      +
      14483  m_hDevice(pCreateInfo->device),
      +
      14484  m_hInstance(pCreateInfo->instance),
      +
      14485  m_AllocationCallbacksSpecified(pCreateInfo->pAllocationCallbacks != VMA_NULL),
      +
      14486  m_AllocationCallbacks(pCreateInfo->pAllocationCallbacks ?
      +
      14487  *pCreateInfo->pAllocationCallbacks : VmaEmptyAllocationCallbacks),
      +
      14488  m_AllocationObjectAllocator(&m_AllocationCallbacks),
      +
      14489  m_HeapSizeLimitMask(0),
      +
      14490  m_PreferredLargeHeapBlockSize(0),
      +
      14491  m_PhysicalDevice(pCreateInfo->physicalDevice),
      +
      14492  m_CurrentFrameIndex(0),
      +
      14493  m_GpuDefragmentationMemoryTypeBits(UINT32_MAX),
      +
      14494  m_Pools(VmaStlAllocator<VmaPool>(GetAllocationCallbacks())),
      +
      14495  m_NextPoolId(0)
      +
      14496 #if VMA_RECORDING_ENABLED
      +
      14497  ,m_pRecorder(VMA_NULL)
      +
      14498 #endif
      +
      14499 {
      +
      14500  if(VMA_DEBUG_DETECT_CORRUPTION)
      +
      14501  {
      +
      14502  // Needs to be multiply of uint32_t size because we are going to write VMA_CORRUPTION_DETECTION_MAGIC_VALUE to it.
      +
      14503  VMA_ASSERT(VMA_DEBUG_MARGIN % sizeof(uint32_t) == 0);
      +
      14504  }
      +
      14505 
      +
      14506  VMA_ASSERT(pCreateInfo->physicalDevice && pCreateInfo->device);
      +
      14507 
      +
      14508 #if !(VMA_DEDICATED_ALLOCATION)
      +
      14509  if((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT) != 0)
      +
      14510  {
      +
      14511  VMA_ASSERT(0 && "VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT set but required extensions are disabled by preprocessor macros.");
      +
      14512  }
      +
      14513 #endif
      +
      14514 #if !(VMA_BIND_MEMORY2)
      +
      14515  if((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT) != 0)
      +
      14516  {
      +
      14517  VMA_ASSERT(0 && "VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT set but required extension is disabled by preprocessor macros.");
      14518  }
      -
      14519 
      -
      14520 #if VMA_MEMORY_BUDGET
      -
      14521  if(m_UseExtMemoryBudget)
      +
      14519 #endif
      +
      14520 #if !(VMA_MEMORY_BUDGET)
      +
      14521  if((pCreateInfo->flags & VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT) != 0)
      14522  {
      -
      14523  UpdateVulkanBudget();
      +
      14523  VMA_ASSERT(0 && "VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT set but required extension is disabled by preprocessor macros.");
      14524  }
      -
      14525 #endif // #if VMA_MEMORY_BUDGET
      +
      14525 #endif
      14526 
      -
      14527  return res;
      -
      14528 }
      -
      14529 
      -
      14530 VmaAllocator_T::~VmaAllocator_T()
      -
      14531 {
      -
      14532 #if VMA_RECORDING_ENABLED
      -
      14533  if(m_pRecorder != VMA_NULL)
      -
      14534  {
      -
      14535  m_pRecorder->RecordDestroyAllocator(GetCurrentFrameIndex());
      -
      14536  vma_delete(this, m_pRecorder);
      -
      14537  }
      -
      14538 #endif
      -
      14539 
      -
      14540  VMA_ASSERT(m_Pools.empty());
      -
      14541 
      -
      14542  for(size_t i = GetMemoryTypeCount(); i--; )
      -
      14543  {
      -
      14544  if(m_pDedicatedAllocations[i] != VMA_NULL && !m_pDedicatedAllocations[i]->empty())
      -
      14545  {
      -
      14546  VMA_ASSERT(0 && "Unfreed dedicated allocations found.");
      -
      14547  }
      -
      14548 
      -
      14549  vma_delete(this, m_pDedicatedAllocations[i]);
      -
      14550  vma_delete(this, m_pBlockVectors[i]);
      -
      14551  }
      -
      14552 }
      +
      14527  memset(&m_DeviceMemoryCallbacks, 0 ,sizeof(m_DeviceMemoryCallbacks));
      +
      14528  memset(&m_PhysicalDeviceProperties, 0, sizeof(m_PhysicalDeviceProperties));
      +
      14529  memset(&m_MemProps, 0, sizeof(m_MemProps));
      +
      14530 
      +
      14531  memset(&m_pBlockVectors, 0, sizeof(m_pBlockVectors));
      +
      14532  memset(&m_pDedicatedAllocations, 0, sizeof(m_pDedicatedAllocations));
      +
      14533  memset(&m_VulkanFunctions, 0, sizeof(m_VulkanFunctions));
      +
      14534 
      +
      14535  if(pCreateInfo->pDeviceMemoryCallbacks != VMA_NULL)
      +
      14536  {
      +
      14537  m_DeviceMemoryCallbacks.pfnAllocate = pCreateInfo->pDeviceMemoryCallbacks->pfnAllocate;
      +
      14538  m_DeviceMemoryCallbacks.pfnFree = pCreateInfo->pDeviceMemoryCallbacks->pfnFree;
      +
      14539  }
      +
      14540 
      +
      14541  ImportVulkanFunctions(pCreateInfo->pVulkanFunctions);
      +
      14542 
      +
      14543  (*m_VulkanFunctions.vkGetPhysicalDeviceProperties)(m_PhysicalDevice, &m_PhysicalDeviceProperties);
      +
      14544  (*m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties)(m_PhysicalDevice, &m_MemProps);
      +
      14545 
      +
      14546  VMA_ASSERT(VmaIsPow2(VMA_DEBUG_ALIGNMENT));
      +
      14547  VMA_ASSERT(VmaIsPow2(VMA_DEBUG_MIN_BUFFER_IMAGE_GRANULARITY));
      +
      14548  VMA_ASSERT(VmaIsPow2(m_PhysicalDeviceProperties.limits.bufferImageGranularity));
      +
      14549  VMA_ASSERT(VmaIsPow2(m_PhysicalDeviceProperties.limits.nonCoherentAtomSize));
      +
      14550 
      +
      14551  m_PreferredLargeHeapBlockSize = (pCreateInfo->preferredLargeHeapBlockSize != 0) ?
      +
      14552  pCreateInfo->preferredLargeHeapBlockSize : static_cast<VkDeviceSize>(VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE);
      14553 
      -
      14554 void VmaAllocator_T::ImportVulkanFunctions(const VmaVulkanFunctions* pVulkanFunctions)
      -
      14555 {
      -
      14556 #if VMA_STATIC_VULKAN_FUNCTIONS == 1
      -
      14557  m_VulkanFunctions.vkGetPhysicalDeviceProperties = (PFN_vkGetPhysicalDeviceProperties)vkGetPhysicalDeviceProperties;
      -
      14558  m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties = (PFN_vkGetPhysicalDeviceMemoryProperties)vkGetPhysicalDeviceMemoryProperties;
      -
      14559  m_VulkanFunctions.vkAllocateMemory = (PFN_vkAllocateMemory)vkAllocateMemory;
      -
      14560  m_VulkanFunctions.vkFreeMemory = (PFN_vkFreeMemory)vkFreeMemory;
      -
      14561  m_VulkanFunctions.vkMapMemory = (PFN_vkMapMemory)vkMapMemory;
      -
      14562  m_VulkanFunctions.vkUnmapMemory = (PFN_vkUnmapMemory)vkUnmapMemory;
      -
      14563  m_VulkanFunctions.vkFlushMappedMemoryRanges = (PFN_vkFlushMappedMemoryRanges)vkFlushMappedMemoryRanges;
      -
      14564  m_VulkanFunctions.vkInvalidateMappedMemoryRanges = (PFN_vkInvalidateMappedMemoryRanges)vkInvalidateMappedMemoryRanges;
      -
      14565  m_VulkanFunctions.vkBindBufferMemory = (PFN_vkBindBufferMemory)vkBindBufferMemory;
      -
      14566  m_VulkanFunctions.vkBindImageMemory = (PFN_vkBindImageMemory)vkBindImageMemory;
      -
      14567  m_VulkanFunctions.vkGetBufferMemoryRequirements = (PFN_vkGetBufferMemoryRequirements)vkGetBufferMemoryRequirements;
      -
      14568  m_VulkanFunctions.vkGetImageMemoryRequirements = (PFN_vkGetImageMemoryRequirements)vkGetImageMemoryRequirements;
      -
      14569  m_VulkanFunctions.vkCreateBuffer = (PFN_vkCreateBuffer)vkCreateBuffer;
      -
      14570  m_VulkanFunctions.vkDestroyBuffer = (PFN_vkDestroyBuffer)vkDestroyBuffer;
      -
      14571  m_VulkanFunctions.vkCreateImage = (PFN_vkCreateImage)vkCreateImage;
      -
      14572  m_VulkanFunctions.vkDestroyImage = (PFN_vkDestroyImage)vkDestroyImage;
      -
      14573  m_VulkanFunctions.vkCmdCopyBuffer = (PFN_vkCmdCopyBuffer)vkCmdCopyBuffer;
      -
      14574 #if VMA_DEDICATED_ALLOCATION
      -
      14575  if(m_UseKhrDedicatedAllocation)
      -
      14576  {
      -
      14577  m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR =
      -
      14578  (PFN_vkGetBufferMemoryRequirements2KHR)vkGetDeviceProcAddr(m_hDevice, "vkGetBufferMemoryRequirements2KHR");
      -
      14579  m_VulkanFunctions.vkGetImageMemoryRequirements2KHR =
      -
      14580  (PFN_vkGetImageMemoryRequirements2KHR)vkGetDeviceProcAddr(m_hDevice, "vkGetImageMemoryRequirements2KHR");
      -
      14581  }
      -
      14582 #endif // #if VMA_DEDICATED_ALLOCATION
      -
      14583 #if VMA_BIND_MEMORY2
      -
      14584  if(m_UseKhrBindMemory2)
      -
      14585  {
      -
      14586  m_VulkanFunctions.vkBindBufferMemory2KHR =
      -
      14587  (PFN_vkBindBufferMemory2KHR)vkGetDeviceProcAddr(m_hDevice, "vkBindBufferMemory2KHR");
      -
      14588  m_VulkanFunctions.vkBindImageMemory2KHR =
      -
      14589  (PFN_vkBindImageMemory2KHR)vkGetDeviceProcAddr(m_hDevice, "vkBindImageMemory2KHR");
      -
      14590  }
      -
      14591 #endif // #if VMA_BIND_MEMORY2
      -
      14592 #if VMA_MEMORY_BUDGET
      -
      14593  if(m_UseExtMemoryBudget)
      -
      14594  {
      -
      14595  VMA_ASSERT(m_hInstance != VK_NULL_HANDLE);
      -
      14596  m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties2KHR =
      -
      14597  (PFN_vkGetPhysicalDeviceMemoryProperties2KHR)vkGetInstanceProcAddr(m_hInstance, "vkGetPhysicalDeviceMemoryProperties2KHR");
      -
      14598  }
      -
      14599 #endif // #if VMA_MEMORY_BUDGET
      -
      14600 #endif // #if VMA_STATIC_VULKAN_FUNCTIONS == 1
      -
      14601 
      -
      14602 #define VMA_COPY_IF_NOT_NULL(funcName) \
      -
      14603  if(pVulkanFunctions->funcName != VMA_NULL) m_VulkanFunctions.funcName = pVulkanFunctions->funcName;
      -
      14604 
      -
      14605  if(pVulkanFunctions != VMA_NULL)
      -
      14606  {
      -
      14607  VMA_COPY_IF_NOT_NULL(vkGetPhysicalDeviceProperties);
      -
      14608  VMA_COPY_IF_NOT_NULL(vkGetPhysicalDeviceMemoryProperties);
      -
      14609  VMA_COPY_IF_NOT_NULL(vkAllocateMemory);
      -
      14610  VMA_COPY_IF_NOT_NULL(vkFreeMemory);
      -
      14611  VMA_COPY_IF_NOT_NULL(vkMapMemory);
      -
      14612  VMA_COPY_IF_NOT_NULL(vkUnmapMemory);
      -
      14613  VMA_COPY_IF_NOT_NULL(vkFlushMappedMemoryRanges);
      -
      14614  VMA_COPY_IF_NOT_NULL(vkInvalidateMappedMemoryRanges);
      -
      14615  VMA_COPY_IF_NOT_NULL(vkBindBufferMemory);
      -
      14616  VMA_COPY_IF_NOT_NULL(vkBindImageMemory);
      -
      14617  VMA_COPY_IF_NOT_NULL(vkGetBufferMemoryRequirements);
      -
      14618  VMA_COPY_IF_NOT_NULL(vkGetImageMemoryRequirements);
      -
      14619  VMA_COPY_IF_NOT_NULL(vkCreateBuffer);
      -
      14620  VMA_COPY_IF_NOT_NULL(vkDestroyBuffer);
      -
      14621  VMA_COPY_IF_NOT_NULL(vkCreateImage);
      -
      14622  VMA_COPY_IF_NOT_NULL(vkDestroyImage);
      -
      14623  VMA_COPY_IF_NOT_NULL(vkCmdCopyBuffer);
      -
      14624 #if VMA_DEDICATED_ALLOCATION
      -
      14625  VMA_COPY_IF_NOT_NULL(vkGetBufferMemoryRequirements2KHR);
      -
      14626  VMA_COPY_IF_NOT_NULL(vkGetImageMemoryRequirements2KHR);
      -
      14627 #endif
      -
      14628 #if VMA_BIND_MEMORY2
      -
      14629  VMA_COPY_IF_NOT_NULL(vkBindBufferMemory2KHR);
      -
      14630  VMA_COPY_IF_NOT_NULL(vkBindImageMemory2KHR);
      -
      14631 #endif
      -
      14632 #if VMA_MEMORY_BUDGET
      -
      14633  VMA_COPY_IF_NOT_NULL(vkGetPhysicalDeviceMemoryProperties2KHR);
      -
      14634 #endif
      -
      14635  }
      -
      14636 
      -
      14637 #undef VMA_COPY_IF_NOT_NULL
      -
      14638 
      -
      14639  // If these asserts are hit, you must either #define VMA_STATIC_VULKAN_FUNCTIONS 1
      -
      14640  // or pass valid pointers as VmaAllocatorCreateInfo::pVulkanFunctions.
      -
      14641  VMA_ASSERT(m_VulkanFunctions.vkGetPhysicalDeviceProperties != VMA_NULL);
      -
      14642  VMA_ASSERT(m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties != VMA_NULL);
      -
      14643  VMA_ASSERT(m_VulkanFunctions.vkAllocateMemory != VMA_NULL);
      -
      14644  VMA_ASSERT(m_VulkanFunctions.vkFreeMemory != VMA_NULL);
      -
      14645  VMA_ASSERT(m_VulkanFunctions.vkMapMemory != VMA_NULL);
      -
      14646  VMA_ASSERT(m_VulkanFunctions.vkUnmapMemory != VMA_NULL);
      -
      14647  VMA_ASSERT(m_VulkanFunctions.vkFlushMappedMemoryRanges != VMA_NULL);
      -
      14648  VMA_ASSERT(m_VulkanFunctions.vkInvalidateMappedMemoryRanges != VMA_NULL);
      -
      14649  VMA_ASSERT(m_VulkanFunctions.vkBindBufferMemory != VMA_NULL);
      -
      14650  VMA_ASSERT(m_VulkanFunctions.vkBindImageMemory != VMA_NULL);
      -
      14651  VMA_ASSERT(m_VulkanFunctions.vkGetBufferMemoryRequirements != VMA_NULL);
      -
      14652  VMA_ASSERT(m_VulkanFunctions.vkGetImageMemoryRequirements != VMA_NULL);
      -
      14653  VMA_ASSERT(m_VulkanFunctions.vkCreateBuffer != VMA_NULL);
      -
      14654  VMA_ASSERT(m_VulkanFunctions.vkDestroyBuffer != VMA_NULL);
      -
      14655  VMA_ASSERT(m_VulkanFunctions.vkCreateImage != VMA_NULL);
      -
      14656  VMA_ASSERT(m_VulkanFunctions.vkDestroyImage != VMA_NULL);
      -
      14657  VMA_ASSERT(m_VulkanFunctions.vkCmdCopyBuffer != VMA_NULL);
      -
      14658 #if VMA_DEDICATED_ALLOCATION
      -
      14659  if(m_UseKhrDedicatedAllocation)
      -
      14660  {
      -
      14661  VMA_ASSERT(m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR != VMA_NULL);
      -
      14662  VMA_ASSERT(m_VulkanFunctions.vkGetImageMemoryRequirements2KHR != VMA_NULL);
      -
      14663  }
      -
      14664 #endif
      -
      14665 #if VMA_BIND_MEMORY2
      -
      14666  if(m_UseKhrBindMemory2)
      -
      14667  {
      -
      14668  VMA_ASSERT(m_VulkanFunctions.vkBindBufferMemory2KHR != VMA_NULL);
      -
      14669  VMA_ASSERT(m_VulkanFunctions.vkBindImageMemory2KHR != VMA_NULL);
      -
      14670  }
      -
      14671 #endif
      -
      14672 #if VMA_MEMORY_BUDGET
      -
      14673  if(m_UseExtMemoryBudget)
      -
      14674  {
      -
      14675  VMA_ASSERT(m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties2KHR != VMA_NULL);
      -
      14676  }
      -
      14677 #endif
      -
      14678 }
      -
      14679 
      -
      14680 VkDeviceSize VmaAllocator_T::CalcPreferredBlockSize(uint32_t memTypeIndex)
      -
      14681 {
      -
      14682  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
      -
      14683  const VkDeviceSize heapSize = m_MemProps.memoryHeaps[heapIndex].size;
      -
      14684  const bool isSmallHeap = heapSize <= VMA_SMALL_HEAP_MAX_SIZE;
      -
      14685  return VmaAlignUp(isSmallHeap ? (heapSize / 8) : m_PreferredLargeHeapBlockSize, (VkDeviceSize)32);
      -
      14686 }
      -
      14687 
      -
      14688 VkResult VmaAllocator_T::AllocateMemoryOfType(
      -
      14689  VkDeviceSize size,
      -
      14690  VkDeviceSize alignment,
      -
      14691  bool dedicatedAllocation,
      -
      14692  VkBuffer dedicatedBuffer,
      -
      14693  VkImage dedicatedImage,
      -
      14694  const VmaAllocationCreateInfo& createInfo,
      -
      14695  uint32_t memTypeIndex,
      -
      14696  VmaSuballocationType suballocType,
      -
      14697  size_t allocationCount,
      -
      14698  VmaAllocation* pAllocations)
      -
      14699 {
      -
      14700  VMA_ASSERT(pAllocations != VMA_NULL);
      -
      14701  VMA_DEBUG_LOG(" AllocateMemory: MemoryTypeIndex=%u, AllocationCount=%zu, Size=%llu", memTypeIndex, allocationCount, size);
      -
      14702 
      -
      14703  VmaAllocationCreateInfo finalCreateInfo = createInfo;
      -
      14704 
      -
      14705  // If memory type is not HOST_VISIBLE, disable MAPPED.
      -
      14706  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0 &&
      -
      14707  (m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
      -
      14708  {
      -
      14709  finalCreateInfo.flags &= ~VMA_ALLOCATION_CREATE_MAPPED_BIT;
      -
      14710  }
      -
      14711 
      -
      14712  VmaBlockVector* const blockVector = m_pBlockVectors[memTypeIndex];
      -
      14713  VMA_ASSERT(blockVector);
      -
      14714 
      -
      14715  const VkDeviceSize preferredBlockSize = blockVector->GetPreferredBlockSize();
      -
      14716  bool preferDedicatedMemory =
      -
      14717  VMA_DEBUG_ALWAYS_DEDICATED_MEMORY ||
      -
      14718  dedicatedAllocation ||
      -
      14719  // Heuristics: Allocate dedicated memory if requested size if greater than half of preferred block size.
      -
      14720  size > preferredBlockSize / 2;
      -
      14721 
      -
      14722  if(preferDedicatedMemory &&
      -
      14723  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0 &&
      -
      14724  finalCreateInfo.pool == VK_NULL_HANDLE)
      -
      14725  {
      -
      14726  finalCreateInfo.flags |= VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;
      -
      14727  }
      -
      14728 
      -
      14729  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT) != 0)
      -
      14730  {
      -
      14731  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
      -
      14732  {
      -
      14733  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      -
      14734  }
      -
      14735  else
      -
      14736  {
      -
      14737  return AllocateDedicatedMemory(
      -
      14738  size,
      -
      14739  suballocType,
      -
      14740  memTypeIndex,
      -
      14741  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT) != 0,
      -
      14742  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0,
      -
      14743  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0,
      -
      14744  finalCreateInfo.pUserData,
      -
      14745  dedicatedBuffer,
      -
      14746  dedicatedImage,
      -
      14747  allocationCount,
      -
      14748  pAllocations);
      -
      14749  }
      -
      14750  }
      -
      14751  else
      -
      14752  {
      -
      14753  VkResult res = blockVector->Allocate(
      -
      14754  m_CurrentFrameIndex.load(),
      -
      14755  size,
      -
      14756  alignment,
      -
      14757  finalCreateInfo,
      -
      14758  suballocType,
      -
      14759  allocationCount,
      -
      14760  pAllocations);
      -
      14761  if(res == VK_SUCCESS)
      -
      14762  {
      -
      14763  return res;
      -
      14764  }
      -
      14765 
      -
      14766  // 5. Try dedicated memory.
      -
      14767  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
      -
      14768  {
      -
      14769  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      -
      14770  }
      -
      14771  else
      -
      14772  {
      -
      14773  res = AllocateDedicatedMemory(
      -
      14774  size,
      -
      14775  suballocType,
      -
      14776  memTypeIndex,
      -
      14777  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT) != 0,
      -
      14778  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0,
      -
      14779  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0,
      -
      14780  finalCreateInfo.pUserData,
      -
      14781  dedicatedBuffer,
      -
      14782  dedicatedImage,
      -
      14783  allocationCount,
      -
      14784  pAllocations);
      -
      14785  if(res == VK_SUCCESS)
      -
      14786  {
      -
      14787  // Succeeded: AllocateDedicatedMemory function already filld pMemory, nothing more to do here.
      -
      14788  VMA_DEBUG_LOG(" Allocated as DedicatedMemory");
      -
      14789  return VK_SUCCESS;
      -
      14790  }
      -
      14791  else
      -
      14792  {
      -
      14793  // Everything failed: Return error code.
      -
      14794  VMA_DEBUG_LOG(" vkAllocateMemory FAILED");
      -
      14795  return res;
      -
      14796  }
      -
      14797  }
      -
      14798  }
      -
      14799 }
      -
      14800 
      -
      14801 VkResult VmaAllocator_T::AllocateDedicatedMemory(
      -
      14802  VkDeviceSize size,
      -
      14803  VmaSuballocationType suballocType,
      -
      14804  uint32_t memTypeIndex,
      -
      14805  bool withinBudget,
      -
      14806  bool map,
      -
      14807  bool isUserDataString,
      -
      14808  void* pUserData,
      -
      14809  VkBuffer dedicatedBuffer,
      -
      14810  VkImage dedicatedImage,
      -
      14811  size_t allocationCount,
      -
      14812  VmaAllocation* pAllocations)
      -
      14813 {
      -
      14814  VMA_ASSERT(allocationCount > 0 && pAllocations);
      -
      14815 
      -
      14816  if(withinBudget)
      -
      14817  {
      -
      14818  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
      -
      14819  VmaBudget heapBudget = {};
      -
      14820  GetBudget(&heapBudget, heapIndex, 1);
      -
      14821  if(heapBudget.usage + size * allocationCount > heapBudget.budget)
      -
      14822  {
      -
      14823  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      -
      14824  }
      -
      14825  }
      -
      14826 
      -
      14827  VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
      -
      14828  allocInfo.memoryTypeIndex = memTypeIndex;
      -
      14829  allocInfo.allocationSize = size;
      -
      14830 
      -
      14831 #if VMA_DEDICATED_ALLOCATION
      -
      14832  VkMemoryDedicatedAllocateInfoKHR dedicatedAllocInfo = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR };
      -
      14833  if(m_UseKhrDedicatedAllocation)
      -
      14834  {
      -
      14835  if(dedicatedBuffer != VK_NULL_HANDLE)
      -
      14836  {
      -
      14837  VMA_ASSERT(dedicatedImage == VK_NULL_HANDLE);
      -
      14838  dedicatedAllocInfo.buffer = dedicatedBuffer;
      -
      14839  allocInfo.pNext = &dedicatedAllocInfo;
      -
      14840  }
      -
      14841  else if(dedicatedImage != VK_NULL_HANDLE)
      -
      14842  {
      -
      14843  dedicatedAllocInfo.image = dedicatedImage;
      -
      14844  allocInfo.pNext = &dedicatedAllocInfo;
      -
      14845  }
      -
      14846  }
      -
      14847 #endif // #if VMA_DEDICATED_ALLOCATION
      -
      14848 
      -
      14849  size_t allocIndex;
      -
      14850  VkResult res = VK_SUCCESS;
      -
      14851  for(allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
      -
      14852  {
      -
      14853  res = AllocateDedicatedMemoryPage(
      +
      14554  if(pCreateInfo->pHeapSizeLimit != VMA_NULL)
      +
      14555  {
      +
      14556  for(uint32_t heapIndex = 0; heapIndex < GetMemoryHeapCount(); ++heapIndex)
      +
      14557  {
      +
      14558  const VkDeviceSize limit = pCreateInfo->pHeapSizeLimit[heapIndex];
      +
      14559  if(limit != VK_WHOLE_SIZE)
      +
      14560  {
      +
      14561  m_HeapSizeLimitMask |= 1u << heapIndex;
      +
      14562  if(limit < m_MemProps.memoryHeaps[heapIndex].size)
      +
      14563  {
      +
      14564  m_MemProps.memoryHeaps[heapIndex].size = limit;
      +
      14565  }
      +
      14566  }
      +
      14567  }
      +
      14568  }
      +
      14569 
      +
      14570  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
      +
      14571  {
      +
      14572  const VkDeviceSize preferredBlockSize = CalcPreferredBlockSize(memTypeIndex);
      +
      14573 
      +
      14574  m_pBlockVectors[memTypeIndex] = vma_new(this, VmaBlockVector)(
      +
      14575  this,
      +
      14576  VK_NULL_HANDLE, // hParentPool
      +
      14577  memTypeIndex,
      +
      14578  preferredBlockSize,
      +
      14579  0,
      +
      14580  SIZE_MAX,
      +
      14581  GetBufferImageGranularity(),
      +
      14582  pCreateInfo->frameInUseCount,
      +
      14583  false, // explicitBlockSize
      +
      14584  false); // linearAlgorithm
      +
      14585  // No need to call m_pBlockVectors[memTypeIndex][blockVectorTypeIndex]->CreateMinBlocks here,
      +
      14586  // becase minBlockCount is 0.
      +
      14587  m_pDedicatedAllocations[memTypeIndex] = vma_new(this, AllocationVectorType)(VmaStlAllocator<VmaAllocation>(GetAllocationCallbacks()));
      +
      14588 
      +
      14589  }
      +
      14590 }
      +
      14591 
      +
      14592 VkResult VmaAllocator_T::Init(const VmaAllocatorCreateInfo* pCreateInfo)
      +
      14593 {
      +
      14594  VkResult res = VK_SUCCESS;
      +
      14595 
      +
      14596  if(pCreateInfo->pRecordSettings != VMA_NULL &&
      +
      14597  !VmaStrIsEmpty(pCreateInfo->pRecordSettings->pFilePath))
      +
      14598  {
      +
      14599 #if VMA_RECORDING_ENABLED
      +
      14600  m_pRecorder = vma_new(this, VmaRecorder)();
      +
      14601  res = m_pRecorder->Init(*pCreateInfo->pRecordSettings, m_UseMutex);
      +
      14602  if(res != VK_SUCCESS)
      +
      14603  {
      +
      14604  return res;
      +
      14605  }
      +
      14606  m_pRecorder->WriteConfiguration(
      +
      14607  m_PhysicalDeviceProperties,
      +
      14608  m_MemProps,
      +
      14609  m_UseKhrDedicatedAllocation,
      +
      14610  m_UseKhrBindMemory2,
      +
      14611  m_UseExtMemoryBudget);
      +
      14612  m_pRecorder->RecordCreateAllocator(GetCurrentFrameIndex());
      +
      14613 #else
      +
      14614  VMA_ASSERT(0 && "VmaAllocatorCreateInfo::pRecordSettings used, but not supported due to VMA_RECORDING_ENABLED not defined to 1.");
      +
      14615  return VK_ERROR_FEATURE_NOT_PRESENT;
      +
      14616 #endif
      +
      14617  }
      +
      14618 
      +
      14619 #if VMA_MEMORY_BUDGET
      +
      14620  if(m_UseExtMemoryBudget)
      +
      14621  {
      +
      14622  UpdateVulkanBudget();
      +
      14623  }
      +
      14624 #endif // #if VMA_MEMORY_BUDGET
      +
      14625 
      +
      14626  return res;
      +
      14627 }
      +
      14628 
      +
      14629 VmaAllocator_T::~VmaAllocator_T()
      +
      14630 {
      +
      14631 #if VMA_RECORDING_ENABLED
      +
      14632  if(m_pRecorder != VMA_NULL)
      +
      14633  {
      +
      14634  m_pRecorder->RecordDestroyAllocator(GetCurrentFrameIndex());
      +
      14635  vma_delete(this, m_pRecorder);
      +
      14636  }
      +
      14637 #endif
      +
      14638 
      +
      14639  VMA_ASSERT(m_Pools.empty());
      +
      14640 
      +
      14641  for(size_t i = GetMemoryTypeCount(); i--; )
      +
      14642  {
      +
      14643  if(m_pDedicatedAllocations[i] != VMA_NULL && !m_pDedicatedAllocations[i]->empty())
      +
      14644  {
      +
      14645  VMA_ASSERT(0 && "Unfreed dedicated allocations found.");
      +
      14646  }
      +
      14647 
      +
      14648  vma_delete(this, m_pDedicatedAllocations[i]);
      +
      14649  vma_delete(this, m_pBlockVectors[i]);
      +
      14650  }
      +
      14651 }
      +
      14652 
      +
      14653 void VmaAllocator_T::ImportVulkanFunctions(const VmaVulkanFunctions* pVulkanFunctions)
      +
      14654 {
      +
      14655 #if VMA_STATIC_VULKAN_FUNCTIONS == 1
      +
      14656  m_VulkanFunctions.vkGetPhysicalDeviceProperties = (PFN_vkGetPhysicalDeviceProperties)vkGetPhysicalDeviceProperties;
      +
      14657  m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties = (PFN_vkGetPhysicalDeviceMemoryProperties)vkGetPhysicalDeviceMemoryProperties;
      +
      14658  m_VulkanFunctions.vkAllocateMemory = (PFN_vkAllocateMemory)vkAllocateMemory;
      +
      14659  m_VulkanFunctions.vkFreeMemory = (PFN_vkFreeMemory)vkFreeMemory;
      +
      14660  m_VulkanFunctions.vkMapMemory = (PFN_vkMapMemory)vkMapMemory;
      +
      14661  m_VulkanFunctions.vkUnmapMemory = (PFN_vkUnmapMemory)vkUnmapMemory;
      +
      14662  m_VulkanFunctions.vkFlushMappedMemoryRanges = (PFN_vkFlushMappedMemoryRanges)vkFlushMappedMemoryRanges;
      +
      14663  m_VulkanFunctions.vkInvalidateMappedMemoryRanges = (PFN_vkInvalidateMappedMemoryRanges)vkInvalidateMappedMemoryRanges;
      +
      14664  m_VulkanFunctions.vkBindBufferMemory = (PFN_vkBindBufferMemory)vkBindBufferMemory;
      +
      14665  m_VulkanFunctions.vkBindImageMemory = (PFN_vkBindImageMemory)vkBindImageMemory;
      +
      14666  m_VulkanFunctions.vkGetBufferMemoryRequirements = (PFN_vkGetBufferMemoryRequirements)vkGetBufferMemoryRequirements;
      +
      14667  m_VulkanFunctions.vkGetImageMemoryRequirements = (PFN_vkGetImageMemoryRequirements)vkGetImageMemoryRequirements;
      +
      14668  m_VulkanFunctions.vkCreateBuffer = (PFN_vkCreateBuffer)vkCreateBuffer;
      +
      14669  m_VulkanFunctions.vkDestroyBuffer = (PFN_vkDestroyBuffer)vkDestroyBuffer;
      +
      14670  m_VulkanFunctions.vkCreateImage = (PFN_vkCreateImage)vkCreateImage;
      +
      14671  m_VulkanFunctions.vkDestroyImage = (PFN_vkDestroyImage)vkDestroyImage;
      +
      14672  m_VulkanFunctions.vkCmdCopyBuffer = (PFN_vkCmdCopyBuffer)vkCmdCopyBuffer;
      +
      14673 #if VMA_DEDICATED_ALLOCATION
      +
      14674  if(m_UseKhrDedicatedAllocation)
      +
      14675  {
      +
      14676  m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR =
      +
      14677  (PFN_vkGetBufferMemoryRequirements2KHR)vkGetDeviceProcAddr(m_hDevice, "vkGetBufferMemoryRequirements2KHR");
      +
      14678  m_VulkanFunctions.vkGetImageMemoryRequirements2KHR =
      +
      14679  (PFN_vkGetImageMemoryRequirements2KHR)vkGetDeviceProcAddr(m_hDevice, "vkGetImageMemoryRequirements2KHR");
      +
      14680  }
      +
      14681 #endif // #if VMA_DEDICATED_ALLOCATION
      +
      14682 #if VMA_BIND_MEMORY2
      +
      14683  if(m_UseKhrBindMemory2)
      +
      14684  {
      +
      14685  m_VulkanFunctions.vkBindBufferMemory2KHR =
      +
      14686  (PFN_vkBindBufferMemory2KHR)vkGetDeviceProcAddr(m_hDevice, "vkBindBufferMemory2KHR");
      +
      14687  m_VulkanFunctions.vkBindImageMemory2KHR =
      +
      14688  (PFN_vkBindImageMemory2KHR)vkGetDeviceProcAddr(m_hDevice, "vkBindImageMemory2KHR");
      +
      14689  }
      +
      14690 #endif // #if VMA_BIND_MEMORY2
      +
      14691 #if VMA_MEMORY_BUDGET
      +
      14692  if(m_UseExtMemoryBudget)
      +
      14693  {
      +
      14694  VMA_ASSERT(m_hInstance != VK_NULL_HANDLE);
      +
      14695  m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties2KHR =
      +
      14696  (PFN_vkGetPhysicalDeviceMemoryProperties2KHR)vkGetInstanceProcAddr(m_hInstance, "vkGetPhysicalDeviceMemoryProperties2KHR");
      +
      14697  }
      +
      14698 #endif // #if VMA_MEMORY_BUDGET
      +
      14699 #endif // #if VMA_STATIC_VULKAN_FUNCTIONS == 1
      +
      14700 
      +
      14701 #define VMA_COPY_IF_NOT_NULL(funcName) \
      +
      14702  if(pVulkanFunctions->funcName != VMA_NULL) m_VulkanFunctions.funcName = pVulkanFunctions->funcName;
      +
      14703 
      +
      14704  if(pVulkanFunctions != VMA_NULL)
      +
      14705  {
      +
      14706  VMA_COPY_IF_NOT_NULL(vkGetPhysicalDeviceProperties);
      +
      14707  VMA_COPY_IF_NOT_NULL(vkGetPhysicalDeviceMemoryProperties);
      +
      14708  VMA_COPY_IF_NOT_NULL(vkAllocateMemory);
      +
      14709  VMA_COPY_IF_NOT_NULL(vkFreeMemory);
      +
      14710  VMA_COPY_IF_NOT_NULL(vkMapMemory);
      +
      14711  VMA_COPY_IF_NOT_NULL(vkUnmapMemory);
      +
      14712  VMA_COPY_IF_NOT_NULL(vkFlushMappedMemoryRanges);
      +
      14713  VMA_COPY_IF_NOT_NULL(vkInvalidateMappedMemoryRanges);
      +
      14714  VMA_COPY_IF_NOT_NULL(vkBindBufferMemory);
      +
      14715  VMA_COPY_IF_NOT_NULL(vkBindImageMemory);
      +
      14716  VMA_COPY_IF_NOT_NULL(vkGetBufferMemoryRequirements);
      +
      14717  VMA_COPY_IF_NOT_NULL(vkGetImageMemoryRequirements);
      +
      14718  VMA_COPY_IF_NOT_NULL(vkCreateBuffer);
      +
      14719  VMA_COPY_IF_NOT_NULL(vkDestroyBuffer);
      +
      14720  VMA_COPY_IF_NOT_NULL(vkCreateImage);
      +
      14721  VMA_COPY_IF_NOT_NULL(vkDestroyImage);
      +
      14722  VMA_COPY_IF_NOT_NULL(vkCmdCopyBuffer);
      +
      14723 #if VMA_DEDICATED_ALLOCATION
      +
      14724  VMA_COPY_IF_NOT_NULL(vkGetBufferMemoryRequirements2KHR);
      +
      14725  VMA_COPY_IF_NOT_NULL(vkGetImageMemoryRequirements2KHR);
      +
      14726 #endif
      +
      14727 #if VMA_BIND_MEMORY2
      +
      14728  VMA_COPY_IF_NOT_NULL(vkBindBufferMemory2KHR);
      +
      14729  VMA_COPY_IF_NOT_NULL(vkBindImageMemory2KHR);
      +
      14730 #endif
      +
      14731 #if VMA_MEMORY_BUDGET
      +
      14732  VMA_COPY_IF_NOT_NULL(vkGetPhysicalDeviceMemoryProperties2KHR);
      +
      14733 #endif
      +
      14734  }
      +
      14735 
      +
      14736 #undef VMA_COPY_IF_NOT_NULL
      +
      14737 
      +
      14738  // If these asserts are hit, you must either #define VMA_STATIC_VULKAN_FUNCTIONS 1
      +
      14739  // or pass valid pointers as VmaAllocatorCreateInfo::pVulkanFunctions.
      +
      14740  VMA_ASSERT(m_VulkanFunctions.vkGetPhysicalDeviceProperties != VMA_NULL);
      +
      14741  VMA_ASSERT(m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties != VMA_NULL);
      +
      14742  VMA_ASSERT(m_VulkanFunctions.vkAllocateMemory != VMA_NULL);
      +
      14743  VMA_ASSERT(m_VulkanFunctions.vkFreeMemory != VMA_NULL);
      +
      14744  VMA_ASSERT(m_VulkanFunctions.vkMapMemory != VMA_NULL);
      +
      14745  VMA_ASSERT(m_VulkanFunctions.vkUnmapMemory != VMA_NULL);
      +
      14746  VMA_ASSERT(m_VulkanFunctions.vkFlushMappedMemoryRanges != VMA_NULL);
      +
      14747  VMA_ASSERT(m_VulkanFunctions.vkInvalidateMappedMemoryRanges != VMA_NULL);
      +
      14748  VMA_ASSERT(m_VulkanFunctions.vkBindBufferMemory != VMA_NULL);
      +
      14749  VMA_ASSERT(m_VulkanFunctions.vkBindImageMemory != VMA_NULL);
      +
      14750  VMA_ASSERT(m_VulkanFunctions.vkGetBufferMemoryRequirements != VMA_NULL);
      +
      14751  VMA_ASSERT(m_VulkanFunctions.vkGetImageMemoryRequirements != VMA_NULL);
      +
      14752  VMA_ASSERT(m_VulkanFunctions.vkCreateBuffer != VMA_NULL);
      +
      14753  VMA_ASSERT(m_VulkanFunctions.vkDestroyBuffer != VMA_NULL);
      +
      14754  VMA_ASSERT(m_VulkanFunctions.vkCreateImage != VMA_NULL);
      +
      14755  VMA_ASSERT(m_VulkanFunctions.vkDestroyImage != VMA_NULL);
      +
      14756  VMA_ASSERT(m_VulkanFunctions.vkCmdCopyBuffer != VMA_NULL);
      +
      14757 #if VMA_DEDICATED_ALLOCATION
      +
      14758  if(m_UseKhrDedicatedAllocation)
      +
      14759  {
      +
      14760  VMA_ASSERT(m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR != VMA_NULL);
      +
      14761  VMA_ASSERT(m_VulkanFunctions.vkGetImageMemoryRequirements2KHR != VMA_NULL);
      +
      14762  }
      +
      14763 #endif
      +
      14764 #if VMA_BIND_MEMORY2
      +
      14765  if(m_UseKhrBindMemory2)
      +
      14766  {
      +
      14767  VMA_ASSERT(m_VulkanFunctions.vkBindBufferMemory2KHR != VMA_NULL);
      +
      14768  VMA_ASSERT(m_VulkanFunctions.vkBindImageMemory2KHR != VMA_NULL);
      +
      14769  }
      +
      14770 #endif
      +
      14771 #if VMA_MEMORY_BUDGET
      +
      14772  if(m_UseExtMemoryBudget)
      +
      14773  {
      +
      14774  VMA_ASSERT(m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties2KHR != VMA_NULL);
      +
      14775  }
      +
      14776 #endif
      +
      14777 }
      +
      14778 
      +
      14779 VkDeviceSize VmaAllocator_T::CalcPreferredBlockSize(uint32_t memTypeIndex)
      +
      14780 {
      +
      14781  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
      +
      14782  const VkDeviceSize heapSize = m_MemProps.memoryHeaps[heapIndex].size;
      +
      14783  const bool isSmallHeap = heapSize <= VMA_SMALL_HEAP_MAX_SIZE;
      +
      14784  return VmaAlignUp(isSmallHeap ? (heapSize / 8) : m_PreferredLargeHeapBlockSize, (VkDeviceSize)32);
      +
      14785 }
      +
      14786 
      +
      14787 VkResult VmaAllocator_T::AllocateMemoryOfType(
      +
      14788  VkDeviceSize size,
      +
      14789  VkDeviceSize alignment,
      +
      14790  bool dedicatedAllocation,
      +
      14791  VkBuffer dedicatedBuffer,
      +
      14792  VkImage dedicatedImage,
      +
      14793  const VmaAllocationCreateInfo& createInfo,
      +
      14794  uint32_t memTypeIndex,
      +
      14795  VmaSuballocationType suballocType,
      +
      14796  size_t allocationCount,
      +
      14797  VmaAllocation* pAllocations)
      +
      14798 {
      +
      14799  VMA_ASSERT(pAllocations != VMA_NULL);
      +
      14800  VMA_DEBUG_LOG(" AllocateMemory: MemoryTypeIndex=%u, AllocationCount=%zu, Size=%llu", memTypeIndex, allocationCount, size);
      +
      14801 
      +
      14802  VmaAllocationCreateInfo finalCreateInfo = createInfo;
      +
      14803 
      +
      14804  // If memory type is not HOST_VISIBLE, disable MAPPED.
      +
      14805  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0 &&
      +
      14806  (m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
      +
      14807  {
      +
      14808  finalCreateInfo.flags &= ~VMA_ALLOCATION_CREATE_MAPPED_BIT;
      +
      14809  }
      +
      14810 
      +
      14811  VmaBlockVector* const blockVector = m_pBlockVectors[memTypeIndex];
      +
      14812  VMA_ASSERT(blockVector);
      +
      14813 
      +
      14814  const VkDeviceSize preferredBlockSize = blockVector->GetPreferredBlockSize();
      +
      14815  bool preferDedicatedMemory =
      +
      14816  VMA_DEBUG_ALWAYS_DEDICATED_MEMORY ||
      +
      14817  dedicatedAllocation ||
      +
      14818  // Heuristics: Allocate dedicated memory if requested size if greater than half of preferred block size.
      +
      14819  size > preferredBlockSize / 2;
      +
      14820 
      +
      14821  if(preferDedicatedMemory &&
      +
      14822  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0 &&
      +
      14823  finalCreateInfo.pool == VK_NULL_HANDLE)
      +
      14824  {
      +
      14825  finalCreateInfo.flags |= VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;
      +
      14826  }
      +
      14827 
      +
      14828  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT) != 0)
      +
      14829  {
      +
      14830  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
      +
      14831  {
      +
      14832  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      +
      14833  }
      +
      14834  else
      +
      14835  {
      +
      14836  return AllocateDedicatedMemory(
      +
      14837  size,
      +
      14838  suballocType,
      +
      14839  memTypeIndex,
      +
      14840  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT) != 0,
      +
      14841  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0,
      +
      14842  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0,
      +
      14843  finalCreateInfo.pUserData,
      +
      14844  dedicatedBuffer,
      +
      14845  dedicatedImage,
      +
      14846  allocationCount,
      +
      14847  pAllocations);
      +
      14848  }
      +
      14849  }
      +
      14850  else
      +
      14851  {
      +
      14852  VkResult res = blockVector->Allocate(
      +
      14853  m_CurrentFrameIndex.load(),
      14854  size,
      -
      14855  suballocType,
      -
      14856  memTypeIndex,
      -
      14857  allocInfo,
      -
      14858  map,
      -
      14859  isUserDataString,
      -
      14860  pUserData,
      -
      14861  pAllocations + allocIndex);
      -
      14862  if(res != VK_SUCCESS)
      -
      14863  {
      -
      14864  break;
      -
      14865  }
      -
      14866  }
      -
      14867 
      -
      14868  if(res == VK_SUCCESS)
      -
      14869  {
      -
      14870  // Register them in m_pDedicatedAllocations.
      +
      14855  alignment,
      +
      14856  finalCreateInfo,
      +
      14857  suballocType,
      +
      14858  allocationCount,
      +
      14859  pAllocations);
      +
      14860  if(res == VK_SUCCESS)
      +
      14861  {
      +
      14862  return res;
      +
      14863  }
      +
      14864 
      +
      14865  // 5. Try dedicated memory.
      +
      14866  if((finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
      +
      14867  {
      +
      14868  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      +
      14869  }
      +
      14870  else
      14871  {
      -
      14872  VmaMutexLockWrite lock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
      -
      14873  AllocationVectorType* pDedicatedAllocations = m_pDedicatedAllocations[memTypeIndex];
      -
      14874  VMA_ASSERT(pDedicatedAllocations);
      -
      14875  for(allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
      -
      14876  {
      -
      14877  VmaVectorInsertSorted<VmaPointerLess>(*pDedicatedAllocations, pAllocations[allocIndex]);
      -
      14878  }
      -
      14879  }
      -
      14880 
      -
      14881  VMA_DEBUG_LOG(" Allocated DedicatedMemory Count=%zu, MemoryTypeIndex=#%u", allocationCount, memTypeIndex);
      -
      14882  }
      -
      14883  else
      -
      14884  {
      -
      14885  // Free all already created allocations.
      -
      14886  while(allocIndex--)
      -
      14887  {
      -
      14888  VmaAllocation currAlloc = pAllocations[allocIndex];
      -
      14889  VkDeviceMemory hMemory = currAlloc->GetMemory();
      -
      14890 
      -
      14891  /*
      -
      14892  There is no need to call this, because Vulkan spec allows to skip vkUnmapMemory
      -
      14893  before vkFreeMemory.
      -
      14894 
      -
      14895  if(currAlloc->GetMappedData() != VMA_NULL)
      -
      14896  {
      -
      14897  (*m_VulkanFunctions.vkUnmapMemory)(m_hDevice, hMemory);
      -
      14898  }
      -
      14899  */
      -
      14900 
      -
      14901  FreeVulkanMemory(memTypeIndex, currAlloc->GetSize(), hMemory);
      -
      14902  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
      -
      14903  m_Budget.m_AllocationBytes[heapIndex] -= currAlloc->GetSize();
      -
      14904  ++m_Budget.m_OperationsSinceBudgetFetch;
      -
      14905  currAlloc->SetUserData(this, VMA_NULL);
      -
      14906  currAlloc->Dtor();
      -
      14907  m_AllocationObjectAllocator.Free(currAlloc);
      -
      14908  }
      -
      14909 
      -
      14910  memset(pAllocations, 0, sizeof(VmaAllocation) * allocationCount);
      -
      14911  }
      -
      14912 
      -
      14913  return res;
      -
      14914 }
      -
      14915 
      -
      14916 VkResult VmaAllocator_T::AllocateDedicatedMemoryPage(
      -
      14917  VkDeviceSize size,
      -
      14918  VmaSuballocationType suballocType,
      -
      14919  uint32_t memTypeIndex,
      -
      14920  const VkMemoryAllocateInfo& allocInfo,
      -
      14921  bool map,
      -
      14922  bool isUserDataString,
      -
      14923  void* pUserData,
      -
      14924  VmaAllocation* pAllocation)
      -
      14925 {
      -
      14926  VkDeviceMemory hMemory = VK_NULL_HANDLE;
      -
      14927  VkResult res = AllocateVulkanMemory(&allocInfo, &hMemory);
      -
      14928  if(res < 0)
      -
      14929  {
      -
      14930  VMA_DEBUG_LOG(" vkAllocateMemory FAILED");
      -
      14931  return res;
      -
      14932  }
      -
      14933 
      -
      14934  void* pMappedData = VMA_NULL;
      -
      14935  if(map)
      -
      14936  {
      -
      14937  res = (*m_VulkanFunctions.vkMapMemory)(
      -
      14938  m_hDevice,
      -
      14939  hMemory,
      -
      14940  0,
      -
      14941  VK_WHOLE_SIZE,
      -
      14942  0,
      -
      14943  &pMappedData);
      -
      14944  if(res < 0)
      -
      14945  {
      -
      14946  VMA_DEBUG_LOG(" vkMapMemory FAILED");
      -
      14947  FreeVulkanMemory(memTypeIndex, size, hMemory);
      -
      14948  return res;
      -
      14949  }
      -
      14950  }
      -
      14951 
      -
      14952  *pAllocation = m_AllocationObjectAllocator.Allocate();
      -
      14953  (*pAllocation)->Ctor(m_CurrentFrameIndex.load(), isUserDataString);
      -
      14954  (*pAllocation)->InitDedicatedAllocation(memTypeIndex, hMemory, suballocType, pMappedData, size);
      -
      14955  (*pAllocation)->SetUserData(this, pUserData);
      -
      14956  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
      -
      14957  m_Budget.m_AllocationBytes[heapIndex] += size;
      -
      14958  ++m_Budget.m_OperationsSinceBudgetFetch;
      -
      14959  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
      -
      14960  {
      -
      14961  FillAllocation(*pAllocation, VMA_ALLOCATION_FILL_PATTERN_CREATED);
      -
      14962  }
      -
      14963 
      -
      14964  return VK_SUCCESS;
      -
      14965 }
      +
      14872  res = AllocateDedicatedMemory(
      +
      14873  size,
      +
      14874  suballocType,
      +
      14875  memTypeIndex,
      +
      14876  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT) != 0,
      +
      14877  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0,
      +
      14878  (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0,
      +
      14879  finalCreateInfo.pUserData,
      +
      14880  dedicatedBuffer,
      +
      14881  dedicatedImage,
      +
      14882  allocationCount,
      +
      14883  pAllocations);
      +
      14884  if(res == VK_SUCCESS)
      +
      14885  {
      +
      14886  // Succeeded: AllocateDedicatedMemory function already filld pMemory, nothing more to do here.
      +
      14887  VMA_DEBUG_LOG(" Allocated as DedicatedMemory");
      +
      14888  return VK_SUCCESS;
      +
      14889  }
      +
      14890  else
      +
      14891  {
      +
      14892  // Everything failed: Return error code.
      +
      14893  VMA_DEBUG_LOG(" vkAllocateMemory FAILED");
      +
      14894  return res;
      +
      14895  }
      +
      14896  }
      +
      14897  }
      +
      14898 }
      +
      14899 
      +
      14900 VkResult VmaAllocator_T::AllocateDedicatedMemory(
      +
      14901  VkDeviceSize size,
      +
      14902  VmaSuballocationType suballocType,
      +
      14903  uint32_t memTypeIndex,
      +
      14904  bool withinBudget,
      +
      14905  bool map,
      +
      14906  bool isUserDataString,
      +
      14907  void* pUserData,
      +
      14908  VkBuffer dedicatedBuffer,
      +
      14909  VkImage dedicatedImage,
      +
      14910  size_t allocationCount,
      +
      14911  VmaAllocation* pAllocations)
      +
      14912 {
      +
      14913  VMA_ASSERT(allocationCount > 0 && pAllocations);
      +
      14914 
      +
      14915  if(withinBudget)
      +
      14916  {
      +
      14917  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
      +
      14918  VmaBudget heapBudget = {};
      +
      14919  GetBudget(&heapBudget, heapIndex, 1);
      +
      14920  if(heapBudget.usage + size * allocationCount > heapBudget.budget)
      +
      14921  {
      +
      14922  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      +
      14923  }
      +
      14924  }
      +
      14925 
      +
      14926  VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
      +
      14927  allocInfo.memoryTypeIndex = memTypeIndex;
      +
      14928  allocInfo.allocationSize = size;
      +
      14929 
      +
      14930 #if VMA_DEDICATED_ALLOCATION
      +
      14931  VkMemoryDedicatedAllocateInfoKHR dedicatedAllocInfo = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR };
      +
      14932  if(m_UseKhrDedicatedAllocation)
      +
      14933  {
      +
      14934  if(dedicatedBuffer != VK_NULL_HANDLE)
      +
      14935  {
      +
      14936  VMA_ASSERT(dedicatedImage == VK_NULL_HANDLE);
      +
      14937  dedicatedAllocInfo.buffer = dedicatedBuffer;
      +
      14938  allocInfo.pNext = &dedicatedAllocInfo;
      +
      14939  }
      +
      14940  else if(dedicatedImage != VK_NULL_HANDLE)
      +
      14941  {
      +
      14942  dedicatedAllocInfo.image = dedicatedImage;
      +
      14943  allocInfo.pNext = &dedicatedAllocInfo;
      +
      14944  }
      +
      14945  }
      +
      14946 #endif // #if VMA_DEDICATED_ALLOCATION
      +
      14947 
      +
      14948  size_t allocIndex;
      +
      14949  VkResult res = VK_SUCCESS;
      +
      14950  for(allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
      +
      14951  {
      +
      14952  res = AllocateDedicatedMemoryPage(
      +
      14953  size,
      +
      14954  suballocType,
      +
      14955  memTypeIndex,
      +
      14956  allocInfo,
      +
      14957  map,
      +
      14958  isUserDataString,
      +
      14959  pUserData,
      +
      14960  pAllocations + allocIndex);
      +
      14961  if(res != VK_SUCCESS)
      +
      14962  {
      +
      14963  break;
      +
      14964  }
      +
      14965  }
      14966 
      -
      14967 void VmaAllocator_T::GetBufferMemoryRequirements(
      -
      14968  VkBuffer hBuffer,
      -
      14969  VkMemoryRequirements& memReq,
      -
      14970  bool& requiresDedicatedAllocation,
      -
      14971  bool& prefersDedicatedAllocation) const
      -
      14972 {
      -
      14973 #if VMA_DEDICATED_ALLOCATION
      -
      14974  if(m_UseKhrDedicatedAllocation)
      -
      14975  {
      -
      14976  VkBufferMemoryRequirementsInfo2KHR memReqInfo = { VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR };
      -
      14977  memReqInfo.buffer = hBuffer;
      -
      14978 
      -
      14979  VkMemoryDedicatedRequirementsKHR memDedicatedReq = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR };
      -
      14980 
      -
      14981  VkMemoryRequirements2KHR memReq2 = { VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR };
      -
      14982  memReq2.pNext = &memDedicatedReq;
      -
      14983 
      -
      14984  (*m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR)(m_hDevice, &memReqInfo, &memReq2);
      -
      14985 
      -
      14986  memReq = memReq2.memoryRequirements;
      -
      14987  requiresDedicatedAllocation = (memDedicatedReq.requiresDedicatedAllocation != VK_FALSE);
      -
      14988  prefersDedicatedAllocation = (memDedicatedReq.prefersDedicatedAllocation != VK_FALSE);
      -
      14989  }
      -
      14990  else
      -
      14991 #endif // #if VMA_DEDICATED_ALLOCATION
      -
      14992  {
      -
      14993  (*m_VulkanFunctions.vkGetBufferMemoryRequirements)(m_hDevice, hBuffer, &memReq);
      -
      14994  requiresDedicatedAllocation = false;
      -
      14995  prefersDedicatedAllocation = false;
      -
      14996  }
      -
      14997 }
      -
      14998 
      -
      14999 void VmaAllocator_T::GetImageMemoryRequirements(
      -
      15000  VkImage hImage,
      -
      15001  VkMemoryRequirements& memReq,
      -
      15002  bool& requiresDedicatedAllocation,
      -
      15003  bool& prefersDedicatedAllocation) const
      -
      15004 {
      -
      15005 #if VMA_DEDICATED_ALLOCATION
      -
      15006  if(m_UseKhrDedicatedAllocation)
      -
      15007  {
      -
      15008  VkImageMemoryRequirementsInfo2KHR memReqInfo = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR };
      -
      15009  memReqInfo.image = hImage;
      -
      15010 
      -
      15011  VkMemoryDedicatedRequirementsKHR memDedicatedReq = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR };
      +
      14967  if(res == VK_SUCCESS)
      +
      14968  {
      +
      14969  // Register them in m_pDedicatedAllocations.
      +
      14970  {
      +
      14971  VmaMutexLockWrite lock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
      +
      14972  AllocationVectorType* pDedicatedAllocations = m_pDedicatedAllocations[memTypeIndex];
      +
      14973  VMA_ASSERT(pDedicatedAllocations);
      +
      14974  for(allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
      +
      14975  {
      +
      14976  VmaVectorInsertSorted<VmaPointerLess>(*pDedicatedAllocations, pAllocations[allocIndex]);
      +
      14977  }
      +
      14978  }
      +
      14979 
      +
      14980  VMA_DEBUG_LOG(" Allocated DedicatedMemory Count=%zu, MemoryTypeIndex=#%u", allocationCount, memTypeIndex);
      +
      14981  }
      +
      14982  else
      +
      14983  {
      +
      14984  // Free all already created allocations.
      +
      14985  while(allocIndex--)
      +
      14986  {
      +
      14987  VmaAllocation currAlloc = pAllocations[allocIndex];
      +
      14988  VkDeviceMemory hMemory = currAlloc->GetMemory();
      +
      14989 
      +
      14990  /*
      +
      14991  There is no need to call this, because Vulkan spec allows to skip vkUnmapMemory
      +
      14992  before vkFreeMemory.
      +
      14993 
      +
      14994  if(currAlloc->GetMappedData() != VMA_NULL)
      +
      14995  {
      +
      14996  (*m_VulkanFunctions.vkUnmapMemory)(m_hDevice, hMemory);
      +
      14997  }
      +
      14998  */
      +
      14999 
      +
      15000  FreeVulkanMemory(memTypeIndex, currAlloc->GetSize(), hMemory);
      +
      15001  m_Budget.RemoveAllocation(MemoryTypeIndexToHeapIndex(memTypeIndex), currAlloc->GetSize());
      +
      15002  currAlloc->SetUserData(this, VMA_NULL);
      +
      15003  currAlloc->Dtor();
      +
      15004  m_AllocationObjectAllocator.Free(currAlloc);
      +
      15005  }
      +
      15006 
      +
      15007  memset(pAllocations, 0, sizeof(VmaAllocation) * allocationCount);
      +
      15008  }
      +
      15009 
      +
      15010  return res;
      +
      15011 }
      15012 
      -
      15013  VkMemoryRequirements2KHR memReq2 = { VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR };
      -
      15014  memReq2.pNext = &memDedicatedReq;
      -
      15015 
      -
      15016  (*m_VulkanFunctions.vkGetImageMemoryRequirements2KHR)(m_hDevice, &memReqInfo, &memReq2);
      -
      15017 
      -
      15018  memReq = memReq2.memoryRequirements;
      -
      15019  requiresDedicatedAllocation = (memDedicatedReq.requiresDedicatedAllocation != VK_FALSE);
      -
      15020  prefersDedicatedAllocation = (memDedicatedReq.prefersDedicatedAllocation != VK_FALSE);
      -
      15021  }
      -
      15022  else
      -
      15023 #endif // #if VMA_DEDICATED_ALLOCATION
      -
      15024  {
      -
      15025  (*m_VulkanFunctions.vkGetImageMemoryRequirements)(m_hDevice, hImage, &memReq);
      -
      15026  requiresDedicatedAllocation = false;
      -
      15027  prefersDedicatedAllocation = false;
      -
      15028  }
      -
      15029 }
      +
      15013 VkResult VmaAllocator_T::AllocateDedicatedMemoryPage(
      +
      15014  VkDeviceSize size,
      +
      15015  VmaSuballocationType suballocType,
      +
      15016  uint32_t memTypeIndex,
      +
      15017  const VkMemoryAllocateInfo& allocInfo,
      +
      15018  bool map,
      +
      15019  bool isUserDataString,
      +
      15020  void* pUserData,
      +
      15021  VmaAllocation* pAllocation)
      +
      15022 {
      +
      15023  VkDeviceMemory hMemory = VK_NULL_HANDLE;
      +
      15024  VkResult res = AllocateVulkanMemory(&allocInfo, &hMemory);
      +
      15025  if(res < 0)
      +
      15026  {
      +
      15027  VMA_DEBUG_LOG(" vkAllocateMemory FAILED");
      +
      15028  return res;
      +
      15029  }
      15030 
      -
      15031 VkResult VmaAllocator_T::AllocateMemory(
      -
      15032  const VkMemoryRequirements& vkMemReq,
      -
      15033  bool requiresDedicatedAllocation,
      -
      15034  bool prefersDedicatedAllocation,
      -
      15035  VkBuffer dedicatedBuffer,
      -
      15036  VkImage dedicatedImage,
      -
      15037  const VmaAllocationCreateInfo& createInfo,
      -
      15038  VmaSuballocationType suballocType,
      -
      15039  size_t allocationCount,
      -
      15040  VmaAllocation* pAllocations)
      -
      15041 {
      -
      15042  memset(pAllocations, 0, sizeof(VmaAllocation) * allocationCount);
      -
      15043 
      -
      15044  VMA_ASSERT(VmaIsPow2(vkMemReq.alignment));
      -
      15045 
      -
      15046  if(vkMemReq.size == 0)
      -
      15047  {
      -
      15048  return VK_ERROR_VALIDATION_FAILED_EXT;
      -
      15049  }
      -
      15050  if((createInfo.flags & VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT) != 0 &&
      -
      15051  (createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
      -
      15052  {
      -
      15053  VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT together with VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT makes no sense.");
      -
      15054  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      -
      15055  }
      -
      15056  if((createInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0 &&
      -
      15057  (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0)
      -
      15058  {
      -
      15059  VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_MAPPED_BIT together with VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT is invalid.");
      -
      15060  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      -
      15061  }
      -
      15062  if(requiresDedicatedAllocation)
      -
      15063  {
      -
      15064  if((createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
      -
      15065  {
      -
      15066  VMA_ASSERT(0 && "VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT specified while dedicated allocation is required.");
      -
      15067  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      -
      15068  }
      -
      15069  if(createInfo.pool != VK_NULL_HANDLE)
      -
      15070  {
      -
      15071  VMA_ASSERT(0 && "Pool specified while dedicated allocation is required.");
      -
      15072  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      -
      15073  }
      -
      15074  }
      -
      15075  if((createInfo.pool != VK_NULL_HANDLE) &&
      -
      15076  ((createInfo.flags & (VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT)) != 0))
      -
      15077  {
      -
      15078  VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT when pool != null is invalid.");
      -
      15079  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      -
      15080  }
      -
      15081 
      -
      15082  if(createInfo.pool != VK_NULL_HANDLE)
      -
      15083  {
      -
      15084  const VkDeviceSize alignmentForPool = VMA_MAX(
      -
      15085  vkMemReq.alignment,
      -
      15086  GetMemoryTypeMinAlignment(createInfo.pool->m_BlockVector.GetMemoryTypeIndex()));
      -
      15087 
      -
      15088  VmaAllocationCreateInfo createInfoForPool = createInfo;
      -
      15089  // If memory type is not HOST_VISIBLE, disable MAPPED.
      -
      15090  if((createInfoForPool.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0 &&
      -
      15091  (m_MemProps.memoryTypes[createInfo.pool->m_BlockVector.GetMemoryTypeIndex()].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
      -
      15092  {
      -
      15093  createInfoForPool.flags &= ~VMA_ALLOCATION_CREATE_MAPPED_BIT;
      -
      15094  }
      -
      15095 
      -
      15096  return createInfo.pool->m_BlockVector.Allocate(
      -
      15097  m_CurrentFrameIndex.load(),
      -
      15098  vkMemReq.size,
      -
      15099  alignmentForPool,
      -
      15100  createInfoForPool,
      -
      15101  suballocType,
      -
      15102  allocationCount,
      -
      15103  pAllocations);
      -
      15104  }
      -
      15105  else
      -
      15106  {
      -
      15107  // Bit mask of memory Vulkan types acceptable for this allocation.
      -
      15108  uint32_t memoryTypeBits = vkMemReq.memoryTypeBits;
      -
      15109  uint32_t memTypeIndex = UINT32_MAX;
      -
      15110  VkResult res = vmaFindMemoryTypeIndex(this, memoryTypeBits, &createInfo, &memTypeIndex);
      -
      15111  if(res == VK_SUCCESS)
      -
      15112  {
      -
      15113  VkDeviceSize alignmentForMemType = VMA_MAX(
      -
      15114  vkMemReq.alignment,
      -
      15115  GetMemoryTypeMinAlignment(memTypeIndex));
      -
      15116 
      -
      15117  res = AllocateMemoryOfType(
      -
      15118  vkMemReq.size,
      -
      15119  alignmentForMemType,
      -
      15120  requiresDedicatedAllocation || prefersDedicatedAllocation,
      -
      15121  dedicatedBuffer,
      -
      15122  dedicatedImage,
      -
      15123  createInfo,
      -
      15124  memTypeIndex,
      -
      15125  suballocType,
      -
      15126  allocationCount,
      -
      15127  pAllocations);
      -
      15128  // Succeeded on first try.
      -
      15129  if(res == VK_SUCCESS)
      -
      15130  {
      -
      15131  return res;
      -
      15132  }
      -
      15133  // Allocation from this memory type failed. Try other compatible memory types.
      -
      15134  else
      -
      15135  {
      -
      15136  for(;;)
      -
      15137  {
      -
      15138  // Remove old memTypeIndex from list of possibilities.
      -
      15139  memoryTypeBits &= ~(1u << memTypeIndex);
      -
      15140  // Find alternative memTypeIndex.
      -
      15141  res = vmaFindMemoryTypeIndex(this, memoryTypeBits, &createInfo, &memTypeIndex);
      -
      15142  if(res == VK_SUCCESS)
      -
      15143  {
      -
      15144  alignmentForMemType = VMA_MAX(
      -
      15145  vkMemReq.alignment,
      -
      15146  GetMemoryTypeMinAlignment(memTypeIndex));
      -
      15147 
      -
      15148  res = AllocateMemoryOfType(
      -
      15149  vkMemReq.size,
      -
      15150  alignmentForMemType,
      -
      15151  requiresDedicatedAllocation || prefersDedicatedAllocation,
      -
      15152  dedicatedBuffer,
      -
      15153  dedicatedImage,
      -
      15154  createInfo,
      -
      15155  memTypeIndex,
      -
      15156  suballocType,
      -
      15157  allocationCount,
      -
      15158  pAllocations);
      -
      15159  // Allocation from this alternative memory type succeeded.
      -
      15160  if(res == VK_SUCCESS)
      -
      15161  {
      -
      15162  return res;
      -
      15163  }
      -
      15164  // else: Allocation from this memory type failed. Try next one - next loop iteration.
      -
      15165  }
      -
      15166  // No other matching memory type index could be found.
      -
      15167  else
      -
      15168  {
      -
      15169  // Not returning res, which is VK_ERROR_FEATURE_NOT_PRESENT, because we already failed to allocate once.
      -
      15170  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      -
      15171  }
      -
      15172  }
      -
      15173  }
      -
      15174  }
      -
      15175  // Can't find any single memory type maching requirements. res is VK_ERROR_FEATURE_NOT_PRESENT.
      -
      15176  else
      -
      15177  return res;
      -
      15178  }
      -
      15179 }
      -
      15180 
      -
      15181 void VmaAllocator_T::FreeMemory(
      -
      15182  size_t allocationCount,
      -
      15183  const VmaAllocation* pAllocations)
      -
      15184 {
      -
      15185  VMA_ASSERT(pAllocations);
      -
      15186 
      -
      15187  for(size_t allocIndex = allocationCount; allocIndex--; )
      -
      15188  {
      -
      15189  VmaAllocation allocation = pAllocations[allocIndex];
      +
      15031  void* pMappedData = VMA_NULL;
      +
      15032  if(map)
      +
      15033  {
      +
      15034  res = (*m_VulkanFunctions.vkMapMemory)(
      +
      15035  m_hDevice,
      +
      15036  hMemory,
      +
      15037  0,
      +
      15038  VK_WHOLE_SIZE,
      +
      15039  0,
      +
      15040  &pMappedData);
      +
      15041  if(res < 0)
      +
      15042  {
      +
      15043  VMA_DEBUG_LOG(" vkMapMemory FAILED");
      +
      15044  FreeVulkanMemory(memTypeIndex, size, hMemory);
      +
      15045  return res;
      +
      15046  }
      +
      15047  }
      +
      15048 
      +
      15049  *pAllocation = m_AllocationObjectAllocator.Allocate();
      +
      15050  (*pAllocation)->Ctor(m_CurrentFrameIndex.load(), isUserDataString);
      +
      15051  (*pAllocation)->InitDedicatedAllocation(memTypeIndex, hMemory, suballocType, pMappedData, size);
      +
      15052  (*pAllocation)->SetUserData(this, pUserData);
      +
      15053  m_Budget.AddAllocation(MemoryTypeIndexToHeapIndex(memTypeIndex), size);
      +
      15054  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
      +
      15055  {
      +
      15056  FillAllocation(*pAllocation, VMA_ALLOCATION_FILL_PATTERN_CREATED);
      +
      15057  }
      +
      15058 
      +
      15059  return VK_SUCCESS;
      +
      15060 }
      +
      15061 
      +
      15062 void VmaAllocator_T::GetBufferMemoryRequirements(
      +
      15063  VkBuffer hBuffer,
      +
      15064  VkMemoryRequirements& memReq,
      +
      15065  bool& requiresDedicatedAllocation,
      +
      15066  bool& prefersDedicatedAllocation) const
      +
      15067 {
      +
      15068 #if VMA_DEDICATED_ALLOCATION
      +
      15069  if(m_UseKhrDedicatedAllocation)
      +
      15070  {
      +
      15071  VkBufferMemoryRequirementsInfo2KHR memReqInfo = { VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR };
      +
      15072  memReqInfo.buffer = hBuffer;
      +
      15073 
      +
      15074  VkMemoryDedicatedRequirementsKHR memDedicatedReq = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR };
      +
      15075 
      +
      15076  VkMemoryRequirements2KHR memReq2 = { VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR };
      +
      15077  memReq2.pNext = &memDedicatedReq;
      +
      15078 
      +
      15079  (*m_VulkanFunctions.vkGetBufferMemoryRequirements2KHR)(m_hDevice, &memReqInfo, &memReq2);
      +
      15080 
      +
      15081  memReq = memReq2.memoryRequirements;
      +
      15082  requiresDedicatedAllocation = (memDedicatedReq.requiresDedicatedAllocation != VK_FALSE);
      +
      15083  prefersDedicatedAllocation = (memDedicatedReq.prefersDedicatedAllocation != VK_FALSE);
      +
      15084  }
      +
      15085  else
      +
      15086 #endif // #if VMA_DEDICATED_ALLOCATION
      +
      15087  {
      +
      15088  (*m_VulkanFunctions.vkGetBufferMemoryRequirements)(m_hDevice, hBuffer, &memReq);
      +
      15089  requiresDedicatedAllocation = false;
      +
      15090  prefersDedicatedAllocation = false;
      +
      15091  }
      +
      15092 }
      +
      15093 
      +
      15094 void VmaAllocator_T::GetImageMemoryRequirements(
      +
      15095  VkImage hImage,
      +
      15096  VkMemoryRequirements& memReq,
      +
      15097  bool& requiresDedicatedAllocation,
      +
      15098  bool& prefersDedicatedAllocation) const
      +
      15099 {
      +
      15100 #if VMA_DEDICATED_ALLOCATION
      +
      15101  if(m_UseKhrDedicatedAllocation)
      +
      15102  {
      +
      15103  VkImageMemoryRequirementsInfo2KHR memReqInfo = { VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR };
      +
      15104  memReqInfo.image = hImage;
      +
      15105 
      +
      15106  VkMemoryDedicatedRequirementsKHR memDedicatedReq = { VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR };
      +
      15107 
      +
      15108  VkMemoryRequirements2KHR memReq2 = { VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR };
      +
      15109  memReq2.pNext = &memDedicatedReq;
      +
      15110 
      +
      15111  (*m_VulkanFunctions.vkGetImageMemoryRequirements2KHR)(m_hDevice, &memReqInfo, &memReq2);
      +
      15112 
      +
      15113  memReq = memReq2.memoryRequirements;
      +
      15114  requiresDedicatedAllocation = (memDedicatedReq.requiresDedicatedAllocation != VK_FALSE);
      +
      15115  prefersDedicatedAllocation = (memDedicatedReq.prefersDedicatedAllocation != VK_FALSE);
      +
      15116  }
      +
      15117  else
      +
      15118 #endif // #if VMA_DEDICATED_ALLOCATION
      +
      15119  {
      +
      15120  (*m_VulkanFunctions.vkGetImageMemoryRequirements)(m_hDevice, hImage, &memReq);
      +
      15121  requiresDedicatedAllocation = false;
      +
      15122  prefersDedicatedAllocation = false;
      +
      15123  }
      +
      15124 }
      +
      15125 
      +
      15126 VkResult VmaAllocator_T::AllocateMemory(
      +
      15127  const VkMemoryRequirements& vkMemReq,
      +
      15128  bool requiresDedicatedAllocation,
      +
      15129  bool prefersDedicatedAllocation,
      +
      15130  VkBuffer dedicatedBuffer,
      +
      15131  VkImage dedicatedImage,
      +
      15132  const VmaAllocationCreateInfo& createInfo,
      +
      15133  VmaSuballocationType suballocType,
      +
      15134  size_t allocationCount,
      +
      15135  VmaAllocation* pAllocations)
      +
      15136 {
      +
      15137  memset(pAllocations, 0, sizeof(VmaAllocation) * allocationCount);
      +
      15138 
      +
      15139  VMA_ASSERT(VmaIsPow2(vkMemReq.alignment));
      +
      15140 
      +
      15141  if(vkMemReq.size == 0)
      +
      15142  {
      +
      15143  return VK_ERROR_VALIDATION_FAILED_EXT;
      +
      15144  }
      +
      15145  if((createInfo.flags & VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT) != 0 &&
      +
      15146  (createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
      +
      15147  {
      +
      15148  VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT together with VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT makes no sense.");
      +
      15149  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      +
      15150  }
      +
      15151  if((createInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0 &&
      +
      15152  (createInfo.flags & VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT) != 0)
      +
      15153  {
      +
      15154  VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_MAPPED_BIT together with VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT is invalid.");
      +
      15155  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      +
      15156  }
      +
      15157  if(requiresDedicatedAllocation)
      +
      15158  {
      +
      15159  if((createInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) != 0)
      +
      15160  {
      +
      15161  VMA_ASSERT(0 && "VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT specified while dedicated allocation is required.");
      +
      15162  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      +
      15163  }
      +
      15164  if(createInfo.pool != VK_NULL_HANDLE)
      +
      15165  {
      +
      15166  VMA_ASSERT(0 && "Pool specified while dedicated allocation is required.");
      +
      15167  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      +
      15168  }
      +
      15169  }
      +
      15170  if((createInfo.pool != VK_NULL_HANDLE) &&
      +
      15171  ((createInfo.flags & (VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT)) != 0))
      +
      15172  {
      +
      15173  VMA_ASSERT(0 && "Specifying VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT when pool != null is invalid.");
      +
      15174  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      +
      15175  }
      +
      15176 
      +
      15177  if(createInfo.pool != VK_NULL_HANDLE)
      +
      15178  {
      +
      15179  const VkDeviceSize alignmentForPool = VMA_MAX(
      +
      15180  vkMemReq.alignment,
      +
      15181  GetMemoryTypeMinAlignment(createInfo.pool->m_BlockVector.GetMemoryTypeIndex()));
      +
      15182 
      +
      15183  VmaAllocationCreateInfo createInfoForPool = createInfo;
      +
      15184  // If memory type is not HOST_VISIBLE, disable MAPPED.
      +
      15185  if((createInfoForPool.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0 &&
      +
      15186  (m_MemProps.memoryTypes[createInfo.pool->m_BlockVector.GetMemoryTypeIndex()].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
      +
      15187  {
      +
      15188  createInfoForPool.flags &= ~VMA_ALLOCATION_CREATE_MAPPED_BIT;
      +
      15189  }
      15190 
      -
      15191  if(allocation != VK_NULL_HANDLE)
      -
      15192  {
      -
      15193  if(TouchAllocation(allocation))
      -
      15194  {
      -
      15195  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
      -
      15196  {
      -
      15197  FillAllocation(allocation, VMA_ALLOCATION_FILL_PATTERN_DESTROYED);
      -
      15198  }
      -
      15199 
      -
      15200  switch(allocation->GetType())
      -
      15201  {
      -
      15202  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
      -
      15203  {
      -
      15204  VmaBlockVector* pBlockVector = VMA_NULL;
      -
      15205  VmaPool hPool = allocation->GetBlock()->GetParentPool();
      -
      15206  if(hPool != VK_NULL_HANDLE)
      -
      15207  {
      -
      15208  pBlockVector = &hPool->m_BlockVector;
      -
      15209  }
      -
      15210  else
      -
      15211  {
      -
      15212  const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
      -
      15213  pBlockVector = m_pBlockVectors[memTypeIndex];
      -
      15214  }
      -
      15215  pBlockVector->Free(allocation);
      -
      15216  }
      -
      15217  break;
      -
      15218  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
      -
      15219  FreeDedicatedMemory(allocation);
      -
      15220  break;
      -
      15221  default:
      -
      15222  VMA_ASSERT(0);
      -
      15223  }
      -
      15224  }
      -
      15225 
      -
      15226  m_Budget.m_AllocationBytes[MemoryTypeIndexToHeapIndex(allocation->GetMemoryTypeIndex())] -= allocation->GetSize();
      -
      15227  ++m_Budget.m_OperationsSinceBudgetFetch;
      -
      15228  allocation->SetUserData(this, VMA_NULL);
      -
      15229  allocation->Dtor();
      -
      15230  m_AllocationObjectAllocator.Free(allocation);
      -
      15231  }
      -
      15232  }
      -
      15233 }
      -
      15234 
      -
      15235 VkResult VmaAllocator_T::ResizeAllocation(
      -
      15236  const VmaAllocation alloc,
      -
      15237  VkDeviceSize newSize)
      -
      15238 {
      -
      15239  // This function is deprecated and so it does nothing. It's left for backward compatibility.
      -
      15240  if(newSize == 0 || alloc->GetLastUseFrameIndex() == VMA_FRAME_INDEX_LOST)
      -
      15241  {
      -
      15242  return VK_ERROR_VALIDATION_FAILED_EXT;
      -
      15243  }
      -
      15244  if(newSize == alloc->GetSize())
      -
      15245  {
      -
      15246  return VK_SUCCESS;
      -
      15247  }
      -
      15248  return VK_ERROR_OUT_OF_POOL_MEMORY;
      -
      15249 }
      -
      15250 
      -
      15251 void VmaAllocator_T::CalculateStats(VmaStats* pStats)
      -
      15252 {
      -
      15253  // Initialize.
      -
      15254  InitStatInfo(pStats->total);
      -
      15255  for(size_t i = 0; i < VK_MAX_MEMORY_TYPES; ++i)
      -
      15256  InitStatInfo(pStats->memoryType[i]);
      -
      15257  for(size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i)
      -
      15258  InitStatInfo(pStats->memoryHeap[i]);
      -
      15259 
      -
      15260  // Process default pools.
      -
      15261  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
      -
      15262  {
      -
      15263  VmaBlockVector* const pBlockVector = m_pBlockVectors[memTypeIndex];
      -
      15264  VMA_ASSERT(pBlockVector);
      -
      15265  pBlockVector->AddStats(pStats);
      -
      15266  }
      -
      15267 
      -
      15268  // Process custom pools.
      -
      15269  {
      -
      15270  VmaMutexLockRead lock(m_PoolsMutex, m_UseMutex);
      -
      15271  for(size_t poolIndex = 0, poolCount = m_Pools.size(); poolIndex < poolCount; ++poolIndex)
      -
      15272  {
      -
      15273  m_Pools[poolIndex]->m_BlockVector.AddStats(pStats);
      -
      15274  }
      -
      15275  }
      -
      15276 
      -
      15277  // Process dedicated allocations.
      -
      15278  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
      -
      15279  {
      -
      15280  const uint32_t memHeapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
      -
      15281  VmaMutexLockRead dedicatedAllocationsLock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
      -
      15282  AllocationVectorType* const pDedicatedAllocVector = m_pDedicatedAllocations[memTypeIndex];
      -
      15283  VMA_ASSERT(pDedicatedAllocVector);
      -
      15284  for(size_t allocIndex = 0, allocCount = pDedicatedAllocVector->size(); allocIndex < allocCount; ++allocIndex)
      -
      15285  {
      -
      15286  VmaStatInfo allocationStatInfo;
      -
      15287  (*pDedicatedAllocVector)[allocIndex]->DedicatedAllocCalcStatsInfo(allocationStatInfo);
      -
      15288  VmaAddStatInfo(pStats->total, allocationStatInfo);
      -
      15289  VmaAddStatInfo(pStats->memoryType[memTypeIndex], allocationStatInfo);
      -
      15290  VmaAddStatInfo(pStats->memoryHeap[memHeapIndex], allocationStatInfo);
      -
      15291  }
      -
      15292  }
      -
      15293 
      -
      15294  // Postprocess.
      -
      15295  VmaPostprocessCalcStatInfo(pStats->total);
      -
      15296  for(size_t i = 0; i < GetMemoryTypeCount(); ++i)
      -
      15297  VmaPostprocessCalcStatInfo(pStats->memoryType[i]);
      -
      15298  for(size_t i = 0; i < GetMemoryHeapCount(); ++i)
      -
      15299  VmaPostprocessCalcStatInfo(pStats->memoryHeap[i]);
      -
      15300 }
      -
      15301 
      -
      15302 void VmaAllocator_T::GetBudget(VmaBudget* outBudget, uint32_t firstHeap, uint32_t heapCount)
      -
      15303 {
      -
      15304 #if VMA_MEMORY_BUDGET
      -
      15305  if(m_UseExtMemoryBudget)
      -
      15306  {
      -
      15307  if(m_Budget.m_OperationsSinceBudgetFetch < 30)
      -
      15308  {
      -
      15309  VmaMutexLockRead lockRead(m_Budget.m_BudgetMutex, m_UseMutex);
      -
      15310  for(uint32_t i = 0; i < heapCount; ++i, ++outBudget)
      -
      15311  {
      -
      15312  const uint32_t heapIndex = firstHeap + i;
      -
      15313 
      -
      15314  outBudget->blockBytes = m_Budget.m_BlockBytes[heapIndex];
      -
      15315  outBudget->allocationBytes = m_Budget.m_AllocationBytes[heapIndex];
      -
      15316 
      -
      15317  if(m_Budget.m_VulkanUsage[heapIndex] + outBudget->blockBytes > m_Budget.m_BlockBytesAtBudgetFetch[heapIndex])
      -
      15318  {
      -
      15319  outBudget->usage = m_Budget.m_VulkanUsage[heapIndex] +
      -
      15320  outBudget->blockBytes - m_Budget.m_BlockBytesAtBudgetFetch[heapIndex];
      -
      15321  }
      -
      15322  else
      -
      15323  {
      -
      15324  outBudget->usage = 0;
      -
      15325  }
      -
      15326 
      -
      15327  // Have to take MIN with heap size because explicit HeapSizeLimit is included in it.
      -
      15328  outBudget->budget = VMA_MIN(
      -
      15329  m_Budget.m_VulkanBudget[heapIndex], m_MemProps.memoryHeaps[heapIndex].size);
      -
      15330  }
      -
      15331  }
      -
      15332  else
      -
      15333  {
      -
      15334  UpdateVulkanBudget(); // Outside of mutex lock
      -
      15335  GetBudget(outBudget, firstHeap, heapCount); // Recursion
      -
      15336  }
      -
      15337  }
      -
      15338  else
      -
      15339 #endif
      +
      15191  return createInfo.pool->m_BlockVector.Allocate(
      +
      15192  m_CurrentFrameIndex.load(),
      +
      15193  vkMemReq.size,
      +
      15194  alignmentForPool,
      +
      15195  createInfoForPool,
      +
      15196  suballocType,
      +
      15197  allocationCount,
      +
      15198  pAllocations);
      +
      15199  }
      +
      15200  else
      +
      15201  {
      +
      15202  // Bit mask of memory Vulkan types acceptable for this allocation.
      +
      15203  uint32_t memoryTypeBits = vkMemReq.memoryTypeBits;
      +
      15204  uint32_t memTypeIndex = UINT32_MAX;
      +
      15205  VkResult res = vmaFindMemoryTypeIndex(this, memoryTypeBits, &createInfo, &memTypeIndex);
      +
      15206  if(res == VK_SUCCESS)
      +
      15207  {
      +
      15208  VkDeviceSize alignmentForMemType = VMA_MAX(
      +
      15209  vkMemReq.alignment,
      +
      15210  GetMemoryTypeMinAlignment(memTypeIndex));
      +
      15211 
      +
      15212  res = AllocateMemoryOfType(
      +
      15213  vkMemReq.size,
      +
      15214  alignmentForMemType,
      +
      15215  requiresDedicatedAllocation || prefersDedicatedAllocation,
      +
      15216  dedicatedBuffer,
      +
      15217  dedicatedImage,
      +
      15218  createInfo,
      +
      15219  memTypeIndex,
      +
      15220  suballocType,
      +
      15221  allocationCount,
      +
      15222  pAllocations);
      +
      15223  // Succeeded on first try.
      +
      15224  if(res == VK_SUCCESS)
      +
      15225  {
      +
      15226  return res;
      +
      15227  }
      +
      15228  // Allocation from this memory type failed. Try other compatible memory types.
      +
      15229  else
      +
      15230  {
      +
      15231  for(;;)
      +
      15232  {
      +
      15233  // Remove old memTypeIndex from list of possibilities.
      +
      15234  memoryTypeBits &= ~(1u << memTypeIndex);
      +
      15235  // Find alternative memTypeIndex.
      +
      15236  res = vmaFindMemoryTypeIndex(this, memoryTypeBits, &createInfo, &memTypeIndex);
      +
      15237  if(res == VK_SUCCESS)
      +
      15238  {
      +
      15239  alignmentForMemType = VMA_MAX(
      +
      15240  vkMemReq.alignment,
      +
      15241  GetMemoryTypeMinAlignment(memTypeIndex));
      +
      15242 
      +
      15243  res = AllocateMemoryOfType(
      +
      15244  vkMemReq.size,
      +
      15245  alignmentForMemType,
      +
      15246  requiresDedicatedAllocation || prefersDedicatedAllocation,
      +
      15247  dedicatedBuffer,
      +
      15248  dedicatedImage,
      +
      15249  createInfo,
      +
      15250  memTypeIndex,
      +
      15251  suballocType,
      +
      15252  allocationCount,
      +
      15253  pAllocations);
      +
      15254  // Allocation from this alternative memory type succeeded.
      +
      15255  if(res == VK_SUCCESS)
      +
      15256  {
      +
      15257  return res;
      +
      15258  }
      +
      15259  // else: Allocation from this memory type failed. Try next one - next loop iteration.
      +
      15260  }
      +
      15261  // No other matching memory type index could be found.
      +
      15262  else
      +
      15263  {
      +
      15264  // Not returning res, which is VK_ERROR_FEATURE_NOT_PRESENT, because we already failed to allocate once.
      +
      15265  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      +
      15266  }
      +
      15267  }
      +
      15268  }
      +
      15269  }
      +
      15270  // Can't find any single memory type maching requirements. res is VK_ERROR_FEATURE_NOT_PRESENT.
      +
      15271  else
      +
      15272  return res;
      +
      15273  }
      +
      15274 }
      +
      15275 
      +
      15276 void VmaAllocator_T::FreeMemory(
      +
      15277  size_t allocationCount,
      +
      15278  const VmaAllocation* pAllocations)
      +
      15279 {
      +
      15280  VMA_ASSERT(pAllocations);
      +
      15281 
      +
      15282  for(size_t allocIndex = allocationCount; allocIndex--; )
      +
      15283  {
      +
      15284  VmaAllocation allocation = pAllocations[allocIndex];
      +
      15285 
      +
      15286  if(allocation != VK_NULL_HANDLE)
      +
      15287  {
      +
      15288  if(TouchAllocation(allocation))
      +
      15289  {
      +
      15290  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS)
      +
      15291  {
      +
      15292  FillAllocation(allocation, VMA_ALLOCATION_FILL_PATTERN_DESTROYED);
      +
      15293  }
      +
      15294 
      +
      15295  switch(allocation->GetType())
      +
      15296  {
      +
      15297  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
      +
      15298  {
      +
      15299  VmaBlockVector* pBlockVector = VMA_NULL;
      +
      15300  VmaPool hPool = allocation->GetBlock()->GetParentPool();
      +
      15301  if(hPool != VK_NULL_HANDLE)
      +
      15302  {
      +
      15303  pBlockVector = &hPool->m_BlockVector;
      +
      15304  }
      +
      15305  else
      +
      15306  {
      +
      15307  const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
      +
      15308  pBlockVector = m_pBlockVectors[memTypeIndex];
      +
      15309  }
      +
      15310  pBlockVector->Free(allocation);
      +
      15311  }
      +
      15312  break;
      +
      15313  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
      +
      15314  FreeDedicatedMemory(allocation);
      +
      15315  break;
      +
      15316  default:
      +
      15317  VMA_ASSERT(0);
      +
      15318  }
      +
      15319  }
      +
      15320 
      +
      15321  // Do this regardless of whether the allocation is lost. Lost allocations still account to Budget.AllocationBytes.
      +
      15322  m_Budget.RemoveAllocation(MemoryTypeIndexToHeapIndex(allocation->GetMemoryTypeIndex()), allocation->GetSize());
      +
      15323  allocation->SetUserData(this, VMA_NULL);
      +
      15324  allocation->Dtor();
      +
      15325  m_AllocationObjectAllocator.Free(allocation);
      +
      15326  }
      +
      15327  }
      +
      15328 }
      +
      15329 
      +
      15330 VkResult VmaAllocator_T::ResizeAllocation(
      +
      15331  const VmaAllocation alloc,
      +
      15332  VkDeviceSize newSize)
      +
      15333 {
      +
      15334  // This function is deprecated and so it does nothing. It's left for backward compatibility.
      +
      15335  if(newSize == 0 || alloc->GetLastUseFrameIndex() == VMA_FRAME_INDEX_LOST)
      +
      15336  {
      +
      15337  return VK_ERROR_VALIDATION_FAILED_EXT;
      +
      15338  }
      +
      15339  if(newSize == alloc->GetSize())
      15340  {
      -
      15341  for(uint32_t i = 0; i < heapCount; ++i, ++outBudget)
      -
      15342  {
      -
      15343  const uint32_t heapIndex = firstHeap + i;
      -
      15344 
      -
      15345  outBudget->blockBytes = m_Budget.m_BlockBytes[heapIndex];
      -
      15346  outBudget->allocationBytes = m_Budget.m_AllocationBytes[heapIndex];
      -
      15347 
      -
      15348  outBudget->usage = outBudget->blockBytes;
      -
      15349  outBudget->budget = m_MemProps.memoryHeaps[heapIndex].size * 8 / 10; // 80% heuristics.
      -
      15350  }
      -
      15351  }
      -
      15352 }
      -
      15353 
      -
      15354 static const uint32_t VMA_VENDOR_ID_AMD = 4098;
      -
      15355 
      -
      15356 VkResult VmaAllocator_T::DefragmentationBegin(
      -
      15357  const VmaDefragmentationInfo2& info,
      -
      15358  VmaDefragmentationStats* pStats,
      -
      15359  VmaDefragmentationContext* pContext)
      -
      15360 {
      -
      15361  if(info.pAllocationsChanged != VMA_NULL)
      -
      15362  {
      -
      15363  memset(info.pAllocationsChanged, 0, info.allocationCount * sizeof(VkBool32));
      -
      15364  }
      -
      15365 
      -
      15366  *pContext = vma_new(this, VmaDefragmentationContext_T)(
      -
      15367  this, m_CurrentFrameIndex.load(), info.flags, pStats);
      -
      15368 
      -
      15369  (*pContext)->AddPools(info.poolCount, info.pPools);
      -
      15370  (*pContext)->AddAllocations(
      -
      15371  info.allocationCount, info.pAllocations, info.pAllocationsChanged);
      -
      15372 
      -
      15373  VkResult res = (*pContext)->Defragment(
      -
      15374  info.maxCpuBytesToMove, info.maxCpuAllocationsToMove,
      -
      15375  info.maxGpuBytesToMove, info.maxGpuAllocationsToMove,
      -
      15376  info.commandBuffer, pStats);
      -
      15377 
      -
      15378  if(res != VK_NOT_READY)
      -
      15379  {
      -
      15380  vma_delete(this, *pContext);
      -
      15381  *pContext = VMA_NULL;
      -
      15382  }
      -
      15383 
      -
      15384  return res;
      -
      15385 }
      -
      15386 
      -
      15387 VkResult VmaAllocator_T::DefragmentationEnd(
      -
      15388  VmaDefragmentationContext context)
      -
      15389 {
      -
      15390  vma_delete(this, context);
      -
      15391  return VK_SUCCESS;
      -
      15392 }
      -
      15393 
      -
      15394 void VmaAllocator_T::GetAllocationInfo(VmaAllocation hAllocation, VmaAllocationInfo* pAllocationInfo)
      -
      15395 {
      -
      15396  if(hAllocation->CanBecomeLost())
      -
      15397  {
      -
      15398  /*
      -
      15399  Warning: This is a carefully designed algorithm.
      -
      15400  Do not modify unless you really know what you're doing :)
      -
      15401  */
      -
      15402  const uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
      -
      15403  uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
      -
      15404  for(;;)
      -
      15405  {
      -
      15406  if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)
      -
      15407  {
      -
      15408  pAllocationInfo->memoryType = UINT32_MAX;
      -
      15409  pAllocationInfo->deviceMemory = VK_NULL_HANDLE;
      -
      15410  pAllocationInfo->offset = 0;
      -
      15411  pAllocationInfo->size = hAllocation->GetSize();
      -
      15412  pAllocationInfo->pMappedData = VMA_NULL;
      -
      15413  pAllocationInfo->pUserData = hAllocation->GetUserData();
      -
      15414  return;
      -
      15415  }
      -
      15416  else if(localLastUseFrameIndex == localCurrFrameIndex)
      -
      15417  {
      -
      15418  pAllocationInfo->memoryType = hAllocation->GetMemoryTypeIndex();
      -
      15419  pAllocationInfo->deviceMemory = hAllocation->GetMemory();
      -
      15420  pAllocationInfo->offset = hAllocation->GetOffset();
      -
      15421  pAllocationInfo->size = hAllocation->GetSize();
      -
      15422  pAllocationInfo->pMappedData = VMA_NULL;
      -
      15423  pAllocationInfo->pUserData = hAllocation->GetUserData();
      -
      15424  return;
      +
      15341  return VK_SUCCESS;
      +
      15342  }
      +
      15343  return VK_ERROR_OUT_OF_POOL_MEMORY;
      +
      15344 }
      +
      15345 
      +
      15346 void VmaAllocator_T::CalculateStats(VmaStats* pStats)
      +
      15347 {
      +
      15348  // Initialize.
      +
      15349  InitStatInfo(pStats->total);
      +
      15350  for(size_t i = 0; i < VK_MAX_MEMORY_TYPES; ++i)
      +
      15351  InitStatInfo(pStats->memoryType[i]);
      +
      15352  for(size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i)
      +
      15353  InitStatInfo(pStats->memoryHeap[i]);
      +
      15354 
      +
      15355  // Process default pools.
      +
      15356  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
      +
      15357  {
      +
      15358  VmaBlockVector* const pBlockVector = m_pBlockVectors[memTypeIndex];
      +
      15359  VMA_ASSERT(pBlockVector);
      +
      15360  pBlockVector->AddStats(pStats);
      +
      15361  }
      +
      15362 
      +
      15363  // Process custom pools.
      +
      15364  {
      +
      15365  VmaMutexLockRead lock(m_PoolsMutex, m_UseMutex);
      +
      15366  for(size_t poolIndex = 0, poolCount = m_Pools.size(); poolIndex < poolCount; ++poolIndex)
      +
      15367  {
      +
      15368  m_Pools[poolIndex]->m_BlockVector.AddStats(pStats);
      +
      15369  }
      +
      15370  }
      +
      15371 
      +
      15372  // Process dedicated allocations.
      +
      15373  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
      +
      15374  {
      +
      15375  const uint32_t memHeapIndex = MemoryTypeIndexToHeapIndex(memTypeIndex);
      +
      15376  VmaMutexLockRead dedicatedAllocationsLock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
      +
      15377  AllocationVectorType* const pDedicatedAllocVector = m_pDedicatedAllocations[memTypeIndex];
      +
      15378  VMA_ASSERT(pDedicatedAllocVector);
      +
      15379  for(size_t allocIndex = 0, allocCount = pDedicatedAllocVector->size(); allocIndex < allocCount; ++allocIndex)
      +
      15380  {
      +
      15381  VmaStatInfo allocationStatInfo;
      +
      15382  (*pDedicatedAllocVector)[allocIndex]->DedicatedAllocCalcStatsInfo(allocationStatInfo);
      +
      15383  VmaAddStatInfo(pStats->total, allocationStatInfo);
      +
      15384  VmaAddStatInfo(pStats->memoryType[memTypeIndex], allocationStatInfo);
      +
      15385  VmaAddStatInfo(pStats->memoryHeap[memHeapIndex], allocationStatInfo);
      +
      15386  }
      +
      15387  }
      +
      15388 
      +
      15389  // Postprocess.
      +
      15390  VmaPostprocessCalcStatInfo(pStats->total);
      +
      15391  for(size_t i = 0; i < GetMemoryTypeCount(); ++i)
      +
      15392  VmaPostprocessCalcStatInfo(pStats->memoryType[i]);
      +
      15393  for(size_t i = 0; i < GetMemoryHeapCount(); ++i)
      +
      15394  VmaPostprocessCalcStatInfo(pStats->memoryHeap[i]);
      +
      15395 }
      +
      15396 
      +
      15397 void VmaAllocator_T::GetBudget(VmaBudget* outBudget, uint32_t firstHeap, uint32_t heapCount)
      +
      15398 {
      +
      15399 #if VMA_MEMORY_BUDGET
      +
      15400  if(m_UseExtMemoryBudget)
      +
      15401  {
      +
      15402  if(m_Budget.m_OperationsSinceBudgetFetch < 30)
      +
      15403  {
      +
      15404  VmaMutexLockRead lockRead(m_Budget.m_BudgetMutex, m_UseMutex);
      +
      15405  for(uint32_t i = 0; i < heapCount; ++i, ++outBudget)
      +
      15406  {
      +
      15407  const uint32_t heapIndex = firstHeap + i;
      +
      15408 
      +
      15409  outBudget->blockBytes = m_Budget.m_BlockBytes[heapIndex];
      +
      15410  outBudget->allocationBytes = m_Budget.m_AllocationBytes[heapIndex];
      +
      15411 
      +
      15412  if(m_Budget.m_VulkanUsage[heapIndex] + outBudget->blockBytes > m_Budget.m_BlockBytesAtBudgetFetch[heapIndex])
      +
      15413  {
      +
      15414  outBudget->usage = m_Budget.m_VulkanUsage[heapIndex] +
      +
      15415  outBudget->blockBytes - m_Budget.m_BlockBytesAtBudgetFetch[heapIndex];
      +
      15416  }
      +
      15417  else
      +
      15418  {
      +
      15419  outBudget->usage = 0;
      +
      15420  }
      +
      15421 
      +
      15422  // Have to take MIN with heap size because explicit HeapSizeLimit is included in it.
      +
      15423  outBudget->budget = VMA_MIN(
      +
      15424  m_Budget.m_VulkanBudget[heapIndex], m_MemProps.memoryHeaps[heapIndex].size);
      15425  }
      -
      15426  else // Last use time earlier than current time.
      -
      15427  {
      -
      15428  if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
      -
      15429  {
      -
      15430  localLastUseFrameIndex = localCurrFrameIndex;
      -
      15431  }
      -
      15432  }
      -
      15433  }
      -
      15434  }
      -
      15435  else
      -
      15436  {
      -
      15437 #if VMA_STATS_STRING_ENABLED
      -
      15438  uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
      -
      15439  uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
      -
      15440  for(;;)
      -
      15441  {
      -
      15442  VMA_ASSERT(localLastUseFrameIndex != VMA_FRAME_INDEX_LOST);
      -
      15443  if(localLastUseFrameIndex == localCurrFrameIndex)
      -
      15444  {
      -
      15445  break;
      -
      15446  }
      -
      15447  else // Last use time earlier than current time.
      -
      15448  {
      -
      15449  if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
      -
      15450  {
      -
      15451  localLastUseFrameIndex = localCurrFrameIndex;
      -
      15452  }
      -
      15453  }
      -
      15454  }
      -
      15455 #endif
      -
      15456 
      -
      15457  pAllocationInfo->memoryType = hAllocation->GetMemoryTypeIndex();
      -
      15458  pAllocationInfo->deviceMemory = hAllocation->GetMemory();
      -
      15459  pAllocationInfo->offset = hAllocation->GetOffset();
      -
      15460  pAllocationInfo->size = hAllocation->GetSize();
      -
      15461  pAllocationInfo->pMappedData = hAllocation->GetMappedData();
      -
      15462  pAllocationInfo->pUserData = hAllocation->GetUserData();
      -
      15463  }
      -
      15464 }
      -
      15465 
      -
      15466 bool VmaAllocator_T::TouchAllocation(VmaAllocation hAllocation)
      -
      15467 {
      -
      15468  // This is a stripped-down version of VmaAllocator_T::GetAllocationInfo.
      -
      15469  if(hAllocation->CanBecomeLost())
      -
      15470  {
      -
      15471  uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
      -
      15472  uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
      -
      15473  for(;;)
      -
      15474  {
      -
      15475  if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)
      -
      15476  {
      -
      15477  return false;
      -
      15478  }
      -
      15479  else if(localLastUseFrameIndex == localCurrFrameIndex)
      -
      15480  {
      -
      15481  return true;
      -
      15482  }
      -
      15483  else // Last use time earlier than current time.
      -
      15484  {
      -
      15485  if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
      -
      15486  {
      -
      15487  localLastUseFrameIndex = localCurrFrameIndex;
      -
      15488  }
      -
      15489  }
      -
      15490  }
      -
      15491  }
      -
      15492  else
      -
      15493  {
      -
      15494 #if VMA_STATS_STRING_ENABLED
      -
      15495  uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
      -
      15496  uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
      -
      15497  for(;;)
      -
      15498  {
      -
      15499  VMA_ASSERT(localLastUseFrameIndex != VMA_FRAME_INDEX_LOST);
      -
      15500  if(localLastUseFrameIndex == localCurrFrameIndex)
      -
      15501  {
      -
      15502  break;
      -
      15503  }
      -
      15504  else // Last use time earlier than current time.
      -
      15505  {
      -
      15506  if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
      -
      15507  {
      -
      15508  localLastUseFrameIndex = localCurrFrameIndex;
      -
      15509  }
      +
      15426  }
      +
      15427  else
      +
      15428  {
      +
      15429  UpdateVulkanBudget(); // Outside of mutex lock
      +
      15430  GetBudget(outBudget, firstHeap, heapCount); // Recursion
      +
      15431  }
      +
      15432  }
      +
      15433  else
      +
      15434 #endif
      +
      15435  {
      +
      15436  for(uint32_t i = 0; i < heapCount; ++i, ++outBudget)
      +
      15437  {
      +
      15438  const uint32_t heapIndex = firstHeap + i;
      +
      15439 
      +
      15440  outBudget->blockBytes = m_Budget.m_BlockBytes[heapIndex];
      +
      15441  outBudget->allocationBytes = m_Budget.m_AllocationBytes[heapIndex];
      +
      15442 
      +
      15443  outBudget->usage = outBudget->blockBytes;
      +
      15444  outBudget->budget = m_MemProps.memoryHeaps[heapIndex].size * 8 / 10; // 80% heuristics.
      +
      15445  }
      +
      15446  }
      +
      15447 }
      +
      15448 
      +
      15449 static const uint32_t VMA_VENDOR_ID_AMD = 4098;
      +
      15450 
      +
      15451 VkResult VmaAllocator_T::DefragmentationBegin(
      +
      15452  const VmaDefragmentationInfo2& info,
      +
      15453  VmaDefragmentationStats* pStats,
      +
      15454  VmaDefragmentationContext* pContext)
      +
      15455 {
      +
      15456  if(info.pAllocationsChanged != VMA_NULL)
      +
      15457  {
      +
      15458  memset(info.pAllocationsChanged, 0, info.allocationCount * sizeof(VkBool32));
      +
      15459  }
      +
      15460 
      +
      15461  *pContext = vma_new(this, VmaDefragmentationContext_T)(
      +
      15462  this, m_CurrentFrameIndex.load(), info.flags, pStats);
      +
      15463 
      +
      15464  (*pContext)->AddPools(info.poolCount, info.pPools);
      +
      15465  (*pContext)->AddAllocations(
      +
      15466  info.allocationCount, info.pAllocations, info.pAllocationsChanged);
      +
      15467 
      +
      15468  VkResult res = (*pContext)->Defragment(
      +
      15469  info.maxCpuBytesToMove, info.maxCpuAllocationsToMove,
      +
      15470  info.maxGpuBytesToMove, info.maxGpuAllocationsToMove,
      +
      15471  info.commandBuffer, pStats);
      +
      15472 
      +
      15473  if(res != VK_NOT_READY)
      +
      15474  {
      +
      15475  vma_delete(this, *pContext);
      +
      15476  *pContext = VMA_NULL;
      +
      15477  }
      +
      15478 
      +
      15479  return res;
      +
      15480 }
      +
      15481 
      +
      15482 VkResult VmaAllocator_T::DefragmentationEnd(
      +
      15483  VmaDefragmentationContext context)
      +
      15484 {
      +
      15485  vma_delete(this, context);
      +
      15486  return VK_SUCCESS;
      +
      15487 }
      +
      15488 
      +
      15489 void VmaAllocator_T::GetAllocationInfo(VmaAllocation hAllocation, VmaAllocationInfo* pAllocationInfo)
      +
      15490 {
      +
      15491  if(hAllocation->CanBecomeLost())
      +
      15492  {
      +
      15493  /*
      +
      15494  Warning: This is a carefully designed algorithm.
      +
      15495  Do not modify unless you really know what you're doing :)
      +
      15496  */
      +
      15497  const uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
      +
      15498  uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
      +
      15499  for(;;)
      +
      15500  {
      +
      15501  if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)
      +
      15502  {
      +
      15503  pAllocationInfo->memoryType = UINT32_MAX;
      +
      15504  pAllocationInfo->deviceMemory = VK_NULL_HANDLE;
      +
      15505  pAllocationInfo->offset = 0;
      +
      15506  pAllocationInfo->size = hAllocation->GetSize();
      +
      15507  pAllocationInfo->pMappedData = VMA_NULL;
      +
      15508  pAllocationInfo->pUserData = hAllocation->GetUserData();
      +
      15509  return;
      15510  }
      -
      15511  }
      -
      15512 #endif
      -
      15513 
      -
      15514  return true;
      -
      15515  }
      -
      15516 }
      -
      15517 
      -
      15518 VkResult VmaAllocator_T::CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool)
      -
      15519 {
      -
      15520  VMA_DEBUG_LOG(" CreatePool: MemoryTypeIndex=%u, flags=%u", pCreateInfo->memoryTypeIndex, pCreateInfo->flags);
      -
      15521 
      -
      15522  VmaPoolCreateInfo newCreateInfo = *pCreateInfo;
      -
      15523 
      -
      15524  if(newCreateInfo.maxBlockCount == 0)
      -
      15525  {
      -
      15526  newCreateInfo.maxBlockCount = SIZE_MAX;
      -
      15527  }
      -
      15528  if(newCreateInfo.minBlockCount > newCreateInfo.maxBlockCount)
      -
      15529  {
      -
      15530  return VK_ERROR_INITIALIZATION_FAILED;
      -
      15531  }
      -
      15532 
      -
      15533  const VkDeviceSize preferredBlockSize = CalcPreferredBlockSize(newCreateInfo.memoryTypeIndex);
      -
      15534 
      -
      15535  *pPool = vma_new(this, VmaPool_T)(this, newCreateInfo, preferredBlockSize);
      -
      15536 
      -
      15537  VkResult res = (*pPool)->m_BlockVector.CreateMinBlocks();
      -
      15538  if(res != VK_SUCCESS)
      -
      15539  {
      -
      15540  vma_delete(this, *pPool);
      -
      15541  *pPool = VMA_NULL;
      -
      15542  return res;
      -
      15543  }
      -
      15544 
      -
      15545  // Add to m_Pools.
      -
      15546  {
      -
      15547  VmaMutexLockWrite lock(m_PoolsMutex, m_UseMutex);
      -
      15548  (*pPool)->SetId(m_NextPoolId++);
      -
      15549  VmaVectorInsertSorted<VmaPointerLess>(m_Pools, *pPool);
      -
      15550  }
      +
      15511  else if(localLastUseFrameIndex == localCurrFrameIndex)
      +
      15512  {
      +
      15513  pAllocationInfo->memoryType = hAllocation->GetMemoryTypeIndex();
      +
      15514  pAllocationInfo->deviceMemory = hAllocation->GetMemory();
      +
      15515  pAllocationInfo->offset = hAllocation->GetOffset();
      +
      15516  pAllocationInfo->size = hAllocation->GetSize();
      +
      15517  pAllocationInfo->pMappedData = VMA_NULL;
      +
      15518  pAllocationInfo->pUserData = hAllocation->GetUserData();
      +
      15519  return;
      +
      15520  }
      +
      15521  else // Last use time earlier than current time.
      +
      15522  {
      +
      15523  if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
      +
      15524  {
      +
      15525  localLastUseFrameIndex = localCurrFrameIndex;
      +
      15526  }
      +
      15527  }
      +
      15528  }
      +
      15529  }
      +
      15530  else
      +
      15531  {
      +
      15532 #if VMA_STATS_STRING_ENABLED
      +
      15533  uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
      +
      15534  uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
      +
      15535  for(;;)
      +
      15536  {
      +
      15537  VMA_ASSERT(localLastUseFrameIndex != VMA_FRAME_INDEX_LOST);
      +
      15538  if(localLastUseFrameIndex == localCurrFrameIndex)
      +
      15539  {
      +
      15540  break;
      +
      15541  }
      +
      15542  else // Last use time earlier than current time.
      +
      15543  {
      +
      15544  if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
      +
      15545  {
      +
      15546  localLastUseFrameIndex = localCurrFrameIndex;
      +
      15547  }
      +
      15548  }
      +
      15549  }
      +
      15550 #endif
      15551 
      -
      15552  return VK_SUCCESS;
      -
      15553 }
      -
      15554 
      -
      15555 void VmaAllocator_T::DestroyPool(VmaPool pool)
      -
      15556 {
      -
      15557  // Remove from m_Pools.
      -
      15558  {
      -
      15559  VmaMutexLockWrite lock(m_PoolsMutex, m_UseMutex);
      -
      15560  bool success = VmaVectorRemoveSorted<VmaPointerLess>(m_Pools, pool);
      -
      15561  VMA_ASSERT(success && "Pool not found in Allocator.");
      -
      15562  }
      -
      15563 
      -
      15564  vma_delete(this, pool);
      -
      15565 }
      -
      15566 
      -
      15567 void VmaAllocator_T::GetPoolStats(VmaPool pool, VmaPoolStats* pPoolStats)
      -
      15568 {
      -
      15569  pool->m_BlockVector.GetPoolStats(pPoolStats);
      -
      15570 }
      -
      15571 
      -
      15572 void VmaAllocator_T::SetCurrentFrameIndex(uint32_t frameIndex)
      -
      15573 {
      -
      15574  m_CurrentFrameIndex.store(frameIndex);
      -
      15575 
      -
      15576 #if VMA_MEMORY_BUDGET
      -
      15577  if(m_UseExtMemoryBudget)
      -
      15578  {
      -
      15579  UpdateVulkanBudget();
      -
      15580  }
      -
      15581 #endif // #if VMA_MEMORY_BUDGET
      -
      15582 }
      -
      15583 
      -
      15584 void VmaAllocator_T::MakePoolAllocationsLost(
      -
      15585  VmaPool hPool,
      -
      15586  size_t* pLostAllocationCount)
      -
      15587 {
      -
      15588  hPool->m_BlockVector.MakePoolAllocationsLost(
      -
      15589  m_CurrentFrameIndex.load(),
      -
      15590  pLostAllocationCount);
      -
      15591 }
      -
      15592 
      -
      15593 VkResult VmaAllocator_T::CheckPoolCorruption(VmaPool hPool)
      -
      15594 {
      -
      15595  return hPool->m_BlockVector.CheckCorruption();
      -
      15596 }
      -
      15597 
      -
      15598 VkResult VmaAllocator_T::CheckCorruption(uint32_t memoryTypeBits)
      -
      15599 {
      -
      15600  VkResult finalRes = VK_ERROR_FEATURE_NOT_PRESENT;
      -
      15601 
      -
      15602  // Process default pools.
      -
      15603  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
      -
      15604  {
      -
      15605  if(((1u << memTypeIndex) & memoryTypeBits) != 0)
      -
      15606  {
      -
      15607  VmaBlockVector* const pBlockVector = m_pBlockVectors[memTypeIndex];
      -
      15608  VMA_ASSERT(pBlockVector);
      -
      15609  VkResult localRes = pBlockVector->CheckCorruption();
      -
      15610  switch(localRes)
      -
      15611  {
      -
      15612  case VK_ERROR_FEATURE_NOT_PRESENT:
      -
      15613  break;
      -
      15614  case VK_SUCCESS:
      -
      15615  finalRes = VK_SUCCESS;
      -
      15616  break;
      -
      15617  default:
      -
      15618  return localRes;
      -
      15619  }
      -
      15620  }
      -
      15621  }
      -
      15622 
      -
      15623  // Process custom pools.
      +
      15552  pAllocationInfo->memoryType = hAllocation->GetMemoryTypeIndex();
      +
      15553  pAllocationInfo->deviceMemory = hAllocation->GetMemory();
      +
      15554  pAllocationInfo->offset = hAllocation->GetOffset();
      +
      15555  pAllocationInfo->size = hAllocation->GetSize();
      +
      15556  pAllocationInfo->pMappedData = hAllocation->GetMappedData();
      +
      15557  pAllocationInfo->pUserData = hAllocation->GetUserData();
      +
      15558  }
      +
      15559 }
      +
      15560 
      +
      15561 bool VmaAllocator_T::TouchAllocation(VmaAllocation hAllocation)
      +
      15562 {
      +
      15563  // This is a stripped-down version of VmaAllocator_T::GetAllocationInfo.
      +
      15564  if(hAllocation->CanBecomeLost())
      +
      15565  {
      +
      15566  uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
      +
      15567  uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
      +
      15568  for(;;)
      +
      15569  {
      +
      15570  if(localLastUseFrameIndex == VMA_FRAME_INDEX_LOST)
      +
      15571  {
      +
      15572  return false;
      +
      15573  }
      +
      15574  else if(localLastUseFrameIndex == localCurrFrameIndex)
      +
      15575  {
      +
      15576  return true;
      +
      15577  }
      +
      15578  else // Last use time earlier than current time.
      +
      15579  {
      +
      15580  if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
      +
      15581  {
      +
      15582  localLastUseFrameIndex = localCurrFrameIndex;
      +
      15583  }
      +
      15584  }
      +
      15585  }
      +
      15586  }
      +
      15587  else
      +
      15588  {
      +
      15589 #if VMA_STATS_STRING_ENABLED
      +
      15590  uint32_t localCurrFrameIndex = m_CurrentFrameIndex.load();
      +
      15591  uint32_t localLastUseFrameIndex = hAllocation->GetLastUseFrameIndex();
      +
      15592  for(;;)
      +
      15593  {
      +
      15594  VMA_ASSERT(localLastUseFrameIndex != VMA_FRAME_INDEX_LOST);
      +
      15595  if(localLastUseFrameIndex == localCurrFrameIndex)
      +
      15596  {
      +
      15597  break;
      +
      15598  }
      +
      15599  else // Last use time earlier than current time.
      +
      15600  {
      +
      15601  if(hAllocation->CompareExchangeLastUseFrameIndex(localLastUseFrameIndex, localCurrFrameIndex))
      +
      15602  {
      +
      15603  localLastUseFrameIndex = localCurrFrameIndex;
      +
      15604  }
      +
      15605  }
      +
      15606  }
      +
      15607 #endif
      +
      15608 
      +
      15609  return true;
      +
      15610  }
      +
      15611 }
      +
      15612 
      +
      15613 VkResult VmaAllocator_T::CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool)
      +
      15614 {
      +
      15615  VMA_DEBUG_LOG(" CreatePool: MemoryTypeIndex=%u, flags=%u", pCreateInfo->memoryTypeIndex, pCreateInfo->flags);
      +
      15616 
      +
      15617  VmaPoolCreateInfo newCreateInfo = *pCreateInfo;
      +
      15618 
      +
      15619  if(newCreateInfo.maxBlockCount == 0)
      +
      15620  {
      +
      15621  newCreateInfo.maxBlockCount = SIZE_MAX;
      +
      15622  }
      +
      15623  if(newCreateInfo.minBlockCount > newCreateInfo.maxBlockCount)
      15624  {
      -
      15625  VmaMutexLockRead lock(m_PoolsMutex, m_UseMutex);
      -
      15626  for(size_t poolIndex = 0, poolCount = m_Pools.size(); poolIndex < poolCount; ++poolIndex)
      -
      15627  {
      -
      15628  if(((1u << m_Pools[poolIndex]->m_BlockVector.GetMemoryTypeIndex()) & memoryTypeBits) != 0)
      -
      15629  {
      -
      15630  VkResult localRes = m_Pools[poolIndex]->m_BlockVector.CheckCorruption();
      -
      15631  switch(localRes)
      -
      15632  {
      -
      15633  case VK_ERROR_FEATURE_NOT_PRESENT:
      -
      15634  break;
      -
      15635  case VK_SUCCESS:
      -
      15636  finalRes = VK_SUCCESS;
      -
      15637  break;
      -
      15638  default:
      -
      15639  return localRes;
      -
      15640  }
      -
      15641  }
      -
      15642  }
      -
      15643  }
      -
      15644 
      -
      15645  return finalRes;
      -
      15646 }
      -
      15647 
      -
      15648 void VmaAllocator_T::CreateLostAllocation(VmaAllocation* pAllocation)
      -
      15649 {
      -
      15650  *pAllocation = m_AllocationObjectAllocator.Allocate();
      -
      15651  (*pAllocation)->Ctor(VMA_FRAME_INDEX_LOST, false);
      -
      15652  (*pAllocation)->InitLost();
      -
      15653 }
      -
      15654 
      -
      15655 VkResult VmaAllocator_T::AllocateVulkanMemory(const VkMemoryAllocateInfo* pAllocateInfo, VkDeviceMemory* pMemory)
      -
      15656 {
      -
      15657  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(pAllocateInfo->memoryTypeIndex);
      +
      15625  return VK_ERROR_INITIALIZATION_FAILED;
      +
      15626  }
      +
      15627 
      +
      15628  const VkDeviceSize preferredBlockSize = CalcPreferredBlockSize(newCreateInfo.memoryTypeIndex);
      +
      15629 
      +
      15630  *pPool = vma_new(this, VmaPool_T)(this, newCreateInfo, preferredBlockSize);
      +
      15631 
      +
      15632  VkResult res = (*pPool)->m_BlockVector.CreateMinBlocks();
      +
      15633  if(res != VK_SUCCESS)
      +
      15634  {
      +
      15635  vma_delete(this, *pPool);
      +
      15636  *pPool = VMA_NULL;
      +
      15637  return res;
      +
      15638  }
      +
      15639 
      +
      15640  // Add to m_Pools.
      +
      15641  {
      +
      15642  VmaMutexLockWrite lock(m_PoolsMutex, m_UseMutex);
      +
      15643  (*pPool)->SetId(m_NextPoolId++);
      +
      15644  VmaVectorInsertSorted<VmaPointerLess>(m_Pools, *pPool);
      +
      15645  }
      +
      15646 
      +
      15647  return VK_SUCCESS;
      +
      15648 }
      +
      15649 
      +
      15650 void VmaAllocator_T::DestroyPool(VmaPool pool)
      +
      15651 {
      +
      15652  // Remove from m_Pools.
      +
      15653  {
      +
      15654  VmaMutexLockWrite lock(m_PoolsMutex, m_UseMutex);
      +
      15655  bool success = VmaVectorRemoveSorted<VmaPointerLess>(m_Pools, pool);
      +
      15656  VMA_ASSERT(success && "Pool not found in Allocator.");
      +
      15657  }
      15658 
      -
      15659  // HeapSizeLimit is in effect for this heap.
      -
      15660  if((m_HeapSizeLimitMask | (1u << heapIndex)) != 0)
      -
      15661  {
      -
      15662  const VkDeviceSize heapSize = m_MemProps.memoryHeaps[heapIndex].size;
      -
      15663  VkDeviceSize blockBytes = m_Budget.m_BlockBytes[heapIndex];
      -
      15664  for(;;)
      -
      15665  {
      -
      15666  const VkDeviceSize blockBytesAfterAllocation = blockBytes + pAllocateInfo->allocationSize;
      -
      15667  if(blockBytesAfterAllocation > heapSize)
      -
      15668  {
      -
      15669  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      -
      15670  }
      -
      15671  if(m_Budget.m_BlockBytes->compare_exchange_strong(blockBytes, blockBytesAfterAllocation))
      -
      15672  {
      -
      15673  break;
      -
      15674  }
      -
      15675  }
      -
      15676  }
      -
      15677  else
      -
      15678  {
      -
      15679  m_Budget.m_BlockBytes[heapIndex] += pAllocateInfo->allocationSize;
      -
      15680  }
      -
      15681 
      -
      15682  // VULKAN CALL vkAllocateMemory.
      -
      15683  VkResult res = (*m_VulkanFunctions.vkAllocateMemory)(m_hDevice, pAllocateInfo, GetAllocationCallbacks(), pMemory);
      -
      15684 
      -
      15685  if(res == VK_SUCCESS)
      -
      15686  {
      -
      15687  ++m_Budget.m_OperationsSinceBudgetFetch;
      -
      15688 
      -
      15689  // Informative callback.
      -
      15690  if(m_DeviceMemoryCallbacks.pfnAllocate != VMA_NULL)
      -
      15691  {
      -
      15692  (*m_DeviceMemoryCallbacks.pfnAllocate)(this, pAllocateInfo->memoryTypeIndex, *pMemory, pAllocateInfo->allocationSize);
      -
      15693  }
      -
      15694  }
      -
      15695  else
      -
      15696  {
      -
      15697  m_Budget.m_BlockBytes[heapIndex] -= pAllocateInfo->allocationSize;
      -
      15698  }
      -
      15699 
      -
      15700  return res;
      -
      15701 }
      -
      15702 
      -
      15703 void VmaAllocator_T::FreeVulkanMemory(uint32_t memoryType, VkDeviceSize size, VkDeviceMemory hMemory)
      -
      15704 {
      -
      15705  // Informative callback.
      -
      15706  if(m_DeviceMemoryCallbacks.pfnFree != VMA_NULL)
      -
      15707  {
      -
      15708  (*m_DeviceMemoryCallbacks.pfnFree)(this, memoryType, hMemory, size);
      -
      15709  }
      -
      15710 
      -
      15711  // VULKAN CALL vkFreeMemory.
      -
      15712  (*m_VulkanFunctions.vkFreeMemory)(m_hDevice, hMemory, GetAllocationCallbacks());
      -
      15713 
      -
      15714  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(memoryType);
      -
      15715  m_Budget.m_BlockBytes[heapIndex] -= size;
      -
      15716  ++m_Budget.m_OperationsSinceBudgetFetch;
      -
      15717 }
      -
      15718 
      -
      15719 VkResult VmaAllocator_T::BindVulkanBuffer(
      -
      15720  VkDeviceMemory memory,
      -
      15721  VkDeviceSize memoryOffset,
      -
      15722  VkBuffer buffer,
      -
      15723  const void* pNext)
      -
      15724 {
      -
      15725  if(pNext != VMA_NULL)
      -
      15726  {
      -
      15727 #if VMA_BIND_MEMORY2
      -
      15728  if(m_UseKhrBindMemory2 && m_VulkanFunctions.vkBindBufferMemory2KHR != VMA_NULL)
      -
      15729  {
      -
      15730  VkBindBufferMemoryInfoKHR bindBufferMemoryInfo = { VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR };
      -
      15731  bindBufferMemoryInfo.pNext = pNext;
      -
      15732  bindBufferMemoryInfo.buffer = buffer;
      -
      15733  bindBufferMemoryInfo.memory = memory;
      -
      15734  bindBufferMemoryInfo.memoryOffset = memoryOffset;
      -
      15735  return (*m_VulkanFunctions.vkBindBufferMemory2KHR)(m_hDevice, 1, &bindBufferMemoryInfo);
      -
      15736  }
      -
      15737  else
      -
      15738 #endif // #if VMA_BIND_MEMORY2
      -
      15739  {
      -
      15740  return VK_ERROR_EXTENSION_NOT_PRESENT;
      -
      15741  }
      -
      15742  }
      -
      15743  else
      -
      15744  {
      -
      15745  return (*m_VulkanFunctions.vkBindBufferMemory)(m_hDevice, buffer, memory, memoryOffset);
      -
      15746  }
      -
      15747 }
      -
      15748 
      -
      15749 VkResult VmaAllocator_T::BindVulkanImage(
      -
      15750  VkDeviceMemory memory,
      -
      15751  VkDeviceSize memoryOffset,
      -
      15752  VkImage image,
      -
      15753  const void* pNext)
      -
      15754 {
      -
      15755  if(pNext != VMA_NULL)
      +
      15659  vma_delete(this, pool);
      +
      15660 }
      +
      15661 
      +
      15662 void VmaAllocator_T::GetPoolStats(VmaPool pool, VmaPoolStats* pPoolStats)
      +
      15663 {
      +
      15664  pool->m_BlockVector.GetPoolStats(pPoolStats);
      +
      15665 }
      +
      15666 
      +
      15667 void VmaAllocator_T::SetCurrentFrameIndex(uint32_t frameIndex)
      +
      15668 {
      +
      15669  m_CurrentFrameIndex.store(frameIndex);
      +
      15670 
      +
      15671 #if VMA_MEMORY_BUDGET
      +
      15672  if(m_UseExtMemoryBudget)
      +
      15673  {
      +
      15674  UpdateVulkanBudget();
      +
      15675  }
      +
      15676 #endif // #if VMA_MEMORY_BUDGET
      +
      15677 }
      +
      15678 
      +
      15679 void VmaAllocator_T::MakePoolAllocationsLost(
      +
      15680  VmaPool hPool,
      +
      15681  size_t* pLostAllocationCount)
      +
      15682 {
      +
      15683  hPool->m_BlockVector.MakePoolAllocationsLost(
      +
      15684  m_CurrentFrameIndex.load(),
      +
      15685  pLostAllocationCount);
      +
      15686 }
      +
      15687 
      +
      15688 VkResult VmaAllocator_T::CheckPoolCorruption(VmaPool hPool)
      +
      15689 {
      +
      15690  return hPool->m_BlockVector.CheckCorruption();
      +
      15691 }
      +
      15692 
      +
      15693 VkResult VmaAllocator_T::CheckCorruption(uint32_t memoryTypeBits)
      +
      15694 {
      +
      15695  VkResult finalRes = VK_ERROR_FEATURE_NOT_PRESENT;
      +
      15696 
      +
      15697  // Process default pools.
      +
      15698  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
      +
      15699  {
      +
      15700  if(((1u << memTypeIndex) & memoryTypeBits) != 0)
      +
      15701  {
      +
      15702  VmaBlockVector* const pBlockVector = m_pBlockVectors[memTypeIndex];
      +
      15703  VMA_ASSERT(pBlockVector);
      +
      15704  VkResult localRes = pBlockVector->CheckCorruption();
      +
      15705  switch(localRes)
      +
      15706  {
      +
      15707  case VK_ERROR_FEATURE_NOT_PRESENT:
      +
      15708  break;
      +
      15709  case VK_SUCCESS:
      +
      15710  finalRes = VK_SUCCESS;
      +
      15711  break;
      +
      15712  default:
      +
      15713  return localRes;
      +
      15714  }
      +
      15715  }
      +
      15716  }
      +
      15717 
      +
      15718  // Process custom pools.
      +
      15719  {
      +
      15720  VmaMutexLockRead lock(m_PoolsMutex, m_UseMutex);
      +
      15721  for(size_t poolIndex = 0, poolCount = m_Pools.size(); poolIndex < poolCount; ++poolIndex)
      +
      15722  {
      +
      15723  if(((1u << m_Pools[poolIndex]->m_BlockVector.GetMemoryTypeIndex()) & memoryTypeBits) != 0)
      +
      15724  {
      +
      15725  VkResult localRes = m_Pools[poolIndex]->m_BlockVector.CheckCorruption();
      +
      15726  switch(localRes)
      +
      15727  {
      +
      15728  case VK_ERROR_FEATURE_NOT_PRESENT:
      +
      15729  break;
      +
      15730  case VK_SUCCESS:
      +
      15731  finalRes = VK_SUCCESS;
      +
      15732  break;
      +
      15733  default:
      +
      15734  return localRes;
      +
      15735  }
      +
      15736  }
      +
      15737  }
      +
      15738  }
      +
      15739 
      +
      15740  return finalRes;
      +
      15741 }
      +
      15742 
      +
      15743 void VmaAllocator_T::CreateLostAllocation(VmaAllocation* pAllocation)
      +
      15744 {
      +
      15745  *pAllocation = m_AllocationObjectAllocator.Allocate();
      +
      15746  (*pAllocation)->Ctor(VMA_FRAME_INDEX_LOST, false);
      +
      15747  (*pAllocation)->InitLost();
      +
      15748 }
      +
      15749 
      +
      15750 VkResult VmaAllocator_T::AllocateVulkanMemory(const VkMemoryAllocateInfo* pAllocateInfo, VkDeviceMemory* pMemory)
      +
      15751 {
      +
      15752  const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(pAllocateInfo->memoryTypeIndex);
      +
      15753 
      +
      15754  // HeapSizeLimit is in effect for this heap.
      +
      15755  if((m_HeapSizeLimitMask & (1u << heapIndex)) != 0)
      15756  {
      -
      15757 #if VMA_BIND_MEMORY2
      -
      15758  if(m_UseKhrBindMemory2 && m_VulkanFunctions.vkBindImageMemory2KHR != VMA_NULL)
      -
      15759  {
      -
      15760  VkBindImageMemoryInfoKHR bindBufferMemoryInfo = { VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR };
      -
      15761  bindBufferMemoryInfo.pNext = pNext;
      -
      15762  bindBufferMemoryInfo.image = image;
      -
      15763  bindBufferMemoryInfo.memory = memory;
      -
      15764  bindBufferMemoryInfo.memoryOffset = memoryOffset;
      -
      15765  return (*m_VulkanFunctions.vkBindImageMemory2KHR)(m_hDevice, 1, &bindBufferMemoryInfo);
      -
      15766  }
      -
      15767  else
      -
      15768 #endif // #if VMA_BIND_MEMORY2
      -
      15769  {
      -
      15770  return VK_ERROR_EXTENSION_NOT_PRESENT;
      -
      15771  }
      -
      15772  }
      -
      15773  else
      -
      15774  {
      -
      15775  return (*m_VulkanFunctions.vkBindImageMemory)(m_hDevice, image, memory, memoryOffset);
      -
      15776  }
      -
      15777 }
      -
      15778 
      -
      15779 VkResult VmaAllocator_T::Map(VmaAllocation hAllocation, void** ppData)
      -
      15780 {
      -
      15781  if(hAllocation->CanBecomeLost())
      -
      15782  {
      -
      15783  return VK_ERROR_MEMORY_MAP_FAILED;
      -
      15784  }
      +
      15757  const VkDeviceSize heapSize = m_MemProps.memoryHeaps[heapIndex].size;
      +
      15758  VkDeviceSize blockBytes = m_Budget.m_BlockBytes[heapIndex];
      +
      15759  for(;;)
      +
      15760  {
      +
      15761  const VkDeviceSize blockBytesAfterAllocation = blockBytes + pAllocateInfo->allocationSize;
      +
      15762  if(blockBytesAfterAllocation > heapSize)
      +
      15763  {
      +
      15764  return VK_ERROR_OUT_OF_DEVICE_MEMORY;
      +
      15765  }
      +
      15766  if(m_Budget.m_BlockBytes->compare_exchange_strong(blockBytes, blockBytesAfterAllocation))
      +
      15767  {
      +
      15768  break;
      +
      15769  }
      +
      15770  }
      +
      15771  }
      +
      15772  else
      +
      15773  {
      +
      15774  m_Budget.m_BlockBytes[heapIndex] += pAllocateInfo->allocationSize;
      +
      15775  }
      +
      15776 
      +
      15777  // VULKAN CALL vkAllocateMemory.
      +
      15778  VkResult res = (*m_VulkanFunctions.vkAllocateMemory)(m_hDevice, pAllocateInfo, GetAllocationCallbacks(), pMemory);
      +
      15779 
      +
      15780  if(res == VK_SUCCESS)
      +
      15781  {
      +
      15782 #if VMA_MEMORY_BUDGET
      +
      15783  ++m_Budget.m_OperationsSinceBudgetFetch;
      +
      15784 #endif
      15785 
      -
      15786  switch(hAllocation->GetType())
      -
      15787  {
      -
      15788  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
      -
      15789  {
      -
      15790  VmaDeviceMemoryBlock* const pBlock = hAllocation->GetBlock();
      -
      15791  char *pBytes = VMA_NULL;
      -
      15792  VkResult res = pBlock->Map(this, 1, (void**)&pBytes);
      -
      15793  if(res == VK_SUCCESS)
      -
      15794  {
      -
      15795  *ppData = pBytes + (ptrdiff_t)hAllocation->GetOffset();
      -
      15796  hAllocation->BlockAllocMap();
      -
      15797  }
      -
      15798  return res;
      -
      15799  }
      -
      15800  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
      -
      15801  return hAllocation->DedicatedAllocMap(this, ppData);
      -
      15802  default:
      -
      15803  VMA_ASSERT(0);
      -
      15804  return VK_ERROR_MEMORY_MAP_FAILED;
      -
      15805  }
      -
      15806 }
      +
      15786  // Informative callback.
      +
      15787  if(m_DeviceMemoryCallbacks.pfnAllocate != VMA_NULL)
      +
      15788  {
      +
      15789  (*m_DeviceMemoryCallbacks.pfnAllocate)(this, pAllocateInfo->memoryTypeIndex, *pMemory, pAllocateInfo->allocationSize);
      +
      15790  }
      +
      15791  }
      +
      15792  else
      +
      15793  {
      +
      15794  m_Budget.m_BlockBytes[heapIndex] -= pAllocateInfo->allocationSize;
      +
      15795  }
      +
      15796 
      +
      15797  return res;
      +
      15798 }
      +
      15799 
      +
      15800 void VmaAllocator_T::FreeVulkanMemory(uint32_t memoryType, VkDeviceSize size, VkDeviceMemory hMemory)
      +
      15801 {
      +
      15802  // Informative callback.
      +
      15803  if(m_DeviceMemoryCallbacks.pfnFree != VMA_NULL)
      +
      15804  {
      +
      15805  (*m_DeviceMemoryCallbacks.pfnFree)(this, memoryType, hMemory, size);
      +
      15806  }
      15807 
      -
      15808 void VmaAllocator_T::Unmap(VmaAllocation hAllocation)
      -
      15809 {
      -
      15810  switch(hAllocation->GetType())
      -
      15811  {
      -
      15812  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
      -
      15813  {
      -
      15814  VmaDeviceMemoryBlock* const pBlock = hAllocation->GetBlock();
      -
      15815  hAllocation->BlockAllocUnmap();
      -
      15816  pBlock->Unmap(this, 1);
      -
      15817  }
      -
      15818  break;
      -
      15819  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
      -
      15820  hAllocation->DedicatedAllocUnmap(this);
      -
      15821  break;
      -
      15822  default:
      -
      15823  VMA_ASSERT(0);
      -
      15824  }
      -
      15825 }
      -
      15826 
      -
      15827 VkResult VmaAllocator_T::BindBufferMemory(
      -
      15828  VmaAllocation hAllocation,
      -
      15829  VkDeviceSize allocationLocalOffset,
      -
      15830  VkBuffer hBuffer,
      -
      15831  const void* pNext)
      -
      15832 {
      -
      15833  VkResult res = VK_SUCCESS;
      -
      15834  switch(hAllocation->GetType())
      -
      15835  {
      -
      15836  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
      -
      15837  res = BindVulkanBuffer(hAllocation->GetMemory(), allocationLocalOffset, hBuffer, pNext);
      -
      15838  break;
      -
      15839  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
      -
      15840  {
      -
      15841  VmaDeviceMemoryBlock* const pBlock = hAllocation->GetBlock();
      -
      15842  VMA_ASSERT(pBlock && "Binding buffer to allocation that doesn't belong to any block. Is the allocation lost?");
      -
      15843  res = pBlock->BindBufferMemory(this, hAllocation, allocationLocalOffset, hBuffer, pNext);
      -
      15844  break;
      -
      15845  }
      -
      15846  default:
      -
      15847  VMA_ASSERT(0);
      -
      15848  }
      -
      15849  return res;
      -
      15850 }
      -
      15851 
      -
      15852 VkResult VmaAllocator_T::BindImageMemory(
      -
      15853  VmaAllocation hAllocation,
      -
      15854  VkDeviceSize allocationLocalOffset,
      -
      15855  VkImage hImage,
      -
      15856  const void* pNext)
      -
      15857 {
      -
      15858  VkResult res = VK_SUCCESS;
      -
      15859  switch(hAllocation->GetType())
      -
      15860  {
      -
      15861  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
      -
      15862  res = BindVulkanImage(hAllocation->GetMemory(), allocationLocalOffset, hImage, pNext);
      -
      15863  break;
      -
      15864  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
      -
      15865  {
      -
      15866  VmaDeviceMemoryBlock* pBlock = hAllocation->GetBlock();
      -
      15867  VMA_ASSERT(pBlock && "Binding image to allocation that doesn't belong to any block. Is the allocation lost?");
      -
      15868  res = pBlock->BindImageMemory(this, hAllocation, allocationLocalOffset, hImage, pNext);
      -
      15869  break;
      -
      15870  }
      -
      15871  default:
      -
      15872  VMA_ASSERT(0);
      -
      15873  }
      -
      15874  return res;
      -
      15875 }
      -
      15876 
      -
      15877 void VmaAllocator_T::FlushOrInvalidateAllocation(
      -
      15878  VmaAllocation hAllocation,
      -
      15879  VkDeviceSize offset, VkDeviceSize size,
      -
      15880  VMA_CACHE_OPERATION op)
      -
      15881 {
      -
      15882  const uint32_t memTypeIndex = hAllocation->GetMemoryTypeIndex();
      -
      15883  if(size > 0 && IsMemoryTypeNonCoherent(memTypeIndex))
      -
      15884  {
      -
      15885  const VkDeviceSize allocationSize = hAllocation->GetSize();
      -
      15886  VMA_ASSERT(offset <= allocationSize);
      -
      15887 
      -
      15888  const VkDeviceSize nonCoherentAtomSize = m_PhysicalDeviceProperties.limits.nonCoherentAtomSize;
      -
      15889 
      -
      15890  VkMappedMemoryRange memRange = { VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE };
      -
      15891  memRange.memory = hAllocation->GetMemory();
      -
      15892 
      -
      15893  switch(hAllocation->GetType())
      -
      15894  {
      -
      15895  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
      -
      15896  memRange.offset = VmaAlignDown(offset, nonCoherentAtomSize);
      -
      15897  if(size == VK_WHOLE_SIZE)
      -
      15898  {
      -
      15899  memRange.size = allocationSize - memRange.offset;
      -
      15900  }
      -
      15901  else
      -
      15902  {
      -
      15903  VMA_ASSERT(offset + size <= allocationSize);
      -
      15904  memRange.size = VMA_MIN(
      -
      15905  VmaAlignUp(size + (offset - memRange.offset), nonCoherentAtomSize),
      -
      15906  allocationSize - memRange.offset);
      -
      15907  }
      -
      15908  break;
      -
      15909 
      -
      15910  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
      -
      15911  {
      -
      15912  // 1. Still within this allocation.
      -
      15913  memRange.offset = VmaAlignDown(offset, nonCoherentAtomSize);
      -
      15914  if(size == VK_WHOLE_SIZE)
      -
      15915  {
      -
      15916  size = allocationSize - offset;
      -
      15917  }
      -
      15918  else
      -
      15919  {
      -
      15920  VMA_ASSERT(offset + size <= allocationSize);
      -
      15921  }
      -
      15922  memRange.size = VmaAlignUp(size + (offset - memRange.offset), nonCoherentAtomSize);
      -
      15923 
      -
      15924  // 2. Adjust to whole block.
      -
      15925  const VkDeviceSize allocationOffset = hAllocation->GetOffset();
      -
      15926  VMA_ASSERT(allocationOffset % nonCoherentAtomSize == 0);
      -
      15927  const VkDeviceSize blockSize = hAllocation->GetBlock()->m_pMetadata->GetSize();
      -
      15928  memRange.offset += allocationOffset;
      -
      15929  memRange.size = VMA_MIN(memRange.size, blockSize - memRange.offset);
      -
      15930 
      -
      15931  break;
      -
      15932  }
      -
      15933 
      -
      15934  default:
      -
      15935  VMA_ASSERT(0);
      -
      15936  }
      -
      15937 
      -
      15938  switch(op)
      -
      15939  {
      -
      15940  case VMA_CACHE_FLUSH:
      -
      15941  (*GetVulkanFunctions().vkFlushMappedMemoryRanges)(m_hDevice, 1, &memRange);
      -
      15942  break;
      -
      15943  case VMA_CACHE_INVALIDATE:
      -
      15944  (*GetVulkanFunctions().vkInvalidateMappedMemoryRanges)(m_hDevice, 1, &memRange);
      -
      15945  break;
      -
      15946  default:
      -
      15947  VMA_ASSERT(0);
      -
      15948  }
      -
      15949  }
      -
      15950  // else: Just ignore this call.
      -
      15951 }
      -
      15952 
      -
      15953 void VmaAllocator_T::FreeDedicatedMemory(const VmaAllocation allocation)
      -
      15954 {
      -
      15955  VMA_ASSERT(allocation && allocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_DEDICATED);
      -
      15956 
      -
      15957  const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
      -
      15958  {
      -
      15959  VmaMutexLockWrite lock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
      -
      15960  AllocationVectorType* const pDedicatedAllocations = m_pDedicatedAllocations[memTypeIndex];
      -
      15961  VMA_ASSERT(pDedicatedAllocations);
      -
      15962  bool success = VmaVectorRemoveSorted<VmaPointerLess>(*pDedicatedAllocations, allocation);
      -
      15963  VMA_ASSERT(success);
      -
      15964  }
      -
      15965 
      -
      15966  VkDeviceMemory hMemory = allocation->GetMemory();
      -
      15967 
      -
      15968  /*
      -
      15969  There is no need to call this, because Vulkan spec allows to skip vkUnmapMemory
      -
      15970  before vkFreeMemory.
      -
      15971 
      -
      15972  if(allocation->GetMappedData() != VMA_NULL)
      -
      15973  {
      -
      15974  (*m_VulkanFunctions.vkUnmapMemory)(m_hDevice, hMemory);
      -
      15975  }
      -
      15976  */
      -
      15977 
      -
      15978  FreeVulkanMemory(memTypeIndex, allocation->GetSize(), hMemory);
      -
      15979 
      -
      15980  VMA_DEBUG_LOG(" Freed DedicatedMemory MemoryTypeIndex=%u", memTypeIndex);
      -
      15981 }
      +
      15808  // VULKAN CALL vkFreeMemory.
      +
      15809  (*m_VulkanFunctions.vkFreeMemory)(m_hDevice, hMemory, GetAllocationCallbacks());
      +
      15810 
      +
      15811  m_Budget.m_BlockBytes[MemoryTypeIndexToHeapIndex(memoryType)] -= size;
      +
      15812 }
      +
      15813 
      +
      15814 VkResult VmaAllocator_T::BindVulkanBuffer(
      +
      15815  VkDeviceMemory memory,
      +
      15816  VkDeviceSize memoryOffset,
      +
      15817  VkBuffer buffer,
      +
      15818  const void* pNext)
      +
      15819 {
      +
      15820  if(pNext != VMA_NULL)
      +
      15821  {
      +
      15822 #if VMA_BIND_MEMORY2
      +
      15823  if(m_UseKhrBindMemory2 && m_VulkanFunctions.vkBindBufferMemory2KHR != VMA_NULL)
      +
      15824  {
      +
      15825  VkBindBufferMemoryInfoKHR bindBufferMemoryInfo = { VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR };
      +
      15826  bindBufferMemoryInfo.pNext = pNext;
      +
      15827  bindBufferMemoryInfo.buffer = buffer;
      +
      15828  bindBufferMemoryInfo.memory = memory;
      +
      15829  bindBufferMemoryInfo.memoryOffset = memoryOffset;
      +
      15830  return (*m_VulkanFunctions.vkBindBufferMemory2KHR)(m_hDevice, 1, &bindBufferMemoryInfo);
      +
      15831  }
      +
      15832  else
      +
      15833 #endif // #if VMA_BIND_MEMORY2
      +
      15834  {
      +
      15835  return VK_ERROR_EXTENSION_NOT_PRESENT;
      +
      15836  }
      +
      15837  }
      +
      15838  else
      +
      15839  {
      +
      15840  return (*m_VulkanFunctions.vkBindBufferMemory)(m_hDevice, buffer, memory, memoryOffset);
      +
      15841  }
      +
      15842 }
      +
      15843 
      +
      15844 VkResult VmaAllocator_T::BindVulkanImage(
      +
      15845  VkDeviceMemory memory,
      +
      15846  VkDeviceSize memoryOffset,
      +
      15847  VkImage image,
      +
      15848  const void* pNext)
      +
      15849 {
      +
      15850  if(pNext != VMA_NULL)
      +
      15851  {
      +
      15852 #if VMA_BIND_MEMORY2
      +
      15853  if(m_UseKhrBindMemory2 && m_VulkanFunctions.vkBindImageMemory2KHR != VMA_NULL)
      +
      15854  {
      +
      15855  VkBindImageMemoryInfoKHR bindBufferMemoryInfo = { VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR };
      +
      15856  bindBufferMemoryInfo.pNext = pNext;
      +
      15857  bindBufferMemoryInfo.image = image;
      +
      15858  bindBufferMemoryInfo.memory = memory;
      +
      15859  bindBufferMemoryInfo.memoryOffset = memoryOffset;
      +
      15860  return (*m_VulkanFunctions.vkBindImageMemory2KHR)(m_hDevice, 1, &bindBufferMemoryInfo);
      +
      15861  }
      +
      15862  else
      +
      15863 #endif // #if VMA_BIND_MEMORY2
      +
      15864  {
      +
      15865  return VK_ERROR_EXTENSION_NOT_PRESENT;
      +
      15866  }
      +
      15867  }
      +
      15868  else
      +
      15869  {
      +
      15870  return (*m_VulkanFunctions.vkBindImageMemory)(m_hDevice, image, memory, memoryOffset);
      +
      15871  }
      +
      15872 }
      +
      15873 
      +
      15874 VkResult VmaAllocator_T::Map(VmaAllocation hAllocation, void** ppData)
      +
      15875 {
      +
      15876  if(hAllocation->CanBecomeLost())
      +
      15877  {
      +
      15878  return VK_ERROR_MEMORY_MAP_FAILED;
      +
      15879  }
      +
      15880 
      +
      15881  switch(hAllocation->GetType())
      +
      15882  {
      +
      15883  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
      +
      15884  {
      +
      15885  VmaDeviceMemoryBlock* const pBlock = hAllocation->GetBlock();
      +
      15886  char *pBytes = VMA_NULL;
      +
      15887  VkResult res = pBlock->Map(this, 1, (void**)&pBytes);
      +
      15888  if(res == VK_SUCCESS)
      +
      15889  {
      +
      15890  *ppData = pBytes + (ptrdiff_t)hAllocation->GetOffset();
      +
      15891  hAllocation->BlockAllocMap();
      +
      15892  }
      +
      15893  return res;
      +
      15894  }
      +
      15895  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
      +
      15896  return hAllocation->DedicatedAllocMap(this, ppData);
      +
      15897  default:
      +
      15898  VMA_ASSERT(0);
      +
      15899  return VK_ERROR_MEMORY_MAP_FAILED;
      +
      15900  }
      +
      15901 }
      +
      15902 
      +
      15903 void VmaAllocator_T::Unmap(VmaAllocation hAllocation)
      +
      15904 {
      +
      15905  switch(hAllocation->GetType())
      +
      15906  {
      +
      15907  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
      +
      15908  {
      +
      15909  VmaDeviceMemoryBlock* const pBlock = hAllocation->GetBlock();
      +
      15910  hAllocation->BlockAllocUnmap();
      +
      15911  pBlock->Unmap(this, 1);
      +
      15912  }
      +
      15913  break;
      +
      15914  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
      +
      15915  hAllocation->DedicatedAllocUnmap(this);
      +
      15916  break;
      +
      15917  default:
      +
      15918  VMA_ASSERT(0);
      +
      15919  }
      +
      15920 }
      +
      15921 
      +
      15922 VkResult VmaAllocator_T::BindBufferMemory(
      +
      15923  VmaAllocation hAllocation,
      +
      15924  VkDeviceSize allocationLocalOffset,
      +
      15925  VkBuffer hBuffer,
      +
      15926  const void* pNext)
      +
      15927 {
      +
      15928  VkResult res = VK_SUCCESS;
      +
      15929  switch(hAllocation->GetType())
      +
      15930  {
      +
      15931  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
      +
      15932  res = BindVulkanBuffer(hAllocation->GetMemory(), allocationLocalOffset, hBuffer, pNext);
      +
      15933  break;
      +
      15934  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
      +
      15935  {
      +
      15936  VmaDeviceMemoryBlock* const pBlock = hAllocation->GetBlock();
      +
      15937  VMA_ASSERT(pBlock && "Binding buffer to allocation that doesn't belong to any block. Is the allocation lost?");
      +
      15938  res = pBlock->BindBufferMemory(this, hAllocation, allocationLocalOffset, hBuffer, pNext);
      +
      15939  break;
      +
      15940  }
      +
      15941  default:
      +
      15942  VMA_ASSERT(0);
      +
      15943  }
      +
      15944  return res;
      +
      15945 }
      +
      15946 
      +
      15947 VkResult VmaAllocator_T::BindImageMemory(
      +
      15948  VmaAllocation hAllocation,
      +
      15949  VkDeviceSize allocationLocalOffset,
      +
      15950  VkImage hImage,
      +
      15951  const void* pNext)
      +
      15952 {
      +
      15953  VkResult res = VK_SUCCESS;
      +
      15954  switch(hAllocation->GetType())
      +
      15955  {
      +
      15956  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
      +
      15957  res = BindVulkanImage(hAllocation->GetMemory(), allocationLocalOffset, hImage, pNext);
      +
      15958  break;
      +
      15959  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
      +
      15960  {
      +
      15961  VmaDeviceMemoryBlock* pBlock = hAllocation->GetBlock();
      +
      15962  VMA_ASSERT(pBlock && "Binding image to allocation that doesn't belong to any block. Is the allocation lost?");
      +
      15963  res = pBlock->BindImageMemory(this, hAllocation, allocationLocalOffset, hImage, pNext);
      +
      15964  break;
      +
      15965  }
      +
      15966  default:
      +
      15967  VMA_ASSERT(0);
      +
      15968  }
      +
      15969  return res;
      +
      15970 }
      +
      15971 
      +
      15972 void VmaAllocator_T::FlushOrInvalidateAllocation(
      +
      15973  VmaAllocation hAllocation,
      +
      15974  VkDeviceSize offset, VkDeviceSize size,
      +
      15975  VMA_CACHE_OPERATION op)
      +
      15976 {
      +
      15977  const uint32_t memTypeIndex = hAllocation->GetMemoryTypeIndex();
      +
      15978  if(size > 0 && IsMemoryTypeNonCoherent(memTypeIndex))
      +
      15979  {
      +
      15980  const VkDeviceSize allocationSize = hAllocation->GetSize();
      +
      15981  VMA_ASSERT(offset <= allocationSize);
      15982 
      -
      15983 uint32_t VmaAllocator_T::CalculateGpuDefragmentationMemoryTypeBits() const
      -
      15984 {
      -
      15985  VkBufferCreateInfo dummyBufCreateInfo;
      -
      15986  VmaFillGpuDefragmentationBufferCreateInfo(dummyBufCreateInfo);
      -
      15987 
      -
      15988  uint32_t memoryTypeBits = 0;
      -
      15989 
      -
      15990  // Create buffer.
      -
      15991  VkBuffer buf = VK_NULL_HANDLE;
      -
      15992  VkResult res = (*GetVulkanFunctions().vkCreateBuffer)(
      -
      15993  m_hDevice, &dummyBufCreateInfo, GetAllocationCallbacks(), &buf);
      -
      15994  if(res == VK_SUCCESS)
      -
      15995  {
      -
      15996  // Query for supported memory types.
      -
      15997  VkMemoryRequirements memReq;
      -
      15998  (*GetVulkanFunctions().vkGetBufferMemoryRequirements)(m_hDevice, buf, &memReq);
      -
      15999  memoryTypeBits = memReq.memoryTypeBits;
      -
      16000 
      -
      16001  // Destroy buffer.
      -
      16002  (*GetVulkanFunctions().vkDestroyBuffer)(m_hDevice, buf, GetAllocationCallbacks());
      -
      16003  }
      +
      15983  const VkDeviceSize nonCoherentAtomSize = m_PhysicalDeviceProperties.limits.nonCoherentAtomSize;
      +
      15984 
      +
      15985  VkMappedMemoryRange memRange = { VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE };
      +
      15986  memRange.memory = hAllocation->GetMemory();
      +
      15987 
      +
      15988  switch(hAllocation->GetType())
      +
      15989  {
      +
      15990  case VmaAllocation_T::ALLOCATION_TYPE_DEDICATED:
      +
      15991  memRange.offset = VmaAlignDown(offset, nonCoherentAtomSize);
      +
      15992  if(size == VK_WHOLE_SIZE)
      +
      15993  {
      +
      15994  memRange.size = allocationSize - memRange.offset;
      +
      15995  }
      +
      15996  else
      +
      15997  {
      +
      15998  VMA_ASSERT(offset + size <= allocationSize);
      +
      15999  memRange.size = VMA_MIN(
      +
      16000  VmaAlignUp(size + (offset - memRange.offset), nonCoherentAtomSize),
      +
      16001  allocationSize - memRange.offset);
      +
      16002  }
      +
      16003  break;
      16004 
      -
      16005  return memoryTypeBits;
      -
      16006 }
      -
      16007 
      -
      16008 #if VMA_MEMORY_BUDGET
      -
      16009 
      -
      16010 void VmaAllocator_T::UpdateVulkanBudget()
      -
      16011 {
      -
      16012  VMA_ASSERT(m_UseExtMemoryBudget);
      -
      16013 
      -
      16014  VkPhysicalDeviceMemoryProperties2KHR memProps = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR };
      -
      16015 
      -
      16016  VkPhysicalDeviceMemoryBudgetPropertiesEXT budgetProps = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT };
      -
      16017  memProps.pNext = &budgetProps;
      +
      16005  case VmaAllocation_T::ALLOCATION_TYPE_BLOCK:
      +
      16006  {
      +
      16007  // 1. Still within this allocation.
      +
      16008  memRange.offset = VmaAlignDown(offset, nonCoherentAtomSize);
      +
      16009  if(size == VK_WHOLE_SIZE)
      +
      16010  {
      +
      16011  size = allocationSize - offset;
      +
      16012  }
      +
      16013  else
      +
      16014  {
      +
      16015  VMA_ASSERT(offset + size <= allocationSize);
      +
      16016  }
      +
      16017  memRange.size = VmaAlignUp(size + (offset - memRange.offset), nonCoherentAtomSize);
      16018 
      -
      16019  GetVulkanFunctions().vkGetPhysicalDeviceMemoryProperties2KHR(m_PhysicalDevice, &memProps);
      -
      16020 
      -
      16021  {
      -
      16022  VmaMutexLockWrite lockWrite(m_Budget.m_BudgetMutex, m_UseMutex);
      -
      16023 
      -
      16024  for(uint32_t heapIndex = 0; heapIndex < GetMemoryHeapCount(); ++heapIndex)
      -
      16025  {
      -
      16026  m_Budget.m_VulkanUsage[heapIndex] = budgetProps.heapUsage[heapIndex];
      -
      16027  m_Budget.m_VulkanBudget[heapIndex] = budgetProps.heapBudget[heapIndex];
      -
      16028  m_Budget.m_BlockBytesAtBudgetFetch[heapIndex] = m_Budget.m_BlockBytes[heapIndex].load();
      -
      16029  }
      -
      16030  m_Budget.m_OperationsSinceBudgetFetch = 0;
      -
      16031  }
      -
      16032 }
      -
      16033 
      -
      16034 #endif // #if VMA_MEMORY_BUDGET
      -
      16035 
      -
      16036 void VmaAllocator_T::FillAllocation(const VmaAllocation hAllocation, uint8_t pattern)
      -
      16037 {
      -
      16038  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS &&
      -
      16039  !hAllocation->CanBecomeLost() &&
      -
      16040  (m_MemProps.memoryTypes[hAllocation->GetMemoryTypeIndex()].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
      -
      16041  {
      -
      16042  void* pData = VMA_NULL;
      -
      16043  VkResult res = Map(hAllocation, &pData);
      -
      16044  if(res == VK_SUCCESS)
      -
      16045  {
      -
      16046  memset(pData, (int)pattern, (size_t)hAllocation->GetSize());
      -
      16047  FlushOrInvalidateAllocation(hAllocation, 0, VK_WHOLE_SIZE, VMA_CACHE_FLUSH);
      -
      16048  Unmap(hAllocation);
      -
      16049  }
      -
      16050  else
      -
      16051  {
      -
      16052  VMA_ASSERT(0 && "VMA_DEBUG_INITIALIZE_ALLOCATIONS is enabled, but couldn't map memory to fill allocation.");
      -
      16053  }
      -
      16054  }
      -
      16055 }
      -
      16056 
      -
      16057 uint32_t VmaAllocator_T::GetGpuDefragmentationMemoryTypeBits()
      -
      16058 {
      -
      16059  uint32_t memoryTypeBits = m_GpuDefragmentationMemoryTypeBits.load();
      -
      16060  if(memoryTypeBits == UINT32_MAX)
      -
      16061  {
      -
      16062  memoryTypeBits = CalculateGpuDefragmentationMemoryTypeBits();
      -
      16063  m_GpuDefragmentationMemoryTypeBits.store(memoryTypeBits);
      -
      16064  }
      -
      16065  return memoryTypeBits;
      -
      16066 }
      -
      16067 
      -
      16068 #if VMA_STATS_STRING_ENABLED
      -
      16069 
      -
      16070 void VmaAllocator_T::PrintDetailedMap(VmaJsonWriter& json)
      -
      16071 {
      -
      16072  bool dedicatedAllocationsStarted = false;
      -
      16073  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
      -
      16074  {
      -
      16075  VmaMutexLockRead dedicatedAllocationsLock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
      -
      16076  AllocationVectorType* const pDedicatedAllocVector = m_pDedicatedAllocations[memTypeIndex];
      -
      16077  VMA_ASSERT(pDedicatedAllocVector);
      -
      16078  if(pDedicatedAllocVector->empty() == false)
      -
      16079  {
      -
      16080  if(dedicatedAllocationsStarted == false)
      -
      16081  {
      -
      16082  dedicatedAllocationsStarted = true;
      -
      16083  json.WriteString("DedicatedAllocations");
      -
      16084  json.BeginObject();
      -
      16085  }
      -
      16086 
      -
      16087  json.BeginString("Type ");
      -
      16088  json.ContinueString(memTypeIndex);
      -
      16089  json.EndString();
      -
      16090 
      -
      16091  json.BeginArray();
      -
      16092 
      -
      16093  for(size_t i = 0; i < pDedicatedAllocVector->size(); ++i)
      -
      16094  {
      -
      16095  json.BeginObject(true);
      -
      16096  const VmaAllocation hAlloc = (*pDedicatedAllocVector)[i];
      -
      16097  hAlloc->PrintParameters(json);
      -
      16098  json.EndObject();
      -
      16099  }
      -
      16100 
      -
      16101  json.EndArray();
      -
      16102  }
      -
      16103  }
      -
      16104  if(dedicatedAllocationsStarted)
      -
      16105  {
      -
      16106  json.EndObject();
      -
      16107  }
      +
      16019  // 2. Adjust to whole block.
      +
      16020  const VkDeviceSize allocationOffset = hAllocation->GetOffset();
      +
      16021  VMA_ASSERT(allocationOffset % nonCoherentAtomSize == 0);
      +
      16022  const VkDeviceSize blockSize = hAllocation->GetBlock()->m_pMetadata->GetSize();
      +
      16023  memRange.offset += allocationOffset;
      +
      16024  memRange.size = VMA_MIN(memRange.size, blockSize - memRange.offset);
      +
      16025 
      +
      16026  break;
      +
      16027  }
      +
      16028 
      +
      16029  default:
      +
      16030  VMA_ASSERT(0);
      +
      16031  }
      +
      16032 
      +
      16033  switch(op)
      +
      16034  {
      +
      16035  case VMA_CACHE_FLUSH:
      +
      16036  (*GetVulkanFunctions().vkFlushMappedMemoryRanges)(m_hDevice, 1, &memRange);
      +
      16037  break;
      +
      16038  case VMA_CACHE_INVALIDATE:
      +
      16039  (*GetVulkanFunctions().vkInvalidateMappedMemoryRanges)(m_hDevice, 1, &memRange);
      +
      16040  break;
      +
      16041  default:
      +
      16042  VMA_ASSERT(0);
      +
      16043  }
      +
      16044  }
      +
      16045  // else: Just ignore this call.
      +
      16046 }
      +
      16047 
      +
      16048 void VmaAllocator_T::FreeDedicatedMemory(const VmaAllocation allocation)
      +
      16049 {
      +
      16050  VMA_ASSERT(allocation && allocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_DEDICATED);
      +
      16051 
      +
      16052  const uint32_t memTypeIndex = allocation->GetMemoryTypeIndex();
      +
      16053  {
      +
      16054  VmaMutexLockWrite lock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
      +
      16055  AllocationVectorType* const pDedicatedAllocations = m_pDedicatedAllocations[memTypeIndex];
      +
      16056  VMA_ASSERT(pDedicatedAllocations);
      +
      16057  bool success = VmaVectorRemoveSorted<VmaPointerLess>(*pDedicatedAllocations, allocation);
      +
      16058  VMA_ASSERT(success);
      +
      16059  }
      +
      16060 
      +
      16061  VkDeviceMemory hMemory = allocation->GetMemory();
      +
      16062 
      +
      16063  /*
      +
      16064  There is no need to call this, because Vulkan spec allows to skip vkUnmapMemory
      +
      16065  before vkFreeMemory.
      +
      16066 
      +
      16067  if(allocation->GetMappedData() != VMA_NULL)
      +
      16068  {
      +
      16069  (*m_VulkanFunctions.vkUnmapMemory)(m_hDevice, hMemory);
      +
      16070  }
      +
      16071  */
      +
      16072 
      +
      16073  FreeVulkanMemory(memTypeIndex, allocation->GetSize(), hMemory);
      +
      16074 
      +
      16075  VMA_DEBUG_LOG(" Freed DedicatedMemory MemoryTypeIndex=%u", memTypeIndex);
      +
      16076 }
      +
      16077 
      +
      16078 uint32_t VmaAllocator_T::CalculateGpuDefragmentationMemoryTypeBits() const
      +
      16079 {
      +
      16080  VkBufferCreateInfo dummyBufCreateInfo;
      +
      16081  VmaFillGpuDefragmentationBufferCreateInfo(dummyBufCreateInfo);
      +
      16082 
      +
      16083  uint32_t memoryTypeBits = 0;
      +
      16084 
      +
      16085  // Create buffer.
      +
      16086  VkBuffer buf = VK_NULL_HANDLE;
      +
      16087  VkResult res = (*GetVulkanFunctions().vkCreateBuffer)(
      +
      16088  m_hDevice, &dummyBufCreateInfo, GetAllocationCallbacks(), &buf);
      +
      16089  if(res == VK_SUCCESS)
      +
      16090  {
      +
      16091  // Query for supported memory types.
      +
      16092  VkMemoryRequirements memReq;
      +
      16093  (*GetVulkanFunctions().vkGetBufferMemoryRequirements)(m_hDevice, buf, &memReq);
      +
      16094  memoryTypeBits = memReq.memoryTypeBits;
      +
      16095 
      +
      16096  // Destroy buffer.
      +
      16097  (*GetVulkanFunctions().vkDestroyBuffer)(m_hDevice, buf, GetAllocationCallbacks());
      +
      16098  }
      +
      16099 
      +
      16100  return memoryTypeBits;
      +
      16101 }
      +
      16102 
      +
      16103 #if VMA_MEMORY_BUDGET
      +
      16104 
      +
      16105 void VmaAllocator_T::UpdateVulkanBudget()
      +
      16106 {
      +
      16107  VMA_ASSERT(m_UseExtMemoryBudget);
      16108 
      -
      16109  {
      -
      16110  bool allocationsStarted = false;
      -
      16111  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
      -
      16112  {
      -
      16113  if(m_pBlockVectors[memTypeIndex]->IsEmpty() == false)
      -
      16114  {
      -
      16115  if(allocationsStarted == false)
      -
      16116  {
      -
      16117  allocationsStarted = true;
      -
      16118  json.WriteString("DefaultPools");
      -
      16119  json.BeginObject();
      -
      16120  }
      -
      16121 
      -
      16122  json.BeginString("Type ");
      -
      16123  json.ContinueString(memTypeIndex);
      -
      16124  json.EndString();
      -
      16125 
      -
      16126  m_pBlockVectors[memTypeIndex]->PrintDetailedMap(json);
      -
      16127  }
      -
      16128  }
      -
      16129  if(allocationsStarted)
      -
      16130  {
      -
      16131  json.EndObject();
      -
      16132  }
      -
      16133  }
      -
      16134 
      -
      16135  // Custom pools
      +
      16109  VkPhysicalDeviceMemoryProperties2KHR memProps = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR };
      +
      16110 
      +
      16111  VkPhysicalDeviceMemoryBudgetPropertiesEXT budgetProps = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT };
      +
      16112  memProps.pNext = &budgetProps;
      +
      16113 
      +
      16114  GetVulkanFunctions().vkGetPhysicalDeviceMemoryProperties2KHR(m_PhysicalDevice, &memProps);
      +
      16115 
      +
      16116  {
      +
      16117  VmaMutexLockWrite lockWrite(m_Budget.m_BudgetMutex, m_UseMutex);
      +
      16118 
      +
      16119  for(uint32_t heapIndex = 0; heapIndex < GetMemoryHeapCount(); ++heapIndex)
      +
      16120  {
      +
      16121  m_Budget.m_VulkanUsage[heapIndex] = budgetProps.heapUsage[heapIndex];
      +
      16122  m_Budget.m_VulkanBudget[heapIndex] = budgetProps.heapBudget[heapIndex];
      +
      16123  m_Budget.m_BlockBytesAtBudgetFetch[heapIndex] = m_Budget.m_BlockBytes[heapIndex].load();
      +
      16124  }
      +
      16125  m_Budget.m_OperationsSinceBudgetFetch = 0;
      +
      16126  }
      +
      16127 }
      +
      16128 
      +
      16129 #endif // #if VMA_MEMORY_BUDGET
      +
      16130 
      +
      16131 void VmaAllocator_T::FillAllocation(const VmaAllocation hAllocation, uint8_t pattern)
      +
      16132 {
      +
      16133  if(VMA_DEBUG_INITIALIZE_ALLOCATIONS &&
      +
      16134  !hAllocation->CanBecomeLost() &&
      +
      16135  (m_MemProps.memoryTypes[hAllocation->GetMemoryTypeIndex()].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
      16136  {
      -
      16137  VmaMutexLockRead lock(m_PoolsMutex, m_UseMutex);
      -
      16138  const size_t poolCount = m_Pools.size();
      -
      16139  if(poolCount > 0)
      +
      16137  void* pData = VMA_NULL;
      +
      16138  VkResult res = Map(hAllocation, &pData);
      +
      16139  if(res == VK_SUCCESS)
      16140  {
      -
      16141  json.WriteString("Pools");
      -
      16142  json.BeginObject();
      -
      16143  for(size_t poolIndex = 0; poolIndex < poolCount; ++poolIndex)
      -
      16144  {
      -
      16145  json.BeginString();
      -
      16146  json.ContinueString(m_Pools[poolIndex]->GetId());
      -
      16147  json.EndString();
      -
      16148 
      -
      16149  m_Pools[poolIndex]->m_BlockVector.PrintDetailedMap(json);
      -
      16150  }
      -
      16151  json.EndObject();
      -
      16152  }
      -
      16153  }
      -
      16154 }
      -
      16155 
      -
      16156 #endif // #if VMA_STATS_STRING_ENABLED
      -
      16157 
      -
      16159 // Public interface
      -
      16160 
      -
      16161 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateAllocator(
      -
      16162  const VmaAllocatorCreateInfo* pCreateInfo,
      -
      16163  VmaAllocator* pAllocator)
      -
      16164 {
      -
      16165  VMA_ASSERT(pCreateInfo && pAllocator);
      -
      16166  VMA_DEBUG_LOG("vmaCreateAllocator");
      -
      16167  *pAllocator = vma_new(pCreateInfo->pAllocationCallbacks, VmaAllocator_T)(pCreateInfo);
      -
      16168  return (*pAllocator)->Init(pCreateInfo);
      -
      16169 }
      -
      16170 
      -
      16171 VMA_CALL_PRE void VMA_CALL_POST vmaDestroyAllocator(
      -
      16172  VmaAllocator allocator)
      -
      16173 {
      -
      16174  if(allocator != VK_NULL_HANDLE)
      -
      16175  {
      -
      16176  VMA_DEBUG_LOG("vmaDestroyAllocator");
      -
      16177  VkAllocationCallbacks allocationCallbacks = allocator->m_AllocationCallbacks;
      -
      16178  vma_delete(&allocationCallbacks, allocator);
      -
      16179  }
      -
      16180 }
      +
      16141  memset(pData, (int)pattern, (size_t)hAllocation->GetSize());
      +
      16142  FlushOrInvalidateAllocation(hAllocation, 0, VK_WHOLE_SIZE, VMA_CACHE_FLUSH);
      +
      16143  Unmap(hAllocation);
      +
      16144  }
      +
      16145  else
      +
      16146  {
      +
      16147  VMA_ASSERT(0 && "VMA_DEBUG_INITIALIZE_ALLOCATIONS is enabled, but couldn't map memory to fill allocation.");
      +
      16148  }
      +
      16149  }
      +
      16150 }
      +
      16151 
      +
      16152 uint32_t VmaAllocator_T::GetGpuDefragmentationMemoryTypeBits()
      +
      16153 {
      +
      16154  uint32_t memoryTypeBits = m_GpuDefragmentationMemoryTypeBits.load();
      +
      16155  if(memoryTypeBits == UINT32_MAX)
      +
      16156  {
      +
      16157  memoryTypeBits = CalculateGpuDefragmentationMemoryTypeBits();
      +
      16158  m_GpuDefragmentationMemoryTypeBits.store(memoryTypeBits);
      +
      16159  }
      +
      16160  return memoryTypeBits;
      +
      16161 }
      +
      16162 
      +
      16163 #if VMA_STATS_STRING_ENABLED
      +
      16164 
      +
      16165 void VmaAllocator_T::PrintDetailedMap(VmaJsonWriter& json)
      +
      16166 {
      +
      16167  bool dedicatedAllocationsStarted = false;
      +
      16168  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
      +
      16169  {
      +
      16170  VmaMutexLockRead dedicatedAllocationsLock(m_DedicatedAllocationsMutex[memTypeIndex], m_UseMutex);
      +
      16171  AllocationVectorType* const pDedicatedAllocVector = m_pDedicatedAllocations[memTypeIndex];
      +
      16172  VMA_ASSERT(pDedicatedAllocVector);
      +
      16173  if(pDedicatedAllocVector->empty() == false)
      +
      16174  {
      +
      16175  if(dedicatedAllocationsStarted == false)
      +
      16176  {
      +
      16177  dedicatedAllocationsStarted = true;
      +
      16178  json.WriteString("DedicatedAllocations");
      +
      16179  json.BeginObject();
      +
      16180  }
      16181 
      -
      16182 VMA_CALL_PRE void VMA_CALL_POST vmaGetPhysicalDeviceProperties(
      -
      16183  VmaAllocator allocator,
      -
      16184  const VkPhysicalDeviceProperties **ppPhysicalDeviceProperties)
      -
      16185 {
      -
      16186  VMA_ASSERT(allocator && ppPhysicalDeviceProperties);
      -
      16187  *ppPhysicalDeviceProperties = &allocator->m_PhysicalDeviceProperties;
      -
      16188 }
      -
      16189 
      -
      16190 VMA_CALL_PRE void VMA_CALL_POST vmaGetMemoryProperties(
      -
      16191  VmaAllocator allocator,
      -
      16192  const VkPhysicalDeviceMemoryProperties** ppPhysicalDeviceMemoryProperties)
      -
      16193 {
      -
      16194  VMA_ASSERT(allocator && ppPhysicalDeviceMemoryProperties);
      -
      16195  *ppPhysicalDeviceMemoryProperties = &allocator->m_MemProps;
      -
      16196 }
      -
      16197 
      -
      16198 VMA_CALL_PRE void VMA_CALL_POST vmaGetMemoryTypeProperties(
      -
      16199  VmaAllocator allocator,
      -
      16200  uint32_t memoryTypeIndex,
      -
      16201  VkMemoryPropertyFlags* pFlags)
      -
      16202 {
      -
      16203  VMA_ASSERT(allocator && pFlags);
      -
      16204  VMA_ASSERT(memoryTypeIndex < allocator->GetMemoryTypeCount());
      -
      16205  *pFlags = allocator->m_MemProps.memoryTypes[memoryTypeIndex].propertyFlags;
      -
      16206 }
      -
      16207 
      -
      16208 VMA_CALL_PRE void VMA_CALL_POST vmaSetCurrentFrameIndex(
      -
      16209  VmaAllocator allocator,
      -
      16210  uint32_t frameIndex)
      -
      16211 {
      -
      16212  VMA_ASSERT(allocator);
      -
      16213  VMA_ASSERT(frameIndex != VMA_FRAME_INDEX_LOST);
      -
      16214 
      -
      16215  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      16182  json.BeginString("Type ");
      +
      16183  json.ContinueString(memTypeIndex);
      +
      16184  json.EndString();
      +
      16185 
      +
      16186  json.BeginArray();
      +
      16187 
      +
      16188  for(size_t i = 0; i < pDedicatedAllocVector->size(); ++i)
      +
      16189  {
      +
      16190  json.BeginObject(true);
      +
      16191  const VmaAllocation hAlloc = (*pDedicatedAllocVector)[i];
      +
      16192  hAlloc->PrintParameters(json);
      +
      16193  json.EndObject();
      +
      16194  }
      +
      16195 
      +
      16196  json.EndArray();
      +
      16197  }
      +
      16198  }
      +
      16199  if(dedicatedAllocationsStarted)
      +
      16200  {
      +
      16201  json.EndObject();
      +
      16202  }
      +
      16203 
      +
      16204  {
      +
      16205  bool allocationsStarted = false;
      +
      16206  for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
      +
      16207  {
      +
      16208  if(m_pBlockVectors[memTypeIndex]->IsEmpty() == false)
      +
      16209  {
      +
      16210  if(allocationsStarted == false)
      +
      16211  {
      +
      16212  allocationsStarted = true;
      +
      16213  json.WriteString("DefaultPools");
      +
      16214  json.BeginObject();
      +
      16215  }
      16216 
      -
      16217  allocator->SetCurrentFrameIndex(frameIndex);
      -
      16218 }
      -
      16219 
      -
      16220 VMA_CALL_PRE void VMA_CALL_POST vmaCalculateStats(
      -
      16221  VmaAllocator allocator,
      -
      16222  VmaStats* pStats)
      -
      16223 {
      -
      16224  VMA_ASSERT(allocator && pStats);
      -
      16225  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      -
      16226  allocator->CalculateStats(pStats);
      -
      16227 }
      -
      16228 
      -
      16229 VMA_CALL_PRE void VMA_CALL_POST vmaGetBudget(
      -
      16230  VmaAllocator allocator,
      -
      16231  VmaBudget* pBudget)
      -
      16232 {
      -
      16233  VMA_ASSERT(allocator && pBudget);
      -
      16234  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      -
      16235  allocator->GetBudget(pBudget, 0, allocator->GetMemoryHeapCount());
      -
      16236 }
      -
      16237 
      -
      16238 #if VMA_STATS_STRING_ENABLED
      -
      16239 
      -
      16240 VMA_CALL_PRE void VMA_CALL_POST vmaBuildStatsString(
      -
      16241  VmaAllocator allocator,
      -
      16242  char** ppStatsString,
      -
      16243  VkBool32 detailedMap)
      -
      16244 {
      -
      16245  VMA_ASSERT(allocator && ppStatsString);
      -
      16246  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      -
      16247 
      -
      16248  VmaStringBuilder sb(allocator);
      -
      16249  {
      -
      16250  VmaJsonWriter json(allocator->GetAllocationCallbacks(), sb);
      -
      16251  json.BeginObject();
      +
      16217  json.BeginString("Type ");
      +
      16218  json.ContinueString(memTypeIndex);
      +
      16219  json.EndString();
      +
      16220 
      +
      16221  m_pBlockVectors[memTypeIndex]->PrintDetailedMap(json);
      +
      16222  }
      +
      16223  }
      +
      16224  if(allocationsStarted)
      +
      16225  {
      +
      16226  json.EndObject();
      +
      16227  }
      +
      16228  }
      +
      16229 
      +
      16230  // Custom pools
      +
      16231  {
      +
      16232  VmaMutexLockRead lock(m_PoolsMutex, m_UseMutex);
      +
      16233  const size_t poolCount = m_Pools.size();
      +
      16234  if(poolCount > 0)
      +
      16235  {
      +
      16236  json.WriteString("Pools");
      +
      16237  json.BeginObject();
      +
      16238  for(size_t poolIndex = 0; poolIndex < poolCount; ++poolIndex)
      +
      16239  {
      +
      16240  json.BeginString();
      +
      16241  json.ContinueString(m_Pools[poolIndex]->GetId());
      +
      16242  json.EndString();
      +
      16243 
      +
      16244  m_Pools[poolIndex]->m_BlockVector.PrintDetailedMap(json);
      +
      16245  }
      +
      16246  json.EndObject();
      +
      16247  }
      +
      16248  }
      +
      16249 }
      +
      16250 
      +
      16251 #endif // #if VMA_STATS_STRING_ENABLED
      16252 
      -
      16253  VmaStats stats;
      -
      16254  allocator->CalculateStats(&stats);
      +
      16254 // Public interface
      16255 
      -
      16256  json.WriteString("Total");
      -
      16257  VmaPrintStatInfo(json, stats.total);
      -
      16258 
      -
      16259  for(uint32_t heapIndex = 0; heapIndex < allocator->GetMemoryHeapCount(); ++heapIndex)
      -
      16260  {
      -
      16261  json.BeginString("Heap ");
      -
      16262  json.ContinueString(heapIndex);
      -
      16263  json.EndString();
      -
      16264  json.BeginObject();
      +
      16256 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateAllocator(
      +
      16257  const VmaAllocatorCreateInfo* pCreateInfo,
      +
      16258  VmaAllocator* pAllocator)
      +
      16259 {
      +
      16260  VMA_ASSERT(pCreateInfo && pAllocator);
      +
      16261  VMA_DEBUG_LOG("vmaCreateAllocator");
      +
      16262  *pAllocator = vma_new(pCreateInfo->pAllocationCallbacks, VmaAllocator_T)(pCreateInfo);
      +
      16263  return (*pAllocator)->Init(pCreateInfo);
      +
      16264 }
      16265 
      -
      16266  json.WriteString("Size");
      -
      16267  json.WriteNumber(allocator->m_MemProps.memoryHeaps[heapIndex].size);
      -
      16268 
      -
      16269  json.WriteString("Flags");
      -
      16270  json.BeginArray(true);
      -
      16271  if((allocator->m_MemProps.memoryHeaps[heapIndex].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) != 0)
      -
      16272  {
      -
      16273  json.WriteString("DEVICE_LOCAL");
      -
      16274  }
      -
      16275  json.EndArray();
      +
      16266 VMA_CALL_PRE void VMA_CALL_POST vmaDestroyAllocator(
      +
      16267  VmaAllocator allocator)
      +
      16268 {
      +
      16269  if(allocator != VK_NULL_HANDLE)
      +
      16270  {
      +
      16271  VMA_DEBUG_LOG("vmaDestroyAllocator");
      +
      16272  VkAllocationCallbacks allocationCallbacks = allocator->m_AllocationCallbacks;
      +
      16273  vma_delete(&allocationCallbacks, allocator);
      +
      16274  }
      +
      16275 }
      16276 
      -
      16277  if(stats.memoryHeap[heapIndex].blockCount > 0)
      -
      16278  {
      -
      16279  json.WriteString("Stats");
      -
      16280  VmaPrintStatInfo(json, stats.memoryHeap[heapIndex]);
      -
      16281  }
      -
      16282 
      -
      16283  for(uint32_t typeIndex = 0; typeIndex < allocator->GetMemoryTypeCount(); ++typeIndex)
      -
      16284  {
      -
      16285  if(allocator->MemoryTypeIndexToHeapIndex(typeIndex) == heapIndex)
      -
      16286  {
      -
      16287  json.BeginString("Type ");
      -
      16288  json.ContinueString(typeIndex);
      -
      16289  json.EndString();
      -
      16290 
      -
      16291  json.BeginObject();
      +
      16277 VMA_CALL_PRE void VMA_CALL_POST vmaGetPhysicalDeviceProperties(
      +
      16278  VmaAllocator allocator,
      +
      16279  const VkPhysicalDeviceProperties **ppPhysicalDeviceProperties)
      +
      16280 {
      +
      16281  VMA_ASSERT(allocator && ppPhysicalDeviceProperties);
      +
      16282  *ppPhysicalDeviceProperties = &allocator->m_PhysicalDeviceProperties;
      +
      16283 }
      +
      16284 
      +
      16285 VMA_CALL_PRE void VMA_CALL_POST vmaGetMemoryProperties(
      +
      16286  VmaAllocator allocator,
      +
      16287  const VkPhysicalDeviceMemoryProperties** ppPhysicalDeviceMemoryProperties)
      +
      16288 {
      +
      16289  VMA_ASSERT(allocator && ppPhysicalDeviceMemoryProperties);
      +
      16290  *ppPhysicalDeviceMemoryProperties = &allocator->m_MemProps;
      +
      16291 }
      16292 
      -
      16293  json.WriteString("Flags");
      -
      16294  json.BeginArray(true);
      -
      16295  VkMemoryPropertyFlags flags = allocator->m_MemProps.memoryTypes[typeIndex].propertyFlags;
      -
      16296  if((flags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) != 0)
      -
      16297  {
      -
      16298  json.WriteString("DEVICE_LOCAL");
      -
      16299  }
      -
      16300  if((flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
      -
      16301  {
      -
      16302  json.WriteString("HOST_VISIBLE");
      -
      16303  }
      -
      16304  if((flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) != 0)
      -
      16305  {
      -
      16306  json.WriteString("HOST_COHERENT");
      -
      16307  }
      -
      16308  if((flags & VK_MEMORY_PROPERTY_HOST_CACHED_BIT) != 0)
      -
      16309  {
      -
      16310  json.WriteString("HOST_CACHED");
      -
      16311  }
      -
      16312  if((flags & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT) != 0)
      -
      16313  {
      -
      16314  json.WriteString("LAZILY_ALLOCATED");
      -
      16315  }
      -
      16316  json.EndArray();
      -
      16317 
      -
      16318  if(stats.memoryType[typeIndex].blockCount > 0)
      -
      16319  {
      -
      16320  json.WriteString("Stats");
      -
      16321  VmaPrintStatInfo(json, stats.memoryType[typeIndex]);
      -
      16322  }
      +
      16293 VMA_CALL_PRE void VMA_CALL_POST vmaGetMemoryTypeProperties(
      +
      16294  VmaAllocator allocator,
      +
      16295  uint32_t memoryTypeIndex,
      +
      16296  VkMemoryPropertyFlags* pFlags)
      +
      16297 {
      +
      16298  VMA_ASSERT(allocator && pFlags);
      +
      16299  VMA_ASSERT(memoryTypeIndex < allocator->GetMemoryTypeCount());
      +
      16300  *pFlags = allocator->m_MemProps.memoryTypes[memoryTypeIndex].propertyFlags;
      +
      16301 }
      +
      16302 
      +
      16303 VMA_CALL_PRE void VMA_CALL_POST vmaSetCurrentFrameIndex(
      +
      16304  VmaAllocator allocator,
      +
      16305  uint32_t frameIndex)
      +
      16306 {
      +
      16307  VMA_ASSERT(allocator);
      +
      16308  VMA_ASSERT(frameIndex != VMA_FRAME_INDEX_LOST);
      +
      16309 
      +
      16310  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      16311 
      +
      16312  allocator->SetCurrentFrameIndex(frameIndex);
      +
      16313 }
      +
      16314 
      +
      16315 VMA_CALL_PRE void VMA_CALL_POST vmaCalculateStats(
      +
      16316  VmaAllocator allocator,
      +
      16317  VmaStats* pStats)
      +
      16318 {
      +
      16319  VMA_ASSERT(allocator && pStats);
      +
      16320  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      16321  allocator->CalculateStats(pStats);
      +
      16322 }
      16323 
      -
      16324  json.EndObject();
      -
      16325  }
      -
      16326  }
      -
      16327 
      -
      16328  json.EndObject();
      -
      16329  }
      -
      16330  if(detailedMap == VK_TRUE)
      -
      16331  {
      -
      16332  allocator->PrintDetailedMap(json);
      -
      16333  }
      +
      16324 VMA_CALL_PRE void VMA_CALL_POST vmaGetBudget(
      +
      16325  VmaAllocator allocator,
      +
      16326  VmaBudget* pBudget)
      +
      16327 {
      +
      16328  VMA_ASSERT(allocator && pBudget);
      +
      16329  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      16330  allocator->GetBudget(pBudget, 0, allocator->GetMemoryHeapCount());
      +
      16331 }
      +
      16332 
      +
      16333 #if VMA_STATS_STRING_ENABLED
      16334 
      -
      16335  json.EndObject();
      -
      16336  }
      -
      16337 
      -
      16338  const size_t len = sb.GetLength();
      -
      16339  char* const pChars = vma_new_array(allocator, char, len + 1);
      -
      16340  if(len > 0)
      -
      16341  {
      -
      16342  memcpy(pChars, sb.GetData(), len);
      -
      16343  }
      -
      16344  pChars[len] = '\0';
      -
      16345  *ppStatsString = pChars;
      -
      16346 }
      +
      16335 VMA_CALL_PRE void VMA_CALL_POST vmaBuildStatsString(
      +
      16336  VmaAllocator allocator,
      +
      16337  char** ppStatsString,
      +
      16338  VkBool32 detailedMap)
      +
      16339 {
      +
      16340  VMA_ASSERT(allocator && ppStatsString);
      +
      16341  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      16342 
      +
      16343  VmaStringBuilder sb(allocator);
      +
      16344  {
      +
      16345  VmaJsonWriter json(allocator->GetAllocationCallbacks(), sb);
      +
      16346  json.BeginObject();
      16347 
      -
      16348 VMA_CALL_PRE void VMA_CALL_POST vmaFreeStatsString(
      -
      16349  VmaAllocator allocator,
      -
      16350  char* pStatsString)
      -
      16351 {
      -
      16352  if(pStatsString != VMA_NULL)
      -
      16353  {
      -
      16354  VMA_ASSERT(allocator);
      -
      16355  size_t len = strlen(pStatsString);
      -
      16356  vma_delete_array(allocator, pStatsString, len + 1);
      -
      16357  }
      -
      16358 }
      -
      16359 
      -
      16360 #endif // #if VMA_STATS_STRING_ENABLED
      -
      16361 
      -
      16362 /*
      -
      16363 This function is not protected by any mutex because it just reads immutable data.
      -
      16364 */
      -
      16365 VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndex(
      -
      16366  VmaAllocator allocator,
      -
      16367  uint32_t memoryTypeBits,
      -
      16368  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      -
      16369  uint32_t* pMemoryTypeIndex)
      -
      16370 {
      -
      16371  VMA_ASSERT(allocator != VK_NULL_HANDLE);
      -
      16372  VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
      -
      16373  VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);
      +
      16348  VmaBudget budget[VK_MAX_MEMORY_HEAPS];
      +
      16349  allocator->GetBudget(budget, 0, allocator->GetMemoryHeapCount());
      +
      16350 
      +
      16351  VmaStats stats;
      +
      16352  allocator->CalculateStats(&stats);
      +
      16353 
      +
      16354  json.WriteString("Total");
      +
      16355  VmaPrintStatInfo(json, stats.total);
      +
      16356 
      +
      16357  for(uint32_t heapIndex = 0; heapIndex < allocator->GetMemoryHeapCount(); ++heapIndex)
      +
      16358  {
      +
      16359  json.BeginString("Heap ");
      +
      16360  json.ContinueString(heapIndex);
      +
      16361  json.EndString();
      +
      16362  json.BeginObject();
      +
      16363 
      +
      16364  json.WriteString("Size");
      +
      16365  json.WriteNumber(allocator->m_MemProps.memoryHeaps[heapIndex].size);
      +
      16366 
      +
      16367  json.WriteString("Flags");
      +
      16368  json.BeginArray(true);
      +
      16369  if((allocator->m_MemProps.memoryHeaps[heapIndex].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) != 0)
      +
      16370  {
      +
      16371  json.WriteString("DEVICE_LOCAL");
      +
      16372  }
      +
      16373  json.EndArray();
      16374 
      -
      16375  if(pAllocationCreateInfo->memoryTypeBits != 0)
      -
      16376  {
      -
      16377  memoryTypeBits &= pAllocationCreateInfo->memoryTypeBits;
      -
      16378  }
      -
      16379 
      -
      16380  uint32_t requiredFlags = pAllocationCreateInfo->requiredFlags;
      -
      16381  uint32_t preferredFlags = pAllocationCreateInfo->preferredFlags;
      -
      16382 
      -
      16383  // Convert usage to requiredFlags and preferredFlags.
      -
      16384  switch(pAllocationCreateInfo->usage)
      -
      16385  {
      -
      16386  case VMA_MEMORY_USAGE_UNKNOWN:
      -
      16387  break;
      -
      16388  case VMA_MEMORY_USAGE_GPU_ONLY:
      -
      16389  if(!allocator->IsIntegratedGpu() || (preferredFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
      -
      16390  {
      -
      16391  preferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
      -
      16392  }
      -
      16393  break;
      -
      16394  case VMA_MEMORY_USAGE_CPU_ONLY:
      -
      16395  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
      -
      16396  break;
      -
      16397  case VMA_MEMORY_USAGE_CPU_TO_GPU:
      -
      16398  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
      -
      16399  if(!allocator->IsIntegratedGpu() || (preferredFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
      -
      16400  {
      -
      16401  preferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
      -
      16402  }
      -
      16403  break;
      -
      16404  case VMA_MEMORY_USAGE_GPU_TO_CPU:
      -
      16405  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
      -
      16406  preferredFlags |= VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
      -
      16407  break;
      -
      16408  default:
      -
      16409  break;
      -
      16410  }
      -
      16411 
      -
      16412  *pMemoryTypeIndex = UINT32_MAX;
      -
      16413  uint32_t minCost = UINT32_MAX;
      -
      16414  for(uint32_t memTypeIndex = 0, memTypeBit = 1;
      -
      16415  memTypeIndex < allocator->GetMemoryTypeCount();
      -
      16416  ++memTypeIndex, memTypeBit <<= 1)
      -
      16417  {
      -
      16418  // This memory type is acceptable according to memoryTypeBits bitmask.
      -
      16419  if((memTypeBit & memoryTypeBits) != 0)
      -
      16420  {
      -
      16421  const VkMemoryPropertyFlags currFlags =
      -
      16422  allocator->m_MemProps.memoryTypes[memTypeIndex].propertyFlags;
      -
      16423  // This memory type contains requiredFlags.
      -
      16424  if((requiredFlags & ~currFlags) == 0)
      -
      16425  {
      -
      16426  // Calculate cost as number of bits from preferredFlags not present in this memory type.
      -
      16427  uint32_t currCost = VmaCountBitsSet(preferredFlags & ~currFlags);
      -
      16428  // Remember memory type with lowest cost.
      -
      16429  if(currCost < minCost)
      -
      16430  {
      -
      16431  *pMemoryTypeIndex = memTypeIndex;
      -
      16432  if(currCost == 0)
      -
      16433  {
      -
      16434  return VK_SUCCESS;
      -
      16435  }
      -
      16436  minCost = currCost;
      +
      16375  json.WriteString("Budget");
      +
      16376  json.BeginObject();
      +
      16377  {
      +
      16378  json.WriteString("BlockBytes");
      +
      16379  json.WriteNumber(budget[heapIndex].blockBytes);
      +
      16380  json.WriteString("AllocationBytes");
      +
      16381  json.WriteNumber(budget[heapIndex].allocationBytes);
      +
      16382  json.WriteString("Usage");
      +
      16383  json.WriteNumber(budget[heapIndex].usage);
      +
      16384  json.WriteString("Budget");
      +
      16385  json.WriteNumber(budget[heapIndex].budget);
      +
      16386  }
      +
      16387  json.EndObject();
      +
      16388 
      +
      16389  if(stats.memoryHeap[heapIndex].blockCount > 0)
      +
      16390  {
      +
      16391  json.WriteString("Stats");
      +
      16392  VmaPrintStatInfo(json, stats.memoryHeap[heapIndex]);
      +
      16393  }
      +
      16394 
      +
      16395  for(uint32_t typeIndex = 0; typeIndex < allocator->GetMemoryTypeCount(); ++typeIndex)
      +
      16396  {
      +
      16397  if(allocator->MemoryTypeIndexToHeapIndex(typeIndex) == heapIndex)
      +
      16398  {
      +
      16399  json.BeginString("Type ");
      +
      16400  json.ContinueString(typeIndex);
      +
      16401  json.EndString();
      +
      16402 
      +
      16403  json.BeginObject();
      +
      16404 
      +
      16405  json.WriteString("Flags");
      +
      16406  json.BeginArray(true);
      +
      16407  VkMemoryPropertyFlags flags = allocator->m_MemProps.memoryTypes[typeIndex].propertyFlags;
      +
      16408  if((flags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) != 0)
      +
      16409  {
      +
      16410  json.WriteString("DEVICE_LOCAL");
      +
      16411  }
      +
      16412  if((flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
      +
      16413  {
      +
      16414  json.WriteString("HOST_VISIBLE");
      +
      16415  }
      +
      16416  if((flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) != 0)
      +
      16417  {
      +
      16418  json.WriteString("HOST_COHERENT");
      +
      16419  }
      +
      16420  if((flags & VK_MEMORY_PROPERTY_HOST_CACHED_BIT) != 0)
      +
      16421  {
      +
      16422  json.WriteString("HOST_CACHED");
      +
      16423  }
      +
      16424  if((flags & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT) != 0)
      +
      16425  {
      +
      16426  json.WriteString("LAZILY_ALLOCATED");
      +
      16427  }
      +
      16428  json.EndArray();
      +
      16429 
      +
      16430  if(stats.memoryType[typeIndex].blockCount > 0)
      +
      16431  {
      +
      16432  json.WriteString("Stats");
      +
      16433  VmaPrintStatInfo(json, stats.memoryType[typeIndex]);
      +
      16434  }
      +
      16435 
      +
      16436  json.EndObject();
      16437  }
      16438  }
      -
      16439  }
      -
      16440  }
      -
      16441  return (*pMemoryTypeIndex != UINT32_MAX) ? VK_SUCCESS : VK_ERROR_FEATURE_NOT_PRESENT;
      -
      16442 }
      -
      16443 
      -
      16444 VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForBufferInfo(
      -
      16445  VmaAllocator allocator,
      -
      16446  const VkBufferCreateInfo* pBufferCreateInfo,
      -
      16447  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      -
      16448  uint32_t* pMemoryTypeIndex)
      -
      16449 {
      -
      16450  VMA_ASSERT(allocator != VK_NULL_HANDLE);
      -
      16451  VMA_ASSERT(pBufferCreateInfo != VMA_NULL);
      -
      16452  VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
      -
      16453  VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);
      -
      16454 
      -
      16455  const VkDevice hDev = allocator->m_hDevice;
      -
      16456  VkBuffer hBuffer = VK_NULL_HANDLE;
      -
      16457  VkResult res = allocator->GetVulkanFunctions().vkCreateBuffer(
      -
      16458  hDev, pBufferCreateInfo, allocator->GetAllocationCallbacks(), &hBuffer);
      -
      16459  if(res == VK_SUCCESS)
      -
      16460  {
      -
      16461  VkMemoryRequirements memReq = {};
      -
      16462  allocator->GetVulkanFunctions().vkGetBufferMemoryRequirements(
      -
      16463  hDev, hBuffer, &memReq);
      -
      16464 
      -
      16465  res = vmaFindMemoryTypeIndex(
      -
      16466  allocator,
      -
      16467  memReq.memoryTypeBits,
      -
      16468  pAllocationCreateInfo,
      -
      16469  pMemoryTypeIndex);
      -
      16470 
      -
      16471  allocator->GetVulkanFunctions().vkDestroyBuffer(
      -
      16472  hDev, hBuffer, allocator->GetAllocationCallbacks());
      -
      16473  }
      -
      16474  return res;
      -
      16475 }
      -
      16476 
      -
      16477 VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForImageInfo(
      +
      16439 
      +
      16440  json.EndObject();
      +
      16441  }
      +
      16442  if(detailedMap == VK_TRUE)
      +
      16443  {
      +
      16444  allocator->PrintDetailedMap(json);
      +
      16445  }
      +
      16446 
      +
      16447  json.EndObject();
      +
      16448  }
      +
      16449 
      +
      16450  const size_t len = sb.GetLength();
      +
      16451  char* const pChars = vma_new_array(allocator, char, len + 1);
      +
      16452  if(len > 0)
      +
      16453  {
      +
      16454  memcpy(pChars, sb.GetData(), len);
      +
      16455  }
      +
      16456  pChars[len] = '\0';
      +
      16457  *ppStatsString = pChars;
      +
      16458 }
      +
      16459 
      +
      16460 VMA_CALL_PRE void VMA_CALL_POST vmaFreeStatsString(
      +
      16461  VmaAllocator allocator,
      +
      16462  char* pStatsString)
      +
      16463 {
      +
      16464  if(pStatsString != VMA_NULL)
      +
      16465  {
      +
      16466  VMA_ASSERT(allocator);
      +
      16467  size_t len = strlen(pStatsString);
      +
      16468  vma_delete_array(allocator, pStatsString, len + 1);
      +
      16469  }
      +
      16470 }
      +
      16471 
      +
      16472 #endif // #if VMA_STATS_STRING_ENABLED
      +
      16473 
      +
      16474 /*
      +
      16475 This function is not protected by any mutex because it just reads immutable data.
      +
      16476 */
      +
      16477 VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndex(
      16478  VmaAllocator allocator,
      -
      16479  const VkImageCreateInfo* pImageCreateInfo,
      +
      16479  uint32_t memoryTypeBits,
      16480  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      16481  uint32_t* pMemoryTypeIndex)
      16482 {
      16483  VMA_ASSERT(allocator != VK_NULL_HANDLE);
      -
      16484  VMA_ASSERT(pImageCreateInfo != VMA_NULL);
      -
      16485  VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
      -
      16486  VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);
      -
      16487 
      -
      16488  const VkDevice hDev = allocator->m_hDevice;
      -
      16489  VkImage hImage = VK_NULL_HANDLE;
      -
      16490  VkResult res = allocator->GetVulkanFunctions().vkCreateImage(
      -
      16491  hDev, pImageCreateInfo, allocator->GetAllocationCallbacks(), &hImage);
      -
      16492  if(res == VK_SUCCESS)
      -
      16493  {
      -
      16494  VkMemoryRequirements memReq = {};
      -
      16495  allocator->GetVulkanFunctions().vkGetImageMemoryRequirements(
      -
      16496  hDev, hImage, &memReq);
      -
      16497 
      -
      16498  res = vmaFindMemoryTypeIndex(
      -
      16499  allocator,
      -
      16500  memReq.memoryTypeBits,
      -
      16501  pAllocationCreateInfo,
      -
      16502  pMemoryTypeIndex);
      -
      16503 
      -
      16504  allocator->GetVulkanFunctions().vkDestroyImage(
      -
      16505  hDev, hImage, allocator->GetAllocationCallbacks());
      -
      16506  }
      -
      16507  return res;
      -
      16508 }
      -
      16509 
      -
      16510 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreatePool(
      -
      16511  VmaAllocator allocator,
      -
      16512  const VmaPoolCreateInfo* pCreateInfo,
      -
      16513  VmaPool* pPool)
      -
      16514 {
      -
      16515  VMA_ASSERT(allocator && pCreateInfo && pPool);
      -
      16516 
      -
      16517  VMA_DEBUG_LOG("vmaCreatePool");
      -
      16518 
      -
      16519  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      -
      16520 
      -
      16521  VkResult res = allocator->CreatePool(pCreateInfo, pPool);
      -
      16522 
      -
      16523 #if VMA_RECORDING_ENABLED
      -
      16524  if(allocator->GetRecorder() != VMA_NULL)
      -
      16525  {
      -
      16526  allocator->GetRecorder()->RecordCreatePool(allocator->GetCurrentFrameIndex(), *pCreateInfo, *pPool);
      -
      16527  }
      -
      16528 #endif
      -
      16529 
      -
      16530  return res;
      -
      16531 }
      -
      16532 
      -
      16533 VMA_CALL_PRE void VMA_CALL_POST vmaDestroyPool(
      -
      16534  VmaAllocator allocator,
      -
      16535  VmaPool pool)
      -
      16536 {
      -
      16537  VMA_ASSERT(allocator);
      -
      16538 
      -
      16539  if(pool == VK_NULL_HANDLE)
      -
      16540  {
      -
      16541  return;
      -
      16542  }
      -
      16543 
      -
      16544  VMA_DEBUG_LOG("vmaDestroyPool");
      -
      16545 
      -
      16546  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      -
      16547 
      -
      16548 #if VMA_RECORDING_ENABLED
      -
      16549  if(allocator->GetRecorder() != VMA_NULL)
      -
      16550  {
      -
      16551  allocator->GetRecorder()->RecordDestroyPool(allocator->GetCurrentFrameIndex(), pool);
      +
      16484  VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
      +
      16485  VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);
      +
      16486 
      +
      16487  if(pAllocationCreateInfo->memoryTypeBits != 0)
      +
      16488  {
      +
      16489  memoryTypeBits &= pAllocationCreateInfo->memoryTypeBits;
      +
      16490  }
      +
      16491 
      +
      16492  uint32_t requiredFlags = pAllocationCreateInfo->requiredFlags;
      +
      16493  uint32_t preferredFlags = pAllocationCreateInfo->preferredFlags;
      +
      16494 
      +
      16495  // Convert usage to requiredFlags and preferredFlags.
      +
      16496  switch(pAllocationCreateInfo->usage)
      +
      16497  {
      +
      16498  case VMA_MEMORY_USAGE_UNKNOWN:
      +
      16499  break;
      +
      16500  case VMA_MEMORY_USAGE_GPU_ONLY:
      +
      16501  if(!allocator->IsIntegratedGpu() || (preferredFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
      +
      16502  {
      +
      16503  preferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
      +
      16504  }
      +
      16505  break;
      +
      16506  case VMA_MEMORY_USAGE_CPU_ONLY:
      +
      16507  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
      +
      16508  break;
      +
      16509  case VMA_MEMORY_USAGE_CPU_TO_GPU:
      +
      16510  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
      +
      16511  if(!allocator->IsIntegratedGpu() || (preferredFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0)
      +
      16512  {
      +
      16513  preferredFlags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
      +
      16514  }
      +
      16515  break;
      +
      16516  case VMA_MEMORY_USAGE_GPU_TO_CPU:
      +
      16517  requiredFlags |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
      +
      16518  preferredFlags |= VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
      +
      16519  break;
      +
      16520  default:
      +
      16521  break;
      +
      16522  }
      +
      16523 
      +
      16524  *pMemoryTypeIndex = UINT32_MAX;
      +
      16525  uint32_t minCost = UINT32_MAX;
      +
      16526  for(uint32_t memTypeIndex = 0, memTypeBit = 1;
      +
      16527  memTypeIndex < allocator->GetMemoryTypeCount();
      +
      16528  ++memTypeIndex, memTypeBit <<= 1)
      +
      16529  {
      +
      16530  // This memory type is acceptable according to memoryTypeBits bitmask.
      +
      16531  if((memTypeBit & memoryTypeBits) != 0)
      +
      16532  {
      +
      16533  const VkMemoryPropertyFlags currFlags =
      +
      16534  allocator->m_MemProps.memoryTypes[memTypeIndex].propertyFlags;
      +
      16535  // This memory type contains requiredFlags.
      +
      16536  if((requiredFlags & ~currFlags) == 0)
      +
      16537  {
      +
      16538  // Calculate cost as number of bits from preferredFlags not present in this memory type.
      +
      16539  uint32_t currCost = VmaCountBitsSet(preferredFlags & ~currFlags);
      +
      16540  // Remember memory type with lowest cost.
      +
      16541  if(currCost < minCost)
      +
      16542  {
      +
      16543  *pMemoryTypeIndex = memTypeIndex;
      +
      16544  if(currCost == 0)
      +
      16545  {
      +
      16546  return VK_SUCCESS;
      +
      16547  }
      +
      16548  minCost = currCost;
      +
      16549  }
      +
      16550  }
      +
      16551  }
      16552  }
      -
      16553 #endif
      -
      16554 
      -
      16555  allocator->DestroyPool(pool);
      -
      16556 }
      -
      16557 
      -
      16558 VMA_CALL_PRE void VMA_CALL_POST vmaGetPoolStats(
      -
      16559  VmaAllocator allocator,
      -
      16560  VmaPool pool,
      -
      16561  VmaPoolStats* pPoolStats)
      -
      16562 {
      -
      16563  VMA_ASSERT(allocator && pool && pPoolStats);
      -
      16564 
      -
      16565  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      16553  return (*pMemoryTypeIndex != UINT32_MAX) ? VK_SUCCESS : VK_ERROR_FEATURE_NOT_PRESENT;
      +
      16554 }
      +
      16555 
      +
      16556 VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForBufferInfo(
      +
      16557  VmaAllocator allocator,
      +
      16558  const VkBufferCreateInfo* pBufferCreateInfo,
      +
      16559  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      +
      16560  uint32_t* pMemoryTypeIndex)
      +
      16561 {
      +
      16562  VMA_ASSERT(allocator != VK_NULL_HANDLE);
      +
      16563  VMA_ASSERT(pBufferCreateInfo != VMA_NULL);
      +
      16564  VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
      +
      16565  VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);
      16566 
      -
      16567  allocator->GetPoolStats(pool, pPoolStats);
      -
      16568 }
      -
      16569 
      -
      16570 VMA_CALL_PRE void VMA_CALL_POST vmaMakePoolAllocationsLost(
      -
      16571  VmaAllocator allocator,
      -
      16572  VmaPool pool,
      -
      16573  size_t* pLostAllocationCount)
      -
      16574 {
      -
      16575  VMA_ASSERT(allocator && pool);
      +
      16567  const VkDevice hDev = allocator->m_hDevice;
      +
      16568  VkBuffer hBuffer = VK_NULL_HANDLE;
      +
      16569  VkResult res = allocator->GetVulkanFunctions().vkCreateBuffer(
      +
      16570  hDev, pBufferCreateInfo, allocator->GetAllocationCallbacks(), &hBuffer);
      +
      16571  if(res == VK_SUCCESS)
      +
      16572  {
      +
      16573  VkMemoryRequirements memReq = {};
      +
      16574  allocator->GetVulkanFunctions().vkGetBufferMemoryRequirements(
      +
      16575  hDev, hBuffer, &memReq);
      16576 
      -
      16577  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      -
      16578 
      -
      16579 #if VMA_RECORDING_ENABLED
      -
      16580  if(allocator->GetRecorder() != VMA_NULL)
      -
      16581  {
      -
      16582  allocator->GetRecorder()->RecordMakePoolAllocationsLost(allocator->GetCurrentFrameIndex(), pool);
      -
      16583  }
      -
      16584 #endif
      -
      16585 
      -
      16586  allocator->MakePoolAllocationsLost(pool, pLostAllocationCount);
      +
      16577  res = vmaFindMemoryTypeIndex(
      +
      16578  allocator,
      +
      16579  memReq.memoryTypeBits,
      +
      16580  pAllocationCreateInfo,
      +
      16581  pMemoryTypeIndex);
      +
      16582 
      +
      16583  allocator->GetVulkanFunctions().vkDestroyBuffer(
      +
      16584  hDev, hBuffer, allocator->GetAllocationCallbacks());
      +
      16585  }
      +
      16586  return res;
      16587 }
      16588 
      -
      16589 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCheckPoolCorruption(VmaAllocator allocator, VmaPool pool)
      -
      16590 {
      -
      16591  VMA_ASSERT(allocator && pool);
      -
      16592 
      -
      16593  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      -
      16594 
      -
      16595  VMA_DEBUG_LOG("vmaCheckPoolCorruption");
      -
      16596 
      -
      16597  return allocator->CheckPoolCorruption(pool);
      -
      16598 }
      +
      16589 VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForImageInfo(
      +
      16590  VmaAllocator allocator,
      +
      16591  const VkImageCreateInfo* pImageCreateInfo,
      +
      16592  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      +
      16593  uint32_t* pMemoryTypeIndex)
      +
      16594 {
      +
      16595  VMA_ASSERT(allocator != VK_NULL_HANDLE);
      +
      16596  VMA_ASSERT(pImageCreateInfo != VMA_NULL);
      +
      16597  VMA_ASSERT(pAllocationCreateInfo != VMA_NULL);
      +
      16598  VMA_ASSERT(pMemoryTypeIndex != VMA_NULL);
      16599 
      -
      16600 VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemory(
      -
      16601  VmaAllocator allocator,
      -
      16602  const VkMemoryRequirements* pVkMemoryRequirements,
      -
      16603  const VmaAllocationCreateInfo* pCreateInfo,
      -
      16604  VmaAllocation* pAllocation,
      -
      16605  VmaAllocationInfo* pAllocationInfo)
      -
      16606 {
      -
      16607  VMA_ASSERT(allocator && pVkMemoryRequirements && pCreateInfo && pAllocation);
      -
      16608 
      -
      16609  VMA_DEBUG_LOG("vmaAllocateMemory");
      -
      16610 
      -
      16611  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      -
      16612 
      -
      16613  VkResult result = allocator->AllocateMemory(
      -
      16614  *pVkMemoryRequirements,
      -
      16615  false, // requiresDedicatedAllocation
      -
      16616  false, // prefersDedicatedAllocation
      -
      16617  VK_NULL_HANDLE, // dedicatedBuffer
      -
      16618  VK_NULL_HANDLE, // dedicatedImage
      -
      16619  *pCreateInfo,
      -
      16620  VMA_SUBALLOCATION_TYPE_UNKNOWN,
      -
      16621  1, // allocationCount
      -
      16622  pAllocation);
      -
      16623 
      -
      16624 #if VMA_RECORDING_ENABLED
      -
      16625  if(allocator->GetRecorder() != VMA_NULL)
      -
      16626  {
      -
      16627  allocator->GetRecorder()->RecordAllocateMemory(
      -
      16628  allocator->GetCurrentFrameIndex(),
      -
      16629  *pVkMemoryRequirements,
      -
      16630  *pCreateInfo,
      -
      16631  *pAllocation);
      -
      16632  }
      -
      16633 #endif
      -
      16634 
      -
      16635  if(pAllocationInfo != VMA_NULL && result == VK_SUCCESS)
      -
      16636  {
      -
      16637  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
      -
      16638  }
      -
      16639 
      -
      16640  return result;
      -
      16641 }
      -
      16642 
      -
      16643 VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryPages(
      -
      16644  VmaAllocator allocator,
      -
      16645  const VkMemoryRequirements* pVkMemoryRequirements,
      -
      16646  const VmaAllocationCreateInfo* pCreateInfo,
      -
      16647  size_t allocationCount,
      -
      16648  VmaAllocation* pAllocations,
      -
      16649  VmaAllocationInfo* pAllocationInfo)
      -
      16650 {
      -
      16651  if(allocationCount == 0)
      +
      16600  const VkDevice hDev = allocator->m_hDevice;
      +
      16601  VkImage hImage = VK_NULL_HANDLE;
      +
      16602  VkResult res = allocator->GetVulkanFunctions().vkCreateImage(
      +
      16603  hDev, pImageCreateInfo, allocator->GetAllocationCallbacks(), &hImage);
      +
      16604  if(res == VK_SUCCESS)
      +
      16605  {
      +
      16606  VkMemoryRequirements memReq = {};
      +
      16607  allocator->GetVulkanFunctions().vkGetImageMemoryRequirements(
      +
      16608  hDev, hImage, &memReq);
      +
      16609 
      +
      16610  res = vmaFindMemoryTypeIndex(
      +
      16611  allocator,
      +
      16612  memReq.memoryTypeBits,
      +
      16613  pAllocationCreateInfo,
      +
      16614  pMemoryTypeIndex);
      +
      16615 
      +
      16616  allocator->GetVulkanFunctions().vkDestroyImage(
      +
      16617  hDev, hImage, allocator->GetAllocationCallbacks());
      +
      16618  }
      +
      16619  return res;
      +
      16620 }
      +
      16621 
      +
      16622 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreatePool(
      +
      16623  VmaAllocator allocator,
      +
      16624  const VmaPoolCreateInfo* pCreateInfo,
      +
      16625  VmaPool* pPool)
      +
      16626 {
      +
      16627  VMA_ASSERT(allocator && pCreateInfo && pPool);
      +
      16628 
      +
      16629  VMA_DEBUG_LOG("vmaCreatePool");
      +
      16630 
      +
      16631  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      16632 
      +
      16633  VkResult res = allocator->CreatePool(pCreateInfo, pPool);
      +
      16634 
      +
      16635 #if VMA_RECORDING_ENABLED
      +
      16636  if(allocator->GetRecorder() != VMA_NULL)
      +
      16637  {
      +
      16638  allocator->GetRecorder()->RecordCreatePool(allocator->GetCurrentFrameIndex(), *pCreateInfo, *pPool);
      +
      16639  }
      +
      16640 #endif
      +
      16641 
      +
      16642  return res;
      +
      16643 }
      +
      16644 
      +
      16645 VMA_CALL_PRE void VMA_CALL_POST vmaDestroyPool(
      +
      16646  VmaAllocator allocator,
      +
      16647  VmaPool pool)
      +
      16648 {
      +
      16649  VMA_ASSERT(allocator);
      +
      16650 
      +
      16651  if(pool == VK_NULL_HANDLE)
      16652  {
      -
      16653  return VK_SUCCESS;
      +
      16653  return;
      16654  }
      -
      16655 
      -
      16656  VMA_ASSERT(allocator && pVkMemoryRequirements && pCreateInfo && pAllocations);
      -
      16657 
      -
      16658  VMA_DEBUG_LOG("vmaAllocateMemoryPages");
      -
      16659 
      -
      16660  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      -
      16661 
      -
      16662  VkResult result = allocator->AllocateMemory(
      -
      16663  *pVkMemoryRequirements,
      -
      16664  false, // requiresDedicatedAllocation
      -
      16665  false, // prefersDedicatedAllocation
      -
      16666  VK_NULL_HANDLE, // dedicatedBuffer
      -
      16667  VK_NULL_HANDLE, // dedicatedImage
      -
      16668  *pCreateInfo,
      -
      16669  VMA_SUBALLOCATION_TYPE_UNKNOWN,
      -
      16670  allocationCount,
      -
      16671  pAllocations);
      -
      16672 
      -
      16673 #if VMA_RECORDING_ENABLED
      -
      16674  if(allocator->GetRecorder() != VMA_NULL)
      -
      16675  {
      -
      16676  allocator->GetRecorder()->RecordAllocateMemoryPages(
      -
      16677  allocator->GetCurrentFrameIndex(),
      -
      16678  *pVkMemoryRequirements,
      -
      16679  *pCreateInfo,
      -
      16680  (uint64_t)allocationCount,
      -
      16681  pAllocations);
      -
      16682  }
      -
      16683 #endif
      -
      16684 
      -
      16685  if(pAllocationInfo != VMA_NULL && result == VK_SUCCESS)
      -
      16686  {
      -
      16687  for(size_t i = 0; i < allocationCount; ++i)
      -
      16688  {
      -
      16689  allocator->GetAllocationInfo(pAllocations[i], pAllocationInfo + i);
      -
      16690  }
      -
      16691  }
      -
      16692 
      -
      16693  return result;
      -
      16694 }
      -
      16695 
      -
      16696 VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryForBuffer(
      -
      16697  VmaAllocator allocator,
      -
      16698  VkBuffer buffer,
      -
      16699  const VmaAllocationCreateInfo* pCreateInfo,
      -
      16700  VmaAllocation* pAllocation,
      -
      16701  VmaAllocationInfo* pAllocationInfo)
      +
      16655 
      +
      16656  VMA_DEBUG_LOG("vmaDestroyPool");
      +
      16657 
      +
      16658  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      16659 
      +
      16660 #if VMA_RECORDING_ENABLED
      +
      16661  if(allocator->GetRecorder() != VMA_NULL)
      +
      16662  {
      +
      16663  allocator->GetRecorder()->RecordDestroyPool(allocator->GetCurrentFrameIndex(), pool);
      +
      16664  }
      +
      16665 #endif
      +
      16666 
      +
      16667  allocator->DestroyPool(pool);
      +
      16668 }
      +
      16669 
      +
      16670 VMA_CALL_PRE void VMA_CALL_POST vmaGetPoolStats(
      +
      16671  VmaAllocator allocator,
      +
      16672  VmaPool pool,
      +
      16673  VmaPoolStats* pPoolStats)
      +
      16674 {
      +
      16675  VMA_ASSERT(allocator && pool && pPoolStats);
      +
      16676 
      +
      16677  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      16678 
      +
      16679  allocator->GetPoolStats(pool, pPoolStats);
      +
      16680 }
      +
      16681 
      +
      16682 VMA_CALL_PRE void VMA_CALL_POST vmaMakePoolAllocationsLost(
      +
      16683  VmaAllocator allocator,
      +
      16684  VmaPool pool,
      +
      16685  size_t* pLostAllocationCount)
      +
      16686 {
      +
      16687  VMA_ASSERT(allocator && pool);
      +
      16688 
      +
      16689  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      16690 
      +
      16691 #if VMA_RECORDING_ENABLED
      +
      16692  if(allocator->GetRecorder() != VMA_NULL)
      +
      16693  {
      +
      16694  allocator->GetRecorder()->RecordMakePoolAllocationsLost(allocator->GetCurrentFrameIndex(), pool);
      +
      16695  }
      +
      16696 #endif
      +
      16697 
      +
      16698  allocator->MakePoolAllocationsLost(pool, pLostAllocationCount);
      +
      16699 }
      +
      16700 
      +
      16701 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCheckPoolCorruption(VmaAllocator allocator, VmaPool pool)
      16702 {
      -
      16703  VMA_ASSERT(allocator && buffer != VK_NULL_HANDLE && pCreateInfo && pAllocation);
      +
      16703  VMA_ASSERT(allocator && pool);
      16704 
      -
      16705  VMA_DEBUG_LOG("vmaAllocateMemoryForBuffer");
      +
      16705  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      16706 
      -
      16707  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      16707  VMA_DEBUG_LOG("vmaCheckPoolCorruption");
      16708 
      -
      16709  VkMemoryRequirements vkMemReq = {};
      -
      16710  bool requiresDedicatedAllocation = false;
      -
      16711  bool prefersDedicatedAllocation = false;
      -
      16712  allocator->GetBufferMemoryRequirements(buffer, vkMemReq,
      -
      16713  requiresDedicatedAllocation,
      -
      16714  prefersDedicatedAllocation);
      -
      16715 
      -
      16716  VkResult result = allocator->AllocateMemory(
      -
      16717  vkMemReq,
      -
      16718  requiresDedicatedAllocation,
      -
      16719  prefersDedicatedAllocation,
      -
      16720  buffer, // dedicatedBuffer
      -
      16721  VK_NULL_HANDLE, // dedicatedImage
      -
      16722  *pCreateInfo,
      -
      16723  VMA_SUBALLOCATION_TYPE_BUFFER,
      -
      16724  1, // allocationCount
      -
      16725  pAllocation);
      -
      16726 
      -
      16727 #if VMA_RECORDING_ENABLED
      -
      16728  if(allocator->GetRecorder() != VMA_NULL)
      -
      16729  {
      -
      16730  allocator->GetRecorder()->RecordAllocateMemoryForBuffer(
      -
      16731  allocator->GetCurrentFrameIndex(),
      -
      16732  vkMemReq,
      -
      16733  requiresDedicatedAllocation,
      -
      16734  prefersDedicatedAllocation,
      -
      16735  *pCreateInfo,
      -
      16736  *pAllocation);
      -
      16737  }
      -
      16738 #endif
      -
      16739 
      -
      16740  if(pAllocationInfo && result == VK_SUCCESS)
      +
      16709  return allocator->CheckPoolCorruption(pool);
      +
      16710 }
      +
      16711 
      +
      16712 VMA_CALL_PRE void VMA_CALL_POST vmaGetPoolName(
      +
      16713  VmaAllocator allocator,
      +
      16714  VmaPool pool,
      +
      16715  const char** ppName)
      +
      16716 {
      +
      16717  VMA_ASSERT(allocator && pool);
      +
      16718 
      +
      16719  VMA_DEBUG_LOG("vmaGetPoolName");
      +
      16720 
      +
      16721  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      16722 
      +
      16723  *ppName = pool->GetName();
      +
      16724 }
      +
      16725 
      +
      16726 VMA_CALL_PRE void VMA_CALL_POST vmaSetPoolName(
      +
      16727  VmaAllocator allocator,
      +
      16728  VmaPool pool,
      +
      16729  const char* pName)
      +
      16730 {
      +
      16731  VMA_ASSERT(allocator && pool);
      +
      16732 
      +
      16733  VMA_DEBUG_LOG("vmaSetPoolName");
      +
      16734 
      +
      16735  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      16736 
      +
      16737  pool->SetName(pName);
      +
      16738 
      +
      16739 #if VMA_RECORDING_ENABLED
      +
      16740  if(allocator->GetRecorder() != VMA_NULL)
      16741  {
      -
      16742  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
      +
      16742  allocator->GetRecorder()->RecordSetPoolName(allocator->GetCurrentFrameIndex(), pool, pName);
      16743  }
      -
      16744 
      -
      16745  return result;
      -
      16746 }
      -
      16747 
      -
      16748 VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryForImage(
      -
      16749  VmaAllocator allocator,
      -
      16750  VkImage image,
      -
      16751  const VmaAllocationCreateInfo* pCreateInfo,
      -
      16752  VmaAllocation* pAllocation,
      -
      16753  VmaAllocationInfo* pAllocationInfo)
      -
      16754 {
      -
      16755  VMA_ASSERT(allocator && image != VK_NULL_HANDLE && pCreateInfo && pAllocation);
      -
      16756 
      -
      16757  VMA_DEBUG_LOG("vmaAllocateMemoryForImage");
      -
      16758 
      -
      16759  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      -
      16760 
      -
      16761  VkMemoryRequirements vkMemReq = {};
      -
      16762  bool requiresDedicatedAllocation = false;
      -
      16763  bool prefersDedicatedAllocation = false;
      -
      16764  allocator->GetImageMemoryRequirements(image, vkMemReq,
      -
      16765  requiresDedicatedAllocation, prefersDedicatedAllocation);
      -
      16766 
      -
      16767  VkResult result = allocator->AllocateMemory(
      -
      16768  vkMemReq,
      -
      16769  requiresDedicatedAllocation,
      -
      16770  prefersDedicatedAllocation,
      -
      16771  VK_NULL_HANDLE, // dedicatedBuffer
      -
      16772  image, // dedicatedImage
      -
      16773  *pCreateInfo,
      -
      16774  VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN,
      -
      16775  1, // allocationCount
      -
      16776  pAllocation);
      -
      16777 
      -
      16778 #if VMA_RECORDING_ENABLED
      -
      16779  if(allocator->GetRecorder() != VMA_NULL)
      -
      16780  {
      -
      16781  allocator->GetRecorder()->RecordAllocateMemoryForImage(
      -
      16782  allocator->GetCurrentFrameIndex(),
      -
      16783  vkMemReq,
      -
      16784  requiresDedicatedAllocation,
      -
      16785  prefersDedicatedAllocation,
      -
      16786  *pCreateInfo,
      -
      16787  *pAllocation);
      -
      16788  }
      -
      16789 #endif
      -
      16790 
      -
      16791  if(pAllocationInfo && result == VK_SUCCESS)
      -
      16792  {
      -
      16793  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
      -
      16794  }
      -
      16795 
      -
      16796  return result;
      -
      16797 }
      -
      16798 
      -
      16799 VMA_CALL_PRE void VMA_CALL_POST vmaFreeMemory(
      -
      16800  VmaAllocator allocator,
      -
      16801  VmaAllocation allocation)
      -
      16802 {
      -
      16803  VMA_ASSERT(allocator);
      -
      16804 
      -
      16805  if(allocation == VK_NULL_HANDLE)
      -
      16806  {
      -
      16807  return;
      -
      16808  }
      -
      16809 
      -
      16810  VMA_DEBUG_LOG("vmaFreeMemory");
      -
      16811 
      -
      16812  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      -
      16813 
      -
      16814 #if VMA_RECORDING_ENABLED
      -
      16815  if(allocator->GetRecorder() != VMA_NULL)
      -
      16816  {
      -
      16817  allocator->GetRecorder()->RecordFreeMemory(
      -
      16818  allocator->GetCurrentFrameIndex(),
      -
      16819  allocation);
      -
      16820  }
      -
      16821 #endif
      -
      16822 
      -
      16823  allocator->FreeMemory(
      -
      16824  1, // allocationCount
      -
      16825  &allocation);
      -
      16826 }
      -
      16827 
      -
      16828 VMA_CALL_PRE void VMA_CALL_POST vmaFreeMemoryPages(
      -
      16829  VmaAllocator allocator,
      -
      16830  size_t allocationCount,
      -
      16831  VmaAllocation* pAllocations)
      -
      16832 {
      -
      16833  if(allocationCount == 0)
      -
      16834  {
      -
      16835  return;
      -
      16836  }
      -
      16837 
      -
      16838  VMA_ASSERT(allocator);
      -
      16839 
      -
      16840  VMA_DEBUG_LOG("vmaFreeMemoryPages");
      -
      16841 
      -
      16842  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      -
      16843 
      -
      16844 #if VMA_RECORDING_ENABLED
      -
      16845  if(allocator->GetRecorder() != VMA_NULL)
      -
      16846  {
      -
      16847  allocator->GetRecorder()->RecordFreeMemoryPages(
      -
      16848  allocator->GetCurrentFrameIndex(),
      -
      16849  (uint64_t)allocationCount,
      -
      16850  pAllocations);
      -
      16851  }
      -
      16852 #endif
      -
      16853 
      -
      16854  allocator->FreeMemory(allocationCount, pAllocations);
      -
      16855 }
      -
      16856 
      -
      16857 VMA_CALL_PRE VkResult VMA_CALL_POST vmaResizeAllocation(
      -
      16858  VmaAllocator allocator,
      -
      16859  VmaAllocation allocation,
      -
      16860  VkDeviceSize newSize)
      -
      16861 {
      -
      16862  VMA_ASSERT(allocator && allocation);
      -
      16863 
      -
      16864  VMA_DEBUG_LOG("vmaResizeAllocation");
      -
      16865 
      -
      16866  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      -
      16867 
      -
      16868  return allocator->ResizeAllocation(allocation, newSize);
      -
      16869 }
      -
      16870 
      -
      16871 VMA_CALL_PRE void VMA_CALL_POST vmaGetAllocationInfo(
      -
      16872  VmaAllocator allocator,
      -
      16873  VmaAllocation allocation,
      -
      16874  VmaAllocationInfo* pAllocationInfo)
      -
      16875 {
      -
      16876  VMA_ASSERT(allocator && allocation && pAllocationInfo);
      -
      16877 
      -
      16878  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      -
      16879 
      -
      16880 #if VMA_RECORDING_ENABLED
      -
      16881  if(allocator->GetRecorder() != VMA_NULL)
      -
      16882  {
      -
      16883  allocator->GetRecorder()->RecordGetAllocationInfo(
      -
      16884  allocator->GetCurrentFrameIndex(),
      -
      16885  allocation);
      -
      16886  }
      -
      16887 #endif
      -
      16888 
      -
      16889  allocator->GetAllocationInfo(allocation, pAllocationInfo);
      -
      16890 }
      +
      16744 #endif
      +
      16745 }
      +
      16746 
      +
      16747 VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemory(
      +
      16748  VmaAllocator allocator,
      +
      16749  const VkMemoryRequirements* pVkMemoryRequirements,
      +
      16750  const VmaAllocationCreateInfo* pCreateInfo,
      +
      16751  VmaAllocation* pAllocation,
      +
      16752  VmaAllocationInfo* pAllocationInfo)
      +
      16753 {
      +
      16754  VMA_ASSERT(allocator && pVkMemoryRequirements && pCreateInfo && pAllocation);
      +
      16755 
      +
      16756  VMA_DEBUG_LOG("vmaAllocateMemory");
      +
      16757 
      +
      16758  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      16759 
      +
      16760  VkResult result = allocator->AllocateMemory(
      +
      16761  *pVkMemoryRequirements,
      +
      16762  false, // requiresDedicatedAllocation
      +
      16763  false, // prefersDedicatedAllocation
      +
      16764  VK_NULL_HANDLE, // dedicatedBuffer
      +
      16765  VK_NULL_HANDLE, // dedicatedImage
      +
      16766  *pCreateInfo,
      +
      16767  VMA_SUBALLOCATION_TYPE_UNKNOWN,
      +
      16768  1, // allocationCount
      +
      16769  pAllocation);
      +
      16770 
      +
      16771 #if VMA_RECORDING_ENABLED
      +
      16772  if(allocator->GetRecorder() != VMA_NULL)
      +
      16773  {
      +
      16774  allocator->GetRecorder()->RecordAllocateMemory(
      +
      16775  allocator->GetCurrentFrameIndex(),
      +
      16776  *pVkMemoryRequirements,
      +
      16777  *pCreateInfo,
      +
      16778  *pAllocation);
      +
      16779  }
      +
      16780 #endif
      +
      16781 
      +
      16782  if(pAllocationInfo != VMA_NULL && result == VK_SUCCESS)
      +
      16783  {
      +
      16784  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
      +
      16785  }
      +
      16786 
      +
      16787  return result;
      +
      16788 }
      +
      16789 
      +
      16790 VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryPages(
      +
      16791  VmaAllocator allocator,
      +
      16792  const VkMemoryRequirements* pVkMemoryRequirements,
      +
      16793  const VmaAllocationCreateInfo* pCreateInfo,
      +
      16794  size_t allocationCount,
      +
      16795  VmaAllocation* pAllocations,
      +
      16796  VmaAllocationInfo* pAllocationInfo)
      +
      16797 {
      +
      16798  if(allocationCount == 0)
      +
      16799  {
      +
      16800  return VK_SUCCESS;
      +
      16801  }
      +
      16802 
      +
      16803  VMA_ASSERT(allocator && pVkMemoryRequirements && pCreateInfo && pAllocations);
      +
      16804 
      +
      16805  VMA_DEBUG_LOG("vmaAllocateMemoryPages");
      +
      16806 
      +
      16807  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      16808 
      +
      16809  VkResult result = allocator->AllocateMemory(
      +
      16810  *pVkMemoryRequirements,
      +
      16811  false, // requiresDedicatedAllocation
      +
      16812  false, // prefersDedicatedAllocation
      +
      16813  VK_NULL_HANDLE, // dedicatedBuffer
      +
      16814  VK_NULL_HANDLE, // dedicatedImage
      +
      16815  *pCreateInfo,
      +
      16816  VMA_SUBALLOCATION_TYPE_UNKNOWN,
      +
      16817  allocationCount,
      +
      16818  pAllocations);
      +
      16819 
      +
      16820 #if VMA_RECORDING_ENABLED
      +
      16821  if(allocator->GetRecorder() != VMA_NULL)
      +
      16822  {
      +
      16823  allocator->GetRecorder()->RecordAllocateMemoryPages(
      +
      16824  allocator->GetCurrentFrameIndex(),
      +
      16825  *pVkMemoryRequirements,
      +
      16826  *pCreateInfo,
      +
      16827  (uint64_t)allocationCount,
      +
      16828  pAllocations);
      +
      16829  }
      +
      16830 #endif
      +
      16831 
      +
      16832  if(pAllocationInfo != VMA_NULL && result == VK_SUCCESS)
      +
      16833  {
      +
      16834  for(size_t i = 0; i < allocationCount; ++i)
      +
      16835  {
      +
      16836  allocator->GetAllocationInfo(pAllocations[i], pAllocationInfo + i);
      +
      16837  }
      +
      16838  }
      +
      16839 
      +
      16840  return result;
      +
      16841 }
      +
      16842 
      +
      16843 VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryForBuffer(
      +
      16844  VmaAllocator allocator,
      +
      16845  VkBuffer buffer,
      +
      16846  const VmaAllocationCreateInfo* pCreateInfo,
      +
      16847  VmaAllocation* pAllocation,
      +
      16848  VmaAllocationInfo* pAllocationInfo)
      +
      16849 {
      +
      16850  VMA_ASSERT(allocator && buffer != VK_NULL_HANDLE && pCreateInfo && pAllocation);
      +
      16851 
      +
      16852  VMA_DEBUG_LOG("vmaAllocateMemoryForBuffer");
      +
      16853 
      +
      16854  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      16855 
      +
      16856  VkMemoryRequirements vkMemReq = {};
      +
      16857  bool requiresDedicatedAllocation = false;
      +
      16858  bool prefersDedicatedAllocation = false;
      +
      16859  allocator->GetBufferMemoryRequirements(buffer, vkMemReq,
      +
      16860  requiresDedicatedAllocation,
      +
      16861  prefersDedicatedAllocation);
      +
      16862 
      +
      16863  VkResult result = allocator->AllocateMemory(
      +
      16864  vkMemReq,
      +
      16865  requiresDedicatedAllocation,
      +
      16866  prefersDedicatedAllocation,
      +
      16867  buffer, // dedicatedBuffer
      +
      16868  VK_NULL_HANDLE, // dedicatedImage
      +
      16869  *pCreateInfo,
      +
      16870  VMA_SUBALLOCATION_TYPE_BUFFER,
      +
      16871  1, // allocationCount
      +
      16872  pAllocation);
      +
      16873 
      +
      16874 #if VMA_RECORDING_ENABLED
      +
      16875  if(allocator->GetRecorder() != VMA_NULL)
      +
      16876  {
      +
      16877  allocator->GetRecorder()->RecordAllocateMemoryForBuffer(
      +
      16878  allocator->GetCurrentFrameIndex(),
      +
      16879  vkMemReq,
      +
      16880  requiresDedicatedAllocation,
      +
      16881  prefersDedicatedAllocation,
      +
      16882  *pCreateInfo,
      +
      16883  *pAllocation);
      +
      16884  }
      +
      16885 #endif
      +
      16886 
      +
      16887  if(pAllocationInfo && result == VK_SUCCESS)
      +
      16888  {
      +
      16889  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
      +
      16890  }
      16891 
      -
      16892 VMA_CALL_PRE VkBool32 VMA_CALL_POST vmaTouchAllocation(
      -
      16893  VmaAllocator allocator,
      -
      16894  VmaAllocation allocation)
      -
      16895 {
      -
      16896  VMA_ASSERT(allocator && allocation);
      -
      16897 
      -
      16898  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      -
      16899 
      -
      16900 #if VMA_RECORDING_ENABLED
      -
      16901  if(allocator->GetRecorder() != VMA_NULL)
      -
      16902  {
      -
      16903  allocator->GetRecorder()->RecordTouchAllocation(
      -
      16904  allocator->GetCurrentFrameIndex(),
      -
      16905  allocation);
      -
      16906  }
      -
      16907 #endif
      -
      16908 
      -
      16909  return allocator->TouchAllocation(allocation);
      -
      16910 }
      -
      16911 
      -
      16912 VMA_CALL_PRE void VMA_CALL_POST vmaSetAllocationUserData(
      -
      16913  VmaAllocator allocator,
      -
      16914  VmaAllocation allocation,
      -
      16915  void* pUserData)
      -
      16916 {
      -
      16917  VMA_ASSERT(allocator && allocation);
      -
      16918 
      -
      16919  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      -
      16920 
      -
      16921  allocation->SetUserData(allocator, pUserData);
      -
      16922 
      -
      16923 #if VMA_RECORDING_ENABLED
      -
      16924  if(allocator->GetRecorder() != VMA_NULL)
      -
      16925  {
      -
      16926  allocator->GetRecorder()->RecordSetAllocationUserData(
      -
      16927  allocator->GetCurrentFrameIndex(),
      -
      16928  allocation,
      -
      16929  pUserData);
      -
      16930  }
      -
      16931 #endif
      -
      16932 }
      -
      16933 
      -
      16934 VMA_CALL_PRE void VMA_CALL_POST vmaCreateLostAllocation(
      -
      16935  VmaAllocator allocator,
      -
      16936  VmaAllocation* pAllocation)
      -
      16937 {
      -
      16938  VMA_ASSERT(allocator && pAllocation);
      -
      16939 
      -
      16940  VMA_DEBUG_GLOBAL_MUTEX_LOCK;
      -
      16941 
      -
      16942  allocator->CreateLostAllocation(pAllocation);
      -
      16943 
      -
      16944 #if VMA_RECORDING_ENABLED
      -
      16945  if(allocator->GetRecorder() != VMA_NULL)
      -
      16946  {
      -
      16947  allocator->GetRecorder()->RecordCreateLostAllocation(
      -
      16948  allocator->GetCurrentFrameIndex(),
      -
      16949  *pAllocation);
      -
      16950  }
      -
      16951 #endif
      -
      16952 }
      -
      16953 
      -
      16954 VMA_CALL_PRE VkResult VMA_CALL_POST vmaMapMemory(
      -
      16955  VmaAllocator allocator,
      -
      16956  VmaAllocation allocation,
      -
      16957  void** ppData)
      -
      16958 {
      -
      16959  VMA_ASSERT(allocator && allocation && ppData);
      +
      16892  return result;
      +
      16893 }
      +
      16894 
      +
      16895 VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryForImage(
      +
      16896  VmaAllocator allocator,
      +
      16897  VkImage image,
      +
      16898  const VmaAllocationCreateInfo* pCreateInfo,
      +
      16899  VmaAllocation* pAllocation,
      +
      16900  VmaAllocationInfo* pAllocationInfo)
      +
      16901 {
      +
      16902  VMA_ASSERT(allocator && image != VK_NULL_HANDLE && pCreateInfo && pAllocation);
      +
      16903 
      +
      16904  VMA_DEBUG_LOG("vmaAllocateMemoryForImage");
      +
      16905 
      +
      16906  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      16907 
      +
      16908  VkMemoryRequirements vkMemReq = {};
      +
      16909  bool requiresDedicatedAllocation = false;
      +
      16910  bool prefersDedicatedAllocation = false;
      +
      16911  allocator->GetImageMemoryRequirements(image, vkMemReq,
      +
      16912  requiresDedicatedAllocation, prefersDedicatedAllocation);
      +
      16913 
      +
      16914  VkResult result = allocator->AllocateMemory(
      +
      16915  vkMemReq,
      +
      16916  requiresDedicatedAllocation,
      +
      16917  prefersDedicatedAllocation,
      +
      16918  VK_NULL_HANDLE, // dedicatedBuffer
      +
      16919  image, // dedicatedImage
      +
      16920  *pCreateInfo,
      +
      16921  VMA_SUBALLOCATION_TYPE_IMAGE_UNKNOWN,
      +
      16922  1, // allocationCount
      +
      16923  pAllocation);
      +
      16924 
      +
      16925 #if VMA_RECORDING_ENABLED
      +
      16926  if(allocator->GetRecorder() != VMA_NULL)
      +
      16927  {
      +
      16928  allocator->GetRecorder()->RecordAllocateMemoryForImage(
      +
      16929  allocator->GetCurrentFrameIndex(),
      +
      16930  vkMemReq,
      +
      16931  requiresDedicatedAllocation,
      +
      16932  prefersDedicatedAllocation,
      +
      16933  *pCreateInfo,
      +
      16934  *pAllocation);
      +
      16935  }
      +
      16936 #endif
      +
      16937 
      +
      16938  if(pAllocationInfo && result == VK_SUCCESS)
      +
      16939  {
      +
      16940  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
      +
      16941  }
      +
      16942 
      +
      16943  return result;
      +
      16944 }
      +
      16945 
      +
      16946 VMA_CALL_PRE void VMA_CALL_POST vmaFreeMemory(
      +
      16947  VmaAllocator allocator,
      +
      16948  VmaAllocation allocation)
      +
      16949 {
      +
      16950  VMA_ASSERT(allocator);
      +
      16951 
      +
      16952  if(allocation == VK_NULL_HANDLE)
      +
      16953  {
      +
      16954  return;
      +
      16955  }
      +
      16956 
      +
      16957  VMA_DEBUG_LOG("vmaFreeMemory");
      +
      16958 
      +
      16959  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      16960 
      -
      16961  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      -
      16962 
      -
      16963  VkResult res = allocator->Map(allocation, ppData);
      -
      16964 
      -
      16965 #if VMA_RECORDING_ENABLED
      -
      16966  if(allocator->GetRecorder() != VMA_NULL)
      -
      16967  {
      -
      16968  allocator->GetRecorder()->RecordMapMemory(
      -
      16969  allocator->GetCurrentFrameIndex(),
      -
      16970  allocation);
      -
      16971  }
      -
      16972 #endif
      -
      16973 
      -
      16974  return res;
      -
      16975 }
      -
      16976 
      -
      16977 VMA_CALL_PRE void VMA_CALL_POST vmaUnmapMemory(
      -
      16978  VmaAllocator allocator,
      -
      16979  VmaAllocation allocation)
      -
      16980 {
      -
      16981  VMA_ASSERT(allocator && allocation);
      -
      16982 
      -
      16983  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      16961 #if VMA_RECORDING_ENABLED
      +
      16962  if(allocator->GetRecorder() != VMA_NULL)
      +
      16963  {
      +
      16964  allocator->GetRecorder()->RecordFreeMemory(
      +
      16965  allocator->GetCurrentFrameIndex(),
      +
      16966  allocation);
      +
      16967  }
      +
      16968 #endif
      +
      16969 
      +
      16970  allocator->FreeMemory(
      +
      16971  1, // allocationCount
      +
      16972  &allocation);
      +
      16973 }
      +
      16974 
      +
      16975 VMA_CALL_PRE void VMA_CALL_POST vmaFreeMemoryPages(
      +
      16976  VmaAllocator allocator,
      +
      16977  size_t allocationCount,
      +
      16978  VmaAllocation* pAllocations)
      +
      16979 {
      +
      16980  if(allocationCount == 0)
      +
      16981  {
      +
      16982  return;
      +
      16983  }
      16984 
      -
      16985 #if VMA_RECORDING_ENABLED
      -
      16986  if(allocator->GetRecorder() != VMA_NULL)
      -
      16987  {
      -
      16988  allocator->GetRecorder()->RecordUnmapMemory(
      -
      16989  allocator->GetCurrentFrameIndex(),
      -
      16990  allocation);
      -
      16991  }
      -
      16992 #endif
      -
      16993 
      -
      16994  allocator->Unmap(allocation);
      -
      16995 }
      -
      16996 
      -
      16997 VMA_CALL_PRE void VMA_CALL_POST vmaFlushAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
      -
      16998 {
      -
      16999  VMA_ASSERT(allocator && allocation);
      -
      17000 
      -
      17001  VMA_DEBUG_LOG("vmaFlushAllocation");
      -
      17002 
      -
      17003  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      -
      17004 
      -
      17005  allocator->FlushOrInvalidateAllocation(allocation, offset, size, VMA_CACHE_FLUSH);
      -
      17006 
      -
      17007 #if VMA_RECORDING_ENABLED
      -
      17008  if(allocator->GetRecorder() != VMA_NULL)
      -
      17009  {
      -
      17010  allocator->GetRecorder()->RecordFlushAllocation(
      -
      17011  allocator->GetCurrentFrameIndex(),
      -
      17012  allocation, offset, size);
      -
      17013  }
      -
      17014 #endif
      -
      17015 }
      -
      17016 
      -
      17017 VMA_CALL_PRE void VMA_CALL_POST vmaInvalidateAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
      -
      17018 {
      -
      17019  VMA_ASSERT(allocator && allocation);
      -
      17020 
      -
      17021  VMA_DEBUG_LOG("vmaInvalidateAllocation");
      -
      17022 
      -
      17023  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      16985  VMA_ASSERT(allocator);
      +
      16986 
      +
      16987  VMA_DEBUG_LOG("vmaFreeMemoryPages");
      +
      16988 
      +
      16989  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      16990 
      +
      16991 #if VMA_RECORDING_ENABLED
      +
      16992  if(allocator->GetRecorder() != VMA_NULL)
      +
      16993  {
      +
      16994  allocator->GetRecorder()->RecordFreeMemoryPages(
      +
      16995  allocator->GetCurrentFrameIndex(),
      +
      16996  (uint64_t)allocationCount,
      +
      16997  pAllocations);
      +
      16998  }
      +
      16999 #endif
      +
      17000 
      +
      17001  allocator->FreeMemory(allocationCount, pAllocations);
      +
      17002 }
      +
      17003 
      +
      17004 VMA_CALL_PRE VkResult VMA_CALL_POST vmaResizeAllocation(
      +
      17005  VmaAllocator allocator,
      +
      17006  VmaAllocation allocation,
      +
      17007  VkDeviceSize newSize)
      +
      17008 {
      +
      17009  VMA_ASSERT(allocator && allocation);
      +
      17010 
      +
      17011  VMA_DEBUG_LOG("vmaResizeAllocation");
      +
      17012 
      +
      17013  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      17014 
      +
      17015  return allocator->ResizeAllocation(allocation, newSize);
      +
      17016 }
      +
      17017 
      +
      17018 VMA_CALL_PRE void VMA_CALL_POST vmaGetAllocationInfo(
      +
      17019  VmaAllocator allocator,
      +
      17020  VmaAllocation allocation,
      +
      17021  VmaAllocationInfo* pAllocationInfo)
      +
      17022 {
      +
      17023  VMA_ASSERT(allocator && allocation && pAllocationInfo);
      17024 
      -
      17025  allocator->FlushOrInvalidateAllocation(allocation, offset, size, VMA_CACHE_INVALIDATE);
      +
      17025  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      17026 
      17027 #if VMA_RECORDING_ENABLED
      17028  if(allocator->GetRecorder() != VMA_NULL)
      17029  {
      -
      17030  allocator->GetRecorder()->RecordInvalidateAllocation(
      +
      17030  allocator->GetRecorder()->RecordGetAllocationInfo(
      17031  allocator->GetCurrentFrameIndex(),
      -
      17032  allocation, offset, size);
      +
      17032  allocation);
      17033  }
      17034 #endif
      -
      17035 }
      -
      17036 
      -
      17037 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCheckCorruption(VmaAllocator allocator, uint32_t memoryTypeBits)
      -
      17038 {
      -
      17039  VMA_ASSERT(allocator);
      -
      17040 
      -
      17041  VMA_DEBUG_LOG("vmaCheckCorruption");
      -
      17042 
      -
      17043  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      17035 
      +
      17036  allocator->GetAllocationInfo(allocation, pAllocationInfo);
      +
      17037 }
      +
      17038 
      +
      17039 VMA_CALL_PRE VkBool32 VMA_CALL_POST vmaTouchAllocation(
      +
      17040  VmaAllocator allocator,
      +
      17041  VmaAllocation allocation)
      +
      17042 {
      +
      17043  VMA_ASSERT(allocator && allocation);
      17044 
      -
      17045  return allocator->CheckCorruption(memoryTypeBits);
      -
      17046 }
      -
      17047 
      -
      17048 VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragment(
      -
      17049  VmaAllocator allocator,
      -
      17050  VmaAllocation* pAllocations,
      -
      17051  size_t allocationCount,
      -
      17052  VkBool32* pAllocationsChanged,
      -
      17053  const VmaDefragmentationInfo *pDefragmentationInfo,
      -
      17054  VmaDefragmentationStats* pDefragmentationStats)
      -
      17055 {
      -
      17056  // Deprecated interface, reimplemented using new one.
      -
      17057 
      -
      17058  VmaDefragmentationInfo2 info2 = {};
      -
      17059  info2.allocationCount = (uint32_t)allocationCount;
      -
      17060  info2.pAllocations = pAllocations;
      -
      17061  info2.pAllocationsChanged = pAllocationsChanged;
      -
      17062  if(pDefragmentationInfo != VMA_NULL)
      -
      17063  {
      -
      17064  info2.maxCpuAllocationsToMove = pDefragmentationInfo->maxAllocationsToMove;
      -
      17065  info2.maxCpuBytesToMove = pDefragmentationInfo->maxBytesToMove;
      -
      17066  }
      -
      17067  else
      -
      17068  {
      -
      17069  info2.maxCpuAllocationsToMove = UINT32_MAX;
      -
      17070  info2.maxCpuBytesToMove = VK_WHOLE_SIZE;
      -
      17071  }
      -
      17072  // info2.flags, maxGpuAllocationsToMove, maxGpuBytesToMove, commandBuffer deliberately left zero.
      -
      17073 
      -
      17074  VmaDefragmentationContext ctx;
      -
      17075  VkResult res = vmaDefragmentationBegin(allocator, &info2, pDefragmentationStats, &ctx);
      -
      17076  if(res == VK_NOT_READY)
      -
      17077  {
      -
      17078  res = vmaDefragmentationEnd( allocator, ctx);
      -
      17079  }
      -
      17080  return res;
      -
      17081 }
      -
      17082 
      -
      17083 VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragmentationBegin(
      -
      17084  VmaAllocator allocator,
      -
      17085  const VmaDefragmentationInfo2* pInfo,
      -
      17086  VmaDefragmentationStats* pStats,
      -
      17087  VmaDefragmentationContext *pContext)
      -
      17088 {
      -
      17089  VMA_ASSERT(allocator && pInfo && pContext);
      +
      17045  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      17046 
      +
      17047 #if VMA_RECORDING_ENABLED
      +
      17048  if(allocator->GetRecorder() != VMA_NULL)
      +
      17049  {
      +
      17050  allocator->GetRecorder()->RecordTouchAllocation(
      +
      17051  allocator->GetCurrentFrameIndex(),
      +
      17052  allocation);
      +
      17053  }
      +
      17054 #endif
      +
      17055 
      +
      17056  return allocator->TouchAllocation(allocation);
      +
      17057 }
      +
      17058 
      +
      17059 VMA_CALL_PRE void VMA_CALL_POST vmaSetAllocationUserData(
      +
      17060  VmaAllocator allocator,
      +
      17061  VmaAllocation allocation,
      +
      17062  void* pUserData)
      +
      17063 {
      +
      17064  VMA_ASSERT(allocator && allocation);
      +
      17065 
      +
      17066  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      17067 
      +
      17068  allocation->SetUserData(allocator, pUserData);
      +
      17069 
      +
      17070 #if VMA_RECORDING_ENABLED
      +
      17071  if(allocator->GetRecorder() != VMA_NULL)
      +
      17072  {
      +
      17073  allocator->GetRecorder()->RecordSetAllocationUserData(
      +
      17074  allocator->GetCurrentFrameIndex(),
      +
      17075  allocation,
      +
      17076  pUserData);
      +
      17077  }
      +
      17078 #endif
      +
      17079 }
      +
      17080 
      +
      17081 VMA_CALL_PRE void VMA_CALL_POST vmaCreateLostAllocation(
      +
      17082  VmaAllocator allocator,
      +
      17083  VmaAllocation* pAllocation)
      +
      17084 {
      +
      17085  VMA_ASSERT(allocator && pAllocation);
      +
      17086 
      +
      17087  VMA_DEBUG_GLOBAL_MUTEX_LOCK;
      +
      17088 
      +
      17089  allocator->CreateLostAllocation(pAllocation);
      17090 
      -
      17091  // Degenerate case: Nothing to defragment.
      -
      17092  if(pInfo->allocationCount == 0 && pInfo->poolCount == 0)
      +
      17091 #if VMA_RECORDING_ENABLED
      +
      17092  if(allocator->GetRecorder() != VMA_NULL)
      17093  {
      -
      17094  return VK_SUCCESS;
      -
      17095  }
      -
      17096 
      -
      17097  VMA_ASSERT(pInfo->allocationCount == 0 || pInfo->pAllocations != VMA_NULL);
      -
      17098  VMA_ASSERT(pInfo->poolCount == 0 || pInfo->pPools != VMA_NULL);
      -
      17099  VMA_HEAVY_ASSERT(VmaValidatePointerArray(pInfo->allocationCount, pInfo->pAllocations));
      -
      17100  VMA_HEAVY_ASSERT(VmaValidatePointerArray(pInfo->poolCount, pInfo->pPools));
      -
      17101 
      -
      17102  VMA_DEBUG_LOG("vmaDefragmentationBegin");
      -
      17103 
      -
      17104  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      -
      17105 
      -
      17106  VkResult res = allocator->DefragmentationBegin(*pInfo, pStats, pContext);
      +
      17094  allocator->GetRecorder()->RecordCreateLostAllocation(
      +
      17095  allocator->GetCurrentFrameIndex(),
      +
      17096  *pAllocation);
      +
      17097  }
      +
      17098 #endif
      +
      17099 }
      +
      17100 
      +
      17101 VMA_CALL_PRE VkResult VMA_CALL_POST vmaMapMemory(
      +
      17102  VmaAllocator allocator,
      +
      17103  VmaAllocation allocation,
      +
      17104  void** ppData)
      +
      17105 {
      +
      17106  VMA_ASSERT(allocator && allocation && ppData);
      17107 
      -
      17108 #if VMA_RECORDING_ENABLED
      -
      17109  if(allocator->GetRecorder() != VMA_NULL)
      -
      17110  {
      -
      17111  allocator->GetRecorder()->RecordDefragmentationBegin(
      -
      17112  allocator->GetCurrentFrameIndex(), *pInfo, *pContext);
      -
      17113  }
      -
      17114 #endif
      -
      17115 
      -
      17116  return res;
      -
      17117 }
      -
      17118 
      -
      17119 VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragmentationEnd(
      -
      17120  VmaAllocator allocator,
      -
      17121  VmaDefragmentationContext context)
      -
      17122 {
      -
      17123  VMA_ASSERT(allocator);
      -
      17124 
      -
      17125  VMA_DEBUG_LOG("vmaDefragmentationEnd");
      -
      17126 
      -
      17127  if(context != VK_NULL_HANDLE)
      -
      17128  {
      -
      17129  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      -
      17130 
      -
      17131 #if VMA_RECORDING_ENABLED
      -
      17132  if(allocator->GetRecorder() != VMA_NULL)
      -
      17133  {
      -
      17134  allocator->GetRecorder()->RecordDefragmentationEnd(
      -
      17135  allocator->GetCurrentFrameIndex(), context);
      -
      17136  }
      -
      17137 #endif
      -
      17138 
      -
      17139  return allocator->DefragmentationEnd(context);
      -
      17140  }
      -
      17141  else
      -
      17142  {
      -
      17143  return VK_SUCCESS;
      -
      17144  }
      -
      17145 }
      -
      17146 
      -
      17147 VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindBufferMemory(
      -
      17148  VmaAllocator allocator,
      -
      17149  VmaAllocation allocation,
      -
      17150  VkBuffer buffer)
      -
      17151 {
      -
      17152  VMA_ASSERT(allocator && allocation && buffer);
      +
      17108  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      17109 
      +
      17110  VkResult res = allocator->Map(allocation, ppData);
      +
      17111 
      +
      17112 #if VMA_RECORDING_ENABLED
      +
      17113  if(allocator->GetRecorder() != VMA_NULL)
      +
      17114  {
      +
      17115  allocator->GetRecorder()->RecordMapMemory(
      +
      17116  allocator->GetCurrentFrameIndex(),
      +
      17117  allocation);
      +
      17118  }
      +
      17119 #endif
      +
      17120 
      +
      17121  return res;
      +
      17122 }
      +
      17123 
      +
      17124 VMA_CALL_PRE void VMA_CALL_POST vmaUnmapMemory(
      +
      17125  VmaAllocator allocator,
      +
      17126  VmaAllocation allocation)
      +
      17127 {
      +
      17128  VMA_ASSERT(allocator && allocation);
      +
      17129 
      +
      17130  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      17131 
      +
      17132 #if VMA_RECORDING_ENABLED
      +
      17133  if(allocator->GetRecorder() != VMA_NULL)
      +
      17134  {
      +
      17135  allocator->GetRecorder()->RecordUnmapMemory(
      +
      17136  allocator->GetCurrentFrameIndex(),
      +
      17137  allocation);
      +
      17138  }
      +
      17139 #endif
      +
      17140 
      +
      17141  allocator->Unmap(allocation);
      +
      17142 }
      +
      17143 
      +
      17144 VMA_CALL_PRE void VMA_CALL_POST vmaFlushAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
      +
      17145 {
      +
      17146  VMA_ASSERT(allocator && allocation);
      +
      17147 
      +
      17148  VMA_DEBUG_LOG("vmaFlushAllocation");
      +
      17149 
      +
      17150  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      17151 
      +
      17152  allocator->FlushOrInvalidateAllocation(allocation, offset, size, VMA_CACHE_FLUSH);
      17153 
      -
      17154  VMA_DEBUG_LOG("vmaBindBufferMemory");
      -
      17155 
      -
      17156  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      -
      17157 
      -
      17158  return allocator->BindBufferMemory(allocation, 0, buffer, VMA_NULL);
      -
      17159 }
      -
      17160 
      -
      17161 VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindBufferMemory2(
      -
      17162  VmaAllocator allocator,
      -
      17163  VmaAllocation allocation,
      -
      17164  VkDeviceSize allocationLocalOffset,
      -
      17165  VkBuffer buffer,
      -
      17166  const void* pNext)
      -
      17167 {
      -
      17168  VMA_ASSERT(allocator && allocation && buffer);
      +
      17154 #if VMA_RECORDING_ENABLED
      +
      17155  if(allocator->GetRecorder() != VMA_NULL)
      +
      17156  {
      +
      17157  allocator->GetRecorder()->RecordFlushAllocation(
      +
      17158  allocator->GetCurrentFrameIndex(),
      +
      17159  allocation, offset, size);
      +
      17160  }
      +
      17161 #endif
      +
      17162 }
      +
      17163 
      +
      17164 VMA_CALL_PRE void VMA_CALL_POST vmaInvalidateAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
      +
      17165 {
      +
      17166  VMA_ASSERT(allocator && allocation);
      +
      17167 
      +
      17168  VMA_DEBUG_LOG("vmaInvalidateAllocation");
      17169 
      -
      17170  VMA_DEBUG_LOG("vmaBindBufferMemory2");
      +
      17170  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      17171 
      -
      17172  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      17172  allocator->FlushOrInvalidateAllocation(allocation, offset, size, VMA_CACHE_INVALIDATE);
      17173 
      -
      17174  return allocator->BindBufferMemory(allocation, allocationLocalOffset, buffer, pNext);
      -
      17175 }
      -
      17176 
      -
      17177 VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindImageMemory(
      -
      17178  VmaAllocator allocator,
      -
      17179  VmaAllocation allocation,
      -
      17180  VkImage image)
      -
      17181 {
      -
      17182  VMA_ASSERT(allocator && allocation && image);
      +
      17174 #if VMA_RECORDING_ENABLED
      +
      17175  if(allocator->GetRecorder() != VMA_NULL)
      +
      17176  {
      +
      17177  allocator->GetRecorder()->RecordInvalidateAllocation(
      +
      17178  allocator->GetCurrentFrameIndex(),
      +
      17179  allocation, offset, size);
      +
      17180  }
      +
      17181 #endif
      +
      17182 }
      17183 
      -
      17184  VMA_DEBUG_LOG("vmaBindImageMemory");
      -
      17185 
      -
      17186  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      17184 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCheckCorruption(VmaAllocator allocator, uint32_t memoryTypeBits)
      +
      17185 {
      +
      17186  VMA_ASSERT(allocator);
      17187 
      -
      17188  return allocator->BindImageMemory(allocation, 0, image, VMA_NULL);
      -
      17189 }
      -
      17190 
      -
      17191 VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindImageMemory2(
      -
      17192  VmaAllocator allocator,
      -
      17193  VmaAllocation allocation,
      -
      17194  VkDeviceSize allocationLocalOffset,
      -
      17195  VkImage image,
      -
      17196  const void* pNext)
      -
      17197 {
      -
      17198  VMA_ASSERT(allocator && allocation && image);
      -
      17199 
      -
      17200  VMA_DEBUG_LOG("vmaBindImageMemory2");
      -
      17201 
      -
      17202  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      -
      17203 
      -
      17204  return allocator->BindImageMemory(allocation, allocationLocalOffset, image, pNext);
      -
      17205 }
      -
      17206 
      -
      17207 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateBuffer(
      -
      17208  VmaAllocator allocator,
      -
      17209  const VkBufferCreateInfo* pBufferCreateInfo,
      -
      17210  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      -
      17211  VkBuffer* pBuffer,
      -
      17212  VmaAllocation* pAllocation,
      -
      17213  VmaAllocationInfo* pAllocationInfo)
      -
      17214 {
      -
      17215  VMA_ASSERT(allocator && pBufferCreateInfo && pAllocationCreateInfo && pBuffer && pAllocation);
      -
      17216 
      -
      17217  if(pBufferCreateInfo->size == 0)
      -
      17218  {
      -
      17219  return VK_ERROR_VALIDATION_FAILED_EXT;
      -
      17220  }
      -
      17221 
      -
      17222  VMA_DEBUG_LOG("vmaCreateBuffer");
      -
      17223 
      -
      17224  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      -
      17225 
      -
      17226  *pBuffer = VK_NULL_HANDLE;
      -
      17227  *pAllocation = VK_NULL_HANDLE;
      -
      17228 
      -
      17229  // 1. Create VkBuffer.
      -
      17230  VkResult res = (*allocator->GetVulkanFunctions().vkCreateBuffer)(
      -
      17231  allocator->m_hDevice,
      -
      17232  pBufferCreateInfo,
      -
      17233  allocator->GetAllocationCallbacks(),
      -
      17234  pBuffer);
      -
      17235  if(res >= 0)
      -
      17236  {
      -
      17237  // 2. vkGetBufferMemoryRequirements.
      -
      17238  VkMemoryRequirements vkMemReq = {};
      -
      17239  bool requiresDedicatedAllocation = false;
      -
      17240  bool prefersDedicatedAllocation = false;
      -
      17241  allocator->GetBufferMemoryRequirements(*pBuffer, vkMemReq,
      -
      17242  requiresDedicatedAllocation, prefersDedicatedAllocation);
      +
      17188  VMA_DEBUG_LOG("vmaCheckCorruption");
      +
      17189 
      +
      17190  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      17191 
      +
      17192  return allocator->CheckCorruption(memoryTypeBits);
      +
      17193 }
      +
      17194 
      +
      17195 VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragment(
      +
      17196  VmaAllocator allocator,
      +
      17197  VmaAllocation* pAllocations,
      +
      17198  size_t allocationCount,
      +
      17199  VkBool32* pAllocationsChanged,
      +
      17200  const VmaDefragmentationInfo *pDefragmentationInfo,
      +
      17201  VmaDefragmentationStats* pDefragmentationStats)
      +
      17202 {
      +
      17203  // Deprecated interface, reimplemented using new one.
      +
      17204 
      +
      17205  VmaDefragmentationInfo2 info2 = {};
      +
      17206  info2.allocationCount = (uint32_t)allocationCount;
      +
      17207  info2.pAllocations = pAllocations;
      +
      17208  info2.pAllocationsChanged = pAllocationsChanged;
      +
      17209  if(pDefragmentationInfo != VMA_NULL)
      +
      17210  {
      +
      17211  info2.maxCpuAllocationsToMove = pDefragmentationInfo->maxAllocationsToMove;
      +
      17212  info2.maxCpuBytesToMove = pDefragmentationInfo->maxBytesToMove;
      +
      17213  }
      +
      17214  else
      +
      17215  {
      +
      17216  info2.maxCpuAllocationsToMove = UINT32_MAX;
      +
      17217  info2.maxCpuBytesToMove = VK_WHOLE_SIZE;
      +
      17218  }
      +
      17219  // info2.flags, maxGpuAllocationsToMove, maxGpuBytesToMove, commandBuffer deliberately left zero.
      +
      17220 
      +
      17221  VmaDefragmentationContext ctx;
      +
      17222  VkResult res = vmaDefragmentationBegin(allocator, &info2, pDefragmentationStats, &ctx);
      +
      17223  if(res == VK_NOT_READY)
      +
      17224  {
      +
      17225  res = vmaDefragmentationEnd( allocator, ctx);
      +
      17226  }
      +
      17227  return res;
      +
      17228 }
      +
      17229 
      +
      17230 VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragmentationBegin(
      +
      17231  VmaAllocator allocator,
      +
      17232  const VmaDefragmentationInfo2* pInfo,
      +
      17233  VmaDefragmentationStats* pStats,
      +
      17234  VmaDefragmentationContext *pContext)
      +
      17235 {
      +
      17236  VMA_ASSERT(allocator && pInfo && pContext);
      +
      17237 
      +
      17238  // Degenerate case: Nothing to defragment.
      +
      17239  if(pInfo->allocationCount == 0 && pInfo->poolCount == 0)
      +
      17240  {
      +
      17241  return VK_SUCCESS;
      +
      17242  }
      17243 
      -
      17244  // Make sure alignment requirements for specific buffer usages reported
      -
      17245  // in Physical Device Properties are included in alignment reported by memory requirements.
      -
      17246  if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT) != 0)
      -
      17247  {
      -
      17248  VMA_ASSERT(vkMemReq.alignment %
      -
      17249  allocator->m_PhysicalDeviceProperties.limits.minTexelBufferOffsetAlignment == 0);
      -
      17250  }
      -
      17251  if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT) != 0)
      -
      17252  {
      -
      17253  VMA_ASSERT(vkMemReq.alignment %
      -
      17254  allocator->m_PhysicalDeviceProperties.limits.minUniformBufferOffsetAlignment == 0);
      -
      17255  }
      -
      17256  if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_STORAGE_BUFFER_BIT) != 0)
      -
      17257  {
      -
      17258  VMA_ASSERT(vkMemReq.alignment %
      -
      17259  allocator->m_PhysicalDeviceProperties.limits.minStorageBufferOffsetAlignment == 0);
      -
      17260  }
      -
      17261 
      -
      17262  // 3. Allocate memory using allocator.
      -
      17263  res = allocator->AllocateMemory(
      -
      17264  vkMemReq,
      -
      17265  requiresDedicatedAllocation,
      -
      17266  prefersDedicatedAllocation,
      -
      17267  *pBuffer, // dedicatedBuffer
      -
      17268  VK_NULL_HANDLE, // dedicatedImage
      -
      17269  *pAllocationCreateInfo,
      -
      17270  VMA_SUBALLOCATION_TYPE_BUFFER,
      -
      17271  1, // allocationCount
      -
      17272  pAllocation);
      +
      17244  VMA_ASSERT(pInfo->allocationCount == 0 || pInfo->pAllocations != VMA_NULL);
      +
      17245  VMA_ASSERT(pInfo->poolCount == 0 || pInfo->pPools != VMA_NULL);
      +
      17246  VMA_HEAVY_ASSERT(VmaValidatePointerArray(pInfo->allocationCount, pInfo->pAllocations));
      +
      17247  VMA_HEAVY_ASSERT(VmaValidatePointerArray(pInfo->poolCount, pInfo->pPools));
      +
      17248 
      +
      17249  VMA_DEBUG_LOG("vmaDefragmentationBegin");
      +
      17250 
      +
      17251  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      17252 
      +
      17253  VkResult res = allocator->DefragmentationBegin(*pInfo, pStats, pContext);
      +
      17254 
      +
      17255 #if VMA_RECORDING_ENABLED
      +
      17256  if(allocator->GetRecorder() != VMA_NULL)
      +
      17257  {
      +
      17258  allocator->GetRecorder()->RecordDefragmentationBegin(
      +
      17259  allocator->GetCurrentFrameIndex(), *pInfo, *pContext);
      +
      17260  }
      +
      17261 #endif
      +
      17262 
      +
      17263  return res;
      +
      17264 }
      +
      17265 
      +
      17266 VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragmentationEnd(
      +
      17267  VmaAllocator allocator,
      +
      17268  VmaDefragmentationContext context)
      +
      17269 {
      +
      17270  VMA_ASSERT(allocator);
      +
      17271 
      +
      17272  VMA_DEBUG_LOG("vmaDefragmentationEnd");
      17273 
      -
      17274 #if VMA_RECORDING_ENABLED
      -
      17275  if(allocator->GetRecorder() != VMA_NULL)
      -
      17276  {
      -
      17277  allocator->GetRecorder()->RecordCreateBuffer(
      -
      17278  allocator->GetCurrentFrameIndex(),
      -
      17279  *pBufferCreateInfo,
      -
      17280  *pAllocationCreateInfo,
      -
      17281  *pAllocation);
      -
      17282  }
      -
      17283 #endif
      -
      17284 
      -
      17285  if(res >= 0)
      -
      17286  {
      -
      17287  // 3. Bind buffer with memory.
      -
      17288  if((pAllocationCreateInfo->flags & VMA_ALLOCATION_CREATE_DONT_BIND_BIT) == 0)
      -
      17289  {
      -
      17290  res = allocator->BindBufferMemory(*pAllocation, 0, *pBuffer, VMA_NULL);
      -
      17291  }
      -
      17292  if(res >= 0)
      -
      17293  {
      -
      17294  // All steps succeeded.
      -
      17295  #if VMA_STATS_STRING_ENABLED
      -
      17296  (*pAllocation)->InitBufferImageUsage(pBufferCreateInfo->usage);
      -
      17297  #endif
      -
      17298  if(pAllocationInfo != VMA_NULL)
      -
      17299  {
      -
      17300  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
      -
      17301  }
      +
      17274  if(context != VK_NULL_HANDLE)
      +
      17275  {
      +
      17276  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      17277 
      +
      17278 #if VMA_RECORDING_ENABLED
      +
      17279  if(allocator->GetRecorder() != VMA_NULL)
      +
      17280  {
      +
      17281  allocator->GetRecorder()->RecordDefragmentationEnd(
      +
      17282  allocator->GetCurrentFrameIndex(), context);
      +
      17283  }
      +
      17284 #endif
      +
      17285 
      +
      17286  return allocator->DefragmentationEnd(context);
      +
      17287  }
      +
      17288  else
      +
      17289  {
      +
      17290  return VK_SUCCESS;
      +
      17291  }
      +
      17292 }
      +
      17293 
      +
      17294 VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindBufferMemory(
      +
      17295  VmaAllocator allocator,
      +
      17296  VmaAllocation allocation,
      +
      17297  VkBuffer buffer)
      +
      17298 {
      +
      17299  VMA_ASSERT(allocator && allocation && buffer);
      +
      17300 
      +
      17301  VMA_DEBUG_LOG("vmaBindBufferMemory");
      17302 
      -
      17303  return VK_SUCCESS;
      -
      17304  }
      -
      17305  allocator->FreeMemory(
      -
      17306  1, // allocationCount
      -
      17307  pAllocation);
      -
      17308  *pAllocation = VK_NULL_HANDLE;
      -
      17309  (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, *pBuffer, allocator->GetAllocationCallbacks());
      -
      17310  *pBuffer = VK_NULL_HANDLE;
      -
      17311  return res;
      -
      17312  }
      -
      17313  (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, *pBuffer, allocator->GetAllocationCallbacks());
      -
      17314  *pBuffer = VK_NULL_HANDLE;
      -
      17315  return res;
      -
      17316  }
      -
      17317  return res;
      -
      17318 }
      -
      17319 
      -
      17320 VMA_CALL_PRE void VMA_CALL_POST vmaDestroyBuffer(
      -
      17321  VmaAllocator allocator,
      -
      17322  VkBuffer buffer,
      -
      17323  VmaAllocation allocation)
      -
      17324 {
      -
      17325  VMA_ASSERT(allocator);
      -
      17326 
      -
      17327  if(buffer == VK_NULL_HANDLE && allocation == VK_NULL_HANDLE)
      -
      17328  {
      -
      17329  return;
      -
      17330  }
      -
      17331 
      -
      17332  VMA_DEBUG_LOG("vmaDestroyBuffer");
      -
      17333 
      -
      17334  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      -
      17335 
      -
      17336 #if VMA_RECORDING_ENABLED
      -
      17337  if(allocator->GetRecorder() != VMA_NULL)
      -
      17338  {
      -
      17339  allocator->GetRecorder()->RecordDestroyBuffer(
      -
      17340  allocator->GetCurrentFrameIndex(),
      -
      17341  allocation);
      -
      17342  }
      -
      17343 #endif
      -
      17344 
      -
      17345  if(buffer != VK_NULL_HANDLE)
      -
      17346  {
      -
      17347  (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, buffer, allocator->GetAllocationCallbacks());
      -
      17348  }
      -
      17349 
      -
      17350  if(allocation != VK_NULL_HANDLE)
      -
      17351  {
      -
      17352  allocator->FreeMemory(
      -
      17353  1, // allocationCount
      -
      17354  &allocation);
      -
      17355  }
      -
      17356 }
      -
      17357 
      -
      17358 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateImage(
      -
      17359  VmaAllocator allocator,
      -
      17360  const VkImageCreateInfo* pImageCreateInfo,
      -
      17361  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      -
      17362  VkImage* pImage,
      -
      17363  VmaAllocation* pAllocation,
      -
      17364  VmaAllocationInfo* pAllocationInfo)
      -
      17365 {
      -
      17366  VMA_ASSERT(allocator && pImageCreateInfo && pAllocationCreateInfo && pImage && pAllocation);
      -
      17367 
      -
      17368  if(pImageCreateInfo->extent.width == 0 ||
      -
      17369  pImageCreateInfo->extent.height == 0 ||
      -
      17370  pImageCreateInfo->extent.depth == 0 ||
      -
      17371  pImageCreateInfo->mipLevels == 0 ||
      -
      17372  pImageCreateInfo->arrayLayers == 0)
      -
      17373  {
      -
      17374  return VK_ERROR_VALIDATION_FAILED_EXT;
      -
      17375  }
      -
      17376 
      -
      17377  VMA_DEBUG_LOG("vmaCreateImage");
      -
      17378 
      -
      17379  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      -
      17380 
      -
      17381  *pImage = VK_NULL_HANDLE;
      -
      17382  *pAllocation = VK_NULL_HANDLE;
      -
      17383 
      -
      17384  // 1. Create VkImage.
      -
      17385  VkResult res = (*allocator->GetVulkanFunctions().vkCreateImage)(
      -
      17386  allocator->m_hDevice,
      -
      17387  pImageCreateInfo,
      -
      17388  allocator->GetAllocationCallbacks(),
      -
      17389  pImage);
      -
      17390  if(res >= 0)
      -
      17391  {
      -
      17392  VmaSuballocationType suballocType = pImageCreateInfo->tiling == VK_IMAGE_TILING_OPTIMAL ?
      -
      17393  VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL :
      -
      17394  VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR;
      -
      17395 
      -
      17396  // 2. Allocate memory using allocator.
      -
      17397  VkMemoryRequirements vkMemReq = {};
      -
      17398  bool requiresDedicatedAllocation = false;
      -
      17399  bool prefersDedicatedAllocation = false;
      -
      17400  allocator->GetImageMemoryRequirements(*pImage, vkMemReq,
      -
      17401  requiresDedicatedAllocation, prefersDedicatedAllocation);
      -
      17402 
      -
      17403  res = allocator->AllocateMemory(
      -
      17404  vkMemReq,
      -
      17405  requiresDedicatedAllocation,
      -
      17406  prefersDedicatedAllocation,
      -
      17407  VK_NULL_HANDLE, // dedicatedBuffer
      -
      17408  *pImage, // dedicatedImage
      -
      17409  *pAllocationCreateInfo,
      -
      17410  suballocType,
      -
      17411  1, // allocationCount
      -
      17412  pAllocation);
      -
      17413 
      -
      17414 #if VMA_RECORDING_ENABLED
      -
      17415  if(allocator->GetRecorder() != VMA_NULL)
      -
      17416  {
      -
      17417  allocator->GetRecorder()->RecordCreateImage(
      -
      17418  allocator->GetCurrentFrameIndex(),
      -
      17419  *pImageCreateInfo,
      -
      17420  *pAllocationCreateInfo,
      -
      17421  *pAllocation);
      -
      17422  }
      -
      17423 #endif
      -
      17424 
      -
      17425  if(res >= 0)
      -
      17426  {
      -
      17427  // 3. Bind image with memory.
      -
      17428  if((pAllocationCreateInfo->flags & VMA_ALLOCATION_CREATE_DONT_BIND_BIT) == 0)
      -
      17429  {
      -
      17430  res = allocator->BindImageMemory(*pAllocation, 0, *pImage, VMA_NULL);
      -
      17431  }
      -
      17432  if(res >= 0)
      -
      17433  {
      -
      17434  // All steps succeeded.
      -
      17435  #if VMA_STATS_STRING_ENABLED
      -
      17436  (*pAllocation)->InitBufferImageUsage(pImageCreateInfo->usage);
      -
      17437  #endif
      -
      17438  if(pAllocationInfo != VMA_NULL)
      -
      17439  {
      -
      17440  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
      -
      17441  }
      -
      17442 
      -
      17443  return VK_SUCCESS;
      -
      17444  }
      -
      17445  allocator->FreeMemory(
      -
      17446  1, // allocationCount
      -
      17447  pAllocation);
      -
      17448  *pAllocation = VK_NULL_HANDLE;
      -
      17449  (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, *pImage, allocator->GetAllocationCallbacks());
      -
      17450  *pImage = VK_NULL_HANDLE;
      -
      17451  return res;
      -
      17452  }
      -
      17453  (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, *pImage, allocator->GetAllocationCallbacks());
      -
      17454  *pImage = VK_NULL_HANDLE;
      -
      17455  return res;
      -
      17456  }
      -
      17457  return res;
      -
      17458 }
      -
      17459 
      -
      17460 VMA_CALL_PRE void VMA_CALL_POST vmaDestroyImage(
      -
      17461  VmaAllocator allocator,
      -
      17462  VkImage image,
      -
      17463  VmaAllocation allocation)
      -
      17464 {
      -
      17465  VMA_ASSERT(allocator);
      +
      17303  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      17304 
      +
      17305  return allocator->BindBufferMemory(allocation, 0, buffer, VMA_NULL);
      +
      17306 }
      +
      17307 
      +
      17308 VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindBufferMemory2(
      +
      17309  VmaAllocator allocator,
      +
      17310  VmaAllocation allocation,
      +
      17311  VkDeviceSize allocationLocalOffset,
      +
      17312  VkBuffer buffer,
      +
      17313  const void* pNext)
      +
      17314 {
      +
      17315  VMA_ASSERT(allocator && allocation && buffer);
      +
      17316 
      +
      17317  VMA_DEBUG_LOG("vmaBindBufferMemory2");
      +
      17318 
      +
      17319  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      17320 
      +
      17321  return allocator->BindBufferMemory(allocation, allocationLocalOffset, buffer, pNext);
      +
      17322 }
      +
      17323 
      +
      17324 VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindImageMemory(
      +
      17325  VmaAllocator allocator,
      +
      17326  VmaAllocation allocation,
      +
      17327  VkImage image)
      +
      17328 {
      +
      17329  VMA_ASSERT(allocator && allocation && image);
      +
      17330 
      +
      17331  VMA_DEBUG_LOG("vmaBindImageMemory");
      +
      17332 
      +
      17333  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      17334 
      +
      17335  return allocator->BindImageMemory(allocation, 0, image, VMA_NULL);
      +
      17336 }
      +
      17337 
      +
      17338 VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindImageMemory2(
      +
      17339  VmaAllocator allocator,
      +
      17340  VmaAllocation allocation,
      +
      17341  VkDeviceSize allocationLocalOffset,
      +
      17342  VkImage image,
      +
      17343  const void* pNext)
      +
      17344 {
      +
      17345  VMA_ASSERT(allocator && allocation && image);
      +
      17346 
      +
      17347  VMA_DEBUG_LOG("vmaBindImageMemory2");
      +
      17348 
      +
      17349  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      17350 
      +
      17351  return allocator->BindImageMemory(allocation, allocationLocalOffset, image, pNext);
      +
      17352 }
      +
      17353 
      +
      17354 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateBuffer(
      +
      17355  VmaAllocator allocator,
      +
      17356  const VkBufferCreateInfo* pBufferCreateInfo,
      +
      17357  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      +
      17358  VkBuffer* pBuffer,
      +
      17359  VmaAllocation* pAllocation,
      +
      17360  VmaAllocationInfo* pAllocationInfo)
      +
      17361 {
      +
      17362  VMA_ASSERT(allocator && pBufferCreateInfo && pAllocationCreateInfo && pBuffer && pAllocation);
      +
      17363 
      +
      17364  if(pBufferCreateInfo->size == 0)
      +
      17365  {
      +
      17366  return VK_ERROR_VALIDATION_FAILED_EXT;
      +
      17367  }
      +
      17368 
      +
      17369  VMA_DEBUG_LOG("vmaCreateBuffer");
      +
      17370 
      +
      17371  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      17372 
      +
      17373  *pBuffer = VK_NULL_HANDLE;
      +
      17374  *pAllocation = VK_NULL_HANDLE;
      +
      17375 
      +
      17376  // 1. Create VkBuffer.
      +
      17377  VkResult res = (*allocator->GetVulkanFunctions().vkCreateBuffer)(
      +
      17378  allocator->m_hDevice,
      +
      17379  pBufferCreateInfo,
      +
      17380  allocator->GetAllocationCallbacks(),
      +
      17381  pBuffer);
      +
      17382  if(res >= 0)
      +
      17383  {
      +
      17384  // 2. vkGetBufferMemoryRequirements.
      +
      17385  VkMemoryRequirements vkMemReq = {};
      +
      17386  bool requiresDedicatedAllocation = false;
      +
      17387  bool prefersDedicatedAllocation = false;
      +
      17388  allocator->GetBufferMemoryRequirements(*pBuffer, vkMemReq,
      +
      17389  requiresDedicatedAllocation, prefersDedicatedAllocation);
      +
      17390 
      +
      17391  // Make sure alignment requirements for specific buffer usages reported
      +
      17392  // in Physical Device Properties are included in alignment reported by memory requirements.
      +
      17393  if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT) != 0)
      +
      17394  {
      +
      17395  VMA_ASSERT(vkMemReq.alignment %
      +
      17396  allocator->m_PhysicalDeviceProperties.limits.minTexelBufferOffsetAlignment == 0);
      +
      17397  }
      +
      17398  if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT) != 0)
      +
      17399  {
      +
      17400  VMA_ASSERT(vkMemReq.alignment %
      +
      17401  allocator->m_PhysicalDeviceProperties.limits.minUniformBufferOffsetAlignment == 0);
      +
      17402  }
      +
      17403  if((pBufferCreateInfo->usage & VK_BUFFER_USAGE_STORAGE_BUFFER_BIT) != 0)
      +
      17404  {
      +
      17405  VMA_ASSERT(vkMemReq.alignment %
      +
      17406  allocator->m_PhysicalDeviceProperties.limits.minStorageBufferOffsetAlignment == 0);
      +
      17407  }
      +
      17408 
      +
      17409  // 3. Allocate memory using allocator.
      +
      17410  res = allocator->AllocateMemory(
      +
      17411  vkMemReq,
      +
      17412  requiresDedicatedAllocation,
      +
      17413  prefersDedicatedAllocation,
      +
      17414  *pBuffer, // dedicatedBuffer
      +
      17415  VK_NULL_HANDLE, // dedicatedImage
      +
      17416  *pAllocationCreateInfo,
      +
      17417  VMA_SUBALLOCATION_TYPE_BUFFER,
      +
      17418  1, // allocationCount
      +
      17419  pAllocation);
      +
      17420 
      +
      17421 #if VMA_RECORDING_ENABLED
      +
      17422  if(allocator->GetRecorder() != VMA_NULL)
      +
      17423  {
      +
      17424  allocator->GetRecorder()->RecordCreateBuffer(
      +
      17425  allocator->GetCurrentFrameIndex(),
      +
      17426  *pBufferCreateInfo,
      +
      17427  *pAllocationCreateInfo,
      +
      17428  *pAllocation);
      +
      17429  }
      +
      17430 #endif
      +
      17431 
      +
      17432  if(res >= 0)
      +
      17433  {
      +
      17434  // 3. Bind buffer with memory.
      +
      17435  if((pAllocationCreateInfo->flags & VMA_ALLOCATION_CREATE_DONT_BIND_BIT) == 0)
      +
      17436  {
      +
      17437  res = allocator->BindBufferMemory(*pAllocation, 0, *pBuffer, VMA_NULL);
      +
      17438  }
      +
      17439  if(res >= 0)
      +
      17440  {
      +
      17441  // All steps succeeded.
      +
      17442  #if VMA_STATS_STRING_ENABLED
      +
      17443  (*pAllocation)->InitBufferImageUsage(pBufferCreateInfo->usage);
      +
      17444  #endif
      +
      17445  if(pAllocationInfo != VMA_NULL)
      +
      17446  {
      +
      17447  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
      +
      17448  }
      +
      17449 
      +
      17450  return VK_SUCCESS;
      +
      17451  }
      +
      17452  allocator->FreeMemory(
      +
      17453  1, // allocationCount
      +
      17454  pAllocation);
      +
      17455  *pAllocation = VK_NULL_HANDLE;
      +
      17456  (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, *pBuffer, allocator->GetAllocationCallbacks());
      +
      17457  *pBuffer = VK_NULL_HANDLE;
      +
      17458  return res;
      +
      17459  }
      +
      17460  (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, *pBuffer, allocator->GetAllocationCallbacks());
      +
      17461  *pBuffer = VK_NULL_HANDLE;
      +
      17462  return res;
      +
      17463  }
      +
      17464  return res;
      +
      17465 }
      17466 
      -
      17467  if(image == VK_NULL_HANDLE && allocation == VK_NULL_HANDLE)
      -
      17468  {
      -
      17469  return;
      -
      17470  }
      -
      17471 
      -
      17472  VMA_DEBUG_LOG("vmaDestroyImage");
      +
      17467 VMA_CALL_PRE void VMA_CALL_POST vmaDestroyBuffer(
      +
      17468  VmaAllocator allocator,
      +
      17469  VkBuffer buffer,
      +
      17470  VmaAllocation allocation)
      +
      17471 {
      +
      17472  VMA_ASSERT(allocator);
      17473 
      -
      17474  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      -
      17475 
      -
      17476 #if VMA_RECORDING_ENABLED
      -
      17477  if(allocator->GetRecorder() != VMA_NULL)
      -
      17478  {
      -
      17479  allocator->GetRecorder()->RecordDestroyImage(
      -
      17480  allocator->GetCurrentFrameIndex(),
      -
      17481  allocation);
      -
      17482  }
      -
      17483 #endif
      -
      17484 
      -
      17485  if(image != VK_NULL_HANDLE)
      -
      17486  {
      -
      17487  (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, image, allocator->GetAllocationCallbacks());
      -
      17488  }
      -
      17489  if(allocation != VK_NULL_HANDLE)
      -
      17490  {
      -
      17491  allocator->FreeMemory(
      -
      17492  1, // allocationCount
      -
      17493  &allocation);
      -
      17494  }
      -
      17495 }
      +
      17474  if(buffer == VK_NULL_HANDLE && allocation == VK_NULL_HANDLE)
      +
      17475  {
      +
      17476  return;
      +
      17477  }
      +
      17478 
      +
      17479  VMA_DEBUG_LOG("vmaDestroyBuffer");
      +
      17480 
      +
      17481  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      17482 
      +
      17483 #if VMA_RECORDING_ENABLED
      +
      17484  if(allocator->GetRecorder() != VMA_NULL)
      +
      17485  {
      +
      17486  allocator->GetRecorder()->RecordDestroyBuffer(
      +
      17487  allocator->GetCurrentFrameIndex(),
      +
      17488  allocation);
      +
      17489  }
      +
      17490 #endif
      +
      17491 
      +
      17492  if(buffer != VK_NULL_HANDLE)
      +
      17493  {
      +
      17494  (*allocator->GetVulkanFunctions().vkDestroyBuffer)(allocator->m_hDevice, buffer, allocator->GetAllocationCallbacks());
      +
      17495  }
      17496 
      -
      17497 #endif // #ifdef VMA_IMPLEMENTATION
      +
      17497  if(allocation != VK_NULL_HANDLE)
      +
      17498  {
      +
      17499  allocator->FreeMemory(
      +
      17500  1, // allocationCount
      +
      17501  &allocation);
      +
      17502  }
      +
      17503 }
      +
      17504 
      +
      17505 VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateImage(
      +
      17506  VmaAllocator allocator,
      +
      17507  const VkImageCreateInfo* pImageCreateInfo,
      +
      17508  const VmaAllocationCreateInfo* pAllocationCreateInfo,
      +
      17509  VkImage* pImage,
      +
      17510  VmaAllocation* pAllocation,
      +
      17511  VmaAllocationInfo* pAllocationInfo)
      +
      17512 {
      +
      17513  VMA_ASSERT(allocator && pImageCreateInfo && pAllocationCreateInfo && pImage && pAllocation);
      +
      17514 
      +
      17515  if(pImageCreateInfo->extent.width == 0 ||
      +
      17516  pImageCreateInfo->extent.height == 0 ||
      +
      17517  pImageCreateInfo->extent.depth == 0 ||
      +
      17518  pImageCreateInfo->mipLevels == 0 ||
      +
      17519  pImageCreateInfo->arrayLayers == 0)
      +
      17520  {
      +
      17521  return VK_ERROR_VALIDATION_FAILED_EXT;
      +
      17522  }
      +
      17523 
      +
      17524  VMA_DEBUG_LOG("vmaCreateImage");
      +
      17525 
      +
      17526  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      17527 
      +
      17528  *pImage = VK_NULL_HANDLE;
      +
      17529  *pAllocation = VK_NULL_HANDLE;
      +
      17530 
      +
      17531  // 1. Create VkImage.
      +
      17532  VkResult res = (*allocator->GetVulkanFunctions().vkCreateImage)(
      +
      17533  allocator->m_hDevice,
      +
      17534  pImageCreateInfo,
      +
      17535  allocator->GetAllocationCallbacks(),
      +
      17536  pImage);
      +
      17537  if(res >= 0)
      +
      17538  {
      +
      17539  VmaSuballocationType suballocType = pImageCreateInfo->tiling == VK_IMAGE_TILING_OPTIMAL ?
      +
      17540  VMA_SUBALLOCATION_TYPE_IMAGE_OPTIMAL :
      +
      17541  VMA_SUBALLOCATION_TYPE_IMAGE_LINEAR;
      +
      17542 
      +
      17543  // 2. Allocate memory using allocator.
      +
      17544  VkMemoryRequirements vkMemReq = {};
      +
      17545  bool requiresDedicatedAllocation = false;
      +
      17546  bool prefersDedicatedAllocation = false;
      +
      17547  allocator->GetImageMemoryRequirements(*pImage, vkMemReq,
      +
      17548  requiresDedicatedAllocation, prefersDedicatedAllocation);
      +
      17549 
      +
      17550  res = allocator->AllocateMemory(
      +
      17551  vkMemReq,
      +
      17552  requiresDedicatedAllocation,
      +
      17553  prefersDedicatedAllocation,
      +
      17554  VK_NULL_HANDLE, // dedicatedBuffer
      +
      17555  *pImage, // dedicatedImage
      +
      17556  *pAllocationCreateInfo,
      +
      17557  suballocType,
      +
      17558  1, // allocationCount
      +
      17559  pAllocation);
      +
      17560 
      +
      17561 #if VMA_RECORDING_ENABLED
      +
      17562  if(allocator->GetRecorder() != VMA_NULL)
      +
      17563  {
      +
      17564  allocator->GetRecorder()->RecordCreateImage(
      +
      17565  allocator->GetCurrentFrameIndex(),
      +
      17566  *pImageCreateInfo,
      +
      17567  *pAllocationCreateInfo,
      +
      17568  *pAllocation);
      +
      17569  }
      +
      17570 #endif
      +
      17571 
      +
      17572  if(res >= 0)
      +
      17573  {
      +
      17574  // 3. Bind image with memory.
      +
      17575  if((pAllocationCreateInfo->flags & VMA_ALLOCATION_CREATE_DONT_BIND_BIT) == 0)
      +
      17576  {
      +
      17577  res = allocator->BindImageMemory(*pAllocation, 0, *pImage, VMA_NULL);
      +
      17578  }
      +
      17579  if(res >= 0)
      +
      17580  {
      +
      17581  // All steps succeeded.
      +
      17582  #if VMA_STATS_STRING_ENABLED
      +
      17583  (*pAllocation)->InitBufferImageUsage(pImageCreateInfo->usage);
      +
      17584  #endif
      +
      17585  if(pAllocationInfo != VMA_NULL)
      +
      17586  {
      +
      17587  allocator->GetAllocationInfo(*pAllocation, pAllocationInfo);
      +
      17588  }
      +
      17589 
      +
      17590  return VK_SUCCESS;
      +
      17591  }
      +
      17592  allocator->FreeMemory(
      +
      17593  1, // allocationCount
      +
      17594  pAllocation);
      +
      17595  *pAllocation = VK_NULL_HANDLE;
      +
      17596  (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, *pImage, allocator->GetAllocationCallbacks());
      +
      17597  *pImage = VK_NULL_HANDLE;
      +
      17598  return res;
      +
      17599  }
      +
      17600  (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, *pImage, allocator->GetAllocationCallbacks());
      +
      17601  *pImage = VK_NULL_HANDLE;
      +
      17602  return res;
      +
      17603  }
      +
      17604  return res;
      +
      17605 }
      +
      17606 
      +
      17607 VMA_CALL_PRE void VMA_CALL_POST vmaDestroyImage(
      +
      17608  VmaAllocator allocator,
      +
      17609  VkImage image,
      +
      17610  VmaAllocation allocation)
      +
      17611 {
      +
      17612  VMA_ASSERT(allocator);
      +
      17613 
      +
      17614  if(image == VK_NULL_HANDLE && allocation == VK_NULL_HANDLE)
      +
      17615  {
      +
      17616  return;
      +
      17617  }
      +
      17618 
      +
      17619  VMA_DEBUG_LOG("vmaDestroyImage");
      +
      17620 
      +
      17621  VMA_DEBUG_GLOBAL_MUTEX_LOCK
      +
      17622 
      +
      17623 #if VMA_RECORDING_ENABLED
      +
      17624  if(allocator->GetRecorder() != VMA_NULL)
      +
      17625  {
      +
      17626  allocator->GetRecorder()->RecordDestroyImage(
      +
      17627  allocator->GetCurrentFrameIndex(),
      +
      17628  allocation);
      +
      17629  }
      +
      17630 #endif
      +
      17631 
      +
      17632  if(image != VK_NULL_HANDLE)
      +
      17633  {
      +
      17634  (*allocator->GetVulkanFunctions().vkDestroyImage)(allocator->m_hDevice, image, allocator->GetAllocationCallbacks());
      +
      17635  }
      +
      17636  if(allocation != VK_NULL_HANDLE)
      +
      17637  {
      +
      17638  allocator->FreeMemory(
      +
      17639  1, // allocationCount
      +
      17640  &allocation);
      +
      17641  }
      +
      17642 }
      +
      17643 
      +
      17644 #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
      -
      vmaFindMemoryTypeIndexForBufferInfo
      VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForBufferInfo(VmaAllocator allocator, const VkBufferCreateInfo *pBufferCreateInfo, const VmaAllocationCreateInfo *pAllocationCreateInfo, uint32_t *pMemoryTypeIndex)
      Helps to find memoryTypeIndex, given VkBufferCreateInfo and VmaAllocationCreateInfo.
      VmaDeviceMemoryCallbacks::pfnFree
      PFN_vmaFreeDeviceMemoryFunction pfnFree
      Optional, can be null.
      Definition: vk_mem_alloc.h:1851
      -
      vmaGetPoolStats
      VMA_CALL_PRE void VMA_CALL_POST vmaGetPoolStats(VmaAllocator allocator, VmaPool pool, VmaPoolStats *pPoolStats)
      Retrieves statistics of existing VmaPool object.
      VMA_RECORD_FLAG_BITS_MAX_ENUM
      Definition: vk_mem_alloc.h:1956
      -
      vmaCreateLostAllocation
      VMA_CALL_PRE void VMA_CALL_POST vmaCreateLostAllocation(VmaAllocator allocator, VmaAllocation *pAllocation)
      Creates new allocation that is in lost state from the beginning.
      VmaVulkanFunctions::vkGetPhysicalDeviceProperties
      PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties
      Definition: vk_mem_alloc.h:1917
      +
      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
      VmaAllocationInfo
      struct VmaAllocationInfo VmaAllocationInfo
      Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().
      -
      vmaFreeMemory
      VMA_CALL_PRE void VMA_CALL_POST vmaFreeMemory(VmaAllocator allocator, VmaAllocation allocation)
      Frees memory previously allocated using vmaAllocateMemory(), vmaAllocateMemoryForBuffer(),...
      -
      vmaCalculateStats
      VMA_CALL_PRE void VMA_CALL_POST vmaCalculateStats(VmaAllocator allocator, VmaStats *pStats)
      Retrieves statistics from current state of the Allocator.
      -
      VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT
      Enables alternative, linear allocation algorithm in this pool.
      Definition: vk_mem_alloc.h:2530
      -
      VmaDefragmentationInfo2::allocationCount
      uint32_t allocationCount
      Number of allocations in pAllocations array.
      Definition: vk_mem_alloc.h:3046
      +
      VMA_POOL_CREATE_LINEAR_ALGORITHM_BIT
      Enables alternative, linear allocation algorithm in this pool.
      Definition: vk_mem_alloc.h:2533
      +
      VmaDefragmentationInfo2::allocationCount
      uint32_t allocationCount
      Number of allocations in pAllocations array.
      Definition: vk_mem_alloc.h:3070
      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
      +
      vmaInvalidateAllocation
      void vmaInvalidateAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
      Invalidates memory of given allocation.
      VmaAllocationCreateInfo
      struct VmaAllocationCreateInfo VmaAllocationCreateInfo
      -
      VmaPoolStats
      Describes parameter of existing VmaPool.
      Definition: vk_mem_alloc.h:2602
      -
      VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT
      Definition: vk_mem_alloc.h:2359
      +
      VmaPoolStats
      Describes parameter of existing VmaPool.
      Definition: vk_mem_alloc.h:2605
      +
      VMA_ALLOCATION_CREATE_STRATEGY_BEST_FIT_BIT
      Definition: vk_mem_alloc.h:2362
      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:2608
      -
      VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT
      Definition: vk_mem_alloc.h:2339
      +
      VmaPoolStats::unusedSize
      VkDeviceSize unusedSize
      Total number of bytes in the pool not used by any VmaAllocation.
      Definition: vk_mem_alloc.h:2611
      +
      VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT
      Definition: vk_mem_alloc.h:2342
      VmaRecordFlagBits
      VmaRecordFlagBits
      Flags to be used in VmaRecordSettings::flags.
      Definition: vk_mem_alloc.h:1948
      -
      vmaCreateImage
      VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateImage(VmaAllocator allocator, const VkImageCreateInfo *pImageCreateInfo, const VmaAllocationCreateInfo *pAllocationCreateInfo, VkImage *pImage, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
      Function similar to vmaCreateBuffer().
      +
      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
      -
      VMA_CALL_POST
      #define VMA_CALL_POST
      Definition: vk_mem_alloc.h:1813
      -
      VMA_ALLOCATION_CREATE_CAN_BECOME_LOST_BIT
      Definition: vk_mem_alloc.h:2326
      +
      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:2329
      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
      +
      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:2724
      -
      vmaAllocateMemoryPages
      VMA_CALL_PRE VkResult VMA_CALL_POST 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.
      -
      vmaSetAllocationUserData
      VMA_CALL_PRE void VMA_CALL_POST vmaSetAllocationUserData(VmaAllocator allocator, VmaAllocation allocation, void *pUserData)
      Sets pUserData in given allocation to new value.
      +
      VmaAllocationInfo::deviceMemory
      VkDeviceMemory deviceMemory
      Handle to Vulkan memory object.
      Definition: vk_mem_alloc.h:2748
      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:2433
      +
      VmaAllocationCreateInfo::pUserData
      void * pUserData
      Custom general-purpose pointer that will be stored in VmaAllocation, can be read as VmaAllocationInfo...
      Definition: vk_mem_alloc.h:2436
      VmaStatInfo::unusedRangeSizeMax
      VkDeviceSize unusedRangeSizeMax
      Definition: vk_mem_alloc.h:2123
      VmaVulkanFunctions::vkMapMemory
      PFN_vkMapMemory vkMapMemory
      Definition: vk_mem_alloc.h:1921
      -
      vmaDestroyAllocator
      VMA_CALL_PRE void VMA_CALL_POST vmaDestroyAllocator(VmaAllocator allocator)
      Destroys allocator object.
      -
      vmaCheckCorruption
      VMA_CALL_PRE VkResult VMA_CALL_POST vmaCheckCorruption(VmaAllocator allocator, uint32_t memoryTypeBits)
      Checks magic number in margins around all allocations in given memory types (in both default and cust...
      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:2370
      -
      vmaGetMemoryProperties
      VMA_CALL_PRE void VMA_CALL_POST vmaGetMemoryProperties(VmaAllocator allocator, const VkPhysicalDeviceMemoryProperties **ppPhysicalDeviceMemoryProperties)
      -
      VmaBudget::usage
      VkDeviceSize usage
      Estimated current memory usage of the program, in bytes.
      Definition: vk_mem_alloc.h:2171
      +
      VMA_ALLOCATION_CREATE_STRATEGY_FIRST_FIT_BIT
      Definition: vk_mem_alloc.h:2373
      +
      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
      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:2300
      -
      VMA_DEFRAGMENTATION_FLAG_BITS_MAX_ENUM
      Definition: vk_mem_alloc.h:3032
      -
      vmaMapMemory
      VMA_CALL_PRE VkResult VMA_CALL_POST vmaMapMemory(VmaAllocator allocator, VmaAllocation allocation, void **ppData)
      Maps memory represented by given allocation and returns pointer to it.
      -
      VmaPoolStats::unusedRangeSizeMax
      VkDeviceSize unusedRangeSizeMax
      Size of the largest continuous free memory region available for new allocation.
      Definition: vk_mem_alloc.h:2621
      -
      VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT
      Definition: vk_mem_alloc.h:2363
      -
      vmaTouchAllocation
      VMA_CALL_PRE VkBool32 VMA_CALL_POST 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_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:2303
      +
      VMA_DEFRAGMENTATION_FLAG_BITS_MAX_ENUM
      Definition: vk_mem_alloc.h:3056
      +
      VmaPoolStats::unusedRangeSizeMax
      VkDeviceSize unusedRangeSizeMax
      Size of the largest continuous free memory region available for new allocation.
      Definition: vk_mem_alloc.h:2624
      +
      VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT
      Definition: vk_mem_alloc.h:2366
      VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT
      Enables usage of VK_KHR_dedicated_allocation extension.
      Definition: vk_mem_alloc.h:1882
      -
      VmaDefragmentationInfo::maxAllocationsToMove
      uint32_t maxAllocationsToMove
      Maximum number of allocations that can be moved to different place.
      Definition: vk_mem_alloc.h:3126
      -
      VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT
      Definition: vk_mem_alloc.h:2354
      -
      vmaBindImageMemory
      VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindImageMemory(VmaAllocator allocator, VmaAllocation allocation, VkImage image)
      Binds image to allocation.
      -
      VmaMemoryUsage
      VmaMemoryUsage
      Definition: vk_mem_alloc.h:2229
      -
      vmaCreateBuffer
      VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateBuffer(VmaAllocator allocator, const VkBufferCreateInfo *pBufferCreateInfo, const VmaAllocationCreateInfo *pAllocationCreateInfo, VkBuffer *pBuffer, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
      +
      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:3150
      +
      VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT
      Definition: vk_mem_alloc.h:2357
      +
      VmaMemoryUsage
      VmaMemoryUsage
      Definition: vk_mem_alloc.h:2232
      +
      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:2558
      -
      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:2570
      -
      VmaDefragmentationInfo2::poolCount
      uint32_t poolCount
      Numer of pools in pPools array.
      Definition: vk_mem_alloc.h:3064
      +
      VmaPoolCreateInfo::memoryTypeIndex
      uint32_t memoryTypeIndex
      Vulkan memory type index to allocate this pool from.
      Definition: vk_mem_alloc.h:2561
      +
      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:2573
      +
      VmaDefragmentationInfo2::poolCount
      uint32_t poolCount
      Numer of pools in pPools array.
      Definition: vk_mem_alloc.h:3088
      +
      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:2611
      +
      VmaPoolStats::allocationCount
      size_t allocationCount
      Number of VmaAllocation objects created from this pool that were not destroyed or lost.
      Definition: vk_mem_alloc.h:2614
      VmaAllocatorCreateFlags
      VkFlags VmaAllocatorCreateFlags
      Definition: vk_mem_alloc.h:1910
      +
      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:3031
      -
      VmaAllocationInfo::offset
      VkDeviceSize offset
      Offset into deviceMemory object to the beginning of this allocation, in bytes. (deviceMemory,...
      Definition: vk_mem_alloc.h:2729
      -
      VmaAllocationCreateFlagBits
      VmaAllocationCreateFlagBits
      Flags to be passed as VmaAllocationCreateInfo::flags.
      Definition: vk_mem_alloc.h:2282
      -
      vmaDestroyPool
      VMA_CALL_PRE void VMA_CALL_POST vmaDestroyPool(VmaAllocator allocator, VmaPool pool)
      Destroys VmaPool object and frees Vulkan device memory.
      +
      VmaDefragmentationFlagBits
      VmaDefragmentationFlagBits
      Flags to be used in vmaDefragmentationBegin(). None at the moment. Reserved for future use.
      Definition: vk_mem_alloc.h:3055
      +
      VmaAllocationInfo::offset
      VkDeviceSize offset
      Offset into deviceMemory object to the beginning of this allocation, in bytes. (deviceMemory,...
      Definition: vk_mem_alloc.h:2753
      +
      VmaAllocationCreateFlagBits
      VmaAllocationCreateFlagBits
      Flags to be passed as VmaAllocationCreateInfo::flags.
      Definition: vk_mem_alloc.h:2285
      VmaVulkanFunctions::vkGetPhysicalDeviceMemoryProperties
      PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties
      Definition: vk_mem_alloc.h:1918
      -
      VmaPoolCreateFlags
      VkFlags VmaPoolCreateFlags
      Definition: vk_mem_alloc.h:2551
      -
      VmaAllocationCreateInfo::pool
      VmaPool pool
      Pool that this allocation should be created in.
      Definition: vk_mem_alloc.h:2426
      -
      vmaDefragment
      VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragment(VmaAllocator allocator, VmaAllocation *pAllocations, size_t allocationCount, VkBool32 *pAllocationsChanged, const VmaDefragmentationInfo *pDefragmentationInfo, VmaDefragmentationStats *pDefragmentationStats)
      Deprecated. Compacts memory by moving allocations.
      +
      VmaPoolCreateFlags
      VkFlags VmaPoolCreateFlags
      Definition: vk_mem_alloc.h:2554
      +
      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:2429
      +
      vmaGetMemoryProperties
      void vmaGetMemoryProperties(VmaAllocator allocator, const VkPhysicalDeviceMemoryProperties **ppPhysicalDeviceMemoryProperties)
      VmaStats::total
      VmaStatInfo total
      Definition: vk_mem_alloc.h:2131
      -
      vmaBindBufferMemory
      VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindBufferMemory(VmaAllocator allocator, VmaAllocation allocation, VkBuffer buffer)
      Binds buffer to allocation.
      -
      VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT
      Set this flag if the allocation should have its own memory block.
      Definition: vk_mem_alloc.h:2289
      +
      VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT
      Set this flag if the allocation should have its own memory block.
      Definition: vk_mem_alloc.h:2292
      +
      vmaDefragmentationEnd
      VkResult vmaDefragmentationEnd(VmaAllocator allocator, VmaDefragmentationContext context)
      Ends defragmentation process.
      VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT
      Definition: vk_mem_alloc.h:1894
      -
      vmaFreeMemoryPages
      VMA_CALL_PRE void VMA_CALL_POST vmaFreeMemoryPages(VmaAllocator allocator, size_t allocationCount, VmaAllocation *pAllocations)
      Frees memory and destroys multiple allocations.
      -
      VmaDefragmentationInfo2::flags
      VmaDefragmentationFlags flags
      Reserved for future use. Should be 0.
      Definition: vk_mem_alloc.h:3043
      +
      VmaDefragmentationInfo2::flags
      VmaDefragmentationFlags flags
      Reserved for future use. Should be 0.
      Definition: vk_mem_alloc.h:3067
      VmaVulkanFunctions::vkBindImageMemory
      PFN_vkBindImageMemory vkBindImageMemory
      Definition: vk_mem_alloc.h:1926
      -
      vmaInvalidateAllocation
      VMA_CALL_PRE void VMA_CALL_POST vmaInvalidateAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
      Invalidates memory of given allocation.
      -
      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:3095
      -
      VmaDefragmentationStats
      Statistics returned by function vmaDefragment().
      Definition: vk_mem_alloc.h:3130
      -
      VmaPoolStats::size
      VkDeviceSize size
      Total amount of VkDeviceMemory allocated from Vulkan for this pool, in bytes.
      Definition: vk_mem_alloc.h:2605
      -
      vmaUnmapMemory
      VMA_CALL_PRE void VMA_CALL_POST vmaUnmapMemory(VmaAllocator allocator, VmaAllocation allocation)
      Unmaps memory represented by given allocation, mapped previously using vmaMapMemory().
      +
      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:3119
      +
      VmaDefragmentationStats
      Statistics returned by function vmaDefragment().
      Definition: vk_mem_alloc.h:3154
      +
      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:2608
      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:2261
      -
      VmaDefragmentationInfo2::pPools
      VmaPool * pPools
      Either null or pointer to array of pools to be defragmented.
      Definition: vk_mem_alloc.h:3080
      +
      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:3104
      VmaAllocation
      Represents single memory allocation.
      -
      vmaDestroyBuffer
      VMA_CALL_PRE void VMA_CALL_POST vmaDestroyBuffer(VmaAllocator allocator, VkBuffer buffer, VmaAllocation allocation)
      Destroys Vulkan buffer and frees allocated memory.
      +
      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
      -
      vmaGetPhysicalDeviceProperties
      VMA_CALL_PRE void VMA_CALL_POST vmaGetPhysicalDeviceProperties(VmaAllocator allocator, const VkPhysicalDeviceProperties **ppPhysicalDeviceProperties)
      -
      vmaGetBudget
      VMA_CALL_PRE void VMA_CALL_POST vmaGetBudget(VmaAllocator allocator, VmaBudget *pBudget)
      Retrieves information about current memory budget for all memory heaps.
      VmaVulkanFunctions::vkGetBufferMemoryRequirements
      PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements
      Definition: vk_mem_alloc.h:1927
      -
      vmaCreateAllocator
      VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateAllocator(const VmaAllocatorCreateInfo *pCreateInfo, VmaAllocator *pAllocator)
      Creates Allocator object.
      -
      vmaFreeStatsString
      VMA_CALL_PRE void VMA_CALL_POST vmaFreeStatsString(VmaAllocator allocator, char *pStatsString)
      -
      VmaDefragmentationInfo2::commandBuffer
      VkCommandBuffer commandBuffer
      Optional. Command buffer where GPU copy commands will be posted.
      Definition: vk_mem_alloc.h:3109
      +
      VmaDefragmentationInfo2::commandBuffer
      VkCommandBuffer commandBuffer
      Optional. Command buffer where GPU copy commands will be posted.
      Definition: vk_mem_alloc.h:3133
      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
      -
      vmaFindMemoryTypeIndex
      VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndex(VmaAllocator allocator, uint32_t memoryTypeBits, const VmaAllocationCreateInfo *pAllocationCreateInfo, uint32_t *pMemoryTypeIndex)
      Helps to find memoryTypeIndex, given memoryTypeBits and VmaAllocationCreateInfo.
      -
      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:2575
      +
      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:2578
      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:3134
      +
      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:3158
      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.
      -
      VMA_CALL_PRE
      #define VMA_CALL_PRE
      Definition: vk_mem_alloc.h:1810
      +
      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:2251
      -
      vmaDefragmentationEnd
      VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragmentationEnd(VmaAllocator allocator, VmaDefragmentationContext context)
      Ends defragmentation process.
      +
      VMA_MEMORY_USAGE_GPU_ONLY
      Definition: vk_mem_alloc.h:2254
      +
      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
      +
      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
      -
      vmaMakePoolAllocationsLost
      VMA_CALL_PRE void VMA_CALL_POST 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...
      VmaAllocatorCreateFlagBits
      VmaAllocatorCreateFlagBits
      Flags for created VmaAllocator.
      Definition: vk_mem_alloc.h:1855
      -
      VmaPoolCreateInfo::maxBlockCount
      size_t maxBlockCount
      Maximum number of blocks that can be allocated in this pool. Optional.
      Definition: vk_mem_alloc.h:2583
      -
      VmaPoolCreateInfo
      Describes parameter of created VmaPool.
      Definition: vk_mem_alloc.h:2555
      +
      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:2586
      +
      VmaPoolCreateInfo
      Describes parameter of created VmaPool.
      Definition: vk_mem_alloc.h:2558
      VmaDeviceMemoryCallbacks::pfnAllocate
      PFN_vmaAllocateDeviceMemoryFunction pfnAllocate
      Optional, can be null.
      Definition: vk_mem_alloc.h:1849
      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:2277
      -
      VMA_ALLOCATION_CREATE_CAN_MAKE_OTHER_LOST_BIT
      Definition: vk_mem_alloc.h:2333
      -
      VmaPoolCreateInfo::flags
      VmaPoolCreateFlags flags
      Use combination of VmaPoolCreateFlagBits.
      Definition: vk_mem_alloc.h:2561
      -
      VMA_MEMORY_USAGE_MAX_ENUM
      Definition: vk_mem_alloc.h:2278
      +
      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:2336
      +
      VmaPoolCreateInfo::flags
      VmaPoolCreateFlags flags
      Use combination of VmaPoolCreateFlagBits.
      Definition: vk_mem_alloc.h:2564
      +
      VMA_MEMORY_USAGE_MAX_ENUM
      Definition: vk_mem_alloc.h:2281
      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
      -
      VmaDefragmentationInfo2
      Parameters for defragmentation.
      Definition: vk_mem_alloc.h:3040
      -
      VmaDefragmentationInfo::maxBytesToMove
      VkDeviceSize maxBytesToMove
      Maximum total numbers of bytes that can be copied while moving allocations to different places.
      Definition: vk_mem_alloc.h:3121
      +
      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:3064
      +
      VmaDefragmentationInfo::maxBytesToMove
      VkDeviceSize maxBytesToMove
      Maximum total numbers of bytes that can be copied while moving allocations to different places.
      Definition: vk_mem_alloc.h:3145
      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:2549
      -
      VmaAllocationCreateInfo::requiredFlags
      VkMemoryPropertyFlags requiredFlags
      Flags that must be set in a Memory Type chosen for an allocation.
      Definition: vk_mem_alloc.h:2407
      -
      VMA_ALLOCATION_CREATE_STRATEGY_MIN_FRAGMENTATION_BIT
      Definition: vk_mem_alloc.h:2380
      +
      VMA_POOL_CREATE_FLAG_BITS_MAX_ENUM
      Definition: vk_mem_alloc.h:2552
      +
      VmaAllocationCreateInfo::requiredFlags
      VkMemoryPropertyFlags requiredFlags
      Flags that must be set in a Memory Type chosen for an allocation.
      Definition: vk_mem_alloc.h:2410
      +
      VMA_ALLOCATION_CREATE_STRATEGY_MIN_FRAGMENTATION_BIT
      Definition: vk_mem_alloc.h:2383
      VmaStatInfo::allocationSizeAvg
      VkDeviceSize allocationSizeAvg
      Definition: vk_mem_alloc.h:2122
      +
      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:2384
      +
      VMA_ALLOCATION_CREATE_STRATEGY_MASK
      Definition: vk_mem_alloc.h:2387
      VmaAllocatorCreateInfo::device
      VkDevice device
      Vulkan device.
      Definition: vk_mem_alloc.h:1985
      +
      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.
      -
      vmaGetMemoryTypeProperties
      VMA_CALL_PRE void VMA_CALL_POST vmaGetMemoryTypeProperties(VmaAllocator allocator, uint32_t memoryTypeIndex, VkMemoryPropertyFlags *pFlags)
      Given Memory Type Index, returns Property Flags of this memory type.
      +
      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
      -
      VmaBudget::budget
      VkDeviceSize budget
      Estimated amount of memory available to the program, in bytes.
      Definition: vk_mem_alloc.h:2182
      +
      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
      -
      vmaBindBufferMemory2
      VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindBufferMemory2(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize allocationLocalOffset, VkBuffer buffer, const void *pNext)
      Binds buffer to allocation with additional parameters.
      -
      VmaAllocationInfo::pMappedData
      void * pMappedData
      Pointer to the beginning of this allocation as mapped data.
      Definition: vk_mem_alloc.h:2743
      +
      VmaAllocationInfo::pMappedData
      void * pMappedData
      Pointer to the beginning of this allocation as mapped data.
      Definition: vk_mem_alloc.h:2767
      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:3034
      -
      vmaFlushAllocation
      VMA_CALL_PRE void VMA_CALL_POST vmaFlushAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize offset, VkDeviceSize size)
      Flushes memory of given allocation.
      +
      VmaDefragmentationFlags
      VkFlags VmaDefragmentationFlags
      Definition: vk_mem_alloc.h:3058
      +
      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:2268
      +
      VMA_MEMORY_USAGE_CPU_TO_GPU
      Definition: vk_mem_alloc.h:2271
      VmaDefragmentationInfo2
      struct VmaDefragmentationInfo2 VmaDefragmentationInfo2
      Parameters for defragmentation.
      -
      VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT
      Definition: vk_mem_alloc.h:2377
      -
      VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT
      Definition: vk_mem_alloc.h:2374
      -
      VmaAllocationCreateInfo::usage
      VmaMemoryUsage usage
      Intended usage of memory.
      Definition: vk_mem_alloc.h:2402
      +
      VMA_ALLOCATION_CREATE_STRATEGY_MIN_TIME_BIT
      Definition: vk_mem_alloc.h:2380
      +
      VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT
      Definition: vk_mem_alloc.h:2377
      +
      VmaAllocationCreateInfo::usage
      VmaMemoryUsage usage
      Intended usage of memory.
      Definition: vk_mem_alloc.h:2405
      VmaStatInfo::allocationSizeMin
      VkDeviceSize allocationSizeMin
      Definition: vk_mem_alloc.h:2122
      -
      VmaAllocationInfo::size
      VkDeviceSize size
      Size of this allocation, in bytes.
      Definition: vk_mem_alloc.h:2734
      +
      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:2758
      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:2748
      -
      vmaAllocateMemoryForBuffer
      VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryForBuffer(VmaAllocator allocator, VkBuffer buffer, const VmaAllocationCreateInfo *pCreateInfo, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
      -
      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:2513
      -
      vmaAllocateMemory
      VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemory(VmaAllocator allocator, const VkMemoryRequirements *pVkMemoryRequirements, const VmaAllocationCreateInfo *pCreateInfo, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
      General purpose memory allocation.
      +
      VmaAllocationInfo::pUserData
      void * pUserData
      Custom general-purpose pointer that was passed as VmaAllocationCreateInfo::pUserData or set using vma...
      Definition: vk_mem_alloc.h:2772
      +
      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:2516
      +
      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
      -
      vmaSetCurrentFrameIndex
      VMA_CALL_PRE void VMA_CALL_POST vmaSetCurrentFrameIndex(VmaAllocator allocator, uint32_t frameIndex)
      Sets index of the current frame.
      -
      VmaPoolStats::blockCount
      size_t blockCount
      Number of VkDeviceMemory blocks allocated for this pool.
      Definition: vk_mem_alloc.h:2624
      -
      vmaFindMemoryTypeIndexForImageInfo
      VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForImageInfo(VmaAllocator allocator, const VkImageCreateInfo *pImageCreateInfo, const VmaAllocationCreateInfo *pAllocationCreateInfo, uint32_t *pMemoryTypeIndex)
      Helps to find memoryTypeIndex, given VkImageCreateInfo and VmaAllocationCreateInfo.
      -
      vmaDefragmentationBegin
      VMA_CALL_PRE VkResult VMA_CALL_POST vmaDefragmentationBegin(VmaAllocator allocator, const VmaDefragmentationInfo2 *pInfo, VmaDefragmentationStats *pStats, VmaDefragmentationContext *pContext)
      Begins defragmentation process.
      -
      VmaAllocationCreateFlags
      VkFlags VmaAllocationCreateFlags
      Definition: vk_mem_alloc.h:2391
      +
      VmaPoolStats::blockCount
      size_t blockCount
      Number of VkDeviceMemory blocks allocated for this pool.
      Definition: vk_mem_alloc.h:2627
      +
      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:2394
      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
      -
      vmaCreatePool
      VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreatePool(VmaAllocator allocator, const VmaPoolCreateInfo *pCreateInfo, VmaPool *pPool)
      Allocates Vulkan device memory and creates VmaPool object.
      +
      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:2234
      -
      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:3100
      +
      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:3124
      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:2597
      +
      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:2600
      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:3085
      -
      VmaAllocationInfo::memoryType
      uint32_t memoryType
      Memory type index that this allocation was allocated from.
      Definition: vk_mem_alloc.h:2715
      -
      vmaDestroyImage
      VMA_CALL_PRE void VMA_CALL_POST 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:2313
      +
      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:3109
      +
      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:2739
      +
      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:2316
      +
      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
      -
      vmaCheckPoolCorruption
      VMA_CALL_PRE VkResult VMA_CALL_POST vmaCheckPoolCorruption(VmaAllocator allocator, VmaPool pool)
      Checks magic number in margins around all allocations in given memory pool in search for corruptions.
      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:2614
      -
      VmaPoolCreateFlagBits
      VmaPoolCreateFlagBits
      Flags to be passed as VmaPoolCreateInfo::flags.
      Definition: vk_mem_alloc.h:2495
      -
      VmaDefragmentationStats::bytesMoved
      VkDeviceSize bytesMoved
      Total number of bytes that have been copied while moving allocations to different places.
      Definition: vk_mem_alloc.h:3132
      +
      VmaPoolStats::unusedRangeCount
      size_t unusedRangeCount
      Number of continuous memory ranges in the pool not used by any VmaAllocation.
      Definition: vk_mem_alloc.h:2617
      +
      VmaPoolCreateFlagBits
      VmaPoolCreateFlagBits
      Flags to be passed as VmaPoolCreateInfo::flags.
      Definition: vk_mem_alloc.h:2498
      +
      VmaDefragmentationStats::bytesMoved
      VkDeviceSize bytesMoved
      Total number of bytes that have been copied while moving allocations to different places.
      Definition: vk_mem_alloc.h:3156
      VmaStatInfo::unusedRangeSizeMin
      VkDeviceSize unusedRangeSizeMin
      Definition: vk_mem_alloc.h:2123
      -
      VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT
      Definition: vk_mem_alloc.h:2344
      -
      vmaAllocateMemoryForImage
      VMA_CALL_PRE VkResult VMA_CALL_POST vmaAllocateMemoryForImage(VmaAllocator allocator, VkImage image, const VmaAllocationCreateInfo *pCreateInfo, VmaAllocation *pAllocation, VmaAllocationInfo *pAllocationInfo)
      Function similar to vmaAllocateMemoryForBuffer().
      -
      vmaBuildStatsString
      VMA_CALL_PRE void VMA_CALL_POST vmaBuildStatsString(VmaAllocator allocator, char **ppStatsString, VkBool32 detailedMap)
      Builds and returns statistics as string in JSON format.
      -
      VmaAllocationCreateInfo::flags
      VmaAllocationCreateFlags flags
      Use VmaAllocationCreateFlagBits enum.
      Definition: vk_mem_alloc.h:2396
      +
      VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT
      Definition: vk_mem_alloc.h:2347
      +
      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:2399
      VmaVulkanFunctions::vkGetImageMemoryRequirements
      PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements
      Definition: vk_mem_alloc.h:1928
      -
      VmaAllocationCreateInfo
      Definition: vk_mem_alloc.h:2393
      -
      VmaAllocationCreateInfo::preferredFlags
      VkMemoryPropertyFlags preferredFlags
      Flags that preferably should be set in a memory type chosen for an allocation.
      Definition: vk_mem_alloc.h:2412
      -
      vmaBindImageMemory2
      VMA_CALL_PRE VkResult VMA_CALL_POST vmaBindImageMemory2(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize allocationLocalOffset, VkImage image, const void *pNext)
      Binds image to allocation with additional parameters.
      -
      vmaResizeAllocation
      VMA_CALL_PRE VkResult VMA_CALL_POST vmaResizeAllocation(VmaAllocator allocator, VmaAllocation allocation, VkDeviceSize newSize)
      Deprecated.
      -
      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:3061
      -
      VmaDefragmentationStats::allocationsMoved
      uint32_t allocationsMoved
      Number of allocations that have been moved to different places.
      Definition: vk_mem_alloc.h:3136
      -
      VmaAllocationCreateInfo::memoryTypeBits
      uint32_t memoryTypeBits
      Bitmask containing one bit set for every memory type acceptable for this allocation.
      Definition: vk_mem_alloc.h:2420
      -
      VmaDefragmentationStats::deviceMemoryBlocksFreed
      uint32_t deviceMemoryBlocksFreed
      Number of empty VkDeviceMemory objects that have been released to the system.
      Definition: vk_mem_alloc.h:3138
      +
      vmaGetBudget
      void vmaGetBudget(VmaAllocator allocator, VmaBudget *pBudget)
      Retrieves information about current memory budget for all memory heaps.
      +
      VmaAllocationCreateInfo
      Definition: vk_mem_alloc.h:2396
      +
      VmaAllocationCreateInfo::preferredFlags
      VkMemoryPropertyFlags preferredFlags
      Flags that preferably should be set in a memory type chosen for an allocation.
      Definition: vk_mem_alloc.h:2415
      +
      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:3085
      +
      VmaDefragmentationStats::allocationsMoved
      uint32_t allocationsMoved
      Number of allocations that have been moved to different places.
      Definition: vk_mem_alloc.h:3160
      +
      VmaAllocationCreateInfo::memoryTypeBits
      uint32_t memoryTypeBits
      Bitmask containing one bit set for every memory type acceptable for this allocation.
      Definition: vk_mem_alloc.h:2423
      +
      VmaDefragmentationStats::deviceMemoryBlocksFreed
      uint32_t deviceMemoryBlocksFreed
      Number of empty VkDeviceMemory objects that have been released to the system.
      Definition: vk_mem_alloc.h:3162
      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
      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:2710
      -
      vmaGetAllocationInfo
      VMA_CALL_PRE void VMA_CALL_POST vmaGetAllocationInfo(VmaAllocator allocator, VmaAllocation allocation, VmaAllocationInfo *pAllocationInfo)
      Returns current information about specified allocation and atomically marks it as used in current fra...
      -
      VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT
      Enables alternative, buddy allocation algorithm in this pool.
      Definition: vk_mem_alloc.h:2541
      -
      VmaBudget::allocationBytes
      VkDeviceSize allocationBytes
      Sum size of all allocations created in particular heap, in bytes.
      Definition: vk_mem_alloc.h:2161
      -
      VMA_ALLOCATION_CREATE_FLAG_BITS_MAX_ENUM
      Definition: vk_mem_alloc.h:2389
      +
      VmaAllocationInfo
      Parameters of VmaAllocation objects, that can be retrieved using function vmaGetAllocationInfo().
      Definition: vk_mem_alloc.h:2734
      +
      VMA_POOL_CREATE_BUDDY_ALGORITHM_BIT
      Enables alternative, buddy allocation algorithm in this pool.
      Definition: vk_mem_alloc.h:2544
      +
      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:2392
      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:3055
      -
      VMA_POOL_CREATE_ALGORITHM_MASK
      Definition: vk_mem_alloc.h:2545
      -
      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:3090
      -
      VmaDefragmentationInfo
      Deprecated. Optional configuration parameters to be passed to function vmaDefragment().
      Definition: vk_mem_alloc.h:3116
      -
      VMA_ALLOCATION_CREATE_DONT_BIND_BIT
      Definition: vk_mem_alloc.h:2350
      +
      VmaDefragmentationInfo2::pAllocations
      VmaAllocation * pAllocations
      Pointer to array of allocations that can be defragmented.
      Definition: vk_mem_alloc.h:3079
      +
      VMA_POOL_CREATE_ALGORITHM_MASK
      Definition: vk_mem_alloc.h:2548
      +
      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:3114
      +
      VmaDefragmentationInfo
      Deprecated. Optional configuration parameters to be passed to function vmaDefragment().
      Definition: vk_mem_alloc.h:3140
      +
      VMA_ALLOCATION_CREATE_DONT_BIND_BIT
      Definition: vk_mem_alloc.h:2353
      Generated by   diff --git a/docs/html/vk_khr_dedicated_allocation.html b/docs/html/vk_khr_dedicated_allocation.html index 8b1ac00..3b6496b 100644 --- a/docs/html/vk_khr_dedicated_allocation.html +++ b/docs/html/vk_khr_dedicated_allocation.html @@ -76,8 +76,8 @@ $(function() {

      2 . Use VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT flag when creating your VmaAllocator`to inform the library that you enabled required extensions and you want the library to use them.

      allocatorInfo.flags |= VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT;
      -
      vmaCreateAllocator(&allocatorInfo, &allocator);
      -

      That's all. The extension will be automatically used whenever you create a buffer using vmaCreateBuffer() or image using vmaCreateImage().

      +
      vmaCreateAllocator(&allocatorInfo, &allocator);
      +

      That's all. The extension will be automatically used whenever you create a buffer using vmaCreateBuffer() or image using vmaCreateImage().

      When using the extension together with Vulkan Validation Layer, you will receive warnings like this: 

      vkBindBufferMemory(): Binding memory to buffer 0x33 but vkGetBufferMemoryRequirements() has not been called on that buffer.

      It is OK, you should just ignore it. It happens because you use function vkGetBufferMemoryRequirements2KHR() instead of standard vkGetBufferMemoryRequirements(), while the validation layer seems to be unaware of it.

      To learn more about this extension, see:

      @@ -88,8 +88,8 @@ $(function() {
      VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT
      Enables usage of VK_KHR_dedicated_allocation extension.
      Definition: vk_mem_alloc.h:1882
      -
      vmaCreateAllocator
      VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateAllocator(const VmaAllocatorCreateInfo *pCreateInfo, VmaAllocator *pAllocator)
      Creates Allocator object.
      VmaAllocatorCreateInfo::flags
      VmaAllocatorCreateFlags flags
      Flags for created allocator. Use VmaAllocatorCreateFlagBits enum.
      Definition: vk_mem_alloc.h:1979
      +
      vmaCreateAllocator
      VkResult vmaCreateAllocator(const VmaAllocatorCreateInfo *pCreateInfo, VmaAllocator *pAllocator)
      Creates Allocator object.
      Generated by