pkgsrc/lang/jamvm/PLIST

@comment $NetBSD: PLIST,v 1.5 2009/06/14 18:03:34 joerg Exp $
bin/jamvm-java
java/jamvm/bin/jamvm
java/jamvm/include/jni.h
java/jamvm/lib/libjvm.la
java/jamvm/lib/rt.jar
java/jamvm/share/jamvm/classes.zip
Remove @dirrm entries from PLISTs 2009-06-14 20:03:28 +02:00			`@comment $NetBSD: PLIST,v 1.5 2009/06/14 18:03:34 joerg Exp $`
Add bin/jamvm-java to PLIST. Bump revision. 2006-05-21 17:43:09 +02:00			`bin/jamvm-java`
Import lang/jamvm from wip JamVM is a new Java Virtual Machine which conforms to the JVM specification version 2 (blue book). In comparison to most other VM's (free and commercial) it is extremely small, with a stripped executable on PowerPC of only ~135K, and Intel 100K. However, unlike other small VMs (e.g. KVM) it is designed to support the full specification, and includes support for object finalisation, the Java Native Interface (JNI) and the Reflection API. 2006-04-17 00:16:36 +02:00			`java/jamvm/bin/jamvm`
			`java/jamvm/include/jni.h`
Updated jamvm to 1.4.5. JamVM 1.4.5 released on 4th February 2007 ========================================= A summary of changes since 1.4.4: - Support for Java 1.5 Annotations. This includes the following methods for reflection access to Annotations: - VMClass.getDeclaredAnnotations - java.lang.reflect.Field.getDeclaredAnnotations - java.lang.reflect.Constructor - getAnnotation, getDeclaredAnnotations, getParameterAnnotations - java.lang.reflect.Method - getDefaultValue, getAnnotation, getDeclaredAnnotations, getParameterAnnotations - Class sun.misc.Unsafe implemented, providing VM support for JSR-166 (Concurrency Utilities). - Ported to the mipsel architecture. This is a full port, with hand- coded assembler to handle the construction of a call-frame for calling JNI native methods. This supports the O32 ABI (for other ABIs libffi can be used). - Bug fix in registering references external to the heap with the GC. The table should be locked for references registered after VM initialisation. - Bug fix when expanding the heap and the free-list is empty. - Fixed race-condition when rewriting OPC_NEW in the indirect-threaded interpreter (by default the direct-threaded interpreter is used). - Bug fix in the GC compaction phase. The class-loader references within the loaded DLL hashtable must be updated when the class-loader is moved during compaction. This is a regression introduced in JamVM 1.4.3 (DLL unloading), seen while running Eclipse. - Bug fix in JNI_GetStringUTFLength. The reported length should not include space for a NULL terminator. - Various compile fixes for uClibc. Support for the JNI invocation API requires glibc features not implemented in uClibc. - Command line option -fullversion implemented. JamVM 1.4.4 released on 2nd November 2006 ========================================= A summary of changes since 1.4.3: - Full JNI Invocation API implemented, enabling JamVM to be linked into another program. - JNI_CreateJavaVM, DestroyJavaVM, AttachCurrentThread, - AttachCurrentThreadAsDaemon, DetachCurrentThread - JNI_GetDefaultJavaVMInitArgs - JamVM is now also built as a shared library (lib/libjvm.so). - The executable (bin/jamvm) is statically linked with this library instead of being a wrapper. This is because the shared library runs slower than static linking on some architectures. As JamVM is small this is not a problem. - Improved class-loader and shared library support - When a class-loader (and all its classes) is unloaded all shared libraries loaded by the class-loader are unloaded and JNI_OnUnload called (if defined) - A shared library can no longer be opened by two class-loaders at once - A class can only resolve native methods defined in shared libraries opened by its defining class-loader - Major re-working of thread/locking code to support additional Java 1.5 functionality - Thread.getState() implemented - correct thread states and their transistions (e.g. BLOCKING, WAITING, TIMED_WAITING, etc.) - native support for the ThreadMXBean thread system management API - thread creation statistics (count of live, started and peak threads) - Information about a thread (ThreadInfo) - execution information (thread state, stack backtrace to a particular depth, object upon which the thread is blocked or waiting to be notified) - synchronization statistics (counts of the times the thread has been blocked or waited for notification) - Thread.interrupt() re-implemented fixing several bugs - if a thread was waiting on a monitor, previous implementation required the monitor lock to be obtained. If a 3rd thread was holding this, the interrupt could not occur to avoid deadlock. New thread-code does not require lock to be obtained. - in rare circumstances another thread waiting on the monitor could be notified (when there was pending notifications, and then an interrupt, and subsequent threads waiting on the monitor). - a thread waiting on a thin-lock (waiting for inflation) could erroneously report an InterruptedException - GC bug fix for class-unloading when only using the compactor (-Xcompactalways). The compactor in some circumstances could move objects ontop of the object holding the native class-loader VM data before it was freed leading to a SEGV. - Bug fix for abstract methods which fell through previous AbstractMethodError checks (using a stub method) - AbstractMethodError now also gives the method name - Bug fix to not allow abstract classes to be instantiated - Bug fix for NULL in identityHashCode (a regression in JamVM 1.4.3) - Bug fix for NULL in JNI method GetStringUTFLength\|Chars - Bug fix for $ in native method names - FirstNonNullClassLoader implemented - Access-checking bug fix. In reflection method/field access, also check class access in addition to method/field. - Ensure created threads have a native stack size of at least 2MB. This fixes SEGVs due to stack overflow seen on OpenBSD/Darwin (default 512KB). - Property sun.boot.class.path is now also defined in addition to java.boot.classpath. Certain applications look for the Sun property (e.g. Dacapo bloat benchmark). - Extra bootclasspath command line options - bootclasspath/v overrides the default VM classes path - bootclasspath/c overrides the default GNU Classpath classes path - java.endorsed.dirs support added - directories are scanned and any jar/zip files are added to the boot classpath. - Improved thread dump (produced via ctrl-\). Now shows thread state. - JamVM by default now installs in its own directory (/usr/local/jamvm) JamVM 1.4.3 released on 21st May 2006 ===================================== A summary of changes since 1.4.2: - Heap compaction implemented. Previously on some programs the object allocation pattern could lead to a highly fragmented heap (lots of small holes). This caused early heap expansion, and in some cases an OutOfMemory exception (a result of repeated heap expansion until heap fully expanded). JamVM now includes a mark/compact collector in addition to the mark/sweep GC. This is normally ran after forced finalisation, and before heap expansion. It removes fragmentation by sliding the objects to the bottom of the heap, closing the holes. Two new command line options can be used to control compaction : -Xnocompact : don't do compaction and just use the mark/sweep collector. This is equivalent to JamVM 1.4.2 behaviour. -Xcompactalways : do compaction on every garbage-collection. In some cases this may lead to less collections, but the compactor is slower than the sweeper. - The interned String table is now garbage-collected (JamVM uses its own interned String hashtable). - Additional Java 1.5 support - New methods within VMClass implemented - isMemberClass, isLocalClass, isAnonymousClass, getEnclosingClass, getEnclosingMethod, getEnclosingConstructor, getClassSignature. - Generic signature support in reflection classes (Constructor, Method Field). - getTypeParameters, getSignature, getGenericExceptionTypes, getGenericParameterTypes, toGenericString, getGenericType, getGenericReturnType - Uncaught exceptions will now use the thread's uncaughtExceptionHandler (if available). - Fix for Non-ASCII characters in class name parameter - affected methods Class.ForName, ClassLoader.defineClass - Use getcwd() instead of PWD enviroment variable for user.dir property. This fixes problems seen on some applications. - Fix in VMClass.defineClass on 64-bit machines (protection domain parameter assumed to be 4 bytes). - Minor interpreter optimisation in direct-mode with handler prefetch (reload of handler address in aload_0/getfield pair). - Command line options -version and -showversion now prints a "Java compatible" version number. This is to work with shell scripts which parse the output to get the Java version. - Set the java.home property to the JAVA_HOME environment variable if set. - Ported to Mac OS X on Intel. - Runtime.availableProcessors implemented (Linux, Mac OS X and BSD systems). - Updated to be compatible with Classpath 0.91. - Merged in changes to GNU Classpath's VM reference classes and JamVM's classes. - Various compiler warnings. 2007-06-05 16:08:43 +02:00			`java/jamvm/lib/libjvm.la`
Update to 1.5.1 and make it build on amd64. Add destdir support. JamVM 1.5.1 released on 10th March 2008 ======================================= A summary of changes since 1.5.0: - Implemented a new internal VM symbol framework. This ensures that all class, method, field names, etc. are unique thus removing the need to use strcmp for comparison. - Implemented a new internal VM exception mechanism for frequent exceptions thrown within the VM. - Hand-coded support for AMD64 ABI. Previously AMD64 required libffi but this is not individually packaged on some Linux distributions. On a random set of signatures the hand-coded assembler is 4.6 times faster (and jBYTEmark FP Index is 30% faster). - Ported to Darwin/ARM (i.e. the iPhone). Built using unofficial toolchain and tested on jailbroken iPhone (1.1.3 firmware) - Class initialisation/first active use fixes - initialise if first active use is object allocation via reflection (newInstance) - initialise if first active use is object allocation via JNI (AllocObject/NewObject) - The wait in step 2 of the initialisation sequence must be non-interruptible (not specified in the JVM or Java spec). - If allocation of the ExceptionInInitializerError fails, OutOfMemoryError should be thrown not the original exception - Don't resolve if initialiser throws ExceptionInInitializerError (subsequent resolution will not see the class is erroneous) - JNI_OnLoad fixes - initialise JNI local refs before calling - if JNI_FindClass is called from JNI_OnLoad, ensure correct class loader context is used. - JNI_OnUnload fixes - initialise JNI local refs before calling - If a library defines JNI_OnUnload, and the class loader which loaded it is GCed JNI_OnUnload is called and the library is unloaded. Previously this was done within the GC. If OnUnload allocated objects it could corrupt the heap. Dummy unloader objects are now created, and JNI_OnUnload is called from the finalize method by the finalizer thread. - Fix variable argument passing of floats When calling Java methods from native code - Rework VM initialisation/start-up sequence - Fix for JNI_ThrowNew and exceptions loaded by non-bootstrap classloader - Fix for JNI_GetMethodID and object/class initialiser methods (do not search class hierarchy) - During resolution throw IllegalAccessError and not IllegalAccessException - handle loadClass returning null without throwing exception - Fix for running Jar files where the main class is package-protected - Interpeter inlining changes - Do not inline class initialisers (<clinit>). No performance improvement as they are only ran once. Reduces memory usage - Fix for class unloading when inlining disabled (-Xnoinlining) - Bump java.specification.version to 1.5 - Improve error messages if VM aborts during initialisation - During configure, do not disable zip/jar file support if zlib library or header can't be found (now aborts). Users never saw the warning and they ended up with a build which "didn't work". - Various compiler warnings. JamVM 1.5.0 released on 28th October 2007 ========================================= A summary of changes since 1.4.5: - Substantially modified the interpreter to implement inline-threading (also known as super-instructions or code-copying). This copies code sequences together to produce native code that executes without the normal interpreter dispatch overhead (similar to a simple JIT). - Supported on i386, AMD64, PowerPC and ARM, with or without stack- caching. It is enabled by default on i386, AMD64 and PowerPC. - Performance improvement upto 300% on Pentium 4 (NetBurst), and upto 200% on Athlon 64. Less on Core 2 Duo (upto 70% faster as it has indirect branch prediction), and PowerPC which was already very optimised (upto 30% faster). - Tested on gcc 3.4 (i386, AMD64, PowerPC), 4.0 (i386), 4.1 (i386, AMD64, PowerPC, ARM), 4.2 (i386, AMD64) - Several new command line options to control inlining: -Xreplication : determines whether duplicate code sequences are replicated or shared. Can be set to 'none' (no replication), 'always' (all sequences are copies) or a threshold value (e.g. 10, when sharing of a sequence reaches the threshold the sequence is replicated). -Xcodemem : the maximum amount of memory for super-instructions. Once the maximum is reached no new super-instructions are generated but existing super-instructions are reused (class unloading will also free unused sequences). Can be set to a value or 'unlimited'. This option can be used to limit code memory on systems with little RAM (i.e. embedded). -Xshowreloc : debugging option, which shows which opcodes were determined to be relocatable, and for opcodes which aren't why they aren't relocatable. When using stack-caching there are three versions of each opcode (for 3 stack-cache levels). -Xnoinlining : turns off inlining (equivalent to setting codemem to zero). - Opcode relocatability is determined by default at build time, but this doesn't work when cross-compiling (so inlining is disabled). Relocatability can be determined at runtime using configure option --enable-runtime-reloc-checks, but this increases executable size by approx 30%. - Command line options -version and -showversion now shows build information. This includes the execution engine (e.g. inline- threaded interpreter with stack-caching), the gcc version which was used to compile JamVM (useful for debugging) and the "built in" boot library path and classpath. - Ported to ARM systems using EABI. This is a full port, with hand- coded assembler to handle the construction of a call-frame for calling JNI native methods. - Refactored GC to remove all possible calls which may deadlock with threads suspended in "unsafe" operations. This includes use of malloc/realloc/free and pthreads operations. - In allocClass() check if gcMalloc() returns NULL (i.e. OOM). - Copy Sun's behaviour when dealing with an empty property key or no equals after key. - Add java.util.concurrent.atomic.AtomicLong.VMSupportsCS8. - In method and field access checks, put back in access check for class (removed previously because it caused regressions, since fixed in Classpath). - Enable suspend on thread creation (parent thread created thread with suspension disabled). Effects threads which immediately call a long running native method. - Fixed race condition in thread creation and compaction (start function obtains class reference when it is not suspendable, if compaction occurs, the reference may be threaded, or moved). - Fix potential deadlock in threadInterrupt under Linuxthreads. - Protect lock operation in resetPeakThreadsCount(). - In createJavaThread(), re-enable suspension if pthread_create fails. - Fix race-condition in thread deletion. - Fix bug in hash table "scavenge". This could lead to entries not being freed, and exhaustion of Monitors on embedded systems. - Removed use of malloc/free in thread dump. Removes potential deadlock with threads suspended in malloc/realloc/free. - Added symbolic link from lib/rt.jar to Classpath's glibj.zip (fixes programs such as ecj which locates rt.jar via java.home). - Bumped Java compatible version to 1.5.0 as Classpath is now the generics branch (since Classpath 0.95). 2008-09-07 08:41:44 +02:00			`java/jamvm/lib/rt.jar`
Import lang/jamvm from wip JamVM is a new Java Virtual Machine which conforms to the JVM specification version 2 (blue book). In comparison to most other VM's (free and commercial) it is extremely small, with a stripped executable on PowerPC of only ~135K, and Intel 100K. However, unlike other small VMs (e.g. KVM) it is designed to support the full specification, and includes support for object finalisation, the Java Native Interface (JNI) and the Reflection API. 2006-04-17 00:16:36 +02:00			`java/jamvm/share/jamvm/classes.zip`