Problem in invoking 32 bit JVM by using -d32 option

Hi all,
I am facing the following error message on solaris 10, when i use -d32 option in java command.
execv(): No such file or directory
Error trying to exec /usr/j2se/bin/sparcv9/java.
Check if file exists and permissions are set correctly.
Failed to start a 64-bit JVM process from a 32-bit JVM.
Verify all necessary J2SE components have been installed.
(Solaris SPARC 64-bit components must be installed after 32-bit components.)
I am not able to figure out why this error is coming.
cheers,
ngs

Hi Sush,
I tried executing by giving full path of java. It gave same error. I have one more question. I have compiled the code using 64 bit JVM. Can i run that class code by using -d32 option in java command ?
[ Thats exactly what i am doing. And it is giving the same error. ]
bash-3.00$ /omcsw/29.0.1.3.00/lib/3pt/jdk/jre/bin/java -d32 test
execve(): No such file or directory
Error trying to exec /omcsw/29.0.1.3.00/lib/3pt/jdk/jre/bin/../java.
Check if file exists and permissions are set correctly.
Failed to start a 32-bit JVM process from a 64-bit JVM.
Verify all necessary J2SE components have been installed.
(Solaris SPARC 64-bit components must be installed after 32-bit components.)
regards,
ngs

Similar Messages

  • Connection problem while invoking remote method from client using oracle 8.1.6 server

    while using a connection object to make connection to oracle in all remote methods(in EJB)only the first remote method called from the EJB client is getting invoked and the connection stops.It gives me COMM_FAILURE while invoking the second method in oracle 8.1.6.Help me out in this aspect immediately please.

    r singh wrote:
    >
    I am getting "No Suitable Driver" exception from WebLogic 6.1 (sp1) at
    the start up of the server.
    My settings:
    - WLS 6.1 on a solaris 8 machine and Oracle 8.1.6 on a WIN2K machine.
    - I created the connection pool for oracle with the following
    parameters:
    connection name: OracleConnectionPool
    url: jdbc.oracle.thin:@myOracleServer:1521:myDBName
    driver class name: oracle.jdbc.driver.OracleDriver
    properties: user=scott
    password=tiger
    - I have also downloaded classes12.zip and nls_charset12.zip from
    Oracle.com
    and have placed under $WL_HOME/lib.
    - I have added $WL_HOME/lib/classes12.zip:$WL_HOME/lib/nls_charset12.zip
    in
    front of the $CLASSPATH in the startWeblogic.sh script. The echoed
    classpath
    from the startup script is:
    /opt/tools/bea/wlserver6.1/lib/classes12.zip:/opt/tools/bea/wlserver6.1/lib/nls_
    charset12.zip:/opt/tools/bea/wlserver6.1:/opt/tools/bea/wlserver6.1/lib/weblogic
    _sp.jar:/opt/tools/bea/wlserver6.1/lib/weblogic.jar
    - Still I get the error:
    <Jan 16, 2002 1:38:45 PM EST> <Error> <JDBC> <Cannot startup
    connection pool "Or
    acleConnectionPool" No suitable driver>
    Can somebody point me out if i am doing anything wrong here.
    Thanks.
    RamanandHi,
    Sure. Your URL should be "jdbc:oracle:thin:@myOracleServer:1521:myDBName"
    not "jdbc.oracle.thin:@myOracleServer:1521:myDBName"
    Joe

  • Java Performance: Linux vs Windows, 64 bit vs 32 bit JVM

    I am looking for information about how Java performs on Linux vs Windows and how the results are affected when a 64 bit jvm is used.
    Disk access or IO are not important, I would really like to see some benchmarks on floating point arithmetic and/or heavy memory access, assuming that on all environments enough physical memory could be addressed so the extra available memory space for 64 bit os'es/jvm's is not important.
    I have been searching on Google but didn't find any useful recent results, only some very old stuff.
    Does anybody know how the OS and the JVM affect performance? I could imagine that Java VM's are a little less optimized on Linux because of the fact that Linux has a smaller marketshare, but maybe that is not true?
    Also I could imagine that 64 bit JVMs could be faster because they could use more cpu registers, on the other hand they could slow down a little because all memory pointers are twice as long so more data should be processed?
    Any comments are greatly appreciated!

    On the Linux vs Windows theme, you would probably find out, after much browsing & research, that there is no difference in performance or that the difference is too small to be even considered.
    On the 32-bit vs 64-bit subject, here's a recent blog that you could look at:
    http://dev2dev.bea.com/blog/patel_jayesh_j/archive/2007/09/32bit_or_64bit.html
    That blog has some links to some benchmarks, but here again, the differences are unlikely to be earth-shattering.
    Not much to add here, other than the most important improvement in performance derive from how the application is designed, and in some cases, how the JVM heap itself is configured, independently on Linux vs Win or 32 vs 64 -bit considerations.
    In a case when you would really need to know, there is no general right answer to your question, and you'd have to benchmark your specific application yourself in your specific execution environment to be able to evaluate possible benefits of 64-bit vs 32-bit.
    In conclusion, I wouldn't waste much time on all this, and you probably have better things to do yourself.

  • Error: Java HotSpot(TM) 64-Bit Server VM warning: JVM cannot use large page

    Hi,
    i recently came across Error Message (coming up in webadmin Log view):
    ProcessMonitor: Java HotSpot(TM) 64-Bit Server VM warning: JVM cannot use large page memory because it does not have enough privilege to lock pages in memory
    when running Oracle NoSQL on Windows 7 64bit Home Premium system, having 8GB of physical RAM.
    I created the store configuration without explicitly passing a value for parameter memory_mb (was set to -memory_mb 0), so that replication group would take as much
    memory as possible, which found it's reflection in following line from store log:
    Creating rg1-rn1 on sn1 haPort=tangel-lapp:5.011 helpers=tangel-lapp:5011 mountpoint=null heapMB=7.007 cacheSize=5.143.454.023 -XX:ParallelGCThreads=4
    I was a bit surprised because of the fact that i definetly succeeded in running kvstore in this configuration, leading to store using 7007MB of memory.
    It was only possible to run kvstore when creating store configuration with memory configured to be less than 2GB.
    After searching google with error message mentioned above i came across some hints regarding activation of Huge Pages on Windows 7, which mentioned that it could be
    done on systems having at least Windows 7 Professional Edition.
    But finally i found a more helpful hint, referring to size of windows pagefile. As my machine uses an SSD as system disk and there some notes on deactivating pagefile when
    using an SSD, i did so some time ago.
    So i activated the pagefile on windows again and after doing so, the store came up without any problems.
    Maybe it's nothing new to some of you guys, but as there was nothing to be read about this fact in neither admin nor getting started guide, i just wanted to share this
    piece of information with you.
    Regards
    Thomas

    Charles,
    thanks for clarification, obviously i've overseen that in chapter "Installation prerequisites" of
    Admin Guide.
    By the way, are there any specific OS related settings, let's say "best practice" similar as it is
    referred to in documentation of "classic" Oracle Databases?
    Regards
    Thomas

  • Flash CS 5.5 Professional requires 32-bit JVM when publishing for iOS

    When trying to publish my file to AIR for iOS I get the following error:
    Error: This Java instance does not support a 32-bit JVM.Please install the desired version.
    I'm on Mac OS (Mavericks) and have both java 6 (which supports 32-bit) and 7 (which does not) installed. I've verified I can launch a 32-bit jvm from the terminal with "java -d32".
    Interestingly, it publishes to AIR with no problems when it's not to iOS.
    How can I get Flash to use the correct version of Java? I've tried setting JAVA_HOME to point to version 6 in /etc/profile with still no luck.
    Thanks for reading, I will really appreciate the help!!

    Ok, found the answer thanks to Christopher Caleb. Needed to upgraded CS5.5's bundled AIR from 2.6 to the current one, and it compiled with no errors. Directions are here for anyone that winds up having the same issue:
    http://www.yeahbutisitflash.com/?p=2949

  • 64 bit JVM Crash  when loading shared library

    I wrote a simple code to test loading of 64 bit shared library in linux. My JVM crashes on System.loadLibrary method.
    JAVA CODE
    import java.awt.Dimension;
    import javax.swing.JFrame;
    public class TestJNI extends JFrame{
            public native void init();
            static{
                    System.loadLibrary("testJNI");
            public static void main(String ...args){
                    TestJNI test = new TestJNI();
                    test.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
                    test.setSize(new Dimension(500,500));
                    test.setVisible(true);
                    System.out.println("Before init");
                    //test.init();
                    System.out.println("After init");
    } Header file created using javah
    /* DO NOT EDIT THIS FILE - it is machine generated */
    #include <jni.h>
    /* Header for class TestJNI */
    #ifndef _Included_TestJNI
    #define _Included_TestJNI
    #ifdef __cplusplus
    extern "C" {
    #endif
    #undef TestJNI_FOCUS_TRAVERSABLE_UNKNOWN
    #define TestJNI_FOCUS_TRAVERSABLE_UNKNOWN 0L
    #undef TestJNI_FOCUS_TRAVERSABLE_DEFAULT
    #define TestJNI_FOCUS_TRAVERSABLE_DEFAULT 1L
    #undef TestJNI_FOCUS_TRAVERSABLE_SET
    #define TestJNI_FOCUS_TRAVERSABLE_SET 2L
    #undef TestJNI_TOP_ALIGNMENT
    #define TestJNI_TOP_ALIGNMENT 0.0f
    #undef TestJNI_CENTER_ALIGNMENT
    #define TestJNI_CENTER_ALIGNMENT 0.5f
    #undef TestJNI_BOTTOM_ALIGNMENT
    #define TestJNI_BOTTOM_ALIGNMENT 1.0f
    #undef TestJNI_LEFT_ALIGNMENT
    #define TestJNI_LEFT_ALIGNMENT 0.0f
    #undef TestJNI_RIGHT_ALIGNMENT
    #define TestJNI_RIGHT_ALIGNMENT 1.0f
    #undef TestJNI_serialVersionUID
    #define TestJNI_serialVersionUID -7644114512714619750LL
    #undef TestJNI_serialVersionUID
    #define TestJNI_serialVersionUID 4613797578919906343LL
    #undef TestJNI_INCLUDE_SELF
    #define TestJNI_INCLUDE_SELF 1L
    #undef TestJNI_SEARCH_HEAVYWEIGHTS
    #define TestJNI_SEARCH_HEAVYWEIGHTS 1L
    #undef TestJNI_OPENED
    #define TestJNI_OPENED 1L
    #undef TestJNI_serialVersionUID
    #define TestJNI_serialVersionUID 4497834738069338734LL
    #undef TestJNI_DEFAULT_CURSOR
    #define TestJNI_DEFAULT_CURSOR 0L
    #undef TestJNI_CROSSHAIR_CURSOR
    #define TestJNI_CROSSHAIR_CURSOR 1L
    #undef TestJNI_TEXT_CURSOR
    #define TestJNI_TEXT_CURSOR 2L
    #undef TestJNI_WAIT_CURSOR
    #define TestJNI_WAIT_CURSOR 3L
    #undef TestJNI_SW_RESIZE_CURSOR
    #define TestJNI_SW_RESIZE_CURSOR 4L
    #undef TestJNI_SE_RESIZE_CURSOR
    #define TestJNI_SE_RESIZE_CURSOR 5L
    #undef TestJNI_NW_RESIZE_CURSOR
    #define TestJNI_NW_RESIZE_CURSOR 6L
    #undef TestJNI_NE_RESIZE_CURSOR
    #define TestJNI_NE_RESIZE_CURSOR 7L
    #undef TestJNI_N_RESIZE_CURSOR
    #define TestJNI_N_RESIZE_CURSOR 8L
    #undef TestJNI_S_RESIZE_CURSOR
    #define TestJNI_S_RESIZE_CURSOR 9L
    #undef TestJNI_W_RESIZE_CURSOR
    #define TestJNI_W_RESIZE_CURSOR 10L
    #undef TestJNI_E_RESIZE_CURSOR
    #define TestJNI_E_RESIZE_CURSOR 11L
    #undef TestJNI_HAND_CURSOR
    #define TestJNI_HAND_CURSOR 12L
    #undef TestJNI_MOVE_CURSOR
    #define TestJNI_MOVE_CURSOR 13L
    #undef TestJNI_NORMAL
    #define TestJNI_NORMAL 0L
    #undef TestJNI_ICONIFIED
    #define TestJNI_ICONIFIED 1L
    #undef TestJNI_MAXIMIZED_HORIZ
    #define TestJNI_MAXIMIZED_HORIZ 2L
    #undef TestJNI_MAXIMIZED_VERT
    #define TestJNI_MAXIMIZED_VERT 4L
    #undef TestJNI_MAXIMIZED_BOTH
    #define TestJNI_MAXIMIZED_BOTH 6L
    #undef TestJNI_serialVersionUID
    #define TestJNI_serialVersionUID 2673458971256075116LL
    #undef TestJNI_EXIT_ON_CLOSE
    #define TestJNI_EXIT_ON_CLOSE 3L
    * Class:     TestJNI
    * Method:    init
    * Signature: ()V
    JNIEXPORT void JNICALL Java_TestJNI_init
      (JNIEnv *, jobject);
    #ifdef __cplusplus
    #endif
    #endifC code TestJNI.c
    #include "TestJNI.h"
    #include <stdio.h>
    JNIEXPORT void JNICALL Java_TestJNI_init
      (JNIEnv *env, jobject ob){
      printf("TESTING JNI CALL");
    }gcc options are as follows to get the shared library:
    gcc -fPIC -pthread -g -Wall -D_REENTRANT -I/vobs/3p/jdk1.6.0_10/linux/include/linux -I/vobs/3p/jdk1.6.0_10/linux/include/ -c TestJNI.c -o TestJNI.o
    gcc -z defs -pthread -D_REENTRANT -Wl,-soname,libnative.so -shared -o libtestJNI.so TestJNI.o -lcAny help is appreciated. I am not sure what i am doing wrong here.
    Running the same code on a 32 bit jvm with a 32 bit shared library works.

    Hi,
    I was also having a problem under 64 bit, Now I am certain that if ur Java code makes a call to the DLL, make sure that DLL is compiled under 64 bit compiler and not 32 bit compiler. This is the mistake I made and the JVM was throwing unsatisfied link error. Now this DLL (compiled under 64 bit) could call a 32 bit dll, I dont think that should be a problem.
    Hope it helps.
    Subu

  • 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!

  • Loading a 32-bit native library on a 64-bit JVM environment

    Hello
    I have a 3rd party 32-bit native library (abc.so). I am creating a JVM from my 64-bit C code (myC.c). Within this JVM i try to load the 32-bit abc.so
    I get the following run-time error
    Exception in thread "main" java.lang.UnsatisfiedLinkError: abc.so: ld.so.1: myC: fatal: abc.so: wrong ELF class: ELFCLASS32
    at java.lang.ClassLoader$NativeLibrary.load(Native Method)
    at java.lang.ClassLoader.loadLibrary0(ClassLoader.java:1480)
    at java.lang.ClassLoader.loadLibrary(ClassLoader.java:1404)
    at java.lang.Runtime.loadLibrary0(Runtime.java:772)
    at java.lang.System.loadLibrary(System.java:832)
    When I try to load the same abc.so using a wrapper Java code(instead of myC.c) by running it with java -d32, it works ok.
    Do we have any option that we can set while creating a JVM from C, with which we can allow it to load 32-bit native libraries?
    Moreover do we have a list of all the options that can be set in the JavaVMInitArgs?
    I am using Java 1.4, as 1.3 doesn't support 64-bit JVM.
    regards
    Rahul

    Hi,
    I was also having a problem under 64 bit, Now I am certain that if ur Java code makes a call to the DLL, make sure that DLL is compiled under 64 bit compiler and not 32 bit compiler. This is the mistake I made and the JVM was throwing unsatisfied link error. Now this DLL (compiled under 64 bit) could call a 32 bit dll, I dont think that should be a problem.
    Hope it helps.
    Subu

  • Launching a 64 bit jvm from a 32 bit jvm

    I want to launch a 64 bit jvm from a 32 bit jvm. The current application works like this
    1) The parent jvm A allows users to launch a child jvm B. Child jvm B inherits A's libraries (LD_LIBRARY_PATH) and also A's classpath entries.
    2) User can specify his/her own libraries that are to be passed to B (child jvm). These entries are prepended to the inherited entries (A.LD_LIBRARY_PATH).
    3) User can specify his/her own classpath entries that are to be added to B. These entries are appended to the inherited entries (A.classapth).
    The whole idea behind making the child jvm configurable is that the user can specify a suitable jvm for the child. But optionally the user might specify a different java home (pointing to a 64bit jre/jdk).
    Questions :
    1) Would simply changing the java for the child suffice? That is instead of
    java -classpath=<inherited-entries:specified-entries> abc
    we do
    -user-specified-java -classpath=<inherited-entries:specified-entries> abc
    I have seen that the jvm uses the java.home from the java provided while launching the jvm. Example
    $java -version
    1.5
    $java abc
    // will use default java's home as java home internally
    $/usr/lib/java-64/jdk/bin/java -version
    1.5 64bit
    $/usr/lib/java-64/jdk/binjava abc
    // will use /usr/lib/java-64/jdk as java home internally
    2) How will the classpath entries and libraries interact/interfere with the newly spawned jvm?
    Here if the user specifies new libraries for 64 bit jvm, how will they interact/interfere with the 32bit libs.
    3) What about native(esp jni) libraries?
    Bigger picture :
    If A is running sun java jdk1.5_a (32bit) and user can specify B as
    1) sun jdk 1.x_y (32bit) such that x_y != 5_a
    2) sun jdk 64 bit
    3) any other 32 bit java implementation (ibm, jrocket ...)
    4) any other 64 bit java implementation (ibm, jrocket ...)

    jschell wrote:
    Questions :
    1) Would simply changing the java for the child suffice? That is instead of
    java -classpath=<inherited-entries:specified-entries> abc
    we do
    -user-specified-java -classpath=<inherited-entries:specified-entries> abc
    You cannot do it without creating a new process.
    ProcessBuilder/Runtime.exec() create a new process. The new process can do anything.
    You can set the environment using either.
    Yes. The process B will be spawned either using ProcessBuilder or using Runtime. The question still remains,
    Q: If I have a classpath defined already for a particular java implementation and the LD_LIBRARY path is all set, what will be effect of changing the default java.
    Example :
    If my classpath and LD_LIBRARY_PATH is set to use/work-with /usr/lib/javaA/ then
    "/usr/lib/javaA/jre/bin/java -classpath $classpath abc" will work smoothly
    But what will happen if I do classpath=$classpath:$new-javaB-classpath-entries and LD_LIBRARY_PATH=$LD_LIBRARY_PATH_FOR_B:$LD_LIBRARY_PATH and
    "/usr/lib/javaB/jre/bin/java -classpath $classpath abc"
    >
    2) How will the classpath entries and libraries interact/interfere with the newly spawned jvm?
    Here if the user specifies new libraries for 64 bit jvm, how will they interact/interfere with the 32bit libs.
    3) What about native(esp jni) libraries?
    New process = new environment.
    If there is a problem it is because of how you set it up or how they are used in the first place.I am more interested in the if. My question is can it happen and if yes whats the explanation and how to solve it.
    >
    As an example if an app needs a 64 bit library and there is only a 32 bit library then what happens depends entirely on the app that needs the 64 bit library. That question would be the same if you attempted to run the application from a console window.So here is another way of looking at it. Imagine you want to kick off a 64 bit java app from your console. Assume that you can only prepend to classpath. Also you can append to LD path. Now you have provided all that is needed for the app to run. But under the classpath constraints, what will be the behaviour?

  • Java Web Start apps defaulting to 32-bit JVM; need 64-bit

    We use Java Web Start to install our client interface application.
    When I install on a 64-bit Windows Server 2003 system, the desktop icon that is created points to C:\WINDOWS\SysWOW64\javaws.exe, which opens the client in a 32-bit JVM.
    How can I get Web Start to generate the icon with a target of C:\WINDOWS\SYSTEM32\javaws.exe so that it will start in a 64-bit JVM?
    Do we control the string that is used for the target or is it a built-in function that we cannot change? (Note: I'm not the developer, just researching the problem so I can tell the coder what, if anything, should be changed.)

    Jerry_Ford wrote:
    ..When I install on a 64-bit Windows Server 2003 system, the desktop icon that is created points to C:\WINDOWS\SysWOW64\javaws.exe, which opens the client in a 32-bit JVM.
    How can I get Web Start to generate the icon with a target of C:\WINDOWS\SYSTEM32\javaws.exe so that it will start in a 64-bit JVM?Perhaps the ExtensionInstallerService can be of use here, or particularly the [setJREInfo(String,String)|http://java.sun.com/javase/6/docs/jre/api/javaws/jnlp/javax/jnlp/ExtensionInstallerService.html#setJREInfo(java.lang.String,%20java.lang.String)] method.
    Informs the JNLP Client of the path to the executable for the JRE, if this is an installer for a JRE, and about platform-version this JRE implements. I provide a small [demo. of the EIS|http://pscode.org/jws/api.html#eis].

  • INST-07408: Unable to install or configure the product on a 32-bit JVM on a 64-bit machine. Make sure to install and configure the product in supported modes.

    Hi there, i have an issue installing oracle forms and reports. its throwing this error"INST-07408: Unable to install or configure the product on a 32-bit JVM on a 64-bit machine. Make sure to install and configure the product in supported modes." on step 5. I have jdk 64bit installed, weblogic server was installed successfully but iam getting stuck somehow.
    Below are details of my pc.
    OS Name    Microsoft Windows 7 Professional
    Version    6.1.7601 Service Pack 1 Build 7601
    Other OS Description     Not Available
    OS Manufacturer    Microsoft Corporation
    System Name   ...........-HP
    System Manufacturer    Hewlett-Packard
    System Model    HP ProBook 4530s
    System Type    x64-based PC
    Processor    Intel(R) Core(TM) i5-2450M CPU @ 2.50GHz, 2501 Mhz, 2 Core(s), 4 Logical Processor(s)
    BIOS Version/Date    Hewlett-Packard 68SRR Ver. F.23, 09/03/2012
    SMBIOS Version    2.6
    Windows Directory    C:\windows
    System Directory    C:\windows\system32
    Boot Device    \Device\HarddiskVolume1
    Locale    United Kingdom
    Hardware Abstraction Layer    Version = "6.1.7601.17514"
    User Name    ...........-HP\................
    Time Zone    South Africa Standard Time
    Installed Physical Memory (RAM)    4.00 GB
    Total Physical Memory    3.94 GB
    Available Physical Memory    1.00 GB
    Total Virtual Memory    7.87 GB
    Available Virtual Memory    1.25 GB
    Page File Space    3.94 GB
    Page File    C:\pagefile.sys

    To clarify further....  It is important to note that Forms/Repors 11.1.2.x software (including WLS and JDK) must be of the same archetecture as the machine.  In other words, you cannot use the 32bit Forms/Reports 11.1.2 software on 64bit Windows.  If you are using a 64bit OS, you must install the 64bit software.  Again, this would include Forms/Reports, WLS, and JDK

  • How to make 64-bit JVM default on Solaris 10

    Hi,
    I am running my application on Solaris 10. Currently, my application uses JRE 1.6 32-bit version. I am trying to make it work with JRE 1.6 64-bit version. I successfully installed 64-bit java using the instructions here: [http://www.java.com/en/download/help/5000011500.xml] and am able to invoke 64-bit java using either $JAVA_HOME/bin/java -d64 or by using $JAVA_HOME/bin/sparcv9/java.
    My application always invokes the java executable under *$JAVA_HOME/bin*. By default, this is invoking the java 32-bit version which I do not want. Of course, I could add the -d64 option to all calls to java in my application. However, I do not want to do that as java is being called from a number of scripts and some scripts are also being shared between multiple platforms.
    How do I make the 64-bit java the default? I tried copying over the java executable from under *$JAVA_HOME/bin/sparcv9* to *$JAVA_HOME/bin*. This seems to invokes the java 64-bit version correctly from within my application. However I do not know if this is the right thing to do or if it has adverse side effects.
    Any help/inputs will be greatly appreciated!
    Thank you so much.

    So, it may be better to create links in $APP_HOME/bin/java that point to the binaries in /usr/jdk/version-you-want-to-use/bin/sparcv9 rather than copying binaries.
    To see current java links: (I edited all non-java-related links out of listing)
    -> ls -la /usr/bin/j*
    lrwxrwxrwx 1 root other 15 Oct 1 2007 /usr/bin/jar -> ../java/bin/jar
    lrwxrwxrwx 1 root other 21 Oct 1 2007 /usr/bin/jarsigner -> ../java/bin/jarsigner
    lrwxrwxrwx 1 root other 16 Oct 29 2007 /usr/bin/java -> ../java/bin/java
    lrwxrwxrwx 1 root other 17 Oct 1 2007 /usr/bin/javac -> ../java/bin/javac
    lrwxrwxrwx 1 root other 19 Oct 1 2007 /usr/bin/javadoc -> ../java/bin/javadoc
    lrwxrwxrwx 1 root other 17 Oct 1 2007 /usr/bin/javah -> ../java/bin/javah
    lrwxrwxrwx 1 root other 17 Oct 1 2007 /usr/bin/javap -> ../java/bin/javap
    lrwxrwxrwx 1 root other 18 Oct 29 2007 /usr/bin/javaws -> ../java/bin/javaws
    lrwxrwxrwx 1 root other 24 Oct 29 2007 /usr/bin/jcontrol -> ../java/jre/bin/jcontrol
    lrwxrwxrwx 1 root other 15 Oct 1 2007 /usr/bin/jdb -> ../java/bin/jdb
    lrwxrwxrwx 1 root root 30 Oct 1 2007 /usr/bin/jmplay -> ../jdk/packages/jmf/bin/jmp
    lay
    lrwxrwxrwx 1 root root 50 Oct 1 2007 /usr/bin/jnlp2pkg -> ../jdk/packages/org.jdesk
    top.jdic-0.8/bin/jnlp2pkg
    lrwxrwxrwx 1 root root 13 Oct 1 2007 /usr/bin/jsh -> ../../sbin/sh
    BTW, on my machine (SunFire v445, Solaris10, 64-bit)
    isainfo -v produces this:
    -> isainfo -v
    64-bit sparcv9 applications
    vis2 vis
    32-bit sparc applications
    vis2 vis v8plus div32 mul32
    So, what will this do for me?
    or even better $(JAVA_HOME)/bin/`isainfo -v`/Edited by: SolarisSAinPA on Jun 12, 2008 5:38 PM
    Added listing of java-related-links

  • Im having problem setting up my Hotmail account, it used to work fine until few days ago. It says ive entered an incorrect username or password which i can sign in fine with them details if i use laptop or safari through the phone, Please help..

    Im having problem setting up my Hotmail account, it used to work fine until few days ago. It says ive entered an incorrect username or password which i can sign in fine with them details if i use laptop or safari through the phone, Please help..

    I Sugges you to log into your hotmail acc and go to security and password change bit, then you will see two-step verification.. turn that off and you will be able to set it up on your iPhone/iPad or even Mac.
    Give your phone a restart before trying to set it up. Thanks

  • Problems in IE9 32 bit browser but not 64 bit

    When I delete a message(s) in Yahoo Mail or when I go to my mortgage website and login, I get a blank page and then nothing happens.  I only get this problem in IE9 32 bit and not 64 bit.  I reset IE9 Options under the advanced tab, updated Java
    and Adobe, but the problem still persists.  I also did a viral scan using MSE and MalwareBytes and my computer is clean.  Can someone help.  Thank you

    IE9 is fairly old, upgrade you browser.

  • Solaris 10 64 bit and 64 bit JVM support for Weblogic Server 9.1

    Does the following configuration supported:
    Weblogic Server 9.1
    Sun Solaris 10 (64 bit)
    Sun JVM 5.0 (64 bit)
    I could only find reference to 32 bit JVM on bea site.
    Any help is appreciated.
    Thanks

    Hi.
    answers inline:
    sanjay wrote:
    Hi,
    Can Weblogic Express (Cluster edition)6.1J sp2 be installed on Sun Solaris(Sparc)
    8(64 bit) ?Yes - http://edocs.bea.com/wls/platforms/index.html#solaris8
    >
    >
    Can Weblogic Express (Cluster edition)6.1J sp2 JDBC driver be used for Oracle 8.1.7(Solaris
    64 bit) ?
    Yes - http://edocs.bea.com/wls/platforms/index.html#jdbc
    Michael Young
    Developer Relations Engineer
    BEA Support

Maybe you are looking for

  • Print window in version 8.1.2 can't find file to print

    Version 8.1.2, I'm trying to print a PDF from a medical website, i'm prompted to save or open the PDF file.  I choose open. The applet opens up as to print, then an error message appears, unable to find file.  But if I save the file to my desktop, th

  • I upgraded to OS X 10.9.4 and my Autocad not open.

    After updating, my AutoCad not open. What can I do?

  • When opening my computer screen to certain angle, computer goes back to sleep. Help.

    Hello. My computer started having two problems recently. 1. I feel like it overheats (fan is running) after not much use 2. I'll open the Macbook screen after it's been asleep and if I put the screen at certain angles, it'll go back to sleep.

  • ActionScript 3.0 MXI woes

    I'm having an issue creating an MXI that installs a handful of .as files into a location that Flash CS3 projects can see on their default classpath. Unfortunately, the default classpath for AS3 projects is $(AppConfig)/ActionScript 3.0/Classes but th

  • Human Task in BPEL

    Hi, I have a question on Human Task component in BPEL. How do we configure the identity store for users . I mean i did exported some users onto my local machine following the link in the documentation. But how to work on the Human Task at the client