Things That Leak

[edo494]

I'd like texttags more if the limit was 128 or 256 or I don't know, non-existent?
Is there a handle limit? No? Why a texttag limit then? ;_;
WHY? ;____;

there is finite number of handles you can have in handle table before crashing the game, it is however somewhere around several milions of handles

 

[Zwiebelchen]

I can verify that the ids are blocked. Since it did not cause a desync (game kill) in my current test, which surprises me too at the moment, I wonder if objects/agents have another id they use for net-traffic that is not exposed to jass (which of course may alter the life cycle).

Which basicly brings us back to the point admitting that some things in WC3 are a deadly mixture of magic and insanity.
This or WC3 is just plain spaghetti coding at its finest. :/

 

[Magtheridon96]

there is finite number of handles you can have in handle table before crashing the game, it is however somewhere around several milions of handles

Of course, but I'm sure it's not hardcoded (unless someone tried maxing it out before =o)

I don't have enough RAM to test for such a limit.
It will be no more than 2.146 billion given infinite RAM (it can be ~4.293 billion, but who knows what type modifiers they're using in their actual source?), but who's to say they didn't hardcode a limit less than that? ;p

 

[edo494]

when I was just like: I will make wc3 take all my ram(4 giga because of 32 bit OS) it went only up to 1,6 giga aprox and crashed

I was generating 1 point leak and 1 unit without killing it at random position on the map(GetRandomReal(..., ...) with every 0.00 seconds timer

 

[Magtheridon96]

That's approximately 3.9 million handles =o (Not sure - Depends on the size of a unit in memory. Some sources tell me 3KB, others tell me 44 bytes >.<)

I guess the limit might be close to 1 million if it's present? =o

My record for filling up my RAM with Wc3 is different
I generated 1GB of leaks with locations. Knowing that a location is 361 bytes give or take 10 bytes, that's about 2.974 million handles.

There might not actually be a limit for the handles hardcoded internally.
The crash might be caused by some other factor.

 

[Zwiebelchen]

when I was just like: I will make wc3 take all my ram(4 giga because of 32 bit OS) it went only up to 1,6 giga aprox and crashed

I was generating 1 point leak and 1 unit without killing it at random position on the map(GetRandomReal(..., ...) with every 0.00 seconds timer

I'm curious, how did you do that? WC3 does only allow creating a certain number of units (either 4k or 8k, i don't remember) until some units must be removed/killed first.

 

[edo494]

well, the crash maybe happened becuase I had no RAM left or something like that

I did simple GUI trigger with 1 action - Create 1 unit of type footman at position(Random position at(Playable map area))

with event every 0.00 second

and I tested this again with only doing(very similar):

scope myscope initializer i
     private function run takes nothing returns nothing
         call Location(GetRandomReal(-1000, 1000), GetRandomReal(-1000, 1000))
     endfunction

    private function i takes nothing returns nothing
        call TimerStart(CreateTimer(), 0.00, true, function run)
    endfunction
endscope

and funny enough, it seemed like Wc3 actually tried to force remove the leaks because at 1 GB it started dropping a bit and after 1.2 GB it popped error: no CD disk detected in driver or w/e and crashed

 

[deathismyfriend]

mine crashes around the same number. i believe its the max ram that wc3 can handle my pc has 16 gigs of ram and can use all of it. i have windows 7 64 bit ultimate and i have maxed out the ram b4 using rendering software. wc3 crashed around 1.6 to 1.8gb. i havent noticed a limit on the units but i havent sat there and counted them. i added a unit to map and increased an integer to count units on map. making 100 units every .01 seconds i got around 20k for the integer until it finally crashes. i did clean up the point leak w that test

 

[themerion]

Yeah, so, I tested nulling globals vs. not nulling globals using Maker's test code. Conclusion: null globals nulling globals might prevent a very, very insignificant leak. As Zwiebelchen rightly points out below, it should never matter (the test created and destroyed 60 MILLION locations, and memory usage only went up a few megabytes).

Not nulling

Timers created	Memory Consumption
2 702 500	88.1M
4 585 000	88.3M
6 407 000	88.6M
8 240 000	87.7M
11 746 500	83.3M
13 539 500	89.7M
33 932 000	91.0M
40 913 500	90.4M
58 903 000	92.2M

The trend is clearly rising in the long term. Just like Maker said, it's a really minor leak (considering the code is creating 500x100=50000 locations every second).

library leakTest initializer onInit
    globals
        private timer t = CreateTimer()
        private constant integer LOCS = 500
        private integer c = 0
    endglobals

    private function leaks takes nothing returns nothing
        local integer i = LOCS
       
        loop
            exitwhen i == 0
            set udg_loc = Location(0,0)
            call RemoveLocation(udg_loc)
            // set udg_loc = null
            set c = c + 1
            set i = i - 1
        endloop
    endfunction
   
    private function pauseResume takes nothing returns nothing
        if ModuloInteger(GetTriggerExecCount(GetTriggeringTrigger()) , 2) == 1 then
            call BJDebugMsg("started")
            call TimerStart(t, 0.01, true, function leaks)
        else
            call BJDebugMsg("paused, " + "locs created: " + I2S(c))
            call PauseTimer(t)
        endif
    endfunction

    private function onInit takes nothing returns nothing
        local trigger trg = CreateTrigger()
        call TriggerRegisterPlayerEvent(trg, Player(0), EVENT_PLAYER_END_CINEMATIC)
        call TriggerAddAction(trg, function pauseResume)
    endfunction
endlibrary

Nulling

Timers created	Memory Consumption
4 010 500	85.5M
7 815 000	84.8M
12 700 000	84.9M
25 000 000	84.9M
34 800 000	85.1M
42 000 000	85.5M
48 600 000	85.9M
55 000 000	83.3M
59 400 000	82.7M

There is no rising trend here...

library leakTest initializer onInit
    globals
        private timer t = CreateTimer()
        private constant integer LOCS = 500
        private integer c = 0
    endglobals

    private function leaks takes nothing returns nothing
        local integer i = LOCS
       
        loop
            exitwhen i == 0
            set udg_loc = Location(0,0)
            call RemoveLocation(udg_loc)
            set udg_loc = null
            set c = c + 1
            set i = i - 1
        endloop
    endfunction
   
    private function pauseResume takes nothing returns nothing
        if ModuloInteger(GetTriggerExecCount(GetTriggeringTrigger()) , 2) == 1 then
            call BJDebugMsg("started")
            call TimerStart(t, 0.01, true, function leaks)
        else
            call BJDebugMsg("paused, " + "locs created: " + I2S(c))
            call PauseTimer(t)
        endif
    endfunction

    private function onInit takes nothing returns nothing
        local trigger trg = CreateTrigger()
        call TriggerRegisterPlayerEvent(trg, Player(0), EVENT_PLAYER_END_CINEMATIC)
        call TriggerAddAction(trg, function pauseResume)
    endfunction
endlibrary

Nulling only at end of function

13 800 000	82.5M
37 000 000	82.8M
59 000 000	82.5M

And this is horribly confusing! Is WC3-functions somehow making extra memory for globals, which is only released upon nulling? I really expected this to be 499/500 as "leaky" as the not nulling version...

library leakTest initializer onInit
    globals
        private timer t = CreateTimer()
        private constant integer LOCS = 500
        private integer c = 0
    endglobals

    private function leaks takes nothing returns nothing
        local integer i = LOCS
       
        loop
            exitwhen i == 0
            set udg_loc = Location(0,0)
            call RemoveLocation(udg_loc)
            set c = c + 1
            set i = i - 1
        endloop
        set udg_loc = null
    endfunction
   
    private function pauseResume takes nothing returns nothing
        if ModuloInteger(GetTriggerExecCount(GetTriggeringTrigger()) , 2) == 1 then
            call BJDebugMsg("started")
            call TimerStart(t, 0.01, true, function leaks)
        else
            call BJDebugMsg("paused, " + "locs created: " + I2S(c))
            call PauseTimer(t)
        endif
    endfunction

    private function onInit takes nothing returns nothing
        local trigger trg = CreateTrigger()
        call TriggerRegisterPlayerEvent(trg, Player(0), EVENT_PLAYER_END_CINEMATIC)
        call TriggerAddAction(trg, function pauseResume)
    endfunction
endlibrary

 

[Zwiebelchen]

Yeah, so, I tested nulling globals vs. not nulling globals using Maker's test code. Conclusion: null globals.

If we compare this to the unfixable leaks of properly removed units and special effects, this goes into diminishing returns.

I definitely won't go through all the hassle to null my globals just for a megabyte of memory saved after a 3 hour game...

The conclusion should more be:
If you are paranoid, null globals. If you live in the real world, save the time.

And to be honest, I don't even think it's a real leak. More like increasing memory allocation of WC3.
Which means, WC3 probably doesn't always use the same memory adress for a global variable, but changes its adress (possibly due to internal garbage collection) from time to time.
This would mean that WC3 allocates more memory that is just not used yet, but might be used later on.

This is like making a parking lot bigger. You don't have more cars on it, but you could have more cars in it if you wish. That doesn't mean that new cars can not get on the empty spots if the area of the parking lot is enlarged (which would be the case with 'real' leaks). I hope you get the idea...

I'd take that guess a step further by saying, that this is probably caused by your operating system! Operating systems use optimizing strategies so that to reallocate memory for faster reading that is used more frequently. Remember that your nulling operation basicly increases the amount of memory operations by a half. This might affect your OS aswell or the memory allocation of WC3!
The reason I'm saying this is that the rise of memory is so goddamn low, that it's hard to say wether this is an actual memory leak or caused by overhead of WC3 or your OS we don't have any control over (and isn't harmful in any way).
Actually, the random fluctuation of memory usage of WC3 is much larger than the increase seen... (look for example at the sudden drop to 83 megs at 11.000.000 ...)


And looking at the numbers, I feel we should stop making all the less experienced users out there, especially the GUIers worried about nulling globals.
You need literally BILLIONS of global reassignements for a few megabytes of memory. Really, there are far worse things than that you don't even have control over...

 

[themerion]

And to be honest, I don't even think it's a real leak. More like increasing memory allocation of WC3.
Which means, WC3 probably doesn't always use the same memory adress for a global variable, but changes its adress (possibly due to internal garbage collection) from time to time.
This would mean that WC3 allocates more memory that is just not used yet, but might be used later on.

... parking lot...

...The reason I'm saying this is that the rise of memory is so goddamn low, that it's hard to say wether this is an actual memory leak or caused by overhead of WC3 or your OS we don't have any control over (and isn't harmful in any way).

Quite possible! I just find it fascinating that it would do this when not nulling, but not do this when nulling (even if nulling only at end of function). I mean, the values fluctuated a bit over time, but the general trend of the not nulling one... WC3 is such a magic box sometimes...

And looking at the numbers, I feel we should stop making all the less experienced users out there, especially the GUIers worried about nulling globals.
You need literally BILLIONS of global reassignements for a few megabytes of memory. Really, there are far worse things than that you don't even have control over...

Definitely.

 

[deathismyfriend]

only thing is its not that much extra effort to null the variables so y not do it lol. i can understand its not worth going over every one of ur old triggers to do it but when making new ones y not.

 

[Magtheridon96]

I never tell people to null globals. I never did and I never will
Only local agents should be nulled at least. You can play it safe and null local handles too of course, but they're not reference counted, so it's not needed really~

 

[PurgeandFire]

only thing is its not that much extra effort to null the variables so y not do it lol. i can understand its not worth going over every one of ur old triggers to do it but when making new ones y not.

Well, there is a tradeoff for everything. Remember that for every extra character in your code, you are adding a slight boost to the file size and a slight speed decrease. Of course, this is all on a microscopic level, but so is the RAM "leak".

The main reason why we null locals is because it will allow the handle ID to be recycled. Since that problem doesn't exist with globals, we don't have to really worry about it.

You can still null globals if you want to, but it is more of a matter of personal preference.

 

[MasterTrainer]

I never got to comment when I first read this tutorial but I mus say this is very helpful for beginners (like I was in the days before)... this will be helpful to a lot of people =)

@Magtheridon96's earlier post: what happens when someone nulls Globals?

 

[edo494]

nothing special, it just nullifies the memory variable is pointing to(the value stored in variable) so if you call some functions which take that type and you pass global, it will not do anything

Be aware that nullying(I dont know about the y tho) is not the same as destroying the handles

 

[MasterTrainer]

nothing special, it just nullifies the memory variable is pointing to(the value stored in variable) so if you call some functions which take that type and you pass global, it will not do anything

Be aware that nullying(I dont know about the y tho) is not the same as destroying the handles

I never knew that info about Globals until now, but I sure know the difference between nulling a handle and destroying it.

Thanks for answering me =)

 

[mikagami]

Great !! Very helpful

 

[Losam]

Help

What this best way to:

• Create random unit groups.
• MUI/Loop Spells (for GUI's Users).
• Create Channel's Spells.

 

[MasterTrainer]

If you want to make MUI spells, there are some tutorials here on Hive.

 

[deathismyfriend]

u should also create one group for spell. as creating it every iteration is very inefficient.
u also wont have to destroy it anymore.

 

[MasterTrainer]

So store units created in the spell in a group var?

 

[edo494]

yes, the enumeration is bit heavy operation, but create/destroy unit group is lot more heavy, if you create, fill,, itterate, destroy group every .01 sec it may and most likely will start dropping fps just because of how heavy the create destroy combo is

you can just add units to the unit group when spell is cast and remove them when the effect of the spell has ended for them, then when the group is empty you should turn off the trigger to prevent useless iterations, but you most likely know that already

 

[mckill2009]

bj_lastCreatedGroup can be used for instant itineration, so no need to create one group, this usually works but 'might' have problems if someone saved that group then destroys it...

 

[MasterTrainer]

bj_lastCreatedGroup is

Unit Group - Last Created Unit Group

right?

 

[mckill2009]

bj_lastCreatedGroup is used inside that trigger but it's not that...

 

[MasterTrainer]

Oh I see; thanks for the info

 

[WaterKnight]

bj_lastCreatedGroup is

Unit Group - Last Created Unit Group

right?

Not quite:

function GetLastCreatedGroupEnum takes nothing returns nothing
    call GroupAddUnit(bj_groupLastCreatedDest, GetEnumUnit())
endfunction

function GetLastCreatedGroup takes nothing returns group
    set bj_groupLastCreatedDest = CreateGroup()
    call ForGroup(bj_lastCreatedGroup, function GetLastCreatedGroupEnum)
    return bj_groupLastCreatedDest
endfunction

 

[caleman]

u should also create one group for spell. as creating it every iteration is very inefficient.
u also wont have to destroy it anymore.

yes, the enumeration is bit heavy operation, but create/destroy unit group is lot more heavy, if you create, fill,, itterate, destroy group every .01 sec it may and most likely will start dropping fps just because of how heavy the create destroy combo is

you can just add units to the unit group when spell is cast and remove them when the effect of the spell has ended for them, then when the group is empty you should turn off the trigger to prevent useless iterations, but you most likely know that already

please upload a map with a spell example, im interesed

 

[ScorpioT1000]

Or just include http://www.hiveworkshop.com/forums/jass-resources-412/snippet-cjass-anti-leak-library-211205/

 

[Daffa]

Sadly that snippet don't compatible with all Vex Jass and thus can't be recommended here.

 

[Magtheridon96]

This is addressed at people who use the GUI, so a cJASS library isn't fit for them :/

 

[Daffa]

Mag also has a good point.

 

[LordDz]

Today I made the mistake of calling Custom script: call DestroyGroup(udg_tempPoint1), was a bit tired and didn't think correctly..
And then hit save.
..
I will never make that mistake again.

 

[jonhysone]

Why is the font of credits so small ? ._. Btw Good information

 

[deathismyfriend]

this should be added to a unit group leak as not a lot of ppl think this leaks because it is use as an integer comparison condition.

• (Number of units in (Units in (Playable map area))) Equal to 0

 

[Bribe]

http://www.hiveworkshop.com/forums/...quick-tutorial-common-triggering-tips-190802/

 

[deathismyfriend]

http://www.hiveworkshop.com/forums/...quick-tutorial-common-triggering-tips-190802/

Yes i know about how easy leak finding is. But most people just say look at the Things that leak tutorial. That's why i thought it better to post on here also since it does leak and is easily avoided.

 

[plumsy460]

Re-using or changing a var doesn't leak right?

For instance:
I set a var to a point -> spawn a unit at that point throught the var -> change the var to a new location/point -> spawn another unit at that new location through the var.

As long as I reuse the var it's not considered leaking, yes?

 

[Tirlititi]

Yes it is.
Variables are not leaking, objects (like locations) are.
If you change the variable to a new location, then you're creating a new location without clearing the old one : it leaks.

There is an action for moving locations (and do what you want) but it's not available in the normal editor, only is UMSWE and such (some people say it bugs but I never experienced bugs from it myself). Unless you do that, you should remove the leak for each new object you create.

 

[Garfield1337]

Re-using or changing a var doesn't leak right?

For instance:
I set a var to a point -> spawn a unit at that point throught the var -> change the var to a new location/point -> spawn another unit at that new location through the var.

As long as I reuse the var it's not considered leaking, yes?

It leaks. It's not about the variable, it's about the object it stores. By changing what location your variable stores, you can no longer access previous location but it's still there. So before changing variables that point to an object you won't use anymore, destroy the object (location in this case).

 

[Maker]

Set point = position of triggering unit
Set point = position of target unit
Remove point
^Leaks

Set point = position of unit
Create unit at point
Move unit to point
Remove point
^No leak

 

[plumsy460]

Holy ship, I didn't expect an answer so fast! :O
And entire 3 great answers! This is overwhelming.

Thank you all so much! I hope you will be around for more of my noobish questions

Now I've basicly done it like this:

A var defines a point/location -> I spawn a unit through the var so it appears on that location -> i remove the location -> define a new location with the same var -> spawn another unit through the var -> delete the location once again

So I guess it doesn't matter how much or what I spawn at the location through the var? As long as the var doesn't change position I can always delete the location with one action?

 

[Metalbear]

Holy ship, I didn't expect an answer so fast! :O
And entire 3 great answers! This is overwhelming.

Thank you all so much! I hope you will be around for more of my noobish questions

Now I've basicly done it like this:

A var defines a point/location -> I spawn a unit through the var so it appears on that location -> i remove the location -> define a new location with the same var -> spawn another unit through the var -> delete the location once again

So I guess it doesn't matter how much or what I spawn at the location through the var? As long as the var doesn't change position I can always delete the location with one action?

Vas ist correct! As long as you dont change the value association, you will not create any more memory faults. And dont remove every time the point, or it wont work the next time and you will need to create it once again!
Every time you chose a location, its like WC3 editor is auto-creating hidden vars and thats why you need to associate em to your own var, so you can clear em... Sounds dull and complicated?

 

[plumsy460]

Not at all, sounds very good thanks^^

I feel I have a good understanding of it now. I even did some testing just to be clear.

I was wondering about special effects attached to units. I'm aware you need to destroy special effects, but does it leak any points like "create special effect at point" does?

 

[WaterKnight]

"Special effect at point" does not create any location. But you need to pass one and may do so by using a function that creates a new one.

 

[Daffa]

(....)
There is an action for moving locations (and do what you want) but it's not available in the normal editor, only is UMSWE and such (some people say it bugs but I never experienced bugs from it myself). Unless you do that, you should remove the leak for each new object you create.

UMSWE never bugs, at least the 5.0 Version.
Only note is to never use triggers under Compatibility Category

 

[plumsy460]

If I define: Var = (Random unit from Unit Group) and I set the unit group to (Units within range of a Point).
Would that leak both a group and a point?
Do I solve that by creating a Var for both UG and Point and destroying them afterwards?

 

[edo494]

yes, because if you choose from the gui menu, you pretty much always create new group
every time you see Point(…, …), it must be assigned to var or it will leak

you dont technically need group var however, you could use
Custom Script: set bj_wantDestroyGroup = true
and that should clean the group after the enumeration you do

 

[plumsy460]

you dont technically need group var however, you could use Custom Script: set bj_wantDestroyGroup = true
and that should clean the group after the enumeration you do

Does that destroy the last created unit group or how does it work exacly?