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
ThomasCharles,
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
RahulHi,
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]. -
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.sysTo 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..
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 youIE9 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.
ThanksHi.
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?
-
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
-
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