Out of HEAP vs. out of NATIVE memory

I'm working on a document to help our support team classify our customers' out-of-memory errors and know whether it is due to HEAP or NATIVE MEMORY. I've pulled some errors we've seen in domain logs from customers and tried to classify them. Can someone tell me if I got these right?
These are the ones I think are out of heap errors:
1) Allocation of … bytes failed for heap
TLA bailout requested
TLA unwind thread links
2) java.lang.OutOfMemoryError
3) Throwing OutOfMemory: nativeGetNewTLA
Throwing OutOfMemory: allocLargeObjectOrArray
These are the ones I think are out of native memory:
4) Throwing OutOfMemory
Unable to equeue element
JRockit aborted: Out of memory (68)
5) JRockit aborted: Out of memory (68)
Failed to acquire native memory. Try reducing Java heap size
I'm not sure if we've seen this one yet after upgrading to WebLogic 10 from WebLogic 8
Thanks,
-Bill

Hi,
I have some similar problem.
I have have the Maximum heap size set to 4GB, but the total java process takes up to 40GB or 64GB memory. I had this problem in September last year, and it came back yesterday.
I would like to know what in the code of my application can make JRockit behave this way; I get no OutOfMemorError which means that my application does not use too much memory, so what does ??
Any ideas are really welcome :)

Similar Messages

JRockit out of native memory errors - what effects native memory usage

I've seen postings which suggest a way to combat out of native memory errors is to reduce the heap size. That is fine but if you have some parts of your application which run fine and others that run the system out of native memory almost immediately then you may have a code problem. So the question is what, if anything, in the java code affects the JVM's usage of native memory?

There are lots of things that affect the native memory usage. For example: the number of classes, the size of the classes, the complexity of the type hieararchy, the number of threads, the amount of code generated, the complexity of the methods and so on.
It may also be an error in the JVM that either leaks memory or temporarily uses too much memory (for example while generating code for a java method).
Not sure this was very helpful...
/Staffan

How to figure out the size of an object - java out of heap memory error

Hi all,
I am using an object that I found in a library that I didn't create so I don't know its internal state or members.
I created a single one of these objects and I call announce() on this object which just sends a UDP announcement over the channel to notify listeners. However, after a message #124,288 I get a java out of heap memory error.
I am wondering if this announce() method is causing the state of the object to grow with every call...it seems unlikely but I want to check to see if it's reserving a growing amount of heap memory without ever allowing it to free.
My question is how can I check how big the object is within my program? I'd like to check, for instance, at every 10,000 messages sent how much memory the object is taking up. Is there a method call for that? Would I have to use some kind of debugger or memory monitor? I would like something easy to use.
Please let me know, and thanks in advance.
Julian

jboolean23 wrote:
Thanks for the quick reply.
I say it's unlikely that the methods I call are filling up heap memory because I have one Message object. This one Message has a myMsg String member. Whenever I want to change the message I call myMsg = "anewstringhere". And then I do myMessageObject.announce(); And for that reason i say I only have one Message object. The only thing added to the heap would be the strings that I replace myMsg with. The old references to myMsg are no longer valid and should be garbage collected..
Unless of course if you are calling intern() on them.
so here's my train of thought (and this isn't what my actual code looks like):
myMessageObject.myMsg = "hello" //creates a string on the heap? I assume this is equivalent to saying myMsg = new String("hello")No they are not the same.
The text literal will be in the intern space. Both code fragments would do that.
The second example would create a second instance of String(). That second instance would be cleaned when no longer referenced. But the literal will not.
Is my thought process correct? You are calling a third party library right so mock it (write a simple replacement that does the minimal correct functionality.) Substitute it in your code. And then run. If it still fails then the problem is in your code. If not then it is either in the library or the way that you use the library.

Out of heap space erorr

Hi guys,
My app is mainly a wordlist crunching program. Its a swing app.
There are two flat files about 10 MB each. The first part of the app is supposed to read all that data from the two sperate flatfiles and put them into two seperate Hashtables.
The first first file get loaded fine into the Hashtable. But during the loading of the second file, the program crashes giving a "out of Heap space" error.
Is this due to a memory leak? ( But thats not supposed to happen in Java) or the JVM with its default memory allocation cannot support processing such huge flat files?
I dont want to use the -Xmx option cuz thats what I am gonna use as a programmer. But when i deploy the application. nobody is going to use this option to run the program each time.
What do you think guys? How can this be solved?
Message was edited by:
arijit_datta

Hi , all objects in java live on Heap..As objects grow on the heap ,available space on heap will be decreased , In such cases you will get that error..
to solve the problem,unreachable objects needs to be deleted from the heap..
I hope the following can solve yr problem.
1) make null all unuseful object references ( all unused object refrences related to your first file..
obj=null;
2)Call System.gc() method before loading your second file or at end of the first file.
Consider this Example
import java.util.Date;
public class CheckGC {
public static void main(String [] args) {
Runtime rt = Runtime.getRuntime();
System.out.println("Total JVM memory: " + rt.totalMemory());
System.out.println("Before Memory = " + rt.freeMemory());
Date d = null;
for(int i = 0;i<10000;i++) {
d = new Date();
d = null;
System.out.println("After Memory = " + rt.freeMemory());
rt.gc(); // an alternate to System.gc()
System.out.println("After GC Memory = " + rt.freeMemory());
Thanks
RajaSekhar K

Consequences of out of heap space errors

Hello,
I'm curious what are the consequences of an out of heap space error. If my application is running and I get a heap space error does this corrupt my application? If I had some variable x = 123 can a out of heap space error corrupt x to make it -123?
Thanks

Hello,
I'm curious what are the consequences of an out of
heap space error. If my application is running and I
get a heap space error does this corrupt my
application? If I had some variable x = 123 can a
out of heap space error corrupt x to make it -123?
No.
Corrupt is to harsh of a word.
However where you run out of space can make your application unusable. For example you might run out of space when loading a new class. Or when creating a new thread. Does your code account for that? If not then that could be a problem.
On the other hand if you are creating a large data structure and at some point you run out of memory then if you just go back to where you started the creation and remove all references then it shouldn't impact your application.

Out of heap caused by database access

Hi guys. I have a serious problem in my last project. I use a database to get/insert information that I need. Every now and then there is A LOT of db I/O going on (1-2mb of data being loaded/accessed).
I am using a singeton pattern (one instance) for the db connection to ensure that there is only one connection between the software and the db. The problem here is that I eventually run out of heap size. Is there any way to overcome this situation? Something like flushing db buffer (or whatever).
If I use many connections (open one, perform query/insert, close) I eventually run out of sockets because Java states that closing the db connection doesnt free the resources straigh away.
So I am stuck. If anyone can help I would really appreciate it. thx

You're doing something that doesn't release memory. So stop doing that.
But you don't know what to stop doing, right? Then you'll have to find out what's filling up your memory. The tool for that is called a "profiler". Get one and use it.

Out of HEAP error installing JSE8.1 beta

My installatio fails with an out of Heap error - any idea on how to overcome this problem ? There don't seem to be any switches on the installer for setting up a bigger heap.
Using JDK1.6.0 beta 2

I'd suggest the following workaround:
1) Run the installer with -is:extract parameterб e.g.
./jstudio_ent81-beta-linux.sh -is:extractThis will extract the installer jar file either in the current directory, or in a subdirectory named isXXXXXXXXXXX (where X is a number).
2) Then run the jar file, setting the heap space, etc:
java -Xmx1024m -jar jstudio_ent81-beta-linux.jar

Cannot export my D800 images out of lightroom, message reads not enough memory. Anyone any ideas how

cannot export my D800 images out of lightroom, message reads not enough memory. Anyone any ideas how to fix this?

Is it Win7 32-Bit (that's where I've seen it happen). I would report it as a bug at the official Adobe site:
http://feedback.photoshop.com/photoshop_family
Beat

How do I get my MX420 to print out a fax that is in its memory?

How do I get my MX420 to print out a fax that is in its memory?

Hello notatechie,
Please try the following procedure to print the documents in memory:
1. Make sure that the machine is turned on.
2. Load paper.
3. Press the FAX button.
The Fax standby screen is displayed.
4. Press the left Function button.
The Fax menu screen is displayed.
5. Select  Memory reference, then press the OK button.
6. Use the   button to select Print all received documents, then press the OK button.
The confirmation screen is displayed.
7. Use the   button to select Yes, then press the OK button.
All the documents in machine's memory will be printed.
Each time a document is printed, the screen to confirm whether to delete the printed document in machine's memory is displayed.
If you select Yes using the   button and press the OK button, the printed document in machine's memory is deleted.
We hope this helps!
Did this answer your question? Please click the Accept as Solution button so that others may find the answer as well.

How to find native memory usage for a domain

Hi All,
We want to know how to find out current native momory utilization for a perticular weblogic domain. Basically we want to increase our current JVM heap size from 2 GB to 3.5GB because of 32 bit JDK restriction we are not having confident to increase at the memont. If we can get the current native memory utization then we will have a idea how to pregess and change in production env.
OS - Solaris 10
Weblogic - 9.2
Java - 1.5
Thanks and Regards
Dinabandhu

920767 wrote:
Basically we want to increase our current JVM heap size from 2 GB to 3.5GB because of 32 bit JDK restriction we are not having confident to increase at the memontSurprisingly enough to me that will not work. The maximum on solaris is 2G presuming you are running on a 32 OS.
http://www.oracle.com/technetwork/java/hotspotfaq-138619.html#gc_heap_32bit
We want to know how to find out current native momory utilization for a perticular weblogic domainMemory is per process. Weblogic, the server, is one process (one VM.) Thus you can't increase the application memory for only part of it. I doubt weblogic has a way to limit it by app.

Unaccounted for Memory is too big and lead to Native Memory Issuse.

In our server, after running 1 month, Unaccounted memory will increase up to 500m or higher. And the native memory will be big. So it lead to OOM. Below are one sample:
j2eeapp:jhf1wl101:root > jrcmd 27398 print_memusage
27398:
[JRockit] memtrace is collecting data...
[JRockit] *** 19th memory utilization report
(all numbers are in kbytes)
Total mapped ;;;;;;;5100644
; Total in-use ;;;;;;4038952
;; executable ;;;;; 75968
;;; java code ;;;; 23680; 31.2%
;;;; used ;;; 21833; 92.2%
;; shared modules (exec+ro+rw) ;;;;; 4858
;; guards ;;;;; 5928
;; readonly ;;;;; 0
;; rw-memory ;;;;;3986664
;;; Java-heap ;;;;3145728; 78.9%
;;; Stacks ;;;; 126050; 3.2%
;;; Native-memory ;;;; 714885; 17.9%
;;;; java-heap-overhead ;;; 99596
;;;; codegen memory ;;; 1088
;;;; classes ;;; 166656; 23.3%
;;;;; method bytecode ;; 13743
;;;;; method structs ;; 21987 (#281446)
;;;;; constantpool ;; 72105
;;;;; classblock ;; 7711
;;;;; class ;; 11900 (#21166)
;;;;; other classdata ;; 22950
;;;;; overhead ;; 114
;;;; threads ;;; 960; 0.1%
;;;; malloc:ed memory ;;; 81024; 11.3%
;;;;; codeinfo ;; 4815
;;;;; codeinfotrees ;; 2614
;;;;; exceptiontables ;; 1790
;;;;; metainfo/livemaptable ;; 24519
;;;;; codeblock structs ;; 20
;;;;; constants ;; 33
;;;;; livemap global tables ;; 8684
;;;;; callprof cache ;; 0
;;;;; paraminfo ;; 255 (#2929)
;;;;; strings ;; 24040 (#345745)
;;;;; strings(jstring) ;; 0
;;;;; typegraph ;; 10132
;;;;; interface implementor list ;; 260
;;;;; thread contexts ;; 598
;;;;; jar/zip memory ;; 12204
;;;;; native handle memory ;; 486
;;;; unaccounted for memory ;;; 366520; 51.3%;4.52
---------------------!!!

>
"No one is perfect - not even Mac OS X. If a program manages to lock up central processes, a restart will be needed."
That first part of what you said there is indeed true.
But a modern OS is designed to keep processes separated. An application crash
SHOULD NOT
require a complete shut-down and reboot of your system. Yes, the Log-Out/Log back in process might take awhile if you have a particularly bad application crunch, because the OS has detected that something went screwy and is checking to see that the user account is healthy enough to run, and may be fixing some things in the process.
I've run all kinds of not-quite-polished software over the years since my adoption of OS X, and no matter how badly some of it performed nothing ever required me to reboot my system to restore operating health. Now, that's not to say I don't run system maintenance utilities which, after performing their routines, suggest or require a shutdown restart. I usually only do this if I've decided to delete the offending application from my system. (Sidebar: How diligent are you about maintaining the general health of your system through the regular practice of running preventative maintenance routines? Ramon may be along shortly to lay the boiler-plate on you about this :))
Does Photoshop dig its hooks so deeply into the root level of the OS that it could cause the kind of problems you've had? I don't know for sure, but I'd guess that it's possible. And I'd suggest that, if wonky Photoshop behavior can be so bad that it
requires
the user to restart in order to regain operational health, then something is VERY wrong. And I'd go even further out on a limb to guess that this is a fault in Adobe's Photoshop coding, and not in Apple's OS coding.

Native Memory Area

JVM Memory = Heap + Non-Heap
I have configured JVM Memory as 1.5 GB. (OS is Windows) Perm Gen as 74 MB. In between i get "unable to create native threads" issue. I understand that a process in Windows can use a maximum memory of 2 GB.
1. Is the NATIVE MEMORY space part of Non-Heap? Or is it the remaining of (2GB - (HEAP+NON_HEAP)) ?
2. Is there a way to get the NATIVE MEMORY SPACE used by the java instance?

I doubt the answers to any of those matter to your problem.
If you have the heap maxed out and you are getting that error then you are probably just creating too many threads.
If you are doing that on purpose then you need to redesign.
If you are doing it accidently then you need to find the bug that keeps the threads active and fix it.

How do I get System.out.format to print out doubles with the same precision

Using the System.out.format, how do I print out the value of a double such that it looks exactly like it does if it were print from a System.out.println.
For example, take the following code:
double d = 12.48564734342343;
System.out.format("d as format: %f\n", d);
System.out.println("d as sout: " + d);Running the code, I get:

d as format: 12.485647
d as sout: 12.48564734342343

The precision of d has been lost.
I could bump up the precision as follows:
double d = 12.48564734342343;
System.out.format("d as format: %.14f\n", d);
System.out.println("d as sout: " + d);That appears to work, I get:

d as format: 12.48564734342343
d as sout: 12.48564734342343

However, that solution fails if d has a different precision, say 12.48. In that case I get:

d as format: 12.48000000000000
d as sout: 12.48

So how do I get System.out.format to print out doubles with the same precision as System.out.println?
Thanks..

YoungWinston wrote:
Schmoe wrote:
Interesting, but this is not what I am looking for...Your original question was "how do I print out the value of a double such that it looks exactly like it does if it were print from a System.out.println", and you've been told how to do that (although the pattern given by sabre may be a bit excessive - you should only need 15 '#'s).The initial phrase from my question was "Using the System.out.format, how do I..".
It's worth remembering that, unlike the Format hierarchy, 'format()' is NOT native to Java. It's a convenience implementation of the 'printf()' and 'sprintf()' methods provided in C, and first appeared in Java 1.5. Those methods were designed to produced fixed-format output; 'println()' was not.Perhaps it is the case that this can't be done.
Furthermore, Double.toString(), which is what is used by println() does not produce the same format in all cases; format("%.14f\n", d) does. TrySystem.out.println(1.8236473845783d);
System.out.println(1823647384.5783d);and you'll see what I mean.I am fine with that. It still displays all the precision.
I am simply looking for a way to quickly print out multiple variables on a sysout while debugging. I want it as syntactically sweet as possible. System.out.println can be a pain when outputting multiple variables like the following:
"System.out.println("a: " + a + "; b:" + b + "; c: " + c);"
For some reason, my fingers always typo the plus key.
I was hoping that System.out.format would be easier,along the lines of:
"System.out.format("a: %f, b: %f, c: %f\n", a, b, c);"
From a syntactical sweetness point of view, it is easier. However, the %f on doubles truncates the precision. I figured there must be a way to get the full precision.
DecimalFormat is syntactically sour for this purpose, as you need to instantiate the DecimalFormat.
fwiw I have enjoyed reading the suggestions in this thread...

I m not able to find out where is check out and open component(WCM)

hi everyone,
i m not able to find out where is check out and open component and how it works. As m not able to open & edit the native document that m assigning.Plz help me in this ASAP

Here's what I found. If you have a metalink login, try these links. Depends on what version of COAO you need.
CheckoutAndOpenInNative
Patch 6602355 Build version=2007-03-22 for 10.1.3.3.1
http://updates.oracle.com/ARULink/PatchDetails/process_form?patch_num=6602355
Version=2007-03-22 on edelivery in UCM Downloads
https://metalink.oracle.com/metalink/plsql/f?p=130:14:12648830947583585595::::p14_database_id,p14_docid,p14_show_header,p14_show_help,p14_black_frame,p14_font:NOT,455524.1,1,1,0,helvetica#downloads
Version=7.7.0.244-2006-07-31 on edelivery in UCM Downloads
https://metalink.oracle.com/metalink/plsql/f?p=130:14:12648830947583585595::::p14_database_id,p14_docid,p14_show_header,p14_show_help,p14_black_frame,p14_font:NOT,455524.1,1,1,0,helvetica#downloads
There's actually a mapping here to figure out what file these extras are in:
https://metalink.oracle.com/metalink/plsql/f?p=130:14:12648830947583585595::::p14_database_id,p14_docid,p14_show_header,p14_show_help,p14_black_frame,p14_font:NOT,455524.1,1,1,0,helvetica

How is the native memory limit (malloc) computed?

On Windows (32 bits), with the SUN JVM, the memory space that can be allocated in native code (e.g. with malloc in C) is limited and depends on the maximum heap size, specified with the -mx JVM argument. The larger the heap size, the smaller the native code memory limit.
With JRockit, this limit is higher: it is possible to allocate more memory in native code than with the Sun JVM.
However, on some machines the memory limit is not higher. The problem is that I see no difference in the configuration of these machines. They also have 2GB of RAM, with the same amount of free memory (virtual and physical), the same OS and the same OS version. On both machines, the same application is used, with the same JVM arguments.
On some machines, we can use a -mx600m and allocate a given amount of memory in native code, and on other machines, for the same amount of native memory, we can only use a -x300m.
Do you have an idea, what the difference can be? Is it possible on these other machines to use a higher -mx value?
Thanks,
Laurent
We are using jrockit-R27.2.0-jre1.5.0_10 on windows XP.

It's possible that some DLL is eating up process address space. Start JRockit with -Xverbose:memdbg to get an ascii graphic over the address space. Or use something like Process Explorer to see what is loaded into memory and where.
-- Henrik

Out of HEAP vs. out of NATIVE memory

Similar Messages

Maybe you are looking for