[Useless] Array allocation

[the Immortal]

Erm, being kinda homesick, having plenty of free time, blahblah.. in short decided to test how array allocation works.

Conclusion: Arrays are resized (surely reallocated) when a size request is issued. In other words, the size of an array (and correspondingly the memory it takes) depends on the largest index used in it.
I have to note that this is pretty irrelevant anyway (as noted in thread title, lols..) since the memory increase from allocating 100 handle arrays' 8100th index is ~3mb. Anyway, here is the test code:

library TestArray initializer onInit
    
    //! textmacro TestArray takes NUM,IND
        set ARR_$NUM$0[$IND$] = null
        set ARR_$NUM$1[$IND$] = null
        set ARR_$NUM$2[$IND$] = null
        set ARR_$NUM$3[$IND$] = null
        set ARR_$NUM$4[$IND$] = null
        set ARR_$NUM$5[$IND$] = null
        set ARR_$NUM$6[$IND$] = null
        set ARR_$NUM$7[$IND$] = null
        set ARR_$NUM$8[$IND$] = null
        set ARR_$NUM$9[$IND$] = null
    //! endtextmacro
    
    //initialization that allocates array index 0
    function InitArrays takes nothing returns nothing
        //! runtextmacro TestArray("00", "0")
        //! runtextmacro TestArray("01", "0")
        //! runtextmacro TestArray("02", "0")
        //! runtextmacro TestArray("03", "0")
        //! runtextmacro TestArray("04", "0")
        //! runtextmacro TestArray("05", "0")
        //! runtextmacro TestArray("06", "0")
        //! runtextmacro TestArray("07", "0")
        //! runtextmacro TestArray("08", "0")
        //! runtextmacro TestArray("09", "0")
    endfunction
    
    //the callback that expands the array sizes: 0 -> 1 -> 4100 -> 8100
    function ExpandArrays takes nothing returns boolean
        if b == 0 then
            //index 1
            //! runtextmacro TestArray("00", "1")
            //! runtextmacro TestArray("01", "1")
            //! runtextmacro TestArray("02", "1")
            //! runtextmacro TestArray("03", "1")
            //! runtextmacro TestArray("04", "1")
            //! runtextmacro TestArray("05", "1")
            //! runtextmacro TestArray("06", "1")
            //! runtextmacro TestArray("07", "1")
            //! runtextmacro TestArray("08", "1")
            //! runtextmacro TestArray("09", "1")
            call BJDebugMsg("Allocated index 1")
        elseif b == 1 then
            //index 4100
            //! runtextmacro TestArray("00", "4100")
            //! runtextmacro TestArray("01", "4100")
            //! runtextmacro TestArray("02", "4100")
            //! runtextmacro TestArray("03", "4100")
            //! runtextmacro TestArray("04", "4100")
            //! runtextmacro TestArray("05", "4100")
            //! runtextmacro TestArray("06", "4100")
            //! runtextmacro TestArray("07", "4100")
            //! runtextmacro TestArray("08", "4100")
            //! runtextmacro TestArray("09", "4100")
            call BJDebugMsg("Allocated index 4100")
        elseif b == 2 then
            //index 8100
            //! runtextmacro TestArray("00", "8100")
            //! runtextmacro TestArray("01", "8100")
            //! runtextmacro TestArray("02", "8100")
            //! runtextmacro TestArray("03", "8100")
            //! runtextmacro TestArray("04", "8100")
            //! runtextmacro TestArray("05", "8100")
            //! runtextmacro TestArray("06", "8100")
            //! runtextmacro TestArray("07", "8100")
            //! runtextmacro TestArray("08", "8100")
            //! runtextmacro TestArray("09", "8100")
            call BJDebugMsg("Allocated index 8100")
        endif
        set b = b + 1
        return false
    endfunction
    
    
    //textmacro to create arrays and running them in global block
    //! textmacro MakeArray takes NUM
        unit array ARR_$NUM$0
        unit array ARR_$NUM$1
        unit array ARR_$NUM$2
        unit array ARR_$NUM$3
        unit array ARR_$NUM$4
        unit array ARR_$NUM$5
        unit array ARR_$NUM$6
        unit array ARR_$NUM$7
        unit array ARR_$NUM$8
        unit array ARR_$NUM$9
    //! endtextmacro
    
    globals
        integer b = 0
        //! runtextmacro MakeArray("00")
        //! runtextmacro MakeArray("01")
        //! runtextmacro MakeArray("02")
        //! runtextmacro MakeArray("03")
        //! runtextmacro MakeArray("04")
        //! runtextmacro MakeArray("05")
        //! runtextmacro MakeArray("06")
        //! runtextmacro MakeArray("07")
        //! runtextmacro MakeArray("08")
        //! runtextmacro MakeArray("09")
    endglobals
    
    //init arrays and trigger escape press
    private function onInit takes nothing returns nothing
        local trigger t = CreateTrigger()
        call InitArrays()
        call BJDebugMsg("Initialized")
        call TriggerRegisterPlayerEvent(t, Player(0), EVENT_PLAYER_END_CINEMATIC)
        call TriggerAddCondition(t, Condition(function ExpandArrays))
    endfunction
endlibrary

On initialization index 0 is allocated - idk, just to initialize arrays =D

On 1st escape press it allocates index 1 - watching the game's memory in TaskMan it almost doesn't change
On 2nd escape press it allocates index 4100 - which visually increases the memory shown with about 1-1.5Mb.
On 3rd press it allocates index 8100, again increasing memory taken. (and in combination with 2 are to show whether war3 arrays' allocation is the same as C STL vectors' one - and it seems it isn't)

Erm.. yeah.. pretty useless but hopefully someone might be interested in it. Took me less than half an hour so it wasn't such a waste anyway.

 

[Jesus4Lyf]

Pretty sure, more specifically, from my recollection of what Cohadar used to say, that arrays resize in doubled numbers.

IE. when you hit 16, 32, 64, 128, 256, 512, 1024, 2048, 4096. Or as you cross those values, rather.

 

[the Immortal]

That is how Cpp vectors work and that's why I tested first allocating index 4100 (>4096), and only after that - 8100(<8192).

As 4100 > 4096, if it was working as you described (and as C vectors work, as I mentioned), it would allocate all the memory at that point so when I used index 8100 no reallocation and memory increase would be observed. But from my tests (mentioned already) allocating first 4100 and then 8100 both increase the game's memory with approximately the same amount.
Which, as far as I understand, shows that allocation of indices isn't done in powers of two. Sure, it may be some other weirdo method, but I doubt it. I suppose it simply reallocates them when you use a bigger index, even though it is unefficient and slow (even in native C programming)

Which, for freaks, might mean that it is better to iterate and fill arrays backwards so as not to constantly force reallocation.. not that it'd matter even a bit.