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!

Similar Messages

  • Problem while deploying LCAs : Java heap error

    I am deploying a LCA archve thru ant scripts.The erroe coming is like
    run:
         [echo] LC Archives creation and deployment -- In the main ()
         [java] Create and deploy LC archive init() called...
         [java] Nov 11, 2009 6:09:20 PM com.adobe.idp.applicationmanager.client.Appl
    icationManagerClient <init>
         [java] INFO: ApplicationManagerClient:init()
         [java] ###### -- IN the MAIN -----####
         [java]
         [java] ###### -- Length of args -----####4
         [java] ###### -- IN THE  DEPLOY MODE -----####
         [java]
         [java] Deploying New LCAs...
         [java] Nov 11, 2009 6:09:21 PM com.adobe.idp.applicationmanager.client.Appl
    icationManagerClient callApplicationManager
         [java] INFO: ApplicationManagerClient:callApplicationManager:importApplicat
    ionArchive
         [java] Nov 11, 2009 6:09:23 PM com.adobe.idp.applicationmanager.client.Appl
    icationManagerClient callApplicationManager
         [java] SEVERE: ApplicationManagerClient:callApplicationManager:Exception:ja
    va.lang.IllegalStateException
         [java] java.lang.OutOfMemoryError: Java heap space
         [java]     at com.adobe.idp.applicationmanager.client.ApplicationManagerCli
    ent.callApplicationManager(ApplicationManagerClient.java:108)
         [java]     at com.adobe.idp.applicationmanager.client.ApplicationManager.im
    portApplicationArchive(ApplicationManager.java:147)
         [java] ## --- END OF DEPLOYMENT TASK -- ##
         [java]     at test.com.sample.LCAUtils.CreateAndDeployLCA.OriginaldeployLCA(Cre
    ateAndDeployLCA.java:264)
         [java]
         [java]     at test.com.sample.LCAUtils.CreateAndDeployLCA.multipleDeployLCA(Cre
    ateAndDeployLCA.java:337)
         [java]     at test.com.sample.LCAUtils.CreateAndDeployLCA.main(CreateAndDeployL
    CA.java:484)
         [java] Caused by: java.lang.OutOfMemoryError: Java heap space
    here java  java code works fine for small sized LCAs but mLCA which is around 8-9 Mb is creating problems
    PLease suggest a solution.
    REgards,
    Prabhat

    You get a     [java] java.lang.OutOfMemoryError: Java heap space*
    Try to increase your JVM max memory size.
    Jasmin

  • 32 bit Java rather than 64??

    I used to be able to deposit my checks online with my PC. Hooked up seemlessly with my Epson printer. My Mac is asking for a 32 bit Java applet rather than the 64 bit. Apparently the bank system is designed for 32 bit only.  It didn't make any difference with the PC (using XP Prof).  Now I'm stumped.  How or can I select 32 rather than 64?  I'm kind of clueless when it comes to these kinds of things.

    Try changing the priority order within the Java Preference application. Try these steps:
    1) Do a spotlight search for "Java"  "Java Preferences" should show up. (to do a spotlight search, hold the command key and then click spacebar.
    2) Open the Java Preferences app.
    3) Drag the 32 bit Java SE to the top above the 64 bit version.
    Not sure if you'll have to re-start apps, or re-boot, but this may get you back up.  Good luck.
    Don

  • Downgrading (temporarily) to 32-bit Java

    Hi everyone,
    I'm having a trouble activating Matlab 2008a on Mavericks. As far as I understand, the problem is related to Java changes. The log file contains the following error message:
    (Nov 10, 2013 14:25:46)java.lang.UnsatisfiedLinkError: Cant load library: /Applications/MATLAB_R2008a/bin/maci64/libinstutil.jnilib
    Searching online for similar messages, I found this discussion
    http://compgroups.net/comp.soft-sys....on-os-x/959296
    It is suggested to disable 64-bit Java and use an older 32-bit version of Java (1.5 ?) temporarily. However, I don't know how to do that on Mavericks. Java control panel accessible from System Preferences only shows Java 1.7.
    I appreciate your help with this.

    -Using the 64 bit Oracle Java compiler, and the 32 bit Oracle Java runtime,
    is it possible to compile java source code in a 64 bit compiler,
    and run those 64 bit compiled classes in the 32 bit equivalent Java runtime?
    What happened when you tried it?
    Don't be afraid of breaking Java by actually trying things. That is often the best, and fastest, way to learn.
    Just try it yourself and post the results here.

  • Force 32 Bit Java

    My bank has an application that will allow me to do deposits online by scanning the checks. When I try to use it, it says I have 64 bit Java and they are a 32 bit Java ap and to select 32 bit Java.
    So I went to the Java control panel and changed the order to check for 32 bit first then 64 bit.
    Both are checked. When I try to de-select the 64 bit Java the 32 bit also de-selects.
    How do I specify that I want only 32 bit Java?

    Try This, I think it might fix your problem:
    Go - > Utilities -> java preferences
    Click and Drag the
    32bit Java
    and Bring it over the 64 Bit Java
    That should make it look like:
    32bit Java
    64bit Java
    which should launch 32bit Java first.. then 64bit.
    You can also choose to disable 64bit altogether though I find it better to just disable it.
    You may have to restart your computer.
    Let me know if this helps!

  • Servlet/jess :java heap space

    hi,
    i developpe an web application which use a servlets intgrate exspert system(jess).my applet excuted perfectly when asking a servlets.
    but with some slowly,this a first matter.
    which a best architecture for reduce this time ?
    the second matter is :
    i assosiated for each task, a servlet, so i have 6 servlet ,the problem is when i excute a 3 servlet i receave this error:
    Exception in thread "main" java.lang.OutOfMemoryError: Java heap space.
    how modified settings of JVM to make memory of JVM biggest ?
    this is a code of servlet:
    import java.io.*;
    import javax.servlet.ServletContext;
    import javax.servlet.ServletException;
    import javax.servlet.http.*;
    import jess.QueryResult;
    import jess.Rete;
    import se.liu.ida.JessTab.JessTabFunctions;
    * Simple demonstration for an Applet <-> Servlet communication.
    public class EquServlet1 extends HttpServlet {
        private String[] ListeSym;
        private Rete Moteur;   
          * Get a String-object from the applet and send it back.
         public void doPost(
              HttpServletRequest request,
              HttpServletResponse response)
              throws ServletException, IOException {
            QueryResult result;
              try {
                   response.setContentType("application/x-java-serialized-object");
                   //1. read a String-object from applet
                   // instead of a String-object, you can transmit any object, which
                   // is known to the servlet and to the applet
                   InputStream in = request.getInputStream();
                   ObjectInputStream inputFromApplet = new ObjectInputStream(in);
                   String equ = (String) inputFromApplet.readObject();
                            log(equ);
                            //2.Démarre le Moteur Rete
                            Rete mot = new Rete(); 
                            mot.addUserpackage(new JessTabFunctions());
                            mot.executeCommand("(load-project Turb-Onto.pprj)");
                            //ServletContext cxt=getServletContext();
                            //Rete mot =(Rete)cxt.getAttribute("mot");
                            //3.Execute la requete
                            mot.store("CHAINE-1", equ); 
                            //Stocker une valeur dans le moteur dans le cadre d'un prénom
                            //pour une récupération ultérieure. Le magasin de récupération et de méthodes offrent un moyen simple d'échanger des données entre Jess et Java. Ils vous donnent un accès facile à une seule HashMap de deux langues, de sorte que vous pouvez utiliser la HashMap comme une "boîte aux lettres". Utilisez magasin () ou la fonction Jess (magasin) à mettre une valeur dans cette carte, utiliser fetch () ou la fonction Jess (fetch) pour récupérer la valeur.
                            Batch.run(mot,"EquSym.clp");
                            //chargement de code Jess, et excution de la cmd
                             mot.eval("(defquery printSym (sym_sans_redandance (des_sym ?m)) )");
                            //Ecexute a jess expression.
                            Query2 querySys = null;
                             querySys = new Query2 (mot,"printSym");
                            String[] ListeSym = new String[100];
                             querySys.traitement("printSym",ListeSym);
                            // echo it to the applet
                   OutputStream outstr = response.getOutputStream();
                   ObjectOutputStream oos = new ObjectOutputStream(outstr);
                   oos.writeObject(ListeSym);
                   oos.flush();
                   oos.close();
              } catch (Exception e) {
                   e.printStackTrace();
    }

    tkx,
    i use like a profile an integrate profile in a IDE netbeans 6.1.
    but i suppose a problem is between a tomcat and jess,exactely in a clp file .that's why a i ask a question why this same file run without a problem in sample application(non client-server).
    and this error is apear when i run a web application:
    Jess reported an error in routine Jesp.parsePattern.> Message: No such slot is-a-name in template MAIN::object at token 'is-a-name'.
    >Program text: ( defrule symptomes-sans-redandance ( object ( is-a-name at line 20 in file EquSym.clp
    so i study a jess code for a probable error , i welcom u for any suggestion .
    thks.

  • 8.2 EPPM Application Server Java Heap Size

    Hello I am reading the sizing guide is there a way to calculate the Java Heap Size required? The guide suggest 8GB was wondering if anyone has any experience and how much java heap size are you using?

    JVM configuration is largely based on the load on the server. You can start with as little as 2GB and based on the load, you can increase it. Other factors that you need to consider is the number of CPU, RAM, Swap space etc.
    Sachin Gupta

  • Java heap out of memory error with -Xms1g -Xmx4g 64 bit VM

    We are getting Java Heap memory error for the application we are running on linux 64 bit machine (VM).
    The OOM came when heap usage was 1.7gb though we have specified min as 1gb and max as 4gb. If I understand correctly then it should not have been thrown as we have specified max as 4gb. If address space was the problem then it should have thrown swap space error.
    Also, there were no other processes running on this node.
    Below are the specifics of linux node we are using:
    linux kernel: 2.6.18-128.el5
    Linux Version: Red Hat Enterprise Linux Server release 5.3 (Tikanga) 64 Bit
    Ulimts
    [ppoker@aquariusvir11 ~]$ ulimit -a
    core file size (blocks, -c) unlimited
    data seg size (kbytes, -d) unlimited
    scheduling priority (-e) 0
    file size (blocks, -f) unlimited
    pending signals (-i) 139264
    max locked memory (kbytes, -l) unlimited
    max memory size (kbytes, -m) unlimited
    open files (-n) 100000
    pipe size (512 bytes, -p) 8
    POSIX message queues (bytes, -q) 819200
    real-time priority (-r) 0
    stack size (kbytes, -s) 10240
    cpu time (seconds, -t) unlimited
    max user processes (-u) 139264
    virtual memory (kbytes, -v) unlimited
    file locks (-x) unlimited
    Java Version
    [ppoker@aquariusvir11 ~]$ java -version
    java version "1.6.0_21"
    Java(TM) SE Runtime Environment (build 1.6.0_21-b06)
    Java HotSpot(TM) 64-Bit Server VM (build 17.0-b16, mixed mode)
    Kernel Semaophores
    [ppoker@aquariusvir11 ~]$ ipcs -l
    ------ Shared Memory Limits --------
    max number of segments = 4096
    max seg size (kbytes) = 67108864
    max total shared memory (kbytes) = 17179869184
    min seg size (bytes) = 1
    ------ Semaphore Limits --------
    max number of arrays = 128
    max semaphores per array = 250
    max semaphores system wide = 32000
    max ops per semop call = 32
    semaphore max value = 32767
    ------ Messages: Limits --------
    max queues system wide = 16
    max size of message (bytes) = 65536
    default max size of queue (bytes) = 65536
    Please suggest what could be the reason for this error.
    Thanks,
    Ashish

    javaguy4u wrote:
    the OOM error ... wasn't coming when we had set min and max both as 4 GB.You deviously withheld that information.
    When the JVM needs to grow the heap it asks the OS for a bigger memory block than the one it has.
    The OS may refuse this and the JVM will throw an OOME.

  • Flash Builder 4.6 Java Heap Space Error

    Hi,
    I get this error "Java Heap Space" when trying to clean build (or build in any way) my project.
    I have a lot of embeded assets (png, mp3 and some binary files embeded to be read as a ByteArray) which total about 37 MB. Including one more 1.6MB binary asset causes this error to occur.
    I have tried to change my memory settings about (-Xmx and -Xms) as previous posts have suggested but this doesn't seem to make any difference.
    Is there any patch or solution to this very frustrating limitation of Flash Builder?
    Thanks for any help!
    Tom

    I constantly had issues with this.  I managed to run into the max for increasing the heap space.  I was able to get beyond the limit by flagging the FlashBuilder.exe file to allow it to allocate to higher memory address ranges.  I'm on a 64 bit machine, so the only limitation was the 32 bit FlashBuilder process.  Anyways i was able to get from 1024m up to 1720m.  Also note that FlashBuilder 4.7 Beta is out and it is a native 64 bit application, so you will get higher addressing there.  I just found it to be too buggy for my every day development tasks.  Also missing the Design view really hurts development.  I hope they put that back in.
    Here's more detail on how I got beyond the java heap ceiling.
    http://chrsmrtn.azurewebsites.net/flash-builder-java-heap-errors-limitations-of-xms-and-xm x/

  • Flash Builder 4.5 Java Heap Space Error

    Hello everyone,
    I've downloaded Flash Builder 4.5 trial a few days ago. Let me first tell that I like the new features a lot and they help to speed up the development process noticably. I thank Adobe for that very much.
    However I did not notice any performance boost over the Flash Buidler 4. Even worse, the 4.5 version seems to run much slower and use more memory than Flash Builder 4. I constantly keep getting Java Heap Space errors and needles to say, the tool just crashes and I have to restart it.
    Here how my experience working with the new version looks like. I start the Flash Builder 4.5 which has my current project open (for the record, I still use Flex 4.1, and the project includes roughly 300+ classes and 30000+ lines of code (AS and MXML)). At the beggining everything works fine and pretty fast. UI, code completion, snippets and all other good stuff works pretty fast. However, after each build, FlashBuilder.exe process eats up from 50 to 100 megabytes of memory and does not seem to release it or reuse it. So after a 5 or 10 builds it already appears to be using over 1 GB of RAM. At that point the editor becomes sloppy - it can't keep up with my typing, code completion popups takes a few seconds to show up. And a few more builds - the Flash Builder freezes and after a minute or two I get Java Heap Space error.
    I've tried increased the JRE heap space used by the Flash Builder (flashbuilder.ini, flashbuilderc.ini, eclipse.ini) to -Xms512m -Xmx1024m as well as permanent generation heap space to -XX:MaxPermSize=512m -XX:PermSize=256m and the mxml compiler (jvm.config) to -Xms384m -Xmx768m. However this did not solve the problem. Maybe just postponed it a bit.
    Am I the only one observing such behaviour of Flash Builder 4.5? Does any one have any other ideas how to fix this? (by the way, I work on 64bit machine with Widnows Server 2008R2, 4GB of RAM and 2.66 GHz Intel Core 2 Duo).
    Thanks in advance.
    Michael

    I'm seeing nearly the same thing.  I also have a very large set of projects similar to what you are describing and I do have Java Heap Space errors (The details show an error of "java.lang.OutOfMemoryError: unable to create new native thread" occurring for me)
    I had similar issues, although they are more frequent in the 4.5 builder, in the 4.1 builder.  In 4.1 builder, I didn't get the exact same detailed error regarding threads.
    I did install my flash builder into a clean instance of eclipse 3.6.2 vs using the standalone install.  That shouldn't make a difference though.  In 4.1, I tried he standalone install and saw the same issues I saw in the plugin version.
    I'm also using the 4.1 SDK in Flash Builder 4.5 (It appears that is what you are doing).  I've been attributing the crashes to the following bug in the 4.1 SDK, although I have applied the files in the bug report and still have the problem.  I'm hoping when I'm able to switch to the 4.5 SDK it may help.  (I can't switch yet because from what I can tell, it requires 10.2 Flash Player and my company is currently only on 10.0)
    The Bug Report I'm referring to is: https://bugs.adobe.com/jira/browse/SDK-26366
    I've bumped up all of the memory settings you've referred to and it helps the environment run longer, but it still eventually crashes.  One thing I definately do is make sure that the "Build Automatically" is unchecked.
    The machine I'm running on is an Intel 2600K with 16GB of memory running Windows 7 64-bit, so I don't think hardware is the issue.
    No real answer, but your not alone in having similar issues.
    Jon

  • Wily Introscope Enterprise Manager fails to start due to Java Heap

    Hello All,
    I just installed Wily Introscope for the first time. I have successfully installed it from the log below:
    Summary
    Installation: Successfulwith errors.
    396 Successes
    0 Warnings
    1 NonFatalErrors
    0 FatalErrors
    I also confirm that the Introscope Enterprise Manager is started as a service.
    However, when i try to launch enterprise by following the path All Programs > CA Wily > Introscope 8.2.3.5 > Introscope Enterprise Manager....
    I get the error below:
    3/29/11 07:11:46 PM PDT [ERROR] [Manager.Bootstrap] Load all Management Modules FAILED.
    3/29/11 07:11:46 PM PDT [ERROR] [Manager] The EM failed to start. Java heap space
    I have also adapted my Java Heap from 512 to 1024 in EMService.conf file but I still get same error. This was the recommendation in this related forum post - Wily Introscope - EM failed to start
    Please help!!!!

    Hello,
    Like I said, I have increased the value to 1024MB and still not starting.
    The corresponding section of the EMService is pasted below:
    Wrapper Properties
    Java Application
    wrapper.java.command=jre
    bin
    java.exe
    wrapper.working.dir=.\
    Java Main class
    wrapper.java.mainclass=org.tanukisoftware.wrapper.WrapperSimpleApp
    Java Classpath (include wrapper.jar)  Add class path elements as
    needed starting from 1
    wrapper.native_library=ServiceWrapper32
    wrapper.java.classpath.1=./lib/ServiceWrapper32.jar
    wrapper.java.classpath.2=./launcher.jar
    #wrapper.java.classpath.3=
    Java Library Path (location of Wrapper.DLL or libwrapper.so)
    wrapper.java.library.path.1=./lib
    Java Additional Parameters
    Note: On 64-bit Windows only, the first additional parameter must be: -Xrs
    #wrapper.java.additional.1=
    wrapper.java.additional.1=-Xrs
    wrapper.java.additional.2=-Djava.awt.headless=false
    Initial Java Heap Size (in MB)
    wrapper.java.initmemory=512
    Maximum Java Heap Size (in MB)
    wrapper.java.maxmemory=1024
    Application parameters.  Add parameters as needed starting from 1
    wrapper.app.parameter.1=org.eclipse.core.launcher.Main
    wrapper.app.parameter.2=-consolelog
    wrapper.app.parameter.3=-noExit
    wrapper.app.parameter.4=-product
    wrapper.app.parameter.5=com.wily.introscope.em.product
    wrapper.app.parameter.6=-install
    wrapper.app.parameter.7=./product/enterprisemanager
    wrapper.app.parameter.8=-configuration
    wrapper.app.parameter.9=./product/enterprisemanager/configuration
    Number of seconds to allow between the time that the Wrapper launches
    the JVM process and the time that the JVM side of the Wrapper responds
    that the application has started. 0 means never time out. Defaults to 30 seconds.
    wrapper.startup.timeout=300
    Please help

  • Solaris 10 - Zones - Java Heap Allocation

    I have a SUN T5240 running Solaris 10 with 2 zones configured.
    We have 64GB of RAM on board....
    I am unable to start any of my JAVA applications/methods with more than 1280mb of java heap allocated.
    ulimit -a shows:
    time(seconds) unlimited
    file(blocks) unlimited
    data(kbytes) unlimited
    stack(kbytes) unlimited
    coredump(blocks) 0
    nofiles(descriptors) 256
    vmemory(kbytes) unlimited
    Can anyone tell me why I can't get to the RAM/memory that I know is there?
    Thanks

    soularis wrote:
    We're only asking for Xmx2048 currently and we are still being denied...I need to run in 32bit mode for my application.what are you running in 32 bits? solaris? java? or are you locked in a 32 bit zone on a 64bit server? I'm not even sure
    SPARC is supported in 32 bit mode anymore (for solaris, anyway).
    example:
    java -Xmx2g -version
    Error occurred during initialization of VM
    Could not reserve enough space for object heap
    Could not create the Java virtual machine.
    Seems like I should be able get 2GB in 32bit Solaris 10
    Right?one would think. Though you should make sure that whatever you are using is allocated enough swap to run. It's possible that you are running in a constrained zone, so even if the machine has 64G, your zone is only allocated a small portion of that.
    Heres the 64bit attempt:
    # java -d64 -Xmx2048m -version
    java version "1.5.0_14"
    Java(TM) 2 Runtime Environment, Standard Edition (build 1.5.0_14-b03)
    Java HotSpot(TM) 64-Bit Server VM (build 1.5.0_14-b03, mixed mode)This under the same user? Odd that 64 bits starts up, but 32 bits doesn't. You also might try and upgrade to 1.5.0_18 - it might be a bug that was introduced and now fixed.

  • Crash and Java Heap Space

    Hi Everybody, since Yesterday, my Flash Builder 4 has a lot of crashes with the message "Java Heap Space". I tried changing FlashBuilder.ini file to:
    -Xms384m
    -Xmx1024m
    I changed also jvm.config in my /bin subfolder of my SDK to:
    java.args=-Xms384m -Xmx1024m -Dsun.io.useCanonCaches=false
    But nothing happened... I tried also removing and re-installing the builder with no success.
    I have Windows XP Professional 32-bit with 3GB RAM
    I have also a big .log file, if someone wants to see it, I can send it immediately...
    Thanks !!!
    Davide

    Now, afther changing the configuration parameters, Flash Builder uses 1,2 GB RAM and the whole CPU... but the project, when exported to release build, is more or less 3,5MB... What's the problem??? I tried uninstalling and installing again this morning...

  • OPP JAVA HEAP Out of memory

    hi all
    ebs:11.5.10.2
    db:9i
    AIX 5 64-bit
    we have 5 target process and 4 actual process
    all the actual process are struck and one one is active
    and log file of one process out 3 struck is (other 2 logs are same)
    [6/20/11 9:12:44 PM] [15905:RT2458306] Starting XML Publisher post-processing action.
    [6/20/11 9:12:44 PM] [15905:RT2458306]
    Template code: XXXXXXXXXXXXX
    Template app: WSH
    Language: en
    Territory: 00
    Output type: PDF
    java.lang.OutOfMemoryError
         at oracle.ias.cache.DefaultCacheLogger.flushRecords(Unknown Source)
         at oracle.ias.cache.DefaultCacheLogger.flushBuffer(Unknown Source)
         at oracle.ias.cache.DefaultCacheLogger.flush(Unknown Source)
         at oracle.ias.cache.CacheCleaner.run(Unknown Source)
    java.lang.OutOfMemoryError
         at oracle.apps.fnd.cp.opp.OPPRequestThreadManager.checkThreads(OPPRequestThreadManager.java(Compiled Code))
    java.lang.OutOfMemoryError
         at oracle.jdbc.driver.LRUStatementCache.addToImplicitCache(LRUStatementCache.java(Compiled Code))
         at oracle.jdbc.driver.OracleConnection.cacheImplicitStatement(OracleConnection.java(Inlined Compiled Code))
         at oracle.jdbc.driver.OraclePreparedStatement.privateClose(OraclePreparedStatement.java(Compiled Code))
         at oracle.jdbc.driver.OraclePreparedStatement.close(OraclePreparedStatement.java(Compiled Code))
         at oracle.jdbc.driver.OracleCallableStatement.close(OracleCallableStatement.java(Compiled Code))
         at oracle.apps.fnd.cp.opp.OPPAQMonitor.waitForMessage(OPPAQMonitor.java(Compiled Code))
         at oracle.apps.fnd.cp.opp.OPPAQMonitor.run(OPPAQMonitor.java(Compiled Code))
         at java.lang.Thread.run(Thread.java:570)
    java.lang.OutOfMemoryError
    java.lang.OutOfMemoryError
    java.lang.OutOfMemoryError
         at oracle.apps.fnd.common.Pool.createObject(Pool.java(Compiled Code))
         at oracle.apps.fnd.common.Pool.createAvailableObject(Pool.java(Compiled Code))
         at oracle.apps.fnd.common.Pool.resize(Pool.java(Compiled Code))
         at oracle.apps.fnd.common.Pool.run(Pool.java(Compiled Code))
         at java.lang.Thread.run(Thread.java:570)
    Exception: java.lang.OutOfMemoryError
    java.lang.OutOfMemoryError
         at oracle.ias.cache.group.Sender.run(Unknown Source)
    java.lang.OutOfMemoryError
         at oracle.jdbc.dbaccess.DBDataSetImpl._allocItemsAndBuffers(DBDataSetImpl.java(Compiled Code))
         at oracle.jdbc.dbaccess.DBDataSetImpl._allocDataAndItems(DBDataSetImpl.java(Inlined Compiled Code))
         at oracle.jdbc.dbaccess.DBDataSetImpl.setType(DBDataSetImpl.java(Compiled Code))
         at oracle.jdbc.dbaccess.DBDataSetImpl.setType(DBDataSetImpl.java(Compiled Code))
         at oracle.jdbc.driver.OracleCallableStatement.registerOutParameterBytes(OracleCallableStatement.java(Compiled Code))
         at oracle.jdbc.driver.OracleCallableStatement.registerOutParameter(OracleCallableStatement.java(Inlined Compiled Code))
         at oracle.jdbc.driver.OracleCallableStatement.registerOutParameter(OracleCallableStatement.java(Compiled Code))
         at oracle.apps.fnd.cp.gsm.GenCartComm.getQueueMessage(GenCartComm.java:186)
         at oracle.apps.fnd.cp.gsf.GSMStateMonitor.waitForNextEvent(GSMStateMonitor.java:95)
         at oracle.apps.fnd.cp.gsf.GSMServiceController.mainLoop(GSMServiceController.java:236)
         at oracle.apps.fnd.cp.gsf.BaseServiceController.run(BaseServiceController.java:71)
         at java.lang.Thread.run(Thread.java:570)
    [6/20/11 9:59:51 PM] [UNEXPECTED] [15905:RT2458306] java.lang.reflect.InvocationTargetException
    Caused by: java.lang.OutOfMemoryError
         at oracle.xdo.parser.v2.XPathDescendantAxis.getNodeList(XPathAxis.java(Compiled Code))
         at oracle.xdo.parser.v2.XPathStep.evaluate(XPathStep.java(Compiled Code))
         at oracle.xdo.parser.v2.PathExpr.evaluate(XSLNodeSetExpr.java(Compiled Code))
         at oracle.xdo.parser.v2.XSLForEach.processAction(XSLForEach.java(Compiled Code))
         at oracle.xdo.parser.v2.XSLNode.processChildren(XSLNode.java(Compiled Code))
         at oracle.xdo.parser.v2.XSLResultElement.processAction(XSLResultElement.java(Compiled Code))
         at oracle.xdo.parser.v2.XSLNode.processChildren(XSLNode.java(Compiled Code))
         at oracle.xdo.parser.v2.XSLTemplate.processAction(XSLTemplate.java:191)
         at oracle.xdo.parser.v2.XSLStylesheet.execute(XSLStylesheet.java:508)
         at oracle.xdo.parser.v2.XSLStylesheet.execute(XSLStylesheet.java:485)
         at oracle.xdo.parser.v2.XSLProcessor.processXSL(XSLProcessor.java:264)
         at oracle.xdo.parser.v2.XSLProcessor.processXSL(XSLProcessor.java:150)
         at oracle.xdo.parser.v2.XSLProcessor.processXSL(XSLProcessor.java:187)
         at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
         at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java(Compiled Code))
         at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java(Compiled Code))
         at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java(Compiled Code))
         at java.lang.reflect.Method.invoke(Method.java(Compiled Code))
         at oracle.apps.xdo.common.xml.XSLT10gR1.invokeProcessXSL(XSLT10gR1.java(Compiled Code))
         at oracle.apps.xdo.common.xml.XSLT10gR1.transform(XSLT10gR1.java(Compiled Code))
         at oracle.apps.xdo.common.xml.XSLT10gR1.transform(XSLT10gR1.java:233)
         at oracle.apps.xdo.common.xml.XSLTWrapper.transform(XSLTWrapper.java:177)
         at oracle.apps.xdo.template.fo.util.FOUtility.generateFO(FOUtility.java:1044)
         at oracle.apps.xdo.template.fo.util.FOUtility.generateFO(FOUtility.java:997)
         at oracle.apps.xdo.template.fo.util.FOUtility.generateFO(FOUtility.java:212)
         at oracle.apps.xdo.template.FOProcessor.createFO(FOProcessor.java:1657)
         at oracle.apps.xdo.template.FOProcessor.generate(FOProcessor.java:967)
         at oracle.apps.xdo.oa.schema.server.TemplateHelper.runProcessTemplate(TemplateHelper.java:5888)
         at oracle.apps.xdo.oa.schema.server.TemplateHelper.processTemplate(TemplateHelper.java:3438)
         at oracle.apps.xdo.oa.schema.server.TemplateHelper.processTemplate(TemplateHelper.java:3527)
         at oracle.apps.fnd.cp.opp.XMLPublisherProcessor.process(XMLPublisherProcessor.java:247)
         at oracle.apps.fnd.cp.opp.OPPRequestThread.run(OPPRequestThread.java:157)
    [6/20/11 9:59:51 PM] [15905:RT2458306] Completed post-processing actions for request 2458306.
    java.lang.OutOfMemoryError
         at java.io.ObjectOutputStream$HandleTable.growSpine(ObjectOutputStream.java(Compiled Code))
         at java.io.ObjectOutputStream$HandleTable.assign(ObjectOutputStream.java(Inlined Compiled Code))
         at java.io.ObjectOutputStream.writeOrdinaryObject(ObjectOutputStream.java(Compiled Code))
         at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java(Compiled Code))
         at java.io.ObjectOutputStream.writeArray(ObjectOutputStream.java(Compiled Code))
         at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java(Compiled Code))
         at java.io.ObjectOutputStream.defaultWriteFields(ObjectOutputStream.java(Compiled Code))
         at java.io.ObjectOutputStream.defaultWriteObject(ObjectOutputStream.java(Compiled Code))
         at java.util.Vector.writeObject(Vector.java(Inlined Compiled Code))
         at sun.reflect.GeneratedMethodAccessor1.invoke(Unknown Source)
         at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java(Compiled Code))
         at java.lang.reflect.Method.invoke(Method.java(Compiled Code))
         at java.io.ObjectStreamClass.invokeWriteObject(ObjectStreamClass.java(Compiled Code))
         at java.io.ObjectOutputStream.writeSerialData(ObjectOutputStream.java(Compiled Code))
         at java.io.ObjectOutputStream.writeOrdinaryObject(ObjectOutputStream.java(Compiled Code))
         at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java(Compiled Code))
         at java.io.ObjectOutputStream.defaultWriteFields(ObjectOutputStream.java(Inlined Compiled Code))
         at java.io.ObjectOutputStream.writeSerialData(ObjectOutputStream.java(Compiled Code))
         at java.io.ObjectOutputStream.writeOrdinaryObject(ObjectOutputStream.java(Compiled Code))
         at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java(Compiled Code))
         at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java(Compiled Code))
         at oracle.ias.cache.group.StreamHandler.write(Unknown Source)
         at oracle.ias.cache.group.EndPoint.write(Unknown Source)
         at oracle.ias.cache.group.Transport.syncMulticast(Unknown Source)
         at oracle.ias.cache.group.Transport.multicast(Unknown Source)
         at oracle.ias.cache.group.Transport.multicast(Unknown Source)
         at oracle.ias.cache.group.Monitor.ping(Unknown Source)
         at oracle.ias.cache.group.Monitor.run(Unknown Source)
    DG318: Heap dump file written to /prod/oracle/prodcomn/admin/log/PROD_xxxxxx/heapdump1511652.1308591323.phd
    JVMDG303: JVM Requesting Java core file
    JVMDG304: Java core file written to /prod/oracle/prodcomn/admin/log/PROD_xxxxxx/javacore1511652.1308591369.txt
    JVMDG274: Dump Handler has Processed OutOfMemory.
    JVMST109: Insufficient space in Javaheap to satisfy allocation request
    JVMDG217: Dump Handler is Processing OutOfMemory - Please Wait.
    JVMDG315: JVM Requesting Heap dump file
    ...........................................JVMDG318: Heap dump file written to /prod/oracle/prodcomn/admin/log/PROD_xxxxxx/heapdump1511652.1308591404.phd
    JVMDG303: JVM Requesting Java core file
    JVMDG304: Java core file written to /prod/oracle/prodcomn/admin/log/PROD_xxxxxx/javacore1511652.1308591451.txt
    JVMDG274: Dump Handler has Processed OutOfMemory.
    JVMST109: Insufficient space in Javaheap to satisfy allocation request
    JVMDG217: Dump Handler is Processing OutOfMemory - Please Wait.
    JVMDG315: JVM Requesting Heap dump file
    ...........................................JVMDG318: Heap dump file written to /prod/oracle/prodcomn/admin/log/PROD_xxxxxx/heapdump1511652.1308591486.phd
    JVMDG303: JVM Requesting Java core file
    JVMDG304: Java core file written to /prod/oracle/prodcomn/admin/log/PROD_xxxxxx/javacore1511652.1308591533.txt
    JVMDG274: Dump Handler has Processed OutOfMemory.
    JVMST109: Insufficient space in Javaheap to satisfy allocation request
    JVMDG217: Dump Handler is Processing OutOfMemory - Please Wait.
    JVMDG315: JVM Requesting Heap dump file
    ...........................................JVMDG318: Heap dump file written to /prod/oracle/prodcomn/admin/log/PROD_xxxxxx/heapdump1511652.1308591569.phd
    JVMDG303: JVM Requesting Java core file
    JVMDG304: Java core file written to /prod/oracle/prodcomn/admin/log/PROD_xxxxxx/javacore1511652.1308591614.txt
    JVMDG274: Dump Handler has Processed OutOfMemory.
    JVMST109: Insufficient space in Javaheap to satisfy allocation request
    JVMDG217: Dump Handler is Processing OutOfMemory - Please Wait.
    JVMDG315: JVM Requesting Heap dump file
    ...........................................JVMDG318: Heap dump file written to /prod/oracle/prodcomn/admin/log/PROD_xxxxxx/heapdump1511652.1308591652.phd
    JVMDG303: JVM Requesting Java core file
    JVMDG304: Java core file written to /prod/oracle/prodcomn/admin/log/PROD_xxxxxx/javacore1511652.1308591700.txt
    JVMDG274: Dump Handler has Processed OutOfMemory.
    JVMST109: Insufficient space in Javaheap to satisfy allocation request
    JVMDG217: Dump Handler is Processing OutOfMemory - Please Wait.
    JVMDG315: JVM Requesting Heap dump file
    ...........................................JVMDG318: Heap dump file written to /prod/oracle/prodcomn/admin/log/PROD_xxxxxx/heapdump1511652.1308591734.phd
    JVMDG303: JVM Requesting Java core file
    JVMDG304: Java core file written to /prod/oracle/prodcomn/admin/log/PROD_xxxxxx/javacore1511652.1308591780.txt
    JVMDG274: Dump Handler has Processed OutOfMemory.
    JVMST109: Insufficient space in Javaheap to satisfy allocation request
    JVMDG217: Dump Handler is Processing OutOfMemory - Please Wait.
    JVMDG315: JVM Requesting Heap dump file
    ...........................................JVMDG318: Heap dump file written to /prod/oracle/prodcomn/admin/log/PROD_xxxxxx/heapdump1511652.1308591815.phd
    JVMDG303: JVM Requesting Java core file
    JVMDG304: Java core file written to /prod/oracle/prodcomn/admin/log/PROD_xxxxxx/javacore1511652.1308591861.txt
    JVMDG274: Dump Handler has Processed OutOfMemory.
    JVMST109: Insufficient space in Javaheap to satisfy allocation request
    JVMDG217: Dump Handler is Processing OutOfMemory - Please Wait.
    JVMDG315: JVM Requesting Heap dump file
    ...........................................JVMDG318: Heap dump file written to /prod/oracle/prodcomn/admin/log/PROD_xxxxxx/heapdump1511652.1308591900.phd
    JVMDG303: JVM Requesting Java core file
    JVMDG304: Java core file written to /prod/oracle/prodcomn/admin/log/PROD_xxxxxx/javacore1511652.1308591946.txt
    JVMDG274: Dump Handler has Processed OutOfMemory.
    JVMST109: Insufficient space in Javaheap to satisfy allocation request
    JVMXE003
    JVMDG217: Dump Handler is Processing OutOfMemory - Please Wait.
    JVMDG315: JVM Requesting Heap dump file
    ...........................................JVMDG318: Heap dump file written to /prod/oracle/prodcomn/admin/log/PROD_xxxxxx/heapdump1511652.1308591981.phd
    JVMDG303: JVM Requesting Java core file
    JVMDG304: Java core file written to /prod/oracle/prodcomn/admin/log/PROD_xxxxxx/javacore1511652.1308592027.txt
    JVMDG274: Dump Handler has Processed OutOfMemory.
    JVMST109: Insufficient space in Javaheap to satisfy allocation request
    JVMDG217: Dump Handler is Processing OutOfMemory - Please Wait.
    JVMDG315: JVM Requesting Heap dump file
    ...........................................JVMDG318: Heap dump file written to /prod/oracle/prodcomn/admin/log/PROD_xxxxxx/heapdump1511652.1308592061.phd
    JVMDG303: JVM Requesting Java core file
    JVMDG304: Java core file written to /prod/oracle/prodcomn/admin/log/PROD_xxxxxx/javacore1511652.1308592109.txt
    JVMDG274: Dump Handler has Processed OutOfMemory.
    JVMST109: Insufficient space in Javaheap to satisfy allocation request
    JVMDG217: Dump Handler is Processing OutOfMemory - Please Wait.
    JVMDG315: JVM Requesting Heap dump file
    ...........................................JVMDG318: Heap dump file written to /prod/oracle/prodcomn/admin/log/PROD_xxxxxx/heapdump1511652.1308592143.phd
    JVMDG303: JVM Requesting Java core file
    JVMDG304: Java core file written to /prod/oracle/prodcomn/admin/log/PROD_xxxxxx/javacore1511652.1308592189.txt
    JVMDG274: Dump Handler has Processed OutOfMemory.
    JVMST109: Insufficient space in Javaheap to satisfy allocation request
    JVMDG217: Dump Handler is Processing OutOfMemory - Please Wait.
    JVMDG315: JVM Requesting Heap dump file
    ...........................................JVMDG318: Heap dump file written to /prod/oracle/prodcomn/admin/log/PROD_xxxxxx/heapdump1511652.1308592224.phd
    JVMDG303: JVM Requesting Java core file
    JVMDG304: Java core file written to /prod/oracle/prodcomn/admin/log/PROD_xxxxxx/javacore1511652.1308592270.txt
    JVMDG274: Dump Handler has Processed OutOfMemory.
    JVMST109: Insufficient space in Javaheap to satisfy allocation request
    JVMDG217: Dump Handler is Processing OutOfMemory - Please Wait.
    JVMDG315: JVM Requesting Heap dump file
    ...........................................JVMDG318: Heap dump file written to /prod/oracle/prodcomn/admin/log/PROD_xxxxxx/heapdump1511652.1308592305.phd
    JVMDG303: JVM Requesting Java core file
    JVMDG304: Java core file written to /prod/oracle/prodcomn/admin/log/PROD_xxxxxx/javacore1511652.1308592351.txt
    JVMDG274: Dump Handler has Processed OutOfMemory.
    JVMST109: Insufficient space in Javaheap to satisfy allocation request
    JVMDG217: Dump Handler is Processing OutOfMemory - Please Wait.
    JVMDG315: JVM Requesting Heap dump file
    ...........................................JVMDG318: Heap dump file written to /prod/oracle/prodcomn/admin/log/PROD_xxxxxx/heapdump1511652.1308592385.phd
    JVMDG303: JVM Requesting Java core file
    JVMDG304: Java core file written to /prod/oracle/prodcomn/admin/log/PROD_xxxxxx/javacore1511652.1308592433.txt
    JVMDG274: Dump Handler has Processed OutOfMemory.
    JVMST109: Insufficient space in Javaheap to satisfy allocation request
    JVMDG217: Dump Handler is Processing OutOfMemory - Please Wait.
    JVMDG315: JVM Requesting Heap dump file
    ...........................................JVMDG318: Heap dump file written to /prod/oracle/prodcomn/admin/log/PROD_xxxxxx/heapdump1511652.1308592467.phd
    JVMDG303: JVM Requesting Java core file
    JVMDG304: Java core file written to /prod/oracle/prodcomn/admin/log/PROD_xxxxxx/javacore1511652.1308592513.txt
    JVMDG274: Dump Handler has Processed OutOfMemory.
    JVMST109: Insufficient space in Javaheap to satisfy allocation request
    JVMDG217: Dump Handler is Processing OutOfMemory - Please Wait.
    JVMDG315: JVM Requesting Heap dump file
    ...........................................JVMDG318: Heap dump file written to /prod/oracle/prodcomn/admin/log/PROD_xxxxxx/heapdump1511652.1308592547.phd
    JVMDG303: JVM Requesting Java core file
    JVMDG304: Java core file written to /prod/oracle/prodcomn/admin/log/PROD_xxxxxx/javacore1511652.1308592593.txt
    JVMDG274: Dump Handler has Processed OutOfMemory.
    JVMST109: Insufficient space in Javaheap to satisfy allocation request
    JVMDG217: Dump Handler is Processing OutOfMemory - Please Wait.
    JVMDG315: JVM Requesting Heap dump file
    ...........................................JVMDG318: Heap dump file written to /prod/oracle/prodcomn/admin/log/PROD_xxxxxx/heapdump1511652.1308592628.phd
    JVMDG303: JVM Requesting Java core file
    JVMDG304: Java core file written to /prod/oracle/prodcomn/admin/log/PROD_xxxxxx/javacore1511652.1308592674.txt
    JVMDG274: Dump Handler has Processed OutOfMemory.
    JVMST109: Insufficient space in Javaheap to satisfy allocation request
    JVMDG217: Dump Handler is Processing OutOfMemory - Please Wait.
    JVMDG315: JVM Requesting Heap dump file
    ...........................................JVMDG318: Heap dump file written to /prod/oracle/prodcomn/admin/log/PROD_xxxxxx/heapdump1511652.1308592708.phd
    JVMDG303: JVM Requesting Java core file
    JVMDG304: Java core file written to /prod/oracle/prodcomn/admin/log/PROD_xxxxx/javacore1511652.1308592755.txt
    JVMDG274: Dump Handler has Processed OutOfMemory.
    JVMST109: Insufficient space in Javaheap to satisfy allocation request
    JVMXE003
    JVMST109: Insufficient space in Javaheap to satisfy allocation request
    how to get through this error?
    Thankz
    ApPsMaSti

    Please see these MOS docs.
    XML Publisher Report Issues [ID 862644.1]
    Output Post Processor (OPP) Log Contains Error "java.lang.OutOfMemoryError: Java heap space" Error [ID 1268217.1]
    Output Post Processor (OPP) Log Contains Error "java.lang.OutOfMemoryError" [ID 1266368.1]
    OPP Service Log for the 'Create Accounting' process shows 'java.lang.OutOfMemoryError: Java heap space ' Error [ID 1129283.1]
    Retro-Notifications Report (Enhanced) - PDF Errors With 'java.lang.OutOfMemoryError' [ID 557898.1]
    Costing Summary Rep Errors with Jvmst109: Insufficient Space In Javaheap [ID 391131.1]
    Thanks,
    Hussein

  • Pages failing with Java Heap errors

    We are running CF 8,0,0,176276 on a Windows 32 bit 2003
    server, with IIS 6 and Java Runtime version 6 ( it's really version
    1.06).
    We started getting the java heap error messages two weeks
    ago. Now we are also getting the 'GC overhead limit exceeded'
    error, which is concerned with the Java garbage collection. I tried
    to change the JVM heap size from 1GB to 2GB, but CF wouldn't start
    up. I've since found out that Windows 32bit servers can't use 2GB
    for Java.
    One java article I found said to turn off the Java garbage
    collection using -XX:-UseGCOverheadLimit (
    http://forums.java.net/jive/message.jspa?messageID=228596).
    It seems like turning off the garbage collection would be the
    opposite of what I am trying to do. Are there any thoughts about
    this?
    Are there any hotfixes for CF8? and where are they located?
    Scott

    Scott, the error is a symptom, not the cause of your
    problems. Turning off that option won't "solve" the problem, which
    is that you're running out of memory. More on that option in a
    moment.
    Let's talk first about your observation of trying to change
    the max memory from 1 to 2 gig. Since you're on Windows (32 bit),
    as you say, you can't use more than 2g per process (it's not really
    a Java limit, but rather a Windows one).
    But as you found, you can't set CF to 2g because the JVM
    won't start. Again, this is not a CF-specific issue. You can see
    discussions of the same problem with plain old Java apps, as at
    http://forums.java.net/jive/message.jspa?messageID=228596.
    So, similar to what they say, the consensus seems to be that
    you can set it to somewhere between1.3 and 1.7 gb, before the JVM
    won't start. You have to try different values for yourself.
    Now, that extra few hundred meg may be all you need to get
    past your problem, but really that's often just forestalling the
    inevitable. You need to find why CF is using so much memory. You
    say you're using CF8 but don't say if it's Enterprise or Standard.
    If the former, then you have the CF8 Server Monitor (accessible in
    the CF Admin, and discussed in a multipart series I wrote for the
    Adobe Dev Center, as discussed at
    http://carehart.org/blog/client/index.cfm/2008/7/30/45page_server_monitor_guide).
    That, as well as tools like FusionReactor and SeeFusion, can help
    you to better see how CF is using memory.
    All three offer a graphical interface to show how memory use
    is trending. You may see if it grows steadily throughout the day,
    or grows in spikes. People tend to say "I have a memory leak", when
    in fact it may be just that they have either a few requests that
    use too much memory (so you'll see a stair stepping rise in memory
    use concurrent with their execution), or it may be that they're
    sticking stuff into shared scopes (session, application, or server)
    and those are living well beyond the live of each request.
    The CF8 Server Monitor even has a memory tracking feature,
    but it has to be used carefully. If you enable it, you may find it
    brings your server to its knees.I'll do a blog entry soon on how to
    use it most effectively (something I learned since writing the
    articles last year).
    One thing that the monitor can tell you, without any of the
    "start" buttons enabled at the top of the monitor, is how many
    sessions you have. That may be very enlightening. You may have
    thousands of them, and not realize it, because of bots, spiders,
    and other crap requests. See the "active sessions" page of the
    Server Monitor, and its graph icon in particular (discussed in more
    detail in one of my articles).
    Sadly, neither FusionReactor nor SeeFusion can tell you how
    many sessions are currently running, so if you're on CF8 Standard
    (or if others reading this are on 6 or 7, where they can use FR or
    SF), you can't easily see how many sessions there are. (There are
    undocumented, unsupported methods, such as discussed at
    http://rewindlife.com/2003/09/08/undocumented-application-scope-functions/.
    Just be aware some techniques work differently depending on whether
    J2EE sessions are enabled in th CF admin.)
    Finally, about your observation of the usegcoverheadlimit
    option, and the recommendation to turn it off: the article you
    point to doesn't say doing so would disable GC. I'm curious how you
    may have concluded that.But digging into things more, I see that
    disabling it (using the - before it) will turn off a feature
    (introduced in 6) which limits the proportion of the VM's time that
    is spent in GC before an OutOfMemory error is thrown. That's the
    error you're seeing, that the JVM has detected too much time is
    being spent in doing GC.
    So turning off the option doesn't "turn off the Java garbage
    collection". It just changes whether an OOM error will be thrown
    even before being really out of memory, simply because too much
    time is being spent in GC.
    And even then, how this option works (if enabled, which it is
    by default) changes depending on whether you're using a parrallel
    or concurrent collector (as discussed in two places in
    http://java.sun.com/javase/technologies/hotspot/gc/gc_tuning_6.html,
    if you search for that switch).
    Hope some of that helps.

Maybe you are looking for