Native GroupEnumUnitsInRange() leaks?

[AsiaPingPong]

Attached is the test map.

I just used the following function to test for leaks with the GroupEnumUnitsInRange() native, and war3's memory usage skyrocketed.

function SafeFilter takes nothing returns boolean
    return true
endfunction

function Trig_Leak_Test_Actions takes nothing returns nothing
    local group g = CreateGroup()
    local boolexpr b = Condition(function SafeFilter)
    call GroupEnumUnitsInRange(g, 0, 0, 1024, b)
    call DestroyBoolExpr(b)
    call DestroyGroup(g)
    set b = null
    set g = null
endfunction

//===========================================================================
function InitTrig_Leak_Test takes nothing returns nothing
    set gg_trg_Leak_Test = CreateTrigger(  )
    call TriggerRegisterTimerEventPeriodic( gg_trg_Leak_Test, 0.001 )
    call TriggerAddAction( gg_trg_Leak_Test, function Trig_Leak_Test_Actions )
endfunction

Now, if the single line "call GroupEnumUnitsInRange(g, 0, 0, 1024, b)" is commented out, there are no leaks at all.

Can anyone find any flaws in my test? If not, then this native function must leak.

 

[simonake]

I'm not working with jass but let me expect that it might be a missing nunber right here

set gg_trg_Leak_Test = CreateTrigger( HERE )

Has i said before i'm not using jass but it might be that missing number of name

 

[bOb666777]

I'm not working with jass but let me expect that it might be a missing nunber right here

set gg_trg_Leak_Test = CreateTrigger( HERE )

Has i said before i'm not using jass but it might be that missing number of name

No, CreateTrigger takes nothing

Back to the topic, did you try call GroupEnumUnitsInRange(g, 0, 0, 1024, null)?

 

[Azlier]

>Back to the topic, did you try call GroupEnumUnitsInRange(g, 0, 0, 1024, null)?

That would leak a boolexpr. Have you tried using a global boolexpr instead, and a global group? That way, you don't have to recreate or destroy anything.

 

[TriggerHappy]

globals
    boolexpr b
endglobals

function SafeFilter takes nothing returns boolean
    return true
endfunction

function Trig_Leak_Test_Actions takes nothing returns nothing
    local group g = CreateGroup()
    //call GroupEnumUnitsInRange(g, 0, 0, 1024, b)
    call DestroyGroup(g)
    set g = null
endfunction

//===========================================================================
function InitTrig_Leak_Test takes nothing returns nothing
    set gg_trg_Leak_Test = CreateTrigger(  )
    call TriggerRegisterTimerEventPeriodic( gg_trg_Leak_Test, 0.001 )
    call TriggerAddAction( gg_trg_Leak_Test, function Trig_Leak_Test_Actions )
    set b = Condition(function SafeFilter)
endfunction

Caused no memory increase, though when it's not commented, it did. Something is leaking.

Or maybe that function just takes alot of memory, though, wouldn't the memory usage go back down after the function is called?


EDIT:

After some testing, this caused a more stable memory usage.

globals
    boolexpr b
    group g = CreateGroup()
endglobals

function SafeFilter takes nothing returns boolean
    return true
endfunction

function Trig_Leak_Test_Actions takes nothing returns nothing
    call GroupEnumUnitsInRange(g, 0, 0, 1024, b)
endfunction

//===========================================================================
function InitTrig_Leak_Test takes nothing returns nothing
    local trigger t = CreateTrigger()
    call TriggerRegisterTimerEvent(t, 0.001, true)
    call TriggerAddAction(t, function Trig_Leak_Test_Actions )
    set b = Condition(function SafeFilter)
    set t = null
endfunction

 

[Kenny]

It doesn't necessarily cause a leak, as normal leaks use up memory and never free it. However in the case of groupenum functions using dynamic groups, the memory is eventually free'd. Warcraft just grabs the extra memory to use and does not release it for a while.

Using a global group will definately reduce the memory usage though. And its only really important not to use dynamic groups when using them in high frequency periodic timers. And even then you would need a lot of groupenum functions per 0.02 seconds (for example) to make sufficient lag (which will eventually be reduced by warcraft).

 

[Viikuna]

I cant really think a situation where you would need a dynamic group.

It is easy enought to recycle structs group members, and you can also use some system like GroupUtils for recycling groups.

Its funny how functions like DestroyGroup and DestroyTimer have become useless.