Heap problems

for my hosting I have 24MB of heap space, which I can increment by 8MB if needed. Tomcat 5.5.x and Mysql 4.* on Linux (I develop on XP)
I have built a fairly simple app of 12 or so pages which allows someone to browse and search through a property database. There are max 20 properties in the db at this moment.
When I test my app after a tomcat restart, within 15 mouse clicks of page navigation and db searching, I start getting heap errors. My hoster tells me my app is likely to be at fault, so I would appreciate some help to diagnose.
I I have two questions at the moment:
1. how would one diagnose heap errors and find out where in code these heap errors occur, it seems to be random in my app on my hosting service
2. I manage images by storing a record, for each image in my database., holding its relative path. After a property search, when I assemble the property data I also assign each image in the database to the url property of my five image components on my property detail form. Works fine, up until I get heap errors.
Is there a recommended way of releasing the resources used by image components to minimise consumption of resources? Just trying to eliminate this potential cause
Regards, Paul.

I am not quite clear on how you are handling/serving the binary (image) data, but if you are in fact experiencing memory problems as a result of this, then I would recommend that your application only work with the links to the images, and actually serve the images via a separate servlet. This technique is documented at http://developers.sun.com/prodtech/javatools/jscreator/reference/tips/2/retrieve_binary_data.html.

Similar Messages

JAVA UFL java-heap problem

Hi,
Outline
I have developed a User Function Library (UFL) in Java to Internationalize the reports. I have followed the guide provided by BusinessObject: http://www.sdn.sap.com/irj/boc/index?rid=/library/uuid/20d050fc-6464-2b10-88aa-a31e24c4febf&overridelayout=true
System Specifications:
Windows XP
Intel Pentium 4 CPU 3.00GHz
Memory: 3 GB (RAM)
Crystal Reports: 2008 version 12.1.3.1028
Java: JDK 1.6.0.13
Problem
Run into a Java heap space when the report is refreshing.
Description.
I open the report and click the refresh button. The report starts to quickly fetch data but then starts to slow down, it comes to the point where it stops fetching data. After a few seconds, the Formula Editor pops-up, highlights the Internationalization formula and then another small window titled "Crystal Reports" pops up with the message "Java heap space".
Comments
I know that I am running into a memory problem. I have check my memory in the Wondows Task Manager under the tab Performance and I see that my memory never reaches the maximum amount I have. I have also tried changing the Java versions, have also tried the UFL with Crystal reports XI and also tried with different computers all with which I get the same problem.
Has anyone encountered the same problem, if so, how were you able to fix it?
Thank you very much for your help.
Valentine

Valentine,
How big is the report? I had a similar problem when trying to produce a large report, although it did not have any UFL reference.
I increased the JVM stack size with the "-Xms32m -Xmx256m" flags.
But for the life of me I cannot remember where I set this from running within Eclipse. I will have a look around and see
if I can remember, but in the mean time it might help.
Darren

Java heap problem, cant set heapsize

Hi,
I am currently facing problem of java heap. With large number of Objects in ArrayList ( approx 70000), i am getting exception from java heap.
Current task: i am collecting records from database, mysql 5.5, where i have one table about 4 million entries. I am so far successful with fetching records while setting MaxRow() ( although i am failed to use setFetchSize()). Whenever function tries to finish its processing and going to put records in ArrayList. JAva throws an Memory ( Java heap Exception). I like to know your ideas to have a concerete solution. Necessary information related to my development enviourment and solutions is as follows.

IDE: Eclipse europa
Server: Tomcat 6
Database: mysql 5.5
Operating System: Windows XP


Tried Solutions: I have tried to set Java heap size at Tomcat upto 3gb but it do not work.
Source Code :
 

// calcuate count(*) for desired query. 
QueryResultSize = getEvalautionQueryResults(true, 0, user, movie, 
board, hoster, from, until); 
 
if (QueryResultSize > 0) { 
 
// recall query till all results( query result size) are not 
// loaded in links list 
try { 
while (counter < QueryResultSize) { 
 
EvaluationObject eval; 
String q = ""; 
String query = this.getEvaluationQueryString(false, user, 
movie, board, hoster, from, until); 
if (counter < fetchsize) { 
 
q = query + " and fetchid > 0 order by fetchid;"; 
 
} else { 
 
q = query + " and fetchid > " 
+ Long.toString(lastFetchId) 
+ " order by fetchid;"; 
} 
// just for test preparedstatement execution is called here 
pstmt = conn.prepareStatement(q); 
pstmt.setMaxRows(fetchsize); 
ResultSet rs = pstmt.executeQuery(); 
 
while (rs.next()) { 
 
ResultSet nextRs; 
String boardd = ""; 
URI uri = null; 
try { 
lastFetchId = Long.parseLong(rs 
.getString("fetchid")); 
boardd = rs.getString("board"); 
uri = URI.create(boardd); 
} else { 
 
shortBoard = ""; 
} 
 
} 
query = "SELECT * FROM board WHERE board='http://" 
+ shortBoard + "' OR board='http://www." 
+ shortBoard + "';"; 
if (statement.isClosed()) { 
statement = conn.createStatement(); 
} 
nextRs = statement.executeQuery(query); 
if (nextRs.next()) { 
eval = new EvaluationObject()
links.add(eval); 
} else { 
eval = new EvaluationObject()
links.add(eval); 
} 
if (counter > fetchsize) 
if (isCounterChanged) { 
model.notifyLogListener(null, counter 
+ " Links has been copied", "", 
LogEvent.ERROREVENT); 
System.out.println(counter 
+ " Links has been copied"); 
isCounterChanged = false; 
} 
} 
// because each time resultset loads 5000 results 
counter += fetchsize; 
isCounterChanged = true; 
 
} 
 
} catch (SQLException e) { 
e.printStackTrace(); 
model.notifyLogListener(null, e.getMessage(), "", 
LogEvent.ERROREVENT); 
} 
 

 Regards,
Romi
PS: Thanks in advance
I am not quite sure whether it is right place to post the question. If it is not and you know the answer ....... please dont hesitate to reply.


With large number of Objects in ArrayList ( approx 70000),By itself that isn't that big. If each object was 1000 bytes then that would only be 70 meg.
Tried Solutions: I have tried to set Java heap size at Tomcat upto 3gb but it do not work. If you set it correctly and it did not change anything in how your application worked then it is a bug in your code.
You posted your code but however you did it is wrong and you need to use the forum correctly using code tags to post the code so it is readable.

Java heap problem

Hi.
I have a question about objects in session scope.
I have created an object which holds a grid (a matrix of 2046 elements of HtmlnputText). At the beginning everything works ok, but later when several users create this matrix populating from database several times I get a java heap error. Reading several documents I think the object created are never released from memory so I don't know how to focus this stuff.
I have changed the scope of the object to resquest and the behaviour is the same..
Any comments about this?
thanks
PD: I use tomcat 6.0.x

Hi,
thanks both for comments.
I have no access to JVM, so I can't change it.
About the logic I think the problem is the GC is not working, I mean. when I get the recordset from database I make something like this:
Grid grid = new Grid(myData);
myData is an object populated from the recordset and I have defined the beans in request scope (not in session scope).
so everytime I make this, I lose the reference for the old Grid but I think this remains in memory so, when the application is running for some time it collapse and I get a java heap memory error. I'm not sure but I think that is the behaviour. Am I wrong?
Anyway I'll try with jmeter.
Thanks
greetings

Heap Problem with weblogic.security.auth.login.PasswordCredential

Hello,
I am calling EJB's from a Tomcat 6.0.20. The EJB's are contained on a Weblogic 10 mp2. For getting EJBHome, I'm using the following InitialContext-Call:
EJBHome home = null;
try
Properties initialContextProperties = new Properties();
initialContextProps.put(InitialContext.INITIAL_CONTEXT_FACTORY, initialContextFactory);
initialContextProps.put(InitialContext.SECURITY_PRINCIPAL, username);
initialContextProps.put(InitialContext.SECURITY_CREDENTIALS, password);
initialContextProps.put(InitialContext.PROVIDER_URL, url);
initialContext = new InitialContext(initialContextProps);
Object objref = this.initialContext.lookup(jndiHomeName);
home = (EJBHome) PortableRemoteObject.narrow(objref, narrowClass);
finally
if ( initialContext != null )
try
initialContext.close();
catch(Throwable t)
return home;
The Problem is, that after a bulk test on the tomcat (Xmx=256MB), 200MB are filled with 1.500.000 instances of the following class:
weblogic.security.auth.login.PasswordCredential
Has somebody an idea how to remove these classes from tomcat heap, because now the result is an OutOfMemory?
Best regards,
sebbay

Hi,
The authenticate method would take the user and the password details from the environment
(env) that is passed and after successful authentication would populate the subject with
the principals (i.e user, group the user belongs to ..)
It should work with any user that is defined in the WLS not just weblogic/weblogic.
Do you have any other users defined and which group do they belong to?
Vimala
Khalid Rizvi wrote:
I am playing (learning) with weblogic.security.auth.login.UsernamePasswordLoginModule
as a LoginModule using JAAS based authentication. Surprisingly, the only userid
and password combination acceptable is uid=weblogic, pw=weblogic combination.
I went through and looked at the example code under
http://e-docs.bea.com/wls/docs70/security/cli_apps.html#1042212. I found that
the UsernamePasswordLoginModule.login calls into
if (url != null) {
Environment env = new Environment();
env.setProviderUrl(url);
env.setSecurityPrincipal(username);
env.setSecurityCredentials(password);
try {
Authenticate.authenticate(env, subject);
Seems like UsernamePasswordLoginModule only is a router, as it instantiates an
instance of Environemt using the userid and password and passes this Environemtn
instance (env) to Authenticate.authenticate along with the empty Subject instance.
I read about that the Subject instance will be filled in with Principals by the
WL Server.
My question is that firstly,
1. As Authenticate.authenticate is not passed in the uid and pw, will it pick
those from the env?
2. Secondly, why does it only accept uid=weblogic & pw=weblogic.
I will appreciate if some one can put me in the right direction.
Khalid R. Rizvi
508-641-1192
[email protected]

Local Heap problem in WLE client

Hi all,
In visual c++ client, I've a local object which is pass to WLE server.
The server will return the value to this local object. However, the local
object is therefore pointing to the memory address of server's output
object . So, in vc++ client, when program try to free memory of local
object. "Debug Assertion Failure" meesage is occur. _CtrlHeapPointerHeap is
always fail for this local object. And my program is dead.
Do U know how to solve this problem?
Thanks!
Sam

In general, the memory for in-out parameters needs to be allocated
dynamically. The caller (i.e., your code) is responsible for allocating and
initializing the memory before passing the parameter. When the call returns,
the WLE library will de-allocate your memory and allocate memory for the object
being returned and change the pointer passed in to refer to that newly
allocated memory. Your code only needs to de-allocate what is in that pointer
once the call returns (and you are finished with the object); you should not
worry about the previously allocated memory as the WLE libraries have already
freed that for you (in accordance with the CORBA specification).
Hope this helps,
Robert
Sam Ho wrote:
Hi all,
In visual c++ client, I've a local object which is pass to WLE server.
The server will return the value to this local object. However, the local
object is therefore pointing to the memory address of server's output
object . So, in vc++ client, when program try to free memory of local
object. "Debug Assertion Failure" meesage is occur. _CtrlHeapPointerHeap is
always fail for this local object. And my program is dead.
Do U know how to solve this problem?
Thanks!
Sam

Heap size full Error message displayed when build par file in Eclispe.

We are getting below error message.
[plugin-assemble] Java returned: 1
[plugin-assemble] at org.apache.tools.ant.taskdefs.Java.execute(Java.java:107)
[plugin-assemble] at com.mslv.oms.j2ee.deploytool.automation.c.a(Unknown Source)
[plugin-assemble] at com.mslv.oms.deploytool.api.d.a(Unknown Source)
[plugin-assemble] at com.mslv.oms.deploytool.anttasks.OMSPluginAssemble.execute(Unknown Source)
[plugin-assemble] at org.apache.tools.ant.UnknownElement.execute(UnknownElement.java:288)
[plugin-assemble] at sun.reflect.GeneratedMethodAccessor3.invoke(Unknown Source)
[plugin-assemble] at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
[plugin-assemble] at java.lang.reflect.Method.invoke(Method.java:597)
[plugin-assemble] at org.apache.tools.ant.dispatch.DispatchUtils.execute(DispatchUtils.java:105)
[plugin-assemble] at org.apache.tools.ant.Task.perform(Task.java:348)
[plugin-assemble] at org.apache.tools.ant.Target.execute(Target.java:357)
[plugin-assemble] at org.apache.tools.ant.Target.performTasks(Target.java:385)
[plugin-assemble] at org.apache.tools.ant.Project.executeSortedTargets(Project.java:1329)
[plugin-assemble] at org.apache.tools.ant.Project.executeTarget(Project.java:1298)
[plugin-assemble] at org.apache.tools.ant.helper.DefaultExecutor.executeTargets(DefaultExecutor.java:41)
[plugin-assemble] at org.eclipse.ant.internal.ui.antsupport.EclipseDefaultExecutor.executeTargets(EclipseDefaultExecutor.java:32)
[plugin-assemble] at org.apache.tools.ant.Project.executeTargets(Project.java:1181)
[plugin-assemble] at org.eclipse.ant.internal.ui.antsupport.InternalAntRunner.run(InternalAntRunner.java:423)
[plugin-assemble] at org.eclipse.ant.internal.ui.antsupport.InternalAntRunner.main(InternalAntRunner.java:137)
we tried various option to change Xmx & XXMaxPermSize in eclispe ini file.
-showsplash
org.eclipse.platform
-launcher.XXMaxPermSize
2048M
-framework
plugins\org.eclipse.osgi_3.4.3.R34x_v20081215-1030.jar
-vmargs
-Dosgi.requiredJavaVersion=1.5
-Xms64m
-Xmx1024m
Your help is highly appreciated.

I have a couple of recommendations, hopefully they will help:
1. In the Design Studio installation it mentions that you have to append: -vmargs -Dsun.lang.ClassLoader.allowArraySyntax=true to the shortcut created to launch it. Eclipse won't take both: the configuration on your eclipse.ini and the arguments in the shortcut, I recommend to just use the eclipse.ini
Make sure that your configuration is what you have specified by going to:
- In Design Studio open menu: Help ->About Eclipse Platform ->Configuration Details …
2. When you are using Ant to build, deploy a project you may run into Java Heap problem. You may need to increase the amount of memory Ant is allowed to use for your project, to do that:
- In Design Studio open menu: Run->External Tools->Open External Tools Dialog…
- Select the build script you want to change on the left view.
- Select the JRE tab on the right
- Set the following as VM arguments: -Xms768m -Xmx1024m -XX:MaxPermSize=512m (this is just an example, adjust the values to your computer specifications)

Crystal Report export to PDF cause high Heap usage ?

Hi all,
As part of our reporting integrated with our JSF/JSP application, Crystal report is converted to PDF then sent to browser for user to display. mean while during peak load our Heap usage could reach 3.5GB - 4GB. So I am suspecting the unclosed byteArrayInputStream is the cause.
(This is a production application so I am collecting information before change the code)
Is the unclosed() byteArrayInputStream really cause the problem ? (the codes is below)
Thank you,
Krist
ByteArrayInputStream byteArrayInputStream = (ByteArrayInputStream)
                                 reportClientDoc.getPrintOutputController().export(exportOptions);
reportClientDoc.close();
writeToBrowser(byteArrayInputStream, response, "application/csv", EXPORT_FILE);
private void writeToBrowser(ByteArrayInputStream byteArrayInputStream, HttpServletResponse
response, String mimetype, String exportFile)
   throws Exception {
      byte[] buffer = new byte[byteArrayInputStream.available()];
      int bytesRead = 0;
      response.reset();
      response.setHeader("Content-disposition", "inline;filename=" + exportFile);
      response.setContentType(mimetype);
      //Stream the byte array to the client.
      while((bytesRead = byteArrayInputStream.read(buffer)) != -1)
            { response.getOutputStream().write(buffer , 0, bytesRead);}
      //Flush and close the output stream.
      response.getOutputStream().flush();
      response.getOutputStream().close();

I do not know if my solution to my Heap problem will help any of you but I thought I would just post it here
just incase yourselves or others come looking for possible solutions.
I created a very simlpe report with 2 groups and not much in the way of complex functions. Whilst reporting against about
100 pages of output everything worked fine, but as soon as we pushed the report up to 500+ pages we got all sorts
of issues.
java.lang.OutOfMemoryError: Java heap space
After much hair pulling and trial and error I discovered that the issue came about where I did not declare formula variables as local. I was concatinating various street address details for of the envelope windows.
Stringvar Address;      //    I was using this declaration
Global Stringvar Address;    // Specific Global declaration
Local Stringvar Address;    // Changed to this declaration
After changing to Local, my report now runs with no hassels. And the memory usage whilst exporting the report has gone from maxing out at over 1GB to almost nothing (dont even get it registering)
Am sure someone can come up with a better explanation for this and give reasons but just thougth I would share.
Cheers
Darren

Setting heap size

I hope you will all forgive me because this has been exhausted although I followed all the advices.
After the following examples, to check my own environment. I have done the following:
long heapSize = Runtime.getRuntime().totalMemory();
 System.out.println(heapSize);
 // Get maximum size of heap in bytes. The heap cannot grow beyond this size.
 // Any attempt will result in an OutOfMemoryException.
 long heapMaxSize = Runtime.getRuntime().maxMemory();
 System.out.println(heapMaxSize);
 // Get amount of free memory within the heap in bytes. This size will increase
 // after garbage collection and decrease as new objects are created.
 long heapFreeSize = Runtime.getRuntime().freeMemory();
 System.out.println(heapFreeSize);
 Which outputs is:
5177344
66650112
4437824
Currently, it looks like my heap cannot grow more than 6.6M right?
Now if I want to increase my maximum heap size, the command is adviced to be:
java -Xmx128m readFile.class
However, it keeps coming oout with an error:
Exception in thread "main" java.lang.NoClassDefFoundError: readFile/class
Where did that "main" come from? The only thing that I have done is that I have another class called myMain which calls this clss for test purposes.
The class which raised this heap problem was a class I was using to read files as in the bellow:
import java.io.*;
import java.util.*;
import java.util.regex.*;
public class readFile
private ArrayList<String> dataFromFile= new ArrayList<String>();
 public String readFile(String fileNameIn, String encoding) throws IOException {
 BufferedReader in = new BufferedReader(new InputStreamReader(
 new FileInputStream(fileNameIn), encoding));
 buffer = new StringBuffer();
 int i;
 while((i = in.read()) != -1) buffer.append((char)i);
 in.close();
 return buffer.toString();
//return an array of each data read from file separated by a tab etc
public ArrayList<String> getRecords(String fileNameIn) throws IOException {
 String s = this.readFile(fileNameIn);
 String current;
 Pattern p = Pattern.compile("[^\t\n]+|\t(?=\t)|\t$",
 Pattern.CASE_INSENSITIVE);
 Matcher m = p.matcher(s);
 while(m.find()){
 current = m.group(0).trim();
 dataFromFile.add(current);
 }//while
 return dataFromFile;
}Message was edited by:
McTaar
Message was edited by:
McTaar

This is the error displayed:
java.lang.OutOfMemoryError: Java heap space
 at java.util.Arrays.copyOf(Arrays.java:2760)
 at java.util.Arrays.copyOf(Arrays.java:2734)
 at java.util.ArrayList.ensureCapacity(ArrayList.java:167)
 at java.util.ArrayList.add(ArrayList.java:351)
 at readFile.getRecords(readFile.java:41)
 at myMain.main(myMain.java:79)readFile: 41 is
dataFromFile.add(current);

Experiencing a 32-bit Java heap barrier on a 64-bit JVM

We are attempting to run a Java application on a Sun Fire V440 with Solaris 9 and 16GB RAM. We are using the 5.0 JRE.
We are starting the application with the -d64 and -server options, and 6g of heap space with the max/min settings the same.
We have queried the Runtime object to confirm that the heap is what we expect it to be, and have plotted our heap usage.
Our full data matrix requests about 3.4GB of memory at one point in the code. We are unable to analyse the full matrix and encounter an OutOfMemoryError on array allocation. What we notice is that when we scale down the matrix so that heap usage is just under the 32 bit barrier (4.3GB) it runs, but as soon as we cross it we error.
We have checked that we are using the 64-bit JVM via the sun.arch.data.model system property and the java.version property. The Runtime object also clearly shows that the free memory is available.
What we see is that before allocation we are using 1,3GB of heap.
Adding about 3.4GB, on array allocation, to this puts us over the 32-bit threshold and we error. Any input would be greatly appreciated.

Thank you for the replies. It has helped significantly! As was suggested, the problem seems to be a young and old generation heap problem. Unfortunately, it's too late to change the subject heading. The barrier was just an artifact of a number of coincidences.
We are closer to solving the issue, but we're not there yet. We tried an experiment with 8GB of heap split 50/50 for young and old using:
java -d64 -server -Xms8000m -Xmx8000m -Xmn4000m
resulting in settings of:
-XX:MaxHeapSize=8388608000
-XX:MaxNewSize=4194304000
-XX:NewSize=4194304000
-XX:+UseParallelGC
Then we manually GC'd before the array allocation just to make sure the young generation heap was cleared out. Prior to this most of the young generation cycling is due to a BufferedReader readline() command.
After System.gc(), we read in an matrix of 900K x 300 double values = 2.1GB of data. We still run out of heap space. Our manual GC is invocation #3 and clears out the young heap, and even promotes an insignificant amount of data to the old heap, but leaves both generations largely empty:
{Heap before gc invocations=1:
PSYoungGen      total 3584000K, used 3072000K [0xfffffffe3d400000, 0xffffffff37400000, 0xffffffff37400000)
eden space 3072000K, 100% used [0xfffffffe3d400000,0xfffffffef8c00000,0xfffffffef8c00000)
from space 512000K, 0% used [0xffffffff18000000,0xffffffff18000000,0xffffffff37400000)
to   space 512000K, 0% used [0xfffffffef8c00000,0xfffffffef8c00000,0xffffffff18000000)
PSOldGen        total 4096000K, used 0K [0xfffffffd43400000, 0xfffffffe3d400000, 0xfffffffe3d400000)
object space 4096000K, 0% used [0xfffffffd43400000,0xfffffffd43400000,0xfffffffe3d400000)
PSPermGen       total 24576K, used 7593K [0xfffffffd3e400000, 0xfffffffd3fc00000, 0xfffffffd43400000)
object space 24576K, 30% used [0xfffffffd3e400000,0xfffffffd3eb6a718,0xfffffffd3fc00000)
0.000: [GCAdaptiveSizePolicy::compute_survivor_space_size_and_thresh: survived: 1032296 promoted: 0 overflow: falseAdaptiveSizeStart: 0.016 collection: 1
AdaptiveSizePolicy::compute_generation_free_space: minor_time: 0.000157 major_cost: 0.000000 mutator_cost: 0.999843 throughput_goal: 0.990000 live_space: 277243776 free_space: 7340032000 old_promo_size: 4194304000 old_eden_size: 3145728000 desired_promo_size: 4194304000 desired_eden_size: 3145728000
AdaptiveSizeStop: collection: 1
[PSYoungGen: 3072000K->1008K(3584000K)] 3072000K->1008K(7680000K), 0.0162566 secs]
Heap after gc invocations=1:
PSYoungGen total 3584000K, used 1008K [0xfffffffe3d400000, 0xffffffff37400000, 0xffffffff37400000)
eden space 3072000K, 0% used [0xfffffffe3d400000,0xfffffffe3d400000,0xfffffffef8c00000)
from space 512000K, 0% used [0xfffffffef8c00000,0xfffffffef8cfc068,0xffffffff18000000)
to space 512000K, 0% used [0xffffffff18000000,0xffffffff18000000,0xffffffff37400000)
PSOldGen total 4096000K, used 0K [0xfffffffd43400000, 0xfffffffe3d400000, 0xfffffffe3d400000)
object space 4096000K, 0% used [0xfffffffd43400000,0xfffffffd43400000,0xfffffffe3d400000)
PSPermGen total 24576K, used 7593K [0xfffffffd3e400000, 0xfffffffd3fc00000, 0xfffffffd43400000)
object space 24576K, 30% used [0xfffffffd3e400000,0xfffffffd3eb6a718,0xfffffffd3fc00000)
{Heap before gc invocations=2:
PSYoungGen      total 3584000K, used 2952191K [0xfffffffe3d400000, 0xffffffff37400000, 0xffffffff37400000)
eden space 3072000K, 96% used [0xfffffffe3d400000,0xfffffffef1603f40,0xfffffffef8c00000)
from space 512000K, 0% used [0xfffffffef8c00000,0xfffffffef8cfc068,0xffffffff18000000)
to   space 512000K, 0% used [0xffffffff18000000,0xffffffff18000000,0xffffffff37400000)
PSOldGen        total 4096000K, used 0K [0xfffffffd43400000, 0xfffffffe3d400000, 0xfffffffe3d400000)
object space 4096000K, 0% used [0xfffffffd43400000,0xfffffffd43400000,0xfffffffe3d400000)
PSPermGen       total 24576K, used 7596K [0xfffffffd3e400000, 0xfffffffd3fc00000, 0xfffffffd43400000)
object space 24576K, 30% used [0xfffffffd3e400000,0xfffffffd3eb6b3d8,0xfffffffd3fc00000)
88.203: [GCAdaptiveSizePolicy::compute_survivor_space_size_and_thresh: survived: 999520 promoted: 0 overflow: falseAdaptiveSizeStart: 88.212 collection: 2
AdaptiveSizeStop: collection: 2
[PSYoungGen: 2952191K->976K(3584000K)] 2952191K->976K(7680000K), 0.0096021 secs]
Heap after gc invocations=2:
PSYoungGen total 3584000K, used 976K [0xfffffffe3d400000, 0xffffffff37400000, 0xffffffff37400000)
eden space 3072000K, 0% used [0xfffffffe3d400000,0xfffffffe3d400000,0xfffffffef8c00000)
from space 512000K, 0% used [0xffffffff18000000,0xffffffff180f4060,0xffffffff37400000)
to space 512000K, 0% used [0xfffffffef8c00000,0xfffffffef8c00000,0xffffffff18000000)
PSOldGen total 4096000K, used 0K [0xfffffffd43400000, 0xfffffffe3d400000, 0xfffffffe3d400000)
object space 4096000K, 0% used [0xfffffffd43400000,0xfffffffd43400000,0xfffffffe3d400000)
PSPermGen total 24576K, used 7596K [0xfffffffd3e400000, 0xfffffffd3fc00000, 0xfffffffd43400000)
object space 24576K, 30% used [0xfffffffd3e400000,0xfffffffd3eb6b3d8,0xfffffffd3fc00000)
{Heap before gc invocations=3:
PSYoungGen      total 3584000K, used 976K [0xfffffffe3d400000, 0xffffffff37400000, 0xffffffff37400000)
eden space 3072000K, 0% used [0xfffffffe3d400000,0xfffffffe3d400000,0xfffffffef8c00000)
from space 512000K, 0% used [0xffffffff18000000,0xffffffff180f4060,0xffffffff37400000)
to   space 512000K, 0% used [0xfffffffef8c00000,0xfffffffef8c00000,0xffffffff18000000)
PSOldGen        total 4096000K, used 0K [0xfffffffd43400000, 0xfffffffe3d400000, 0xfffffffe3d400000)
object space 4096000K, 0% used [0xfffffffd43400000,0xfffffffd43400000,0xfffffffe3d400000)
PSPermGen       total 24576K, used 7596K [0xfffffffd3e400000, 0xfffffffd3fc00000, 0xfffffffd43400000)
object space 24576K, 30% used [0xfffffffd3e400000,0xfffffffd3eb6b3d8,0xfffffffd3fc00000)
88.213: [Full GCAdaptiveSizeStart: 88.392 collection: 3
AdaptiveSizeStop: collection: 3
[PSYoungGen: 976K->0K(3584000K)] [PSOldGen: 0K->874K(4096000K)] 976K->874K(7680000K) [PSPermGen: 7596K->7596K(24576K)], 0.1788788 secs]
Heap after gc invocations=3:
PSYoungGen total 3584000K, used 0K [0xfffffffe3d400000, 0xffffffff37400000, 0xffffffff37400000)
eden space 3072000K, 0% used [0xfffffffe3d400000,0xfffffffe3d400000,0xfffffffef8c00000)
from space 512000K, 0% used [0xffffffff18000000,0xffffffff18000000,0xffffffff37400000)
to space 512000K, 0% used [0xfffffffef8c00000,0xfffffffef8c00000,0xffffffff18000000)
PSOldGen total 4096000K, used 874K [0xfffffffd43400000, 0xfffffffe3d400000, 0xfffffffe3d400000)
object space 4096000K, 0% used [0xfffffffd43400000,0xfffffffd434da8c0,0xfffffffe3d400000)
PSPermGen total 24576K, used 7596K [0xfffffffd3e400000, 0xfffffffd3fc00000, 0xfffffffd43400000)
object space 24576K, 30% used [0xfffffffd3e400000,0xfffffffd3eb6b3d8,0xfffffffd3fc00000)
java.lang.OutOfMemoryError: Requested array size exceeds VM limit
So next we reduced our data to 890K x 300 double values = 2.14GB of data, not a lot less, and it allocates fine. In fact in GC #4 it has even promoted the signal matrix to the old generation:
{Heap before gc invocations=1:
PSYoungGen      total 3584000K, used 3072000K [0xfffffffe3d400000, 0xffffffff37400000, 0xffffffff37400000)
eden space 3072000K, 100% used [0xfffffffe3d400000,0xfffffffef8c00000,0xfffffffef8c00000)
from space 512000K, 0% used [0xffffffff18000000,0xffffffff18000000,0xffffffff37400000)
to   space 512000K, 0% used [0xfffffffef8c00000,0xfffffffef8c00000,0xffffffff18000000)
PSOldGen        total 4096000K, used 0K [0xfffffffd43400000, 0xfffffffe3d400000, 0xfffffffe3d400000)
object space 4096000K, 0% used [0xfffffffd43400000,0xfffffffd43400000,0xfffffffe3d400000)
PSPermGen       total 24576K, used 7593K [0xfffffffd3e400000, 0xfffffffd3fc00000, 0xfffffffd43400000)
object space 24576K, 30% used [0xfffffffd3e400000,0xfffffffd3eb6a768,0xfffffffd3fc00000)
0.000: [GCAdaptiveSizePolicy::compute_survivor_space_size_and_thresh: survived: 1048656 promoted: 0 overflow: falseAdaptiveSizeStart: 0.017 collection: 1
AdaptiveSizePolicy::compute_generation_free_space: minor_time: 0.000281 major_cost: 0.000000 mutator_cost: 0.999719 throughput_goal: 0.990000 live_space: 277260224 free_space: 7340032000 old_promo_size: 4194304000 old_eden_size: 3145728000 desired_promo_size: 4194304000 desired_eden_size: 3145728000
AdaptiveSizeStop: collection: 1
[PSYoungGen: 3072000K->1024K(3584000K)] 3072000K->1024K(7680000K), 0.0170110 secs]
Heap after gc invocations=1:
PSYoungGen total 3584000K, used 1024K [0xfffffffe3d400000, 0xffffffff37400000, 0xffffffff37400000)
eden space 3072000K, 0% used [0xfffffffe3d400000,0xfffffffe3d400000,0xfffffffef8c00000)
from space 512000K, 0% used [0xfffffffef8c00000,0xfffffffef8d00050,0xffffffff18000000)
to space 512000K, 0% used [0xffffffff18000000,0xffffffff18000000,0xffffffff37400000)
PSOldGen total 4096000K, used 0K [0xfffffffd43400000, 0xfffffffe3d400000, 0xfffffffe3d400000)
object space 4096000K, 0% used [0xfffffffd43400000,0xfffffffd43400000,0xfffffffe3d400000)
PSPermGen total 24576K, used 7593K [0xfffffffd3e400000, 0xfffffffd3fc00000, 0xfffffffd43400000)
object space 24576K, 30% used [0xfffffffd3e400000,0xfffffffd3eb6a768,0xfffffffd3fc00000)
{Heap before gc invocations=2:
PSYoungGen      total 3584000K, used 2891377K [0xfffffffe3d400000, 0xffffffff37400000, 0xffffffff37400000)
eden space 3072000K, 94% used [0xfffffffe3d400000,0xfffffffeeda9c6d8,0xfffffffef8c00000)
from space 512000K, 0% used [0xfffffffef8c00000,0xfffffffef8d00050,0xffffffff18000000)
to   space 512000K, 0% used [0xffffffff18000000,0xffffffff18000000,0xffffffff37400000)
PSOldGen        total 4096000K, used 0K [0xfffffffd43400000, 0xfffffffe3d400000, 0xfffffffe3d400000)
object space 4096000K, 0% used [0xfffffffd43400000,0xfffffffd43400000,0xfffffffe3d400000)
PSPermGen       total 24576K, used 7593K [0xfffffffd3e400000, 0xfffffffd3fc00000, 0xfffffffd43400000)
object space 24576K, 30% used [0xfffffffd3e400000,0xfffffffd3eb6a768,0xfffffffd3fc00000)
37.161: [GCAdaptiveSizePolicy::compute_survivor_space_size_and_thresh: survived: 1015880 promoted: 0 overflow: falseAdaptiveSizeStart: 37.171 collection: 2
AdaptiveSizeStop: collection: 2
[PSYoungGen: 2891377K->992K(3584000K)] 2891377K->992K(7680000K), 0.0098960 secs]
Heap after gc invocations=2:
PSYoungGen total 3584000K, used 992K [0xfffffffe3d400000, 0xffffffff37400000, 0xffffffff37400000)
eden space 3072000K, 0% used [0xfffffffe3d400000,0xfffffffe3d400000,0xfffffffef8c00000)
from space 512000K, 0% used [0xffffffff18000000,0xffffffff180f8048,0xffffffff37400000)
to space 512000K, 0% used [0xfffffffef8c00000,0xfffffffef8c00000,0xffffffff18000000)
PSOldGen total 4096000K, used 0K [0xfffffffd43400000, 0xfffffffe3d400000, 0xfffffffe3d400000)
object space 4096000K, 0% used [0xfffffffd43400000,0xfffffffd43400000,0xfffffffe3d400000)
PSPermGen total 24576K, used 7593K [0xfffffffd3e400000, 0xfffffffd3fc00000, 0xfffffffd43400000)
object space 24576K, 30% used [0xfffffffd3e400000,0xfffffffd3eb6a768,0xfffffffd3fc00000)
{Heap before gc invocations=3:
PSYoungGen      total 3584000K, used 992K [0xfffffffe3d400000, 0xffffffff37400000, 0xffffffff37400000)
eden space 3072000K, 0% used [0xfffffffe3d400000,0xfffffffe3d400000,0xfffffffef8c00000)
from space 512000K, 0% used [0xffffffff18000000,0xffffffff180f8048,0xffffffff37400000)
to   space 512000K, 0% used [0xfffffffef8c00000,0xfffffffef8c00000,0xffffffff18000000)
PSOldGen        total 4096000K, used 0K [0xfffffffd43400000, 0xfffffffe3d400000, 0xfffffffe3d400000)
object space 4096000K, 0% used [0xfffffffd43400000,0xfffffffd43400000,0xfffffffe3d400000)
PSPermGen       total 24576K, used 7593K [0xfffffffd3e400000, 0xfffffffd3fc00000, 0xfffffffd43400000)
object space 24576K, 30% used [0xfffffffd3e400000,0xfffffffd3eb6a768,0xfffffffd3fc00000)
37.172: [Full GCAdaptiveSizeStart: 37.352 collection: 3
AdaptiveSizeStop: collection: 3
[PSYoungGen: 992K->0K(3584000K)] [PSOldGen: 0K->874K(4096000K)] 992K->874K(7680000K) [PSPermGen: 7593K->7593K(24576K)], 0.1802284 secs]
Heap after gc invocations=3:
PSYoungGen total 3584000K, used 0K [0xfffffffe3d400000, 0xffffffff37400000, 0xffffffff37400000)
eden space 3072000K, 0% used [0xfffffffe3d400000,0xfffffffe3d400000,0xfffffffef8c00000)
from space 512000K, 0% used [0xffffffff18000000,0xffffffff18000000,0xffffffff37400000)
to space 512000K, 0% used [0xfffffffef8c00000,0xfffffffef8c00000,0xffffffff18000000)
PSOldGen total 4096000K, used 874K [0xfffffffd43400000, 0xfffffffe3d400000, 0xfffffffe3d400000)
object space 4096000K, 0% used [0xfffffffd43400000,0xfffffffd434da8c0,0xfffffffe3d400000)
PSPermGen total 24576K, used 7593K [0xfffffffd3e400000, 0xfffffffd3fc00000, 0xfffffffd43400000)
object space 24576K, 30% used [0xfffffffd3e400000,0xfffffffd3eb6a768,0xfffffffd3fc00000)
{Heap before gc invocations=4:
PSYoungGen      total 3584000K, used 3072000K [0xfffffffe3d400000, 0xffffffff37400000, 0xffffffff37400000)
eden space 3072000K, 100% used [0xfffffffe3d400000,0xfffffffef8c00000,0xfffffffef8c00000)
from space 512000K, 0% used [0xffffffff18000000,0xffffffff18000000,0xffffffff37400000)
to   space 512000K, 0% used [0xfffffffef8c00000,0xfffffffef8c00000,0xffffffff18000000)
PSOldGen        total 4096000K, used 874K [0xfffffffd43400000, 0xfffffffe3d400000, 0xfffffffe3d400000)
object space 4096000K, 0% used [0xfffffffd43400000,0xfffffffd434da8c0,0xfffffffe3d400000)
PSPermGen       total 24576K, used 7611K [0xfffffffd3e400000, 0xfffffffd3fc00000, 0xfffffffd43400000)
object space 24576K, 30% used [0xfffffffd3e400000,0xfffffffd3eb6eeb0,0xfffffffd3fc00000)
54.054: [GC-- [PSYoungGen: 3072000K->3072000K(3584000K)] 3072874K->5158809K(7680000K), 23.1725940 secs]
Heap after gc invocations=4:
PSYoungGen total 3584000K, used 3072000K [0xfffffffe3d400000, 0xffffffff37400000, 0xffffffff37400000)
eden space 3072000K, 100% used [0xfffffffe3d400000,0xfffffffef8c00000,0xfffffffef8c00000)
from space 512000K, 0% used [0xffffffff18000000,0xffffffff18000000,0xffffffff37400000)
to space 512000K, 1% used [0xfffffffef8c00000,0xfffffffef947a490,0xffffffff18000000)
PSOldGen total 4096000K, used 2086809K [0xfffffffd43400000, 0xfffffffe3d400000, 0xfffffffe3d400000)
object space 4096000K, 50% used [0xfffffffd43400000,0xfffffffdc29e6578,0xfffffffe3d400000)
PSPermGen total 24576K, used 7611K [0xfffffffd3e400000, 0xfffffffd3fc00000, 0xfffffffd43400000)
object space 24576K, 30% used [0xfffffffd3e400000,0xfffffffd3eb6eeb0,0xfffffffd3fc00000)
{Heap before gc invocations=5:
PSYoungGen      total 3584000K, used 3072000K [0xfffffffe3d400000, 0xffffffff37400000, 0xffffffff37400000)
eden space 3072000K, 100% used [0xfffffffe3d400000,0xfffffffef8c00000,0xfffffffef8c00000)
from space 512000K, 0% used [0xffffffff18000000,0xffffffff18000000,0xffffffff37400000)
to   space 512000K, 1% used [0xfffffffef8c00000,0xfffffffef947a490,0xffffffff18000000)
PSOldGen        total 4096000K, used 2086809K [0xfffffffd43400000, 0xfffffffe3d400000, 0xfffffffe3d400000)
object space 4096000K, 50% used [0xfffffffd43400000,0xfffffffdc29e6578,0xfffffffe3d400000)
PSPermGen       total 24576K, used 7611K [0xfffffffd3e400000, 0xfffffffd3fc00000, 0xfffffffd43400000)
object space 24576K, 30% used [0xfffffffd3e400000,0xfffffffd3eb6eeb0,0xfffffffd3fc00000)
77.227: [Full GCAdaptiveSizeStart: 81.903 collection: 5
AdaptiveSizePolicy::compute_generation_free_space limits: desired_promo_size: 5310531271 promo_limit: 4194304000 free_in_old_gen: 2048607488 max_old_gen_size: 4194304000 avg_old_live: 4746786511456829440
AdaptiveSizePolicy::compute_generation_free_space limits: desired_eden_size: 5454285546 old_eden_size: 3145728000 eden_limit: 3145728000 cur_eden: 3145728000 max_eden_size: 3145728000 avg_young_live: 524328
AdaptiveSizePolicy::compute_generation_free_space: minor_time: 0.289393 major_cost: 0.104945 mutator_cost: 0.605662 throughput_goal: 0.990000 live_space: 2422441472 free_space: 7340032000 old_promo_size: 4194304000 old_eden_size: 3145728000 desired_promo_size: 4194304000 desired_eden_size: 3145728000
AdaptiveSizeStop: collection: 5
[PSYoungGen: 3072000K->0K(3584000K)] [PSOldGen: 2086809K->2095406K(4096000K)] 5158809K->2095406K(7680000K) [PSPermGen: 7611K->7611K(24576K)], 4.6758162 secs]
Heap after gc invocations=5:
PSYoungGen total 3584000K, used 0K [0xfffffffe3d400000, 0xffffffff37400000, 0xffffffff37400000)
eden space 3072000K, 0% used [0xfffffffe3d400000,0xfffffffe3d400000,0xfffffffef8c00000)
from space 512000K, 0% used [0xffffffff18000000,0xffffffff18000000,0xffffffff37400000)
to space 512000K, 0% used [0xfffffffef8c00000,0xfffffffef8c00000,0xffffffff18000000)
PSOldGen total 4096000K, used 2095406K [0xfffffffd43400000, 0xfffffffe3d400000, 0xfffffffe3d400000)
object space 4096000K, 51% used [0xfffffffd43400000,0xfffffffdc324bad0,0xfffffffe3d400000)
PSPermGen total 24576K, used 7611K [0xfffffffd3e400000, 0xfffffffd3fc00000, 0xfffffffd43400000)
object space 24576K, 30% used [0xfffffffd3e400000,0xfffffffd3eb6eeb0,0xfffffffd3fc00000)
Apologies for the long trace information, but it's not clear yet what is going on. We even tried to add:
-XX:PretenureSizeThreshold=1000m
to try to force the signal matrix into old generation first upon allocation. This is where it should be, and would save the heap from having to promote it later. So question is: Is there something we're missing w.r.t. eden/from/to space ? Clearly, there is!
Thanks again!

Large dataset insertion into xls sheet ?

Hi to all Forum members,
Currently iam working with huge set of data and java heap problem, as long as i insert data into xls sheet coz my fetched dataset contains more than 50K rows. Therefore i thought perhaps i can spare lil bit heap space by adding few more task into database query.
(ref : http://forums.sun.com/thread.jspa?threadID=5377237)
Question : how can i insert dataset more than 50K rows into xls sheet. So far i know two methods
1 - extend java heap size on both JRE and Tomcat
2- use streams to continously transfer the data.
As far as i know first method is sounds good if an only if there is solo player. But i am allocating 128k to each application user. Therfore it cant be good choice.
2nd method, i never used and dont know whether it is a better choice. Although i have over internet read it works.
If you know any better method would you please furnish me with your kind ideas.
Thanks in advance.
Regards,
Romi

romi_ch wrote:
Question : how can i insert dataset more than 50K rows into xls sheet. So far i know two methods
Why in the name of [J. Presper Eckert|http://en.wikipedia.org/wiki/J._Presper_Eckert] would you want to do something like that?
I'm assuming that you mean Excel© Spreadsheet and not an XML Style Sheet.
Who are these super humans that can comprehend 50,000 rows (who knows how many columns) of stuff?
If for some strange reason you really want to do this, yo might try writing you data as a CSV file and then letting Excel handle the conversion. Should require very little memory as since you only have to store one row of the data at a time.
Edited by: johndjr on Mar 30, 2009 9:49 PM
Forgot the link

Java code vs database query performance ?????

Hi to all forum Members,
I am quite new in this forum, if i am at wrong place to post the query, please direct me to right place.
Question background : I want to have date in dd.MM.yyyy format in my excel sheets. Therefore, i have two possibilities
1- either to parse date from timestamp ( loaded column values from database ) in java
2 - or write a query in such a way which cast timestamp as date e.g.
select *, DATE_FORMAT(cast( inserted_timestamp as date), '%d.%m.%Y') as inserted_date from link where id > 290002;
Question: i like to know which method is better in terms of performance ? Because , in my first internship , i have been always desired to get the most of job done from database instead of one's application code.
Thanks in advance.
Regards,
Romi

Hi Mr / Miss tjacobs01,
Thanks for reply. I had alread knowledge that timestamp is subclass of date. Firstly, I wanted to know how far my x-colleague's statement is authentic.
I am completely agree with your statement
" Doing as much as you can in java / application layer makes scaling + testing SO MUCH EASIER"
So far i am performing convertion related manipulation in java classes. But i am facing some kind of java heap problem, as long as i insert data into xls sheet coz my fetched dataset contains more than 50K rows. Therefore i thought perhaps i can spare lil bit heap space. And i dont think i should let the my own java class handle larger dataset. What i want to say perhaps i can not as a single developer can achieve, with little experience, as much performance as i can achieve from database which is designed by many profis. that is why i am in favor of database query instead of cracking and parsing timestamp into date. If i am getting a ready made solution which is optimized then why should i try to reinvent the wheel again at application level.
I think now, reply to first question truly force me to ask heap related problem. But i am thinking its not good idea to ask related question in this post.
By the way : second question is : how can i insert dataset more than 50K rows into xls sheet. So far i know two methods
1 - extend java heap size on both JRE and Tomcat
2- use streams to continously transfer the data.
About 2nd method, i never used and dont know whether it is a better choice.
If you think you do not like to answer 2nd question in this post then please click on following link.
Kind Regards,
Romi

Ever increaing RAM usage of flashPlayer not shown in memory profiler of FlashBuilder

I have a flash application created with Flex in FlashBuilder which uses the Stage3D-API (Away3D-Library is used).
In this flash application 3D-objects are created and added to scene and they are also removed/disposed again, and then they are created/added again.
Performing these scene altering operations the RAM usage of the flashPlayer process (monitored in Windows7-Taskmanager) steadily increases by big amounts (lets say 20MB).
On the other hand the Memory-profiler does not show any such increases at all. Regarding to memory profiler the application still uses bascially the same amount of memory (the line stays flat).
There are some objects marked as loitering, but they donet seem to build-up. And their total amount is (if at all) 0,3MB.
After a while of 3d-scene altering operations (adding, removeing objects) the application/flash-player crashes, most possibly to not being able to allocate more RAM (Taskmanager shows RAM almost completely used up by flashPlayer-process). The application does not exit due to 3d-resource related limits like vertex-buffers, but here are now my questions:
Questions:
a) Are there areas of RAM-usages a (stage-3d) application uses up, which can not be profiled by FlashBuilder?
For exmaple: Is it possible that some objects (maybe stage-3d related) that hold onto some areas of memory/RAM which do not show up in memory profiler?
c) Is the versioning of used components (flashPlayer, FlashBuilder or used Flex-SDK) in an way relevant when memory profiling an application? It it possible that i dont properly see the used memory by my application because i might have old version of involved components?
d) Do you have any other idea what might be the cause here for increased RAM-usage or why it does not show up in memory profiler? I mean at least i expected to see it in memory profiler.
e) Generally i understand that the flashPlayer allocates RAM as it sees fit, and that its not the same amount of memory my application currently uses. But if my application seems not to use/demand any more memory (at least thats what the profiler tells me) i dont understand why flashPlayer allocates more and more memory - even to the point of crashing. Any ideas here?

Long shot but...
When I had an issue with Flash Builder 4.6 PC mobile in regards to the java heap problem I discovered myself that my project had content which apparently blew out the FB threshold. In particular my mp3 files (3 units) were of too much high quality (360 kbps), I had to scale down the files to 128 kbps. This is an extreme shame.
I am currently running these threshold tests to see if my mp3s can be of better kbps. I did hack my CONFIG scripts in the sdk folders in the installation location but that did not solve my issue. LESSON LEARNED: FB apparently employs the web logic where reduced files equal better performance.

Itunes not syncing tv shows to ipad

Im having heaps problems getting Itunes to sync my tv shows to my ipad. They play fine on the mac and are showing that they are synced to the Ipad, but when I go into the ipad they are not there? Anyone have any ideas? Thanks

Demo,
Thanks for tossing out ideas. I am getting to the point my memory is not bad or is it they are changing the software daily to include and drop options...
I just tried to sync a single tv episode. It did not sync it, but oddly enough it does recoginze that it is selected, because wihen I undelect it after a sync, i get an apply button as if uncheck it is making a change. But space available does not change either way, nor does anything end up on the device.
Do not think too hard on it, it is not a "rush" item, just an annoyance with the software does not work as one would expect it to.

Problem with Java Memory "Could not reserve enough space for object heap"

Hi gurus,
I am not an expert with Java´s configuration, and I have a situation that I don´t understand. First of all, I am working at Centos 6.2 with jdk_1.6 and Tomcat 7.
The problem is...
- If I run Tomcat with JAVA_OPTS="-Xmx128m"* (at catalina.sh) all works fine.
- If I run Tomcat with JAVA_OPTS="-Xmx512m"* (at catalina.sh) an error appears:
Error occurred during initialization of VM
Could not reserve enough space for object heap
Could not create the Java virtual machine.
This appear when I run java -version or when I try to stop Tomcat, and the Tomcat isn´t able to stop.
The strange thing is that my server has more than 200M free in physical memory. So, why Tomcat isn´t able to stop? and Why Java doesn´t use the free memory in my server?
Thanks in advanced.

Hello EJP, thanks for your answer.
I have explained bad.
The server has 703M free when Tomcat is stopped. I had mentioned that my server has more than 200M free in physical memory when Tomcat is running with JAVA_OPTS="-Xmx512m", so I don´t understand why these errors appear.
Do you understand me?
Recently I have checked the swap memory, and it is disabled. In spite of swap memory is disabled I think java wouldn´t need this memory because it has free physical memory
Thanks again.

Heap problems

Similar Messages

Maybe you are looking for