Increasing the priority of garbage collection

We have a JNI application that is running under a
very heavy load. The problem is that the
garbage collection can't catch up with the
application. This creates a problem that looks like a
memory leek, we consume more and more memory.
Is there a way to solve this? Perhaps by increasing
the priority of the garbage collection thread?Addressing this is detail.....
First normally the JVM is free to grab all the memory that it is allowed to. It doesn't have to give anything back to the OS, regardless of whether it is using it or not.
There is a way to tune that but I doubt that is going to help you because if you are actually using the memory (which a "very heavy load" would suggest) then the VM needs the memory.
Secondly why do you consider this a problem? If you are getting an out of memory error then either you have a memory leak or your application needs more memory. And in neither case is the gc going to help.
Now perhaps what is really happening is that you are getting a full gc and that is impacting the application. And you are hoping that there is someway to make the incremental gleaner run faster. There might be. It would be one of the XX options. But again this, in of itself, is not going to normally return memory to the OS.

Similar Messages

Suggestion for increasing the chance of Garbage Collection

To increase the chance of GC, I usually use the following approach to call GC to clean up the memory:
Test testObj = new testObj; // Suppose it is a very large object
/* after some complex processing */
testObj = null; // make the Object (memory location) unable to be referenced and then become a candidate for GC
System.gc(); // Call GC to clean up the memory
Is this approach always reclaim the memory used by testObj as I expected?
Any other good practices for GC in Java Coding (not JVM tunning)?

To increase the chance of GC, I usually use the
following approach to call GC to clean up the
memory:
Test testObj = new testObj; // Suppose it is a very
large object
/* after some complex processing */
testObj = null; // make the Object (memory location)
unable to be referenced and then become a candidate
for GC
System.gc(); // Call GC to clean up the memory
Is this approach always reclaim the memory used by
testObj as I expected?
Yes, but is usually a waste of time since if the variable goes out or scope the same thing will happen.
>
Any other good practices for GC in Java Coding (not
JVM tunning)?
The best general strategy I have found is to do nothing at all.

All Tweens randomly halting (Not Garbage Collection)

I am developing a game with some AS3 tweens. I have encountered the problem of garbage collection affecting tweens before so I have all my tweens referenced at the class level now to ensure that isn't a problem. However, randomly all the current tweens in my game will stop. Other, non-tweened, frame by frame animations continue. It's just like the garbage collection problem but the tweens shouldn't be being collected...
The code I am using for tweens:
Var declaration at the top of the class:
private var gateTween:Tween;
This code in a function:
gateTween = new Tween(currentGate, "x", None.easeOut, 800, 380, 1.5, true);
gateTween.addEventListener(TweenEvent.MOTION_FINISH, horseJump);
Any ideas would be appriciated.

I have Swing based java project. Im setting all the
references to null as and when i dont need them, and
then im calling System.gc() also.
However it seems the memory is not being released,
when i check in the task manager, memory usage does
not reduce. It seems garbage collection is not
happening.Actually I have a small class - where in I try to do this:-
public class TestDebug extends Object{
/** Creates a new instance of TestDebug */
public TestDebug() {
* @param args the command line arguments
public static void main(String[] args) {
System.out.println("Trying to debug this");
TestDebug testDebug = new TestDebug();
testDebug.finalize();
System.out.println("Lasting print");
public void finalize(){
System.out.println("Finalize called");
System.gc();
System.out.println("Finalize finished");
But it is also true that you should never try to force it - It has its own way to do it.
For Example try to execute a big code(so that you can find JVM doing the GC) as "java -verbose:gc class-name"
You will find at some points during the execution process - that the JVM actually runs the GC on its own- but when not that is not defined.It is a low priority thread running under JVM.

Getting memory dump without garbage collection

Hi all.
Does anyone know of a way to get a memory dump from the Sun JVM (version 1.5.0_11 for Windows) without garbage collection occurring first? I've tried the -XX:+PrintClassHistogram option, but this always seems to garbage collect before printing the histogram.
My problem is that I see heap usage increasing very rapidly in the JVM, then garbage collection occurs and reduces memory usage back down to what it was before. However, this results in the JVM spending a large amount of time garbage collecting. I would like to be able to see the contents of the heap before GC occurs.
These are the options I've tried so far:
* Using -XX:+PrintClassHistogram. As mentioned above, this always garbage collects before printing the histogram.
* Using -XX:+HeapDumpOnOutOfMemoryError. The problem is that the JVM always manages to GC before running out of memory, so never dumps the heap.
* Using the jmap tool. Unfortunately I'm running Windows (in production), so this is not available for 1.5.
* Using HPROF. However this seems to slow the JVM down hugely (whenever I use -agentlib:hprof=heap=sites or -agentlib:hprof=heap=dump).
* Using the HeapViewer demo tool that comes with the JVM. This has the same effect as PrintClassHistogram and garbage collects before outputting.
* Using JProfiler. Unfortunately it seems (with the 1.5 JVM anyway) the Concurrent Garbage Collector cannot be used in conjunction with JProfiler (I think this is a JVM TI issue?). With the Parallel GC we don't see the same problem (probably mostly because throughput is crippled with the Parallel GC).
* Using jstat. This only gives us statistics about how much has been garabge collected, not which objects were collected.
Has anybody got any other suggestions?
Thanks.
Neil.

Hi all.
Just an update on this -- I couldn't find any way to do this in Java 1.5 (on Windows).
In Java 1.6 (and maybe in 1.5 on other platforms) jmap will do a heap dump without garbage collecting.
I also came across an open source memory profiling tool called Ariadna (see http://mernst.org/ariadna/) which seems to work quite well. It was only of limited use in Java 1.5 however, since JVM TI doesn't support the concurrent garbage collector in this version.
Hope this is helpful anyway. I'll be trying to get upgraded to 1.6 ASAP!
Thanks.
Neil.

IncompatibleClassChangeError. Caused by garbage collection?

The problem occurs on JDK 1.3.1-b24 compiled in JBuilder Windows and
running on Sun Solaris with identical JDK version.
The application is a relatively complex RMI server.
An error recovery function in the server runs in a Thread every two
minutes. Most of the time it has nothing to do and ends without
incident.
Occasionally conditions require recovery that may not be successful
for many attempts.
Part of the recovery is a simple debug display of parameters involved
in the recovery. There will be multiple displays during a single
recovery cycle.
In a recent example of problem, the recovery executed every two
minutes for over two hours with the debug display working
successfully.
Suddenly one display works successfully and 5 milliseconds later the
same display fails with a IncompatibleClassChangeError.
The last part of the stack trace is:
java.lang.IncompatibleClassChangeError
     at [class name].toString([class name].java:74)
     at java.lang.String.valueOf(String.java:1947)
     at java.lang.StringBuffer.append(StringBuffer.java:370)
     at java.util.AbstractMap.toString(AbstractMap.java:567)
     at java.lang.String.valueOf(String.java:1947)
line 74 of class is
public String toString()
return _responses.toString();
where _responses is an ArrayList that has been stored on Map that
contains the parameters that is being display as part of the debug
information.
Once the failure occurs, it will always occur until the JVM is
restarted. This suggests to me that something in the JVM, maybe garbage collection, has either corrupted the in-memory copy of the class or some internal table used by the JVM has become corrupted.
Anybody else have ideas?

java.lang.IncompatibleClassChangeError
     at [class name].toString([class name].java:74)
     at java.lang.String.valueOf(String.java:1947)
at
java.lang.StringBuffer.append(StringBuffer.java:370)
at
java.util.AbstractMap.toString(AbstractMap.java:567)
     at java.lang.String.valueOf(String.java:1947)
Problem: The IncompatiableClassChangeError is a Symbolic resolution problem. In lamen's terms a package,class,method,or a variable name is corrupted.
Possible problem location: Are you using a Custom ClassLoader? Do you Load and compile on the fly?
where _responses is an ArrayList that has been stored
on Map that
I would look hard at the following methods in your MAP Interface:
public void clear();
public Object put(Object key,Object value);
public void putAll(Map t);
public Object remove(Object key);Is it possible that your MAP interface is corrupting your ArrayList using one of the above methods? Then, when you are building the strings using the AbstractMap's.toString() method, you are getting the IncompatiableClassChangeError?
This is word for word listing of the MAP Interface...V1.41.
Some map implementations have restrictions on the keys and values they may contain. For example, some implementations prohibit null keys and values, and some have restrictions on the types of their keys.
This puzzles me
Attempting to insert an ineligible key or value throws an unchecked exception, typically NullPointerException or ClassCastException.
What's this, they state above that you should get a unchecked Exception, but the first sentence below makes me assume they are pulling a query on an ineligible key or value???
Attempting to query the presence of an ineligible key or value may throw an exception, or it may simply return false; some implementations will exhibit the former behavior and some will exhibit the latter.
Oh,OK. They are basically saying it totally depends on how you implement this Interface <grin>
More generally, attempting an operation on an ineligible key or value whose completion would not result in the insertion of an ineligible element into the map may throw an exception or it may succeed, at the option of the implementation.
The "optional" they are talking about are the methods that I listed above.
Such exceptions are marked as "optional" in the specification for this interface.
Well you asked for ideas, so there's a brain fart for you?
...Hope this helps

Garbage collection Java Virtual Machine : Hewlett-Packard Hotspot release 1.3.1.01

"Hi,
I try and understand the mechanism of garbage collection of the Java Virtual Machine : Hewlett-Packard Hotspot release 1.3.1.01.
There is description of this mechanism in the pdf file : "memory management and garbage collection" available at the paragraph "Java performance tuning tutorial" at the page :
http://h21007.www2.hp.com/dspp/tech/tech_TechDocumentDetailPage_IDX/1,1701,1607,00.html
Regarding my question :
Below is an extract of the log file of garbage collections. This extract has 2 consecutive garbage collections.
(each begins with "<GC:").
<GC: 1 387875.630047 554 1258496 1 161087488 0 161087488 20119552 0 20119552
334758064 238778016 335544320
46294096 46294096 46399488 5.319209 >
<GC: 5 387926.615209 555 1258496 1 161087488 0 161087488 0 0 20119552
240036512 242217264 335544320
46317184 46317184 46399488 5.206192 >
There are 2 "full garbage collections", one of reason "1" and one of reason "5".
For the first one "Old generation After " =238778016
For the second "Old generation After " =238778016
Thus, "Old generation Before garbage collection" of the second is higher than "Old generation After garbage collection". Why?
I expected all objects to be allocated in the "Eden" space. And therefore I did not expect to s

I agree but my current Hp support is not very good on JVM issues.
Rob Woollen <[email protected]> wrote:
You'd probably be better off asking this question to HP.
-- Rob
Martial wrote:
The object of this mail is the Hewlett-Packard 1.3.1.01 Hotspot JavaVirtual Machine
release and its garbage collection mechanism.
I am interested in the "-Xverbosegc" option for garbage collectionmonitoring.
I have been through the online document :
http://www.hp.com/products1/unix/java/infolibrary/prog_guide/java1_3/hotspot.html#-Xverbosegc
I would like to find out more about the garbage collection mechanismand need
further information to understand the result of the log file generatedwith the
"-Xverbosegc"
For example here is an extract of a garbage collection log file generatedwith
Hewlett-Packard Hotspot Java Virtual Machine. Release 1.3.1.01.
These are 2 consecutive rows of the files :
<GC: 5 385565.750251 543 48 1 161087488 0 161087488 0 0 20119552 264184480255179792
335544320 46118384 46118384 46137344 5.514721 >
<GC: 1 385876.530728 544 1258496 1 161087488 0 161087488 20119552 020119552 334969696
255530640 335544320 46121664 46106304 46137344 6.768760 >
We have 2 full garbage collections, one of Reason 5 and the next oneof Reason
1.
What happened between these 2 garbage collections as we got : "Oldgeneration
After" of row 2 is higher than "Old generation Before" of row 1? Iexpected Objects
to be initially allocated in eden and so we could not get "old generation2modified
between the end of one garbage collection and before the next one.
Could you please clarify this issue and/or give more information aboutgarbage
collection mechanisms with the Hewlett-Packard Hotspot Java VirtualMachine. Release
1.3.1.01.

SystemManager and Garbage Collection

Hi everyone, I have a question regarding the SystemManager and Garbage Collection. I have and application that loads in its assets via a swc created in Flash. In that swc I have different MovieClips that act as the different screens of my application each one being tied to its own custom class. For example one MovieClip is a login screen another is the main menu etc. These screens contain components, text fields and animations. The problem that I am having is when I move from one screen to the other the garbage collector is not cleaning up everything. There are still references to the MovieClips that have animations for example. So even though I remove the screen via removeChild and set the variable reference to that object to null it is not releasing the MovieClips. When I pull it up in the profiler it shows me that SystemManager is holding references to them. Also if I debug the applicaion and look inside the instance of the MovieClip I can see that the private property "listeners" has values, but I am not adding listeners. It appears that the SystemManager is adding listeners. Does anyone know how I can clear these listeners or force the SystemManager to release these items. Any ideas or help would be greatly appreciated. I am fairly new to dealing with memory management and garbage collection in Flex. I am using Flash CS4 to create the swc and Flash Builder 4 Beta with the 3.4 framework and Flash Player 10 to create the app. If you need me to clarify any of this please let me know. Again any help or ideas on where to go from here would be great!

This chain says that the focusManager is referencing UserMenu. Is there a default button or focusable objects in UserMenu and references from UserMenu to the objects in question?
BTW, the CS4 fl.managers.FocusManager and any fl.. classes are incompatible with Flex, so make sure you're not using them in your MovieClips.
Alex Harui
Flex SDK Developer
Adobe Systems Inc.
Blog: http://blogs.adobe.com/aharui

Resources garbage collection, can be done this way ?

The problem
I would like to apply the same concept of garbage collection to system resources like Files, Database resulsets, Sockets etc...
The reasons
I am tired of looking around desperately into a program to identify memory leak that are instead resources leak. And this is getting worse while program size grows.
How it could be done
-- Let's have a resource manager class from where I get the wanted resource (I will write this class, fairly easy).
-- Let's say that this manager class is a thread that runs in a scheduled way and this is decided by me (this is also something anybody can write).
-- Let's say that when it runs it checks for all resources (objects) that it has given to the rest of the program if the reference count greater than one. If it is > 1 then the resource is still in use, else it can be deallocated (that just means calling close and then leaving the object to garbage collect).
What I need
A way to know in a reliable way how many objects are having a reference to a given object. Is there such a way ?
Evangelism on..
Please, if anybody at Sun is reading this, this IS a TOP issue. If you look around you will see more and more issues of leaking, they are resources leakage because it is NOT easy to ALWAYS close a resource.
Someone may say "use the finally" of yes, try to think to use the finally to deallocate memory and you will immediatly understand the mess that will come.
Garbage collection is a good idea let's have a way to apply it to resources.
Thanks

I have no problem, as it is, in making applications
reliable.As usual the problems come in deciding how to do
things.Yes.
>
Which is why mine don't. Since resources are usedin
so few places it is easy to manage their usage.We are not talking on who has the biggest gun...Eh?
>
The sad thing is that the problem most of
the time is NOT yours but of somebody else thatforgot
to clean up after himself...Sounds more like a management problem than a code
problem. If you are allowing programmers in your
organization to write code which leaks resources oris
so poorly designed that other users can notproperly
dispose of resources then it is a managementproblem.
Ok, let's drop it here.
I hope you will never have to deal with code other
that yours or written by your coworkers.
I always deal with other people's code. And they with mine. Although I occassionally work on one person projects - perhaps 2 weeks every three years. the rest of my career has always involved multi-person projects and often (if not always) involve third party libraries.
So I believe I have dealt with others code.
in the applications that I work on.)There is java.lang.ref in a way it seems to dowhat
I
want....
I don't believe so. Finalize() more closely fitswhat
you might want to do. java.lang.ref is used in
building caches of disposable entities. And it is
most definitely only useable with memory.I have a funny sensation that whatever I write you say
no...Not necessarily.
Thanks for your help, if anybody wants to add
something useful to
what I am tryng to do they are welcome.I am trying to be useful.
I am trying to point out that you are looking for a new feature in the language that just isn't very useful to most people. I was trying to point out why it wasn't useful to most people.
Perhaps this might help.
Look at it this way, go look at the bug database and look at the top vote getters for things that people want fixed. Then you might trying looking through the RFEs for something like you want. If it isn't there then add it. If enough people actually want it then it will be voted for. With enough votes it would have a better chance of being added.
Of course that presumes it could be done in the first place. Based on my memory of past topics in the forums on reference counting I suspect that the answer is no. But you might want to read those.

Garbage collection

String string1 = "Test";
String string2 = "Today";
string1 = null;
string1 = string2; i want know how many objects have been garbage collected by the JVM in this code .
is there any function of JVM which can tell me how many have been garbage collected for this code.
here its a small code. the reason i am asking , for large code it would difficult to track manually for garbages. . so is there any way out ?

for large code it would difficult to track manually
for garbages. . so is there any way out ?There is an easy way out: stop worrying about it.
You don't need to "track" garbage. That's the beauty of garbage collection. It's mostly automatic (as long as you don't do anything silly in your code, such as build a huge data structure, and keep it stored in a global variable forever even though the program will never use the data again.)
Are you a C++ programmer by any chance? I find that sometimes C++ programmers who run into a garbage collecting system tend to obsess about it needlessly, because so much time and attention has to be spent twiddling with memory allocation in C++.
How many objects does System.gc() collect? Maybe none. Maybe one. Maybe more. System.gc() might not collect anything at all; it might schedule garbage collection to happen at a later time. There are asynchronous garbage collectors that run in their own threads, collecting whenever the cpu has a few spare cycles. Asking "how many objects are collected at point X in the code" makes no sense on those systems.

Help needed!! Novice with Garbage Collection problems.

Hi Guys,
Really hoping somebody can help me here. I am a relative novice when it comes to all things Java but i am slowly trying to learn. I have come across an issue which i have identified but i am just not sure what to do about it.
Ok, in a nut shell the issue seems to be revolving around the frequency of garbage collection. From the default-err.log file i am seeing (on average) an Allocation Failure occur every 2 secs. Here is a sample from the log with verbose:gc active:
<AF[4986]: Allocation Failure. need 208480 bytes, 78 ms since last AF>
<AF[4986]: managing allocation failure, action=2 (559165976/1342176248)>
<GC: Mon Oct 11 11:51:12 2004
<GC(4986): freed 4101528 bytes in 1559 ms, 41% free (563267504/1342176248)>
<GC(4986): mark: 1301 ms, sweep: 258 ms, compact: 0 ms>
<GC(4986): refs: soft 0 (age >= 32), weak 0, final 0, phantom 0>
<AF[4986]: completed in 1563 ms>
<AF[4987]: Allocation Failure. need 208536 bytes, 78 ms since last AF>
<AF[4987]: managing allocation failure, action=2 (559138336/1342176248)>
<GC: Mon Oct 11 11:51:14 2004
<GC(4987): freed 4105128 bytes in 1563 ms, 41% free (563243464/1342176248)>
<GC(4987): mark: 1293 ms, sweep: 270 ms, compact: 0 ms>
<GC(4987): refs: soft 0 (age >= 32), weak 0, final 0, phantom 0>
<AF[4987]: completed in 1563 ms>
As you can see, allocation failures are occuring all the time, and with 2secs between events, and each GC taking around 1.5secs, i am having massive problems with the response of the server. It seems that the javaw.exe process is just pegged at 100% CPU the whole time and then it will eventually grind to a halt, and the users will get terrible response times.
OK, the questions are:
- Even to me (a novice) the above extract from the log doesnt look good. Am i right?
- what would be causing this? (i know - how long is a peice of string but i am hoping somebody can point me in the right direction so i can look some more)
- what can i do about it? Is there any parameters i can put into the java args to help me out?
Currently i am running -Xms of 128meg and an -Xmx of 1024m with no other settings. There are at the moment about 200users logged onto this server concurrently, and it seems to die a couple of hours into them all being logged on. I then have to kick everybody out and reboot to get it in a working state again.
I am in some serious need of help from some gurus!! any help would be invaluable, thanks heaps guys.
Tim

Hi Again guys, thanks for all your replies.
I have been working my butt of on this issue and i just cant seem to get anywhere... probably due to my complete lack of knowledge on this whole GC thing! :)
One thing that i have noticed that seems to be very consistant is the fact that as soon as i get an "action=2" in my default-err.log from an allocation failure, thats when the system goes nuts and tends to not recover.
At all other times it is an action=1, and the system seems to be running OK, but as soon as i get action=2, the time between GC events drop from seconds to miliseconds, and the bytes required just skyrockets. It keeps on this upward spiral till i just have to reboot the box.
From all my reading, i have found that an action=2 means "2 - The Garbage Collector has tried to allocate out of the wilderness, and failed."
This is the only item in the logs that i see is directly related to the server performance.
Can anybody please explain to me (in laymans terms) what the action=2 means, what may cause it and what i should be looking at changing to fix it?
The extract from the log files (in my first post in this thread) are still valid, as are the min/max memory settings.
Any help at all would be invaluable.
Thanks very much.
Tim

Long pauses during ParNew garbage collection Please Help !

Hi,
We are running a server application on an large machine (~120 CPU, ~380 GB Memory).
After running 1 or 2 hours we suddenly get exorbitant application pause times during garbage collection and a massive cpu usage from the java vm
We are running on Java 6 (64Bit) with 6GB Heap.
Concurrent garbage collection is turned on using the parameters:
-XX:+UseConcMarkSweepGC
-XX:+CMSParallelRemarkEnabled
-XX:CMSInitiatingOccupancyFraction=80
-XX:+DisableExplicitGC
We turned on verbose garbage collection and are getting the following output:
1. Normal operation:
Application time: 217.4656792 seconds
3180.905: [GC 3180.906: [ParNew
Desired survivor size 20119552 bytes, new threshold 4 (max 4)
- age   1:    2843824 bytes,    2843824 total
- age   2:    2577128 bytes,    5420952 total
- age   3:    5742024 bytes,   11162976 total
- age   4:     625672 bytes,   11788648 total
: 329531K->15764K(353920K), 0.1484379 secs] 2435799K->2122105K(3392144K), 0.1492386 secs]
Total time for which application threads were stopped: 0.1886810 seconds
2. The Problem:
Application time: 2.8858445 seconds
5008.433: [GC 5008.434: [ParNew
Desired survivor size 20119552 bytes, new threshold 2 (max 4)
- age   1:   15837712 bytes,   15837712 total
- age   2:   12284416 bytes,   28122128 total
: 348338K->39296K(353920K), 138.5317715 secs] 2487779K->2192551K(3392144K), 138.5327383 secs]
Total time for which application threads were stopped: 138.5778558 seconds
Application time: 2.9764564 seconds
5149.957: [GC 5149.957: [ParNew
Desired survivor size 20119552 bytes, new threshold 2 (max 4)
- age   1:    9483176 bytes,    9483176 total
- age   2:   14499344 bytes,   23982520 total
: 353920K->39296K(353920K), 231.5110574 secs] 2507175K->2204546K(3392144K), 231.5121011 secs]
Total time for which application threads were stopped: 231.5257754 seconds
Application time: 2.7932907 seconds
5384.277: [GC 5384.278: [ParNew
Desired survivor size 20119552 bytes, new threshold 4 (max 4)
- age   1:   10756376 bytes,   10756376 total
- age   2:    9135888 bytes,   19892264 total
: 353920K->28449K(353920K), 256.2065591 secs] 2519170K->2207651K(3392144K), 256.2076388 secs]
Total time for which application threads were stopped: 256.2221463 seconds
I can't find any significant differences in the log between fast and long running garbage collections.
I urgently need help in solving this problem !
What can I do ?

After the exciting reply I did get on my question, we did some more investigations on the problem and it seems that we finally found the solution to our problem.
The number of garbage collection threads used by the virtual machine defaults to the number of cpus of the machine.
This is ok for small machines or machines where the main load is produced by the java application itself.
In our environment the main load is not produced by the java application but oracle database processes.
When java tries to do it's garbage collection using 120 threads (# CPU) on the machine which is already overloaded by non java processes, the thread synchronization seems to produce an exorbitant overhead.
My theory is that spin locking is used on memory access, causing threads to spin while waiting for other blocking threads not getting cpu because of the heavy load on the system.
The solution is now to limit the number of garbage collection threads.
We did that on the first try by setting -XX:ParallelGCThreads=8
For over one day with heavy load no long GC pauses were experienced any more.

Garbage collection & memory management causing app to run poorly on iOS 7

Sorry I post the same question but in the wrong forum (I posted it in the Flash Player Beta Channel).
Hi, I am currently working on a game built using Air SDK v. 3.8 that is running fine on iOS 6. However, since the release of iOS, sometime it becomes unresponsive. When profiling with Adobe Scout, the problem seems to have something to do with the garbage collection. In Scout, some GC pass could take up to few seconds on iOS 7, while it would never take more than 700 ms on iOS 6.
I've tried to compile the project using the new 3.9 beta, and the result is somewhere in between what we've got on iOS 6 and iOS 7 (1-2 seconds).
I'm wondering if this is something that you are aware of, and if there's a fix (or optimisation) around the corner. Thanks a lot.

I am also seeing this.
Here are screenshots of Scout profiling the same sequence in my game on iPad 2 iOS 7 vs iPad 2 iOS 6. The initial burst of activity is a loading sequence, followed by automated gameplay.
iOS 7: Please note the position of the red line on the graph, and the time associated with garbage collection.
iOS 6:
Ignoring the "loading sequence" section, the "vertical line" garbage collection spikes on the iOS 7 screen shot are on the order of 2-5 seconds (garbage collection time) each. The biggest spikes in the iOS 6 screen shot are all < 50 ms in comparison (again, note the position of the red line on the graph).
Earlier in the day I captured a few garbage collection spikes on iOS 7 that were > 10 seconds each, with the largest being a whopping 24 seconds.
Any insights, supporting evidence, or alternative theories are appreciated.
UPDATE: I tested an iPad3 iOS7 today and did not experience this behavior.
UPDATE: I tested with another iPad2 iOS7 and did see the behavior on that device as well.

Froce garbage collection

Is there any other way to force garbage collection besides
system.gc()
Runtime.ExcuteFinalization()
I know thoes still does not guranteen garbage collection.
How to improve performace to maximize the possibility for garbage collection?
Thanks

How to improve performace to maximize the possibility
for garbage collection?As soon as you are done using the object references, get them out of scope :) That would help. Calling System.gc() wouldn't.

Garbage Collection in Java

Hi,
In the case of Garbage Collection (GM), if I created a object s in line1, done operation in line2 and made s as null in line3 and after some more execution (may be 10000 lines of code or may running of the prog. for 2 days), I will use same var. s again. Will it will able to work or already Garabage Collected ? Can, I get proper answer ?
bye
RaviGanesh

the object referred to by reference "s" becomes a candidate for garbage collection as soon as the last reference to it is broken. so when you make the reference "s" refer to null, if no other references refer to the originat object, the object can be garbage collected. you are free to assign the reference to other objects at any time (supposing you haven't declared the reference final).
note how careful i was to distinguish "object" from "reference" here. in java, when we say: Object o = new Object();o is the reference, the new Object is the object. if i then say: Object p = o;there are now two references to the initially created object, o and p.
keep in mind the distinction between objects and references to them, and you should be on your way.

[scjp exam] garbage collection questions

can someone please post me some garbage collection questions + correct answers, because i've taken the SCJP test again and i didn't passed it again. A co-worker of mine also didn't passed either.
(We both got 0% on Garbage Collection every time) And i really thought i had it correct the last time.
So please can someone mail/post me some garbage collection questions? thanks!

The garbage collector collects unreachable objects.
You have no control over when the objects are
collected, but there is a guarantee that all
unreachable objects will be collected before an
OutOfMemoryError is thorwn.Exactly my thoughts...
That's it. It really is just that simple. I scored 94%
on the Programmer's Exam, with 100% in the garbage
collection section.Hmm i got 54% last exam i took. I really begin to doubt about myself, because i find the questions on the exam so tricky.. Last book was Exam Cram (Java), and i found this a very nice and good book to study for the exam. Garbage collection is just one question, so it's either 0% or 100%. So far it hasn't gone anything higher then 0% with me.
Here are some questions:
1. When is the Object first available for garbage
collection (when does it become unreachable)?
Object o = new Object();
Object p = o;
o = null;
p = null;p = null; -> available for gc.
2. When is the Object first available for garbage
collection?
Object o = new Object();
Vector v = new Vector();
v.add(o);
o = null;
v = null;v = null; -> available for gc.
3. Can the Vectors be garbage collected at the end of
this code?
Vector v = new Vector();
Vector w = new Vector();
v.add(w);
w.add(v);
v = null;
w = null;yes
Now i have a question:
public int foo {
Integer result = new Integer(10);
result = null;
return result;
when is result available for gc?

Increasing the priority of garbage collection

Similar Messages

Maybe you are looking for