ForGroup() vs Looping through Groups

[N-a-z-g-u-l]

so, how much faster is ForGroup()?
(dont know why nobody wants to answer this question in other threads where both possibilites are discussed)

is it right, that the functions inside the ForGroup()-callback or the loop will be equally fast, so with very long callbacks there is no big difference?

 

[Uberplayer]

http://www.thehelper.net/forums/showthread.php?t=74616

Here it's answered many times.

 

[TheDamien]

It's answered here.

 

[Uberplayer]

It's answered here.

Was that a joke?

ForGroup is faster indeed..

 

[TheDamien]

Was that a joke?

Yes.

It is indeed faster, but there is a lot of circular reasoning when it comes to proving it. Personally I am sticking by what I have read elsewhere - questioning Vexorian and Grim001 almost seems pointless.

 

[Doom-Angel]

so does any of you have a real answer?

 

[Rheias]

> Personally I am sticking by what I have read elsewhere

A link would be nice.

> questioning Vexorian and Grim001 almost seems pointless.

They may be wrong you know. And anyway, if you don't understand something, it is always better to ask than to stay ignorant.

 

[N-a-z-g-u-l]

http://www.thehelper.net/forums/showthread.php?t=74616

Here it's answered many times.

see my last post in that thread... its not yet cleared HOW much faster ForGroup is...

nobody answered to my question... nontheless at least a discussion seems to have started

is it right, that the functions inside the ForGroup()-callback or the loop will be equally fast, so with very long callbacks there is no big difference?

so thats what i currently believe in... i dont really know how to say it, but the performance of the system standing behind the loop should be way faster, but it doesnt change that the code has to be executed, what is the main performance issue, and not the looping algorithm... am i right?

and btw, i would be happier with an explanation instead of a benchmark

 

[TheDamien]

> Personally I am sticking by what I have read elsewhere

A link would be nice.

> questioning Vexorian and Grim001 almost seems pointless.

They may be wrong you know. And anyway, if you don't understand something, it is always better to ask than to stay ignorant.

http://www.wc3campaigns.net/showthread.php?t=85392

There we go. I haven't conducted the tests myself, but it seems superfluous when people have already done them before me.

ForGroup
2.81 seconds

FirstOfGroup Iteration
6.31seconds

 

[Doom-Angel]

so basically forgroup is the fastest but when you if you need to destroy this group after use than it's probably prefered to use FirstOfGroup i guess

 

[N-a-z-g-u-l]

so there is no real difference...

FirstOfGroup:

//===========================================================================
function GroupAddGroupEnum takes nothing returns nothing
    call GroupAddUnit(bj_groupAddGroupDest, GetEnumUnit())
endfunction

//===========================================================================
function GroupAddGroup takes group sourceGroup, group destGroup returns nothing
    // If the user wants the group destroyed, remember that fact and clear
    // the flag, in case it is used again in the callback.
    local boolean wantDestroy = bj_wantDestroyGroup
    set bj_wantDestroyGroup = false

    set bj_groupAddGroupDest = destGroup
    call ForGroup(sourceGroup, function GroupAddGroupEnum)

    // If the user wants the group destroyed, do so now.
    if (wantDestroy) then
        call DestroyGroup(sourceGroup)
    endif
endfunction

function yyY takes nothing returns nothing
 local group g=CreateGroup()
 local unit p
    call GroupAddGroup(udg_allunits,g)
    set bj_forLoopAIndex=0
    loop
        set p=FirstOfGroup(g)
        exitwhen (p==null)
        call GroupRemoveUnit(g,p)
        set bj_forLoopAIndex=bj_forLoopAIndex+1
        
    endloop
    call DestroyGroup(g)
    if (bj_forLoopAIndex==60) then
        set udg_log=udg_log+1
    endif

 set p=null
endfunction

ForGroup:

function zzZ takes nothing returns nothing
   set bj_forLoopAIndex=bj_forLoopAIndex+1
endfunction

function yyY takes nothing returns nothing
    set bj_forLoopAIndex=0
    call ForGroup(udg_allunits,function zzZ)
    if (bj_forLoopAIndex==60) then
        set udg_log=udg_log+1
    endif
endfunction

note that the FirstOfGroup-benchmark itself creates a new group and calls ForGroup() oO of course FirstOfGroup cant be used if the group is not going to be destroyed afterwards, but that does not have to do anything with the performance imo...

ForGroup: 2.81
FirstOfGroup: 6.31

so we can simply substract the ForGroup-time from the FirstOfGroup-time, as a ForGroup is called in that test...

FirstOfGroup: 3.50

now, i assume that GroupAddUnit() and GetEnumUnit() together is much slower than increasing a counter, so we can even substract some more time... additionally in the test a BJ-function is called, which means an additional jump...
the result is, that FirstOfGroup() is about as fast as ForGroup(), with the great advantage that local variables can still be used and there is no need to call GetEnumUnit(), as you already have the unit in a local variable... the disadvantage is of course that the group is destroyed, but often this is no problem


so:
if you dont need the group afterwards, use a loop with FirstOfGroup()
if you need the group afterwards and need every bit of performance at cost of clarity, use ForGroup()

additionally the difference is sooo small, that it will be unrecognizable as soon as you have a script running for every unit, which is bigger than just increasing a counter

i will stick to FirstOfGroup(), no question