JVM Sun vs. IBM

HI,
Unfortunatly we have an environment where the app-server (WLS 7.0) is
running on a AIX IBM box with IBM's JVM and the (fat-)clients are on NT
having their Sun JVM. Both JVM work quite well except some incompatibilties
e.g. the different implemented BigDecimal class (whitch can be serialized
betwean NT and AIX but the opsite way round it doesn't work).
As somebody a solution to this, Changeing the JVM on our NT boxes is not an
option.
Regards
Tomy

Maybe have a look at the System properties for instance "java.vendor"...

Similar Messages

Identifying JVM - Sun or IBM

I am using some third party tool that expects to set a system property depending on the JVM. How can we identify the JVM in which the program is executing?

Maybe have a look at the System properties for instance "java.vendor"...

CAB in JVM Sun

Hi,
Is it possible to run a CAB applet in JVM Sun? How can I do this?
Thanks

And a little more info: Sadly, I'm stuck working on a project which is required to support the MS JVM, and so I've got some very recent info and insight on this issue.
1) The MS JVM is Java version 1.1.4. Therefore it's very very old. Plus full of bugs and such.
2) Code signing for signed applets done the way for the plugin (Sun's JVM) will not work on the MS JVM. It's a totally separate incompatible process for that.
3) The MS JVM was slated for retirement in Sept. 2004. That has been pushed back now to Dec 2007. That doesnt' mean it will stop working then. You cannot get the MS JVM to install on a machine anymore. Any Windows OS older then XP service pack 1a still has it, and any Windows OS XP SP1a or newer that was upgraded from a lower version still has it. But a new install from a Widnows XP SP1a or higher will NOT have it. So buy a new PC today and you shouldn't get it, and you can't get it separately.
It is probably never going to be removed from systems that have it, although MS might end up providing a removal tool. I dont' know if they do, but I don't think you can easily remove it.
All in all, if you have a choice, choose the Java plugin. Also remember that most Macs still run Java 1.4 and the JVM comes from Apple with the OS. The newest version, 10.4, has 1.5 now, but I've heard there's issues.

JVM Experts - Challenging IBM JVM segfault

We have a 100% java web application (running on Tomcat 5) that is occasionally causing a JVM core dump on a single machine. (Redhat Linux
ES3)
SIGSEGV received in ?? at 0xffffffff in ??. Processing terminated.Full core dump is here:
http://office.bensoft.com/ibmjvm/javacore.20060519.122632.20212.txt
This is a baffling problem that only occurs on a single machine (1 out of 7). Due to client 'policies' I am not privy to the hardware, but I do know it's a dual Xeon with hyperthreading enabled (appears as 4
processors)
We cannot reliably replicate the problem. IT recommends that we 'code around' the issue in the application, however, I am convinced this has nothing to do with the application which has never exhibited a segfault on 6 other machines, some under much heavier load.
The problem has never occured on an identical software stack. Running on a Compaq - single CPU Celeron (Coppermine) box.
IT is very inflexible and insists on using only RHES3 binaries. They are unwilling to bend the rules (at least for us). In other words, we cannot upgrade to the latest IBM JVM release, we cannot use a Sun JVM, and we cannot use a different JVM that is not distributed through a RedHat ES3 channel.
The ultimate goal would be to identify the problem and get Redhat to update the kernel, lib, or JVM which would be downloaded via RHN.
Application stats:
- 100% java web app (no JNI, no system calls)
- Using JasperReports for PDF, JFreeChart for GANTT charts
- Running on Tomcat 5 (RHES3 tomcat5-5.0.28-2jpp_5rh)
- DB is MySQL 4.0.13 (only part that is not RHES3, don't ask :)
Here is the part of the core dump that is really interesting:
1HPTHDDETAILS Current Thread Details
NULL           ----------------------
NULL
3HPREGISTERS    Register Values
NULL            ---------------
3HPREGVALUES     EAX : 00000000, EBX : B2B89EEC, ECX : B1467270
3HPREGVALUES     EDX : B42A5EE8, ESI : B44E9520, EDI : B2B89AC0
3HPREGVALUES     EBP : B35DEB48, ESP : B2B89BA0, EIP : FFFFFFFF
3HPREGVALUES     EFLAGS : 00010292
NULL
3HPNATIVESTACK Native Stack of "http-(ip)-8080-Processor3" PID 1802
NULL            -------------------------
3HPSTACKLINE     FFFFFFFF
3HPSTACKLINE     0
3HPSTACKLINE     0In each case:
- EIP is always FFFFFFFF
- EAX is always 00000000
- the value FFFFFFFF(eip) is always at the top of the stack.
- Under cxia32142-20050609, this problem would occur and the value of
EDX was always B42A5EE8.
- After upgrading to cxia32142-20050929 (via RHN) the problem still
occurs but the value of EDX is now B42A8EE8.
- The Processor that the runaway thread is on changes every time.
I can provide objdump segments of any shared library or binary listed.
A ThinkGeek gift certificate is waiting for anyone who can conclusively solve this problem!!!
Thanks,
Dave Bennett
Bensoft Inc.

Which OS will you be installing on? It's likely that you'll be fine, since you'll be able to configure the primary JVM via update-alternatives.
This is how we configure all of ours:
Install IBM JDK into /opt/
Point installers explicitly to the IBM directory.
Keep the default JDK installed for all other functions.

Difference between Sun and IBM JSSE implementations?

Hi!
We have an applet done with Sun JDK 1.4.2-03 which has to connect a domino server in SSL mode.
During the handshake the connection breaks down.
The most surpising thing is to use IBM JDK to generate the applet, and the applet works.
So we are thinking that there are some differences between these jdk (and so jre) which makes connections available or not.
Does or did someone have the same problem, and find a solution ?
Thanks for your help.
Jerome

HI,
YAA THERE IS SOME DIFFER...B/W SUN AND JAVA. BUT MAYBE BRAND IS DIFFER I THINK THIS IS THE REASON.
IF U FINDOUT SOME REASON THEN PLS MAIL ME
REGARDS

Microsoft JVM & Sun JVM

I have the Sun JVM 1.3 and 1.4 installed on my computer.
IE is set to use the sun JVM (1.4) for the <APPLET> tag (in tool->Internet Options->Advanced).
How can I launch an applet using the Microsoft JVM ?
I have try something like:
<object classid="08B0E5C0-4FCB-11CF-AAA5-00401C608500"
width=150 height=150>
<param name=codebase value="http://www.blabla.com/here">
<param name=code value="JavaClass.class">
</object>
But my IE keep craching.
Any help ?

Well in fact I have found a solution, but I don't know if it's full proof, does somebody have any idea ?
I use:
<object classid="java:MyCode.class"
codetype="application/java"
width=my_width
height=my_height>
<param ....>
</object>

Explorer's Microsoft JVM - sun's JVM plugin

Hi All,
I have had to renew verisign's certificate of a signed applet. I have bought a sun's signer certificate to sign my applet. I have done all the work an it has worked perfectly.... with sun's jvm plugin for Internet Explorer !!! I have signed a jar file but M$ wants a signed cab...
How can I (if I can) sign the applet, using sun's jdk, to make it functionally with M$ JVM ???
It's very important (and urgent) for me because I have bought a certificate and maybe I have maked a mistake...
Thanks in advice,
David.

I might be missing something, but I use a single .pfx file certificate for signing using Microsoft's signing tool and Suns' jarsigner. There's a code sample over at http://forums.java.sun.com/thread.jsp?forum=2&thread=4210 that lets you load pkcs12 certificates into the Java keystore.
Hope this helps

How is Sun Java & IBM XML Certifications helpful

Sun Java Certifications
http://educational-world.blogspot.com/2007/06/sun-java-certifications.html
IBM � XML Certification
http://educational-world.blogspot.com/2007/10/ibm-certified-solution-developer-xml-11.html

Sun Java Certifications
http://educational-world.blogspot.com/2007/06/sun-java-certifications.html
IBM � XML Certification
http://educational-world.blogspot.com/2007/10/ibm-certified-solution-developer-xml-11.html

JNDI Tutorial Sun and IBM Directory server v5.1

Hi there guys,
I'm new with JNDI and LDAP but I trying to get the tutorial started with the IBM Directory server v5.1 but with no luck. The tutorial mentions something about root naming contexts. As far as I can find in the docs of the IBM directory server there are no root naming contexts. Am I right? Further when I added the several DN's under the suffixes and I try to restart the server, the server won't start anymore. What I did was adding the following lines as suffixes:
o=JNDITutorial
ou=Groups, o=JNDITutorial
cn=Directory Administrators, ou=Groups, o=JNDITutorial
etc..
Is there someone who had the same problems?
Or are there any suggestions for using another (free) LDAP server?
Hope someone can help.

in suffixes you can only add 'o's ..not ous, cns etc.
For that run a ldif for that o, as an admin to add a tree.
hope this helps.

Anyone had problems with BouncyCastle on AIX using IBM's JVM 1.3.0?

I'm having an issue on AIX with IBM's JVM 1.3.0; the same code and configuration has worked on other OSs and JVMs, including the IBM JVM on Linux and Win2K. The JVM is barfing with a ClassCastException before even the first line of my code is being executed. The rather cryptic (no pun intended) error message is:
Exception in thread "main" java.lang.ClassCastException: org.bouncycastle.jce.X509Principal
The only reference I've seen on this is here:
http://groups.google.com/groups?q=java.lang.ClassCastException:+org.bouncycastle.jce.X509Principal&hl=en&safe=off&rnum=1&selm=8s3l7u%249ks1%40webint.na.informix.com
Anyone else seen this? Any AIX/IBM JVM 1.3.0/BouncyCastle users out there?
TIA,
Matthew
Matthew T. Adams [[email protected]]
Software Engineer, Architecture Group
www.highwire.com

You have the same problem that I was very annoyed.
Remove your IBMJCEfw.jar from %JAVA_HOME%/jre/lib/ext directory.
Anyway , I believe this message and exception is not appropriate ,
or at least unkind one.
I hope the ClassCastException will be handled and another message
and Exception thrown such as "UnverifiedProviderException" in
future release of JCE.
# I'll submit a bug-report later.
UKAI Hiroshi

Suggestions requested on how to understand the JVM

Hi
I would like to understand the fundamentals of the internals of the Java language and I have made a guess that the JVM is probably a good place to do that. I would like to know how to proceed. I would like to be able to write code for the JVM, understand classloaders, garbage collection, etc.
thanks
ilango

Refer Sun's JVM specification. To understand either Sun or IBM's java garbage collection...simply google it.

Spawning too many JVMs

I'm trying to run Java on a RedHat 7.1 server...
My problem is that every time I start up a JVM, it starts a whole bunch of other JVMs that don't seem to be doing anything except sitting there and taking up memory. I've seen it spawn between 8 and 15 JVMs - so many that the rest of my system starts experienceing out-of-memory errors. I've never seen this before.... its definatly some weird behavior.
I initially came across this problem when trying to run JBoss.... but then I wrote up a 10 line test program, and that had the problem too. I've tried this with a varieto of JVMs - Sun's Java 1.4.2 and 1.5.0, and also IBM's Java 1.4.2..... same result every time. I'm pretty stumped.
Has anyone ever seen this before? Any ideas on what could be causing it?
Thanks,
Bobby

This is the same jvm. Linux is quite braindead in the way it handles threads - it kind of 'emulates' threads by having separate processes which share executable/data memory. Please note that all of them have exactly the same memory usage - strange coincidence, isn't it ?
This just means that your program has 8-15 threads, most of them spawned by jvm itself (compilation thread, gc thread, finalization thread, maybe some RMI stuff, AWT event thread, etc). You can do a stack dump to see all the threads.
As far as your real problem (memory) is concerned, it is perfectly possible that you application is using too much memory. Try using -Xmx option to limit it to a number you know - relying on default is quite dangerous, as it changes between jvm versions, processors and systems. Are you running into OOM problems only with JBoss, or also with your 10 line program ? I except that 10-line program is harmless and it is only broken way in which 'top' interacts with linux threading made you worry. JBoss on the other hand is perfectly able to use any amount of memory you allow - J2EE containers are known memory/performance hogs themselves, plus it is very easy to leak memory with incorrect http/EJB session handling, etc.

Reliable JVM crash on our internal benchmark

Hi,
I just downloaded and tried out BEA JRockit R27.3.0 JDK
1.5.0_11 under both ia64 and x64 architectures and our internal benchmark
reliably causes the JVM to crash. I also tried out R27.1 under ia64 and that crashed as well.
I tried out about a dozen different command line arguments
to try to see if I could avoid this crash, but nothing
seemed to help. Any help with resolving this would be greatly appreaciated. This benchmark
has been working
successfully on Sun and IBM JVM's for over a year. The
codebase for the benchmark is quite large >64K methods
and it is very memory intesive (it requires about 8GB
of RAM).
--Tony Brusseau
Cycorp, Inc.
The stack trace always looks similar to this:
Thread Stack Trace:
at get_ifdoffset+35()@0x2aaaab1e6b37
at dtGetVirtualMethodIndex+21()@0x2aaaab1e7771
at dtGetVirtualMethodOffset+9()@0x2aaaab1e778c
at cgGetVirtualMethodOffset+9()@0x2aaaab1ca5e8
at expand_call_dispatch_java_virtual+289()@0x2aaaab2b8bd6
at expand_call_dispatch+158()@0x2aaaab2ac344
at expand_call+190()@0x2aaaab2ac437
at cgTranslateMIROpToLIROp+281()@0x2aaaab2abb96
at cgExpandIR+190()@0x2aaaab1ca231
at cgTranslateMIR2LIR+96()@0x2aaaab2aba59
at generateMethodWithStage+25()@0x2aaaab1cc723
at cmgrGenerateMethodFromPhase+216()@0x2aaaab1cd5c4
at cmgrGenerateNormalMethod+69()@0x2aaaab1cc6e6
at cmgrGenerateCode+243()@0x2aaaab1cc5e1
at generate_code2+205()@0x2aaaab2a8099
at codegenThread+963()@0x2aaaab2a8711
at tsiCallStartFunction+67()@0x2aaaab2826af
at tsiThreadStub+308()@0x2aaaab2838a3
at ptiThreadStub+14()@0x2aaaab2e9753
at start_thread+147()@0x2aaaaabce193
-- Java stack --
===== BEGIN DUMP =============================================================
JRockit dump produced after 0 days, 00:05:43 on Mon Jul 9 19:29:12 2007
Additional information is available in:
/scratch/xxx/cyc-sys1.12439-kb0936/jrockit.13609.dump
No snapshot file (core dump) will be created because core dumps have been
disabled. To enable core dumping, try "ulimit -c unlimited"
before starting JRockit again.
If you see this dump, please open a support case with BEA and
supply as much information as you can on your system setup and
the program you were running. You can also search for solutions
to your problem at http://forums.bea.com in
the forum jrockit.developer.interest.general.
Error Message: Illegal memory access. [54]
Signal info : si_signo=11, si_code=1 si_addr=0x72b3240
Version : BEA JRockit(R) R27.3.0-106-83792-1.5.0_11-20070607-1612-linux-x86_64
GC Strategy : Mode: static, with strategy: genconcon
GC Status : OC is not running. Last finished OC was OC#0.
: YC is not running. Last finished YC was YC#8.
YC History : Ran 8 YCs since last OC.
Heap : 0x2aaaab771000 - 0x2aacab771000
Compaction : (no compaction area)
NurseryList : 0x2aaaab771000 - 0x2aab2b771000
KeepArea : 0x2aaaeb770fe8 - 0x2aab0b770fd8
NurseryMarker: [ 0x2aaaeb770fe8, 0x2aab0b770fd8 ]
CompRefs : References are uncompressed 64-bit.
CPU : Intel Pentium 4 (HT) SSE SSE2 SSE3 NetBurst EM64T
Number CPUs : 4
Tot Phys Mem : 16831234048 (16051 MB)
OS version : SUSE LINUX 10.1 (X86-64)
VERSION = 10.1
Linux version 2.6.16.13-4-smp (geeko@buildhost) (gcc version 4.1.0 (SUSE Linux)) #1 SMP Wed May 3 04:53:23 UTC 2006 (x86_64)
Thread System: NPTL
State : JVM is running (Main thread has finished)
Command Line : -Xgc:gencon -XXgcThreads:4 -Xns2048m -Xms8192m -Xmx8192m -Dsun.java.launcher=SUN_STANDARD -Xmx11000m com.cyc.tool.subl.jrtl.nativeCode.subLisp.SubLMain -i init/jrtl-release-init.lisp
java.home : /cyc/tools-noarch/java/jrockit-jdk1.5.0_11/jre
j.class.path : /cyc/java/lib/UtilConcurrent.jar:/cyc/tools-noarch/java/netbeans-5.5.1/ide7/modules/ext/junit-3.8.1.jar:/scratch/cyc/java/netbeans/project/SubL/build/classes
j.lib.path : /cyc/tools-noarch/java/jrockit-jdk1.5.0_11/jre/lib/amd64/jrockit:/cyc/tools-noarch/java/jrockit-jdk1.5.0_11/jre/lib/amd64:/cyc/tools-noarch/java/jrockit-jdk1.5.0_11/jre/../lib/amd64:/cyc/tools-noarch/java/jdk1.6.0_64bit/jre/lib/amd64/server:/cyc/tools-noarch/java/jdk1.6.0_64bit/jre/lib/amd64:/cyc/tools-noarch/java/jdk1.6.0_64bit/jre/../lib/amd64:/opt/local/lib:/usr/local/lib:/lib:/usr/lib
JAVA_HOME : /cyc/tools-noarch/java/jdk1.6.0_64bit
JAVAOPTIONS: -Xmx11000m
LD_LIBRARY_PATH: /cyc/tools-noarch/java/jrockit-jdk1.5.0_11/jre/lib/amd64/jrockit:/cyc/tools-noarch/java/jrockit-jdk1.5.0_11/jre/lib/amd64:/cyc/tools-noarch/java/jrockit-jdk1.5.0_11/jre/../lib/amd64:/cyc/tools-noarch/java/jdk1.6.0_64bit/jre/lib/amd64/server:/cyc/tools-noarch/java/jdk1.6.0_64bit/jre/lib/amd64:/cyc/tools-noarch/java/jdk1.6.0_64bit/jre/../lib/amd64:/opt/local/lib:/usr/local/lib:/lib:/usr/lib
LD_ASSUME_KERNEL: <not set>
C Heap : Good; no memory allocations have failed
Method : com/cyc/cycjava/cycl/clauses.clause_p(Lcom/cyc/tool/subl/jrtl/nativeCode/type/core/SubLObject;)Lcom/cyc/tool/subl/jrtl/nativeCode/type/core/SubLObject;
StackOverFlow: 0 StackOverFlowErrors have occured
OutOfMemory : 0 OutOfMemoryErrors have occured
Registers (from ThreadContext: 0x40088770 / OS context: 0x40088830):
rax = 0000000006acaaf0 rcx = 00000000007e8750
rdx = 00000000006acaaf rbx = 00000000002d58b0
rsp = 0000000040088c70 rbp = 0000000040088c80
rsi = 00000000002d58b0 rdi = 00000000002d4b58
r8 = 0000000040088c84 r9 = 0000000000000001
r10 = 0000000040088cc8 r11 = 0000000000000002
r12 = 00002aadb8ad0408 r13 = 00002aadb8ade9d8
r14 = 0000000010000038 r15 = 0000000040089080
cs = 0000000000000033 fs = 0000000400000000
gs = 0004000000000000
rip = 00002aaaab1e6b37 flags = 0000000000000206
Stack:
(* marks the word pointed to by the stack pointer)
0000000040088c70: 1000003840088cb0* 00002aadb8ae27a0 0000000040088c90 00002aaaab1e7771
0000000040088c90: 0000000040088ca0 00002aaaab1e778c 0000000040088cb0 00002aaaab1ca5e8
0000000040088cb0: 0000000040088d20 00002aaaab2b8bd6 0000000030000001 0000000010000038
0000000040088cd0: 0000000040088d50 00000000002d58b0 000000000056c878 0000000010000022
0000000040088cf0: 00000000002d4b58 00002aadb8ade9d8 00002aadb8ad0408 000000000056c878
0000000040088d10: 0000000040089080 00002aadb8ade9d8 0000000040088d50 00002aaaab2ac344
Code:
(* marks the word pointed to by the instruction pointer)
00002aaaab1e6ad0: 02000001b8bf83d5 eb00000000b80775 894c00000d3ce825 53034804e2c148e2
00002aaaab1e6af0: 04e2c148128b4858 c148ea894cd00148 8b4810048b4804e2 8b4cf0658b4ce85d
00002aaaab1e6b10: e5894855c3c9f86d f3894808ec834853 c1894800000cfde8 1774caff48108b48
00002aaaab1e6b30: 4804e0c148d08948* d089480575011c39 b8e975caff480aeb 08c4834800000000
00002aaaab1e6b50: 48e5894855c3c95b fffffe7ae828768b 8b4ce5894855c3c9 0000be28568b4806
00002aaaab1e6b70: 000001dc8f8b0000 048d482073ce3948 47034800000000f5 21e8077500394c68
Loaded modules:
(* denotes the module causing the exception)
0000000000400000-000000000041192b /cyc/tools-noarch/java/jrockit-jdk1.5.0_11/bin/java
00002aaaaabc8000-00002aaaaabd8570 /lib64/libpthread.so.0
00002aaaaacde000-00002aaaaad3199b /lib64/libm.so.6
00002aaaaae33000-00002aaaaae34edb /lib64/libdl.so.2
00002aaaaaf38000-00002aaaab05dfdd /lib64/libc.so.6
00002aaaaaaab000-00002aaaaaac5be7 /lib64/ld-linux-x86-64.so.2
00002aaaab169000-00002aaaab3feccf */cyc/tools-noarch/java/jrockit-jdk1.5.0_11/jre/lib/amd64/jrockit/libjvm.so
00002aaaab667000-00002aaaab66e058 /lib64/librt.so.1
00002aad732c7000-00002aad732d3647 /cyc/tools-noarch/java/jrockit-jdk1.5.0_11/jre/lib/amd64/libverify.so
00002aad733d6000-00002aad733fa493 /cyc/tools-noarch/java/jrockit-jdk1.5.0_11/jre/lib/amd64/libjava.so
00002aad73529000-00002aad7353b14b /lib64/libnsl.so.1
00002aadb368f000-00002aadb3697e3f /cyc/tools-noarch/java/jrockit-jdk1.5.0_11/jre/lib/amd64/native_threads/libhpi.so
00002aadb37bc000-00002aadb37caef3 /cyc/tools-noarch/java/jrockit-jdk1.5.0_11/jre/lib/amd64/libzip.so
00002aadb3b30000-00002aadb3b42067 /cyc/tools-noarch/java/jrockit-jdk1.5.0_11/jre/lib/amd64/libnet.so
00002aadb8130000-00002aadb813677b /cyc/tools-noarch/java/jrockit-jdk1.5.0_11/jre/lib/amd64/libnio.so
"(Code Optimization Thread 1)" id=4 idx=0x10 tid=13616 lastJavaFrame=0xfffffffffffffffc
Stack 0: start=0x40068000, end=0x4008c000, guards=0x4006d000 (ok), forbidden=0x4006b000
Thread Stack Trace:
at get_ifdoffset+35()@0x2aaaab1e6b37
at dtGetVirtualMethodIndex+21()@0x2aaaab1e7771
at dtGetVirtualMethodOffset+9()@0x2aaaab1e778c
at cgGetVirtualMethodOffset+9()@0x2aaaab1ca5e8
at expand_call_dispatch_java_virtual+289()@0x2aaaab2b8bd6
at expand_call_dispatch+158()@0x2aaaab2ac344
at expand_call+190()@0x2aaaab2ac437
at cgTranslateMIROpToLIROp+281()@0x2aaaab2abb96
at cgExpandIR+190()@0x2aaaab1ca231
at cgTranslateMIR2LIR+96()@0x2aaaab2aba59
at generateMethodWithStage+25()@0x2aaaab1cc723
at cmgrGenerateMethodFromPhase+216()@0x2aaaab1cd5c4
at cmgrGenerateNormalMethod+69()@0x2aaaab1cc6e6
at cmgrGenerateCode+243()@0x2aaaab1cc5e1
at generate_code2+205()@0x2aaaab2a8099
at codegenThread+963()@0x2aaaab2a8711
at tsiCallStartFunction+67()@0x2aaaab2826af
at tsiThreadStub+308()@0x2aaaab2838a3
at ptiThreadStub+14()@0x2aaaab2e9753
at start_thread+147()@0x2aaaaabce193
-- Java stack --
Additional information is available in:
/scratch/tbrussea/cyc-sys1.12439-kb0936/jrockit.13609.dump
No snapshot file (core dump) will be created because core dumps have been
disabled. To enable core dumping, try "ulimit -c unlimited"
before starting JRockit again.
If you see this dump, please open a support case with BEA and
supply as much information as you can on your system setup and
the program you were running. You can also search for solutions
to your problem at http://forums.bea.com in
the forum jrockit.developer.interest.general.
Extended, platform specific info:
libc release: 2.4-development
Elf headers:
libc ehdrs: EI: 7f454c46020101000000000000000000 ET: 3 EM: 62 V: 1 ENTRY: 000000000001d250 PHOFF: 0000000000000040 SHOFF: 0000000000134448 EF: 0x0 HS: 64 PS: 56 PHN; 11 SS: 64 SHN: 69 STIDX: 66
libpthread ehdrs: EI: 7f454c46020101000000000000000000 ET: 3 EM: 62 V: 1 ENTRY: 0000000000005a20 PHOFF: 0000000000000040 SHOFF: 0000000000012770 EF: 0x0 HS: 64 PS: 56 PHN; 10 SS: 64 SHN: 36 STIDX: 33
libjvm ehdrs: EI: 7f454c46020101000000000000000000 ET: 3 EM: 62 V: 1 ENTRY: 000000000003ede0 PHOFF: 0000000000000040 SHOFF: 000000000036c3c8 EF: 0x0 HS: 64 PS: 56 PHN; 3 SS: 64 SHN: 22 STIDX: 19
===== END DUMP ===============================================================
Edited by APB1 at 07/10/2007 9:54 AM

Tony,
I don't know if its related, but this can happen on SUN JVM if some class touches the final fields of CommonSymbols interface like CommonSymbols.TWO_INTEGER too early inciting a class loading that is incomplete. Maybe it is possible that JRocket is doing a pre-optimization process that makes this happen?
one thing you might try is replacing TWO_INTEGER in
com/cyc/cycjava/cycl/clauses.java
with a class static version like:
in the file "com/cyc/cycjava/cycl/clauses.java"
public static final SubLFixnum TWO_INTEGER = (SubLFixnum) SubLObjectFactory.makeInteger(2);
And see if the stack dump moves to an optimization elsewere in the tests.
Douglas Miles
[email protected]
Edited by [email protected] at 07/24/2007 1:14 AM

JVM crash when calling no-arg methods of a COM object with JACOB

When I try to call no-arg functions of a COM object with JACOM JVM crashes with the following error
# A fatal error has been detected by the Java Runtime Environment:
# EXCEPTION_ACCESS_VIOLATION (0xc0000005) at pc=0x770e47c5, pid=5424, tid=3392
# JRE version: 6.0_17-b04
# Java VM: Java HotSpot(TM) Client VM (14.3-b01 mixed mode, sharing windows-x86 )
# Problematic frame:
# C [ntdll.dll+0x347c5]
The log is at [http://paste.linux-sevenler.org/index.php?id=32319|http://paste.linux-sevenler.org/index.php?id=32319]
Thanks in advance
Serkan

This only happens with sun JDK IBM jdk works fine

Jvm-java virtual machine

Hai iam new to this forum and as well i just started to learn java iwant to know in brief about JVM
i think it may be silly question but as i am bigginer to java kindly expect reply

georgemc wrote:
faustofrancis wrote:
A Java Virtual Machine (JVM) is a set of computer software programs and data structures which use a virtual machine model for the execution of other computer programs and scripts. The model used by a JVM accepts a form of computer intermediate language commonly referred to as Java bytecode. This language conceptually represents the instruction set of a stack-oriented, capability architecture.
Java Virtual Machines operate on Java bytecode, which is normally (but not necessarily) generated from Java source code; a JVM can also be used to implement programming languages other than Java. For example, Ada source code can be compiled to Java bytecode, which may then be executed by a JVM. JVMs can also be released by other companies besides Sun (the developer of Java) -- JVMs using the "Java" trademark may be developed by other companies as long as they adhere to the JVM specification published by Sun (and related contractual obligations).
The JVM is a crucial component of the Java Platform. Because JVMs are available for many hardware and software platforms, Java can be both middleware and a platform in its own right  hence the expression "write once, run anywhere." The use of the same bytecode for all platforms allows Java to be described as "compile once, run anywhere", as opposed to "write once, compile anywhere", which describes cross-platform compiled languages. The JVM also enables such unique features as Automated Exception Handling which provides 'root-cause' debugging information for every software error (exception) independent of the source code.
The JVM is distributed along with a set of standard class libraries which implement the Java API (Application Programming Interface). The virtual machine and API have to be consistent with each other[dubious  discuss] and are therefore bundled together as the Java Runtime Environment.
Execution environment
Programs intended to run on a JVM must be compiled into a standardized portable binary format, which typically comes in the form of .class files. A program may consist of many classes in different files. For easier distribution of large programs, multiple class files may be packaged together in a .jar file (short for Java archive).
The JVM runtime executes .class or .jar files, emulating the JVM instruction set by interpreting it, or using a just-in-time compiler (JIT) such as Sun's HotSpot. JIT compiling, not interpreting, is used in most JVMs today to achieve greater speed. Ahead-of-time compilers that enable the developer to precompile class files into native code for a particular platform also exist.
Like most virtual machines, the Java Virtual Machine has a stack-based architecture.
Although the JVM was primarily aimed at running compiled Java programs, other languages can now run on top of it[1], such as:
* Ruby, with JRuby
* JavaScript, with Rhino
* Python, with Jython
* Common Lisp, with Armed Bear Common Lisp
* Groovy
* Scala
[edit] Bytecode verifier
A basic philosophy of Java is that it is inherently "safe" from the standpoint that no user program can "crash" the host machine or otherwise interfere inappropriately with other operations on the host machine, and that it is possible to protect certain functions and data structures belonging to "trusted" code from access or corruption by "untrusted" code executing within the same JVM. Furthermore, common programmer errors that often lead to data corruption or unpredictable behavior such as accessing off the end of an array or using an uninitialized pointer are not allowed to occur. Several features of Java combine to provide this safety, including the class model, the garbage-collected heap, and the verifier.
The JVM verifies all bytecode before it is executed. This verification consists primarily of three types of checks:
* Branches are always to valid locations
* Data is always initialized and references are always type-safe
* Access to "private" or "package private" data and methods is rigidly controlled.
The first two of these checks take place primarily during the "verification" step which occurs when a class is loaded and made eligible for use. The third is primarily performed dynamically, when data items or methods of a class are first accessed by another class.
The verifier permits only some bytecode sequences in valid programs, e.g. a jump (branch) instruction can only target an instruction within the same function or method. Because of this, the fact that JVM is a stack architecture does not imply a speed penalty for emulation on register-based architectures when using a JIT compiler. In the face of the code-verified JVM architecture, it makes no difference to a JIT compiler whether it gets named imaginary registers or imaginary stack positions that need to be allocated to the target architecture's registers. In fact, code verification makes the JVM different from a classic stack architecture whose efficient emulation with a JIT compiler is more complicated and typically carried out by a slower interpreter.
Code verification also ensures that arbitrary bit patterns cannot get used as an address. Memory protection is achieved without the need for a MMU. Thus, JVM is an efficient way of getting memory protection on simple architectures that lack an MMU. This is analogous to managed code in Microsoft's .NET CLR, and conceptually similar to capability architectures such as the Plessey 250, and IBM System/38.
[edit] Bytecode instructions
Main article: Java bytecode
The JVM has instructions for the following groups of tasks:
* Load and store
* Arithmetic
* Type conversion
* Object creation and manipulation
* Operand stack management (push / pop)
* Control transfer (branching)
* Method invocation and return
* Throwing exceptions
* Monitor-based concurrency
The aim is binary compatibility. Each particular host operating system needs its own implementation of the JVM and runtime. These JVMs interpret the byte code semantically the same way, but the actual implementation may be different. More complicated than just the emulation of bytecode is compatible and efficient implementation of the Java core API which has to be mapped to each host operating system.
[edit] Secure execution of remote code
A virtual machine architecture allows very fine-grained control over the actions that code within the machine is permitted to take. This is designed to allow safe execution of untrusted code from remote sources, a model used by Java applets. Applets run within a VM incorporated into a user's browser, executing code downloaded from a remote HTTP server. The remote code runs in a restricted "sandbox", which is designed to protect the user from misbehaving or malicious code. Publishers can purchase a certificate with which to digitally sign applets as "safe", giving them permission to ask the user to break out of the sandbox and access the local file system and network...
[edit] C to bytecode compilers
From the point of view of a compiler Java bytecode is just another processor with an instruction set for which code can be generated. The JVM was originally designed to execute programs written in the Java language. However, the JVM provides an execution environment in the form of a bytecode instruction set and a runtime system that is general enough that it can be used as the target for compilers of other languages.
Because of its close association with Java the JVM performs the runtime checks mandated by the Java specification. This can make it technically difficult to translate C code (which is much more lax with regard to runtime checking) to the JVM and expect it to run without issuing any warnings.
Compilers targeting many different languages, including Ada and COBOL, have been written.
[edit] Licensing
Starting with J2SE 5.0, changes to the JVM specification have been developed under the Java Community Process as JSR 924[2]. As of 2006, changes to specification to support changes proposed to the class file format (JSR 202[3]) are being done as a maintenance release of JSR 924. The specification for the JVM is published in book form,[4] known as "blue book". The preface states:
We intend that this specification should sufficiently document the Java Virtual Machine to make possible compatible clean-room implementations. Sun provides tests which verify the proper operation of implementations of the Java Virtual Machine.
Sun's JVM is called HotSpot. Clean-room Java implementations include Kaffe and IBM J9. Sun retains control over the Java trademark, which it uses to certify implementation suites as fully compatible with Sun's specification.
[edit] See also
* HotSpot, Sun's Virtual Machine
* Da Vinci Machine, a starting Sun project aiming to prototype the extension of the JVM to add support for dynamic languages.
* List of Java virtual machines
* Automated Exception Handling
* Common Language Runtime
* Parrot virtual machine
* Java bytecode
* Class (file format)
* Java performance
* List of compilers
[edit] Notes
1. ^ Tolksdorf, Robert (2005). Languages for the Java VM. Retrieved on 2008-04-23.
2. ^ JSR 924  Specifies changes to the JVM specification starting with J2SE 5.0
3. ^ JSR 202  Specifies a number of changes to the class file format
4. ^ The Java Virtual Machine Specification (the first and second editions are also available online)
[edit] References
* Clarifications and Amendments to the Java Virtual Machine Specification, Second Edition includes list of changes to be made to support J2SE 5.0 and JSR 45
* JSR 45  Specifies changes to the class file format to support source-level debugging of languages such as JSP and SQLJ that are translated to Java
[edit] External links
* The Java Virtual Machine Specification
* Java-Virtual-Machine.net - All about Java Virtual Machines!
* List of languages which compile to the Java virtual machine.
* A decade after Java arrived, there have been improvements in the runtime performance of platform-independent virtual-machine based software.
* Kaffe.org - the Kaffe project
* JamVM - The Jam Virtual Machine
* The lean, mean, virtual machine - An introduction to the basic structure and functionality of the Java Virtual Machine
* Java Glossary - installing Java useful tips for installing Java for users and developers
* Test your Java Virtual Machine
* A list of Java VM-s used in mobile devices
* More Languages for the JVM
* Sun to build virtual machine for iPhone - ComputerWorldAre you aware that Wikipedia has ripped off your post?not yet?
Let me see if the systems work!

JVM Sun vs. IBM

Similar Messages

Maybe you are looking for