These release notes support ptx® Server Environment for the JavaTM Platform (ptx/JSE) V1.1.2 on systems running DYNIX/ptx® V4.4.2 or later maintenance releases. ptx/JSE is a port of the Java Development Kit (JDKTM) 1.1.6 from Sun Microsystems® for IBM® NUMA-QTM and Symmetry® systems. Read this document before you install or run this release of ptx/JSE.
The changes in ptx/JSE V1.1.2 since ptx/JSE V1.1.1 are as follows:
ptx/JSE V1.1.2 is a port of JDK 1.1.6 and contains all changes that Sun Microsystems included with JDK 1.1.6. For information on the problems that Sun Microsystems fixed in JDK 1.1.6, refer to the following URL:
ptx/JSE V1.1.2 is year 2000 compliant. Information from Sun Microsystems about year 2000 compliance is available at the following URL:
ptx./JSE V1.1.2 is available for download from the SequentDirectTM web site. For more information, refer to "Download ptx/JSE From the Web and Install It With ptx/INSTALL" later in these release notes. Note that ptx/JSE V1.1.2 is also included on the DYNIX/ptx V4.4.5 Operating System and Layered Product Software CD-ROM.
Several problems have been fixed. Refer to "Problems Fixed in ptx/JSE V1.1.2" for more information.
The changes in ptx/JSE V1.1.1 since ptx/JSE V1.1.0 are that several problems were fixed. Refer to "Problems Fixed in ptx/JSE V1.1.1" for more information.
The features in ptx/JSE V1.1.0 are as follows:
ptx/JSE is a port of JDK 1.1.5 and consists of the entire JDK as defined by the Java 1.1 Core API with no changes or extensions beyond those required to build and run the JDK on DYNIX/ptx. That is, ptx/JSE is a straight port of the basic JDK capabilities and no performance enhancements have been made for DYNIX/ptx. Additionally, ptx/JSE does not contain a just-in-time compiler or a native compiler.
For information on the problems that Sun Microsystems fixed in JDK 1.1.5, refer to the following URL:
ptx/JSE has passed 100% of the Java Compatibility Test Kit (JCK) as provided by Sun Microsystems.
ptx/JSE uses a user-level threading package provided by Sun®. This package provides for thread scheduling and activation from within a single Java Virtual Machine (JVM). All I/O calls are non-blocking because of the multi-threaded nature of Java.
ptx/JSE contains an online man page, jse(1), that provides an overview of ptx/JSE. To view the jse man page, enter the command man jse at the UNIX® prompt.
ptx/JSE contains online HTML documentation provided by Sun Microsystems for the JDK. Information is provided about the core JDK API specification, JDK tools, and JDK features. For more information, refer to "Product Documentation" later in these release notes.
ptx/JSE V1.1.2 runs on DYNIX/ptx V4.4.2 and later maintenance releases. ptx/JSE requires ptx/WINDOWS on hosts running DYNIX/ptx V4.4.4 and earlier and requires ptx/XWM on hosts running DYNIX/ptx V4.4.5 and later. Refer to the appropriate version of the DYNIX/ptx Release Notes for the required versions of ptx/WINDOWS and ptx/XWM.
Installing ptx/JSE requires approximately 100 MB. By default, ptx/JSE is installed in the root filesystem, but it can be installed in an alternate filesystem. You should allocate 25 MB of swap space for each Java program that you run.
ptx/JSE is installed with the standard ptx/INSTALL installation process. ptx/JSE V1.1.2 is provided on the DYNIX/ptx V4.4.5 Operating System and Layered Products Software CD-ROM and is also available from the SequentDirect web site. If you are downloading ptx/JSE from the SequentDirect web site, refer to "Download ptx/JSE From the Web and Install It With ptx/INSTALL."
By default, ptx/JSE is installed in the root filesystem under /opt/jse1.1. Alternatively, you can install ptx/JSE in a different filesystem. If you do so, /opt/jse1.1 is created as a symbolic link to the actual installation directory. After installation, update the PATH environment variable so that it includes the /opt/jse1.1/bin directory.
The DYNIX/ptx V4.4.8 and Layered Products Software Installation Release Notes tell how to use ptx/INSTALL to install all software on a host running DYNIX/ptx V4.4.5. If you are installing ptx/JSE on a host running an earlier version of DYNIX/ptx, refer instead to the appropriate installation release notes.. References to ptx/JSE V1.1.0 and ptx/JSE V1.1.1 in the installation release notes also apply to ptx/JSE V1.1.2.
Complete the following steps to download ptx/JSE from the web and install it on a DYNIX/ptx host:
Download ptx/JSE from the SequentDirect web site at http://www.sequent.com/direct/software.asp
Move the downloaded file jse112.tar to the /tmp directory on the DYNIX/ptx host where you want to install ptx/JSE. The exact method you use depends on the network configuration of your site. Most likely, you can use the ftp command or Microsoft® Windows® Explorer to move the file.
Login as root:
# su root
Extract ptx/JSE from the downloaded file:
# tar -xvf jse112.tar
Use ptx/INSTALL and the ROOT installation procedures to install ptx/JSE.
Once the installation is complete, you can either remove or archive the jse112.tar file and the /tmp/jse112 directory.
ptx/JSE includes the CLASSPATH environment variable, which tells the Java Virtual Machine (JVM) and other Java applications where to find the class libraries. To use ptx/JSE you need not set this environment variable. However, if you are building Java applications whose classes reside in a directory structure other than that of ptx/JSE, you must designate the directories that contain the appropriate classes in the CLASSPATH environment variable. If more than one directory is designated, use colons to separate the entries.
The setting of the CLASSPATH environment variable specifies the directories that are to be searched before the standard ptx/JSE class directories are searched.
Java commands are typically initiated by executing Korn shell scripts installed in $JAVA_HOME/bin. The values of environment variables such as CLASSPATH, JAVA_HOME, and LD_LIBRARY_PATH influence the behavior of the Java commands.
If the ENV environment variable is set to expand to the pathname of a script such as $HOME/.profile, undesirable side effects can occur because $HOME/.profile could alter the contents of environment variables used by the Java command scripts.
Prior to executing Java commands, remove the environment variable definitions from any scripts referenced by ENV, or set ENV to the null string as follows:
export ENV=""
The following base tools are provided in ptx/JSE. Complete documentation on these tools and their options can be accessed from the HTML documentation provided with ptx/JSE. Refer to "Product Documentation" later in these release notes for more information.
AppletViewer (appletviewer)
Runs applets without a web browser. The syntax is as follows:
appletviewer [options] urls...
Java Compiler (javac)
Compiles programs written in the Java Programming Language into bytecodes. The syntax is as follows:
javac [options] filename.java...
Java Debugger (jdb)
Helps find and fix bugs in Java programs. The syntax is as follows:
jdb [options]
Java Documentation Generator (javadoc)
Generates API documentation in HTML format from Java source code. The syntax is as follows:
javadoc [options] [package] [source.java]*
Java Interpreter (java)
Executes Java bytecodes. In other words, it runs programs written in the Java Programming Language. The syntax is as follows:
java [options] classname arguments
Java Runtime Interpreter (jre)
Runs Java applications. The jre tool is similar to the java tool, but is intended primarily for end users who do not require all the development-related options available with the java tool. The syntax is as follows:
jre [options] classname arguments
C Header and Stub File Generator (javah)
Creates C header files and C stub files for a Java class. These files provide the connective glue that allow code written in the Java Programming Language to interact with code written in other languages like C. The syntax is as follows:
javah [options] classname...
Class File Disassembler (javap)
Disassembles compiled Java files and prints out a representation of the Java bytecodes. The syntax is as follows:
javap [options] class...
Additional tools provided by ptx/JSE include tools for Remote Method Invocation (RMI), internationalization, Java Archive (JAR) files, and digital signing as follows:
Java Archive Tool (jar)
Combines multiple files into a single Java Archive (JAR) file. The syntax is as follows:
jar [options] [manifest] destination input-file [input-files]
Digital Signing Tool (javakey)
Generates digital signatures for archive files and manages the database of entities and their keys and signatures. The syntax is as follows:
javakey [options]
Native-To-ASCII Converter (native2ascii)
Converts a native encoding file to an ASCII file that includes the Unicode notation. The syntax is as follows:
native2ascii [options] [input-file [output-file] ]
Java RMI Stub Converter (rmic)
Generates objects from the names of compiled Java classes that contain remote object implementations. The syntax is as follows:
rmic [options] package-qualified-class-name(s)
Java Remote Object Registry (rmiregistry)
Creates and starts a remote object registry on the specified port of the current host. The syntax is as follows:
rmiregistry [port]
Serial Version Command (serialver)
Returns the serialVersionUID for one or more classes in a form suitable for copying into an evolving class. The syntax is as follows:
serialver [options]
ptx/JSE includes the following demos from the JDK. Demos are located in the demo subdirectory in the ptx/JSE directory, typically /opt/jse1.1.
Demo Subdirectory |
Description |
Animator |
General-purpose animator |
ArcTest |
Test arc drawing and filling |
BarChart |
Simple bar-chart applet |
Blink |
Blinking, multicolored text |
CardTest |
Test card layout manager |
Clock |
Analog clock |
DitherTest |
Test image dithering |
DrawTest |
Draw points and lines |
EventModel |
AWT eventmodel demos |
Fractal |
Fractal figures |
Gauge |
Bar chart graph layout |
GraphLayout |
Graph layout by iterated relaxation |
GraphicsTest |
Test graphics operations |
ImageMap |
Live-feedback image map |
JumpingBox |
Catch the jumping box |
MoleculeViewer |
Three-dimensional chemical model viewer |
NervousText |
Nervous text |
RoundButtons |
Test mouse clicks |
SimpleGraph |
Draw a simple graph |
SortDemo |
Animated sorting algorithms |
Spinner |
Test graphics colors in a pie chart |
SpreadSheet |
Simple spreadsheet |
SymbolTest |
Test character sets |
TicTacToe |
Tic-tac-toe game |
WireFrame |
Three-dimensional wire-frame model viewer |
ptx/JSE V1.1.2 includes the JDK 1.1.5 online HTML documentation. Information is provided about the core JDK API specification, JDK tools, and JDK features. For updates to the Sun documentation beyond JDK 1.1.5, refer to the following URL, which is maintained by Sun:
http://java.sun.com/products/jdk/1.1/docchanges.html
The latest JDK 1.1 documentation provided by Sun is available at the following URL:
http://java.sun.com/products/jdk/1.1/docs/index.html
The files for the ptx/JSE HTML documents are located in the directory /opt/jse1.1/docs. You can display these HTML documents with a browser, for example, Netscape Navigator® or Mosaic. Use your browser to open the top-level file /opt/jse1.1/docs/index.html. If the browser you are using does not support Java-based applications, you will be unable to see the Java examples that are embedded in some of the HTML documents.
Note that ptx/WINDOWS (DYNIX/ptx V4.4.4 and earlier) and ptx/XWM (DYNIX/ptx V4.4.5 and later) include Mosaic in the contributed software (unsupported), but Mosaic does not support Java-based applications. For more information about contributed ptx/WINDOWS and ptx/XWM software, refer to the ptx/WINDOWS Release Notes or the ptx/XWM Release Notes as appropriate.
The JDK HTML documentation includes references to Solaris® and Microsoft Windows platforms. The Solaris platform references apply to DYNIX/ptx platforms; the Windows references do not. Also, some of these HTML documents contain hotlinks to the Sun Microsystems Java web site-these links may become invalid if Sun Microsystems changes their web site. Lastly, the HTML documentation refers to a CHANGES file. This file is not part of ptx/JSE.
Additional information about Java and the JDK, including information about previous releases of the JDK, is available from the Java Home Page at the following URL:
http://java.sun.com/index.html
This section lists the following problem report summaries:
As a supported IBM NUMA-Q customer, you should always call with questions and to report problems. If you report a problem regarding running a bytecode file and the problem can be reproduced on another platform (such as Microsoft Windows), we will forward it to Sun and track resolution of the problem with Sun. If we determine that the problem is unique to ptx/JSE, then we will determine the resolution of the problem.
H owever, because ptx/JSE is a direct port of the Sun-provided JDK, IBM NUMA-Q cannot add to or modify the behavior of the JDK, including the API set. Any enhancement request of this nature will be forwarded to Sun.
The following problems were fixed in ptx/JSE V1.1.2:
(240173) Invoking java from the installation directory caused it to core dump.
(240390) If a window in a Java application was resized and later the contents of that window's menu bar were changed (for example, a menu title was changed, enabled, or disabled), the window lost its resized dimensions and returned to its original size.
(241397) The javah -trace script created a C code file that could not be compiled.
(241747) ptx/JSE V1.1.1 only provided separate class files which required the CLASSPATH environment variable to point to the directory that contained these files. ptx/JSE V1.1.2 also provides a classes.zip file that can be referenced in the CLASSPATH environment variable.
(242031) The java script did not use fully-qualified pathnames when executing commands like basename and dirname. This situation required that the PATH environment variable for anyone executing java be set to /bin. Now java uses fully-qualified pathnames so the PATH environment variable does not need to be set to /bin for java to work.
(242220) Sometimes after resizing a window, a menu drop down list for that window was not positioned where it was expected to be.
(243266) ptx/JSE V1.1.1 is not Year 2000 compliant. ptx/JSE V1.1.2, which is based on JDK 1.1.6, is Year 2000 compliant.
(243796) ptx/JSE shared libraries did not have execute permission. Now ptx/JSE shared libraries have execute permission, which can reduce the time required for programs to begin execution when the shared library code does not need to be reloaded.
(243798) ptx/JSE did not include the Java Runtime Interpreter (jre) files under one directory. Now the full set of JRE files are included under one directory, jse/opt/jre.
(243801) When a host connection was refused, the JVM incorrectly threw a java.net.SocketException when it should have thrown a java.net.ConnectException.
(243832) Java programs written with ptx/JSE V1.1.1 could not send User Datagram Protocol (UDP) datagrams (Java class DatagramPacket). This problem was initially fixed in Fastpatch #243832, which is not required with ptx/JSE V1.1.2.
The following problems have been fixed in ptx/JSE V1.1.1:
(239502) Java client applications sometimes failed to connect to an X11 WindowTM server.
(239970) ptx/JSE did not properly map some function calls in native code that was used in Java programs to the appropriate system function.
(240012) ptx/JSE incorrectly utilized timeslicing, which resulted in a high number of system calls even when an application was in an idle state.
(240062) The read system call and write system call did not check for EINTR, which caused incomplete reads of class files when running Java across the network and resulted in the error message No Class Def Found.
(240308) The Java Virtual Machine did not properly handle a NULL return from XLoadQueryFont when the requested font was unavailable from the X emulator. This problem was seen when running the AppletViewer from the ReflectionTM X emulator on Microsoft Windows 95 or Windows NT®.
(240627) ptx/JSE generated excessive systems calls because the SIGPOLL signal was not being received.
(240714, 240970, 241048) Windows in client applications sometimes did not allow input to be entered.
(240948) The java.version property did not contain the version string 1.1, which caused some Java applications not to run. This problem was first seen on the Tengah® Java Application Server from WebLogic®.
(241626) Java appeared to crash CommandPoint Clusters with segv.
(241718) VolanoMark crashed with segv.
The following problem has been reported against ptx/JSE. For information on the problems reported to Sun Microsystems against the JDK, you can register free online as a member of the Java Developer Connection and refer to the following URL:
http://developer.javasoft.com/developer/bugParade/index.html
The jre script, which is located at /opt/jse1.1/bin/jre and /opt/jse1.1/jre/bin/jre, contains a syntax error in the last line of the file. The incorrect line is:
exec $JAVA_HOME/bin/$ARCH/$THREADS_TYPE/$PROG $@
Workaround. Add quotes around the parameter as follows:
exec $JAVA_HOME/bin/$ARCH/$THREADS_TYPE/$PROG "$@"
If you use the jre script, be sure to update both the /opt/jse1.1/bin/jre and /opt/jse1.1/jre/bin/jre files.
This sections lists common questions and answers about ptx/JSE in the following areas:
Q: Why is the Java Language Debugger (jdb) not working properly? Why does it tell me it requires a password when I'm running it locally?
The Java Language Debugger (jdb) is launched from a script, which runs the rc file for your default shell. If that rc file starts other processes or is set to echo all script commands, the jdb will think you are starting it to debug one of the processes running remotely. Check your default rc file and make sure it is not starting such processes.
Q: Why do I keep getting failures trying to access shared objects or classes that I should have visibility to?
If your shared object files or class files are accessed over an automounted filesystem, the open call may be getting a SIGALRM failure because of the time it takes the automounter to open the files. Try accessing the files from a local or non-automounted filesystem.
Q: When I set the environment variable LC_CTYPE to any value (including English), why does it sometimes trigger a segfault in some Motif calls?
This is a problem (report 238425) in ptx/WINDOWS (DYNIX/ptx V4.4.4 and earlier) and ptx/XWM (DYNIX/ptx V4.4.5 and later), which are used by ptx/JSE. The workaround is to unset the LC_CTYPE environment variable.
Q. What happens if I try to use the audio application programming interface (API)?
A message is generated when the audio implementation cannot find a sound card on the NUMA-Q or Symmetry system. Otherwise, the application or applet should run normally, except that there will be no sound. The message generated by JDK on any platform without a sound card is the following:
audio device busy (attempt 1 out of 5)
audio player exit
Q. Why does a JVM process use more than 20 MB, even for small applications?
ptx/JSE preallocates the maximum size of the memory allocation pool (the garbage collection heap) when a Java application is started. By default, the maximum size is 16 MB of memory. This results in JVM processes that use typically more than 20 MB, even for very small applications. You can reduce the overhead required for the memory allocation pool by using the -mx option to the Java Interpreter (java) command. For example, to set the maximum to 1 MB, use the syntax java -mx1m when invoking Java programs.
Q: Why does the ptx/C++ compiler return syntax errors when the jni.h file is included or JNI functions are called?
Many Java Native Interface (JNI) functions are defined with long long call arguments and return types. However, ptx/C++ currently does not support the long long data type. Code that includes the jni.h file and code calling JNI functions must be compiled using a compiler that supports the long long data type. Until a version of ptx/C++ supporting long long data types becomes available, ptx/C++ code can interface with JNI functions using ptx/C code as follows:
Implement at least the initial portion of your native methods in a file including jni.h compiled with ptx/C. The initial portion of your native method implementation can make calls to ptx/C++ functions.
Implement your JNI function calls in ptx/C code.
Q: Why are system calls from Java native methods problematic when more than one thread simultaneously calls the same function?
DYNIX/ptx V4.4.x does not contain thread-safe system libraries. For this reason, system calls from Java native methods can be problematic when more than one thread simultaneously calls the same thread-unsafe function. Until a version of DYNIX/ptx that contains thread-safe system libraries is available, you can improve the situation in one of two ways: Either avoid concurrent execution of native methods from multiple threads, or provide a mutual exclusion mechanism to prevent simultaneous calls.
Q: Why am I getting connect errors when I try to use sockets in a native method?
If you write native methods that make calls on sockets or call methods in a Java API that uses sockets, those native methods must be compiled to use BSD sockets and not ABI sockets. This is because the Java Virtual Machine (JVM) is compiled with BSD sockets.
Q: Are there any other problems that I might encounter when writing native methods?
It is possible to get different results from mathematical expressions in a native method than in the Java Virtual Machine (JVM) when dealing with divide-by-zero, remainder-by-zero, square root of negative numbers, rollover from INT_MAX and INT_MIN, not-a-number, infinity, or negative zero. This is because the JVM has explicitly-defined behavior under these "edge conditions" which may differ from some C compiler implementations.
Q: Why are my Java-based GUIs displayed improperly?
The Java Abstract Windows Toolkit (AWT) on UNIX platforms is built on top of Motif® and X Windows. For this reason, you may need to experiment with the settings in the X Windows resource files (.Xdefaults file and .xsession file) to get the desired GUI display. For example, in some cases, the setting of the borderWidth resource has been seen to affect the display of Java GUIs. Appearance problems that you see in Java GUIs, for example, a GUI element not appearing in the desired location, are generally X Windows issues. On the other hand, functionality problems, for example, data cannot be entered into a GUI element, are usually Java issues, and not X Windows related.
If you are using Exceed®, make sure you are running one of the most current versions, which is at least Exceed V5.1.3 or later. Earlier versions of Exceed that were using multiple-window mode have been seen to improperly display Java GUIs.
Q: Why is the color red not displayed and the green and blue colors reversed when GUI objects are built with the Abstract Window Toolkit (AWT)?
Check the color display settings on your user interface device. If you are using 16-bit color, using either 256 colors or 24-bit color settings instead should clear up the problem.
Q: Why do my Java-based applications hang when run on an X terminal?
The JDK code from Sun Microsystems does not support the use of some X terminals. For this reason, ptx/JSE does not support X terminals.