Displaying references to Flex objects

Question

I have a memory leak problem in my Flex application, and a short version of my question: is there a way (in AcitonScript 3) to find all references to a live object for this object?

I have several presentations with presentation models behind each of them (using Swiz). The views of interest are children of TabNavigator, so when I close the tab, the view is removed from the scene. When the view is removed from the scene, Swiz sets the model reference in the view to zero, as it should be. I also remove AllChildren () from the view.

However, when profiling the application, when I do this and run GC, neither the view nor the view model is freed (although both set references to each other to zero). One model object used by the view (but not the leading one, though) is freed, so it is not completely broken.

I just started profiling today (I firmly believe in not optimizing too early), so I guess there is some kind of link somewhere, but I don’t see where and what would be very useful. the ability to debug and view a list of objects that reference the target object. Is this possible, and if not initially, is there an easy way to code this in future applications for debugging purposes?

Greetings.

Answer 1

Assuming you are using Flex Builder, you can try Profiler. In my experience, this is not so good for performance profiling, but it really helped to find memory leaks.

This is not the most intuitive tool, and it takes some time to get used to it (I mean that it really becomes useful). But, in my opinion, investing some time to at least learn the basics pays off. There is a huge difference between just how much memory a player uses globally (which System.totalMemory gives you, a very rude, inaccurate and often misleading indicator) and actually tracking how many instances of each object were created, how many are still alive and where they were allocated (so you can find a potential leak in the code and actually fix it instead of relying on black magic).

I don't know any good tutorials for the FB profiler, but maybe this will get you started.

First run the profiler. Uncheck the performance profiling checkbox and check everything else. (Turn on memory profiling, view real-time data, and create traces of the stack of objects).

When the profiler starts, you will see statistics about application objects grouped by class. At this point you can configure the filters. You will see a lot of data, and it is very easy to be overloaded. For now, if possible, ignore everything you need to create flash-flash files, and focus on some object that you think should be built.

The most important figures are “cumulative instances” and “instances”. The first is the total number of copies created so far; secondly, the number of remaining copies. So, a good starting point is getting your application in a state in which the view you suspect is creating leaks. You should see 1 for “cumulative instances” and “instances”.

Now do everything you need to do to get to the point where this view should be cleared (go to another part of the application, etc.) and launch GC (there is a button for this in the profiler user interface). The decisive point is that you will check the behavior of the application against your expectations, if that makes sense. Automatically detecting leaks in an assembled environment using garbarge is nearly impossible by definition; otherwise there were no leaks. Therefore, remember this: you check your expectations; you are the one who knows the life cycle of your objects and can say: "At this moment, this object should have been assembled, and if not, then something is wrong."

Now, if the number of instances for you is reduced to 0, there is no leak. If you think that the application is leaking, try to find other objects that may be incorrectly deleted. If the counter remains at 1, it means that your look has leaked. Now you will need to find why and where.

At this point, you should take a “snapshot” (the button next to the Force GC button). Open the snapshot, find the object in the grid and double-click on it. This will give you a list of all objects that have a link to this object. This is actually a tree, and probably each element will in turn contain several backlinks and so on. These are objects that prevent the collection of your presentation. The trace of the selection will also be highlighted in the right pane. This will show how the selected object was created (much like a stack trace).

You will probably see the number of Hugh objects. But it’s best to focus on those who have a longer life cycle than the object you are studying (your view). I mean, I look at the stage, parental performance, etc .; the objects that your presentation depends on, not the objects that depend on your idea, if that makes sense. If your view has a button and you add a listener to it, your button will have a link to your view. In most cases, this is not a problem, since the button depends on the view, and as soon as the view is assembled, so is the button. So the idea is that since there are many objects, you should try to concentrate, or you won’t get anything. This method is rather heuristic, but, in my experience, it works.

Once you find the source of the leak, return to the source, change the code accordingly (perhaps this requires not just changing the code, but refactoring). Then repeat the process and check if your change caused the desired effect. This may take some time, depending on how big or complex your application is and how much you know about it. But if you step by step, discovering and fixing one problem at a time, you will eventually get rid of leaks. Or at least the worst and more obvious. Thus, while a little tedious, it pays off (and, as well aside, you will eventually realize that wasting time in most cases is used to use weak references for each event handler on the face of this earth, invalidating each the only variable, etc., etc., is enlightening experience;).

Hope this helps.

Answer 2

Flash GC uses a mixture of ref counting and mark and sweep, so it detects circular references. It seems you have another link in the objects graph. The most common reason is that the objects you want to place still have event handlers registered on objects that are not located. You can try to ensure that handlers always register with a weak reference. You can also override addEventListener and removeEventListener in all (base) classes, if possible, to see which listeners are registered, and is there a chance that some of them will not be removed.

In addition, you can write destructors for your objects, which for components ui clears the graphics and removes all children, and for all objects it removes links to all properties. Thus, only your object is stored in RAM, which does not require large memory (a small size of 20 B or so plus 4 B per variable (8 for a number)).

Greetz
back2dos

Answer 3

also a useful heuristic for finding memory leaks: http://www.tikalk.com/flex/solving-memory-leaks-using-flash-builder-4-profiler