Multiple Calls vs A Variable

[WolfieeifloW]

How many function calls does it take before using a variable is more efficient.

Ex: I use [ljass]GetTriggerUnit()[/ljass] twice in a function.
Is it better to make a variable [ljass]local unit tu = GetTriggerUnit()[/ljass] or just call it twice without the variable?

What's the magic number where it becomes better (More efficient) to use a variable?

 

[rexpim]

more efficient using local and faster

 

[WolfieeifloW]

Even for just one call?
Or you're saying two is the magic number?

 

[Dinowc]

for only 1 call you don't need a local:

function Func1 takes nothing returns nothing
    call KillUnit(GetTriggerUnit())
endfunction

for 2 or more calls it's better with a local:

function Func2 takes nothing returns nothing
    local unit u = GetTriggerUnit()
    call SetUnitX(u, 0.)
    call SetUnitY(u, 0.)
    set u = null
endfunction

it's much faster and more efficient, even if it has more lines of code

 

[WolfieeifloW]

So two's the number.
Okay, thank you!

 

[tooltiperror]

>it's much faster and more efficient, even if it has more lines of code
Yes, what this guy said. I see a lot of stupid posts like "This can be inlined to be faster", but that is simply not the case.

 

[Azlier]

It depends, really.

GetTriggerUnit and other event responses are very fast. A variable read, if I recall correctly is faster.

However, declaring and setting a variable is quite slow. You might need even 3-4 GetTriggerUnit calls to justify using a local. This is a total guess, by the way. However, in reality, the speed difference is entirely negligible. For all intents and purposes, two is the magic number.

 

[lep]

>it's much faster and more efficient, even if it has more lines of code
Yes, what this guy said. I see a lot of stupid posts like "This can be inlined to be faster", but that is simply not the case.

Care to elaborate?

I mean i'm all for readability and i would use the [ljass]local[/ljass] too but im not 100% sure it's actually faster.

In comparison we've got two native calls versus one native call, one local declaration and two local reads. So the local declaration and two reads have to be faster than one native call. Meh, i'm not sure there. And, afair, the more locals you have the slower the read gets.
But this goes really deep into wc3-internals. There are some threads over at wc3c about this [1][2].

But for clarification: use the [ljass]local[/ljass]. It's way nicer. I just posted this for some interesting thoughts.

[1]: http://www.wc3c.net/showthread.php?t=96208
[2]: http://www.wc3c.net/showthread.php?t=98860

 

[WolfieeifloW]

Azlier lives
PM me bro, I miss you

 

[emjlr3]

i always used three as a cut off point, mainly because past that I get tried of typing out the native, and would rather just use a single digit variable name - that and I figure at about that point its as fast, if not faster, to start using a local

you can always use a global, therefore you would not have to declare or null, just set and use, but then again I think globals are slower then locals (un-cited)

 

[tooltiperror]

>you can always use a global, therefore you would not have to declare or null, just set and use, but then again I think globals are slower then locals (un-cited)
I'm 80% sure that a global is faster, actually.

 

[Sevion]

Speedwise, I believe it goes globals, locals, natives.

Nestharus did a benchmark on all of these sometime ago.

If I remember right, in special cases the order changes, but for all intents and purposes that's the way it goes. Either way, it doesn't matter.

 

[WolfieeifloW]

So in each trigger, I should set a global like:

private unit t

Then in my functions something like:

set t = GetTriggerUnit()

And then use it for that function?

I totally forgot about nulling units if their local, so globals would be nice if the above is how it works.

 

[Sevion]

No, don't do that. Just use the local method if there's 2 or more calls and the natives if it's only one.

 

[WolfieeifloW]

Okay.
I have to do [ljass]set t = null[/ljass] at the end though right?
What else has to be nulled?

I used to know all this before I quit for like two years

 

[Laiev]

everything that extend a handle should be nulled

unit, trigger, location, etc...

 

[tooltiperror]

everything that extend a handle should be nulled

unit, trigger, location, etc...

Nope.

 

[Sevion]

Anything that's an Agent.

 

[tooltiperror]

Well, there are exceptions to about every rule, nulling included.

In an initialization (read: only map initilization) function, I don't think you need to null a local trigger, because map initilization only happens once so the address for the local trigger only needs to be assigned once.

 

[Darthfett]

The way I hear it, two is the magic number. However, unless you're doing some INSANELY speed intensive work, you should put readability at a much higher priority than efficiency. In most situations, I wouldn't worry about it.

As far as local variable go, the only things that cause leaks by requiring nulling (and can be taken care of), are types that extend agent. In some cases, like tooltiperror was pointing out, there is no need to null a variable, but this is when the object referred to by the local variable will not be destroyed. For example, an initializer trigger CAN be destroyed, but to fully remove the leak, you would also need to null the local trigger variable. Often times people do not destroy initializer triggers (since it is not that useful to do so), and therefore nulling the local trigger variable is not needed, and useless.