New in JamVM 1.5.4 (Apr 10, 2010)
- GC changes:
- Mark phase rewritten to use an explicit fixed-size mark stack,
- with a moving heap scan pointer. The previous recursive marking
- could lead to stack overflow when marking complex, deeply-linked
- structures. If the explicit mark stack overflows, a slower,
- fallback mechanism is used of scanning the heap. The new mark
- phase is upto 50% faster than the old recursive marking.
- bug fix for unallocated blocks within the heap of >= 1 GB.
- JNI changes:
- Updated to JNI version 1.6. This adds the function
- GetObjectRefType().
- Fully implemented JNI weak global references (NewWeakGlobalRef
- and DeleteWeakGloablRef). Note, these are different to Java
- Soft/Weak/Phantom References which have been supported since
- JamVM 1.4.0.
- verbose:jni now shows details of the opening of native libraries.
- If a library fails to open a diagnostic message is shown (if
- available). This is intended to help debug common library
- problems.
- bug fix for ToReflected[Method|Field] and GetSuperClass. A
- local reference must be created for the return value.
- Platform changes:
- Interpreter inlining (aka code-copying JIT) now enabled by
- default on ARM systems. Testing on Cortex-A8 indicates
- 82% speed improvement on integer benchmarks, and 55% on
- floating-point.
- If cross-compiling, and interpreter inlining is enabled, runtime
- relocation checks will be enabled (relocation information is
- normally generated at compile time; as this can't be done
- when cross-compiling it must be done at runtime, but it
- increases the size of the executable by ~30%).
- Initial port to Sparc/FreeBSD. My thanks to Per Ola Ingvarsson
- for architecture dependent definitions. Interpreter inlining
- (aka code-copying JIT) is currently not supported due to missing
- code for flushing the instruction/data caches, and branch
- generation. It also requires libffi, which is enabled by default.
- Changes to x86 and x86_64 across all platforms to zero/sign
- extend return values from native methods whose size is less
- than an int (i.e. boolean, byte, char and short). This is
- necessary due to changes in code produced by gcc >= 4.3.
- Rare race-condition in thin-locking code on x86 and x86_64
- architectures, leading to deadlock. On modern x86 CPUs, an
- extra memory barrier is required. Seen intermittently while
- running a thread intensive benchmark using at least 4 cores.
- Extensive changes to support 64-bit Big Endian systems. These
- were previously supported, but support was completely broken
- with the introduction of the new object layout in JamVM 1.5.2.
- Miscellaneous fixes:
- Interpreter inlining bug fix: reference to memory after it
- had been freed
- java.lang.reflect.VMField getAnnotation() implemented. This
- has been missing since the reflection rework in JamVM 1.5.2.
- ThreadMXBean: fixes for getThreadInfoForId (VMThreadMXBeanImpl).
- Did not correctly report lock or lock owner, when the thread was
- blocked on an object which was thin-locked by another thread
- It was using a constructor which has since been removed
- Fixes for NULL handling in findClassFromSignature() and
- utf8CharLen()
- Fixed memory leak in bytecode rewriting. Due to missing
- parantheses, old bytecode stream was not being freed (for
- example, this leaks 47K when running "Hello, World")
- Bug-fix for theoretical race-condition in thread deletion when
- notifying joining threads after thread ID has been reused.
New in JamVM 1.5.3 (May 13, 2009)
- Zip/Jar support in the boot classloader has been rewritten to no longer require the Zip/Jar files to be mmap-ed read/write. This increases shareability between multiple VM instances, and improves memory-usage on embedded systems.
- JNI invocation API:
- set thread-self to NULL when thread detaches (if the thread tries to re-attach, it appears to still be attached)
- init args_count in dummy stack frame (fix problem if the thread detaches and then re-attaches)
- Do not create a library unloader for libraries loaded by the bootstrap loader if they have an JNI_OnUnload method (the bootstrap loader is never unloaded, and so they will never be called). Fixes a SEGV with JRuby.
- Fix to annotation handling. When the annotation value is an array, the native annotation parser constructs an Object array. However, the method return value is the specific type. This leads to an AnnotationTypeMismatchException. The fix coerces the Object array to the correct type.
- Simple implementation of java.lang.management.VMManagementFactory (returns no memory pool, memory manager or GC names). Sufficient to run JRuby.
- Implemented package support in the bootstrap class loader. Package information is obtained from the manifest file if it exists. However, GNU Classpath's glibj.zip's manifest has no package information. The class library is therefore recognised by the presence of java/lang/Object.class, and appropriate package information is constructed.
- Fix broken implementation of VMClass.getSimpleName() (use the implementation from gcj)
- Default Java stack size increased to 256K from 64K
- Fix to bootstrap loader getResources() when the bootclasspath entry is relative (prepend the current working directory)
- Fix minor memory leak in bootstrap loader getResources()
- Add --enable-tls option to configure, enabling thread-local-storage (__thread) to be disabled
New in JamVM 1.5.2 (Feb 5, 2009)
- Interpreter inlining changes
- Basic-blocks are now inlined across block boundaries removing the need for dispatching between blocks in the case of fall-through control flow
- Control-flow within inlined sequences now patched with real jumps, removing the need for computed jumps
- Control flow between non-shared sequences now patched, replacing dispatch with real jumps
- Simple basic-block profiling is now implemented. This considerably reduces the size of the code-cache, without reducing performance
- Reworked Object layout
- Previously, on 64-bit machines the object layout was wasteful, with padding on fields less than 64-bits (to preserve 64-bit alignment). The new object layout on average reduces heap usage by approx 10 - 15%
- On 32-bit machines, 64-bit fields are now 64-bit aligned (without introducing extra padding if possible)
- Various alignment fixes
- 64-bit alignment of operand stack64-bit alignment of static variable data
- Reflection support
- Reworking required for new object layout
- Reworked to use VMConstructor, VMMethod, etc.
- Reworked to improve field access and method invocation performance (this offsets the extra costs of the VM interface, and improves performance over 1.5.1).
- Access permission checks take precedence over other errors
- Class/method signatures : do not convert slash to dots
- JNI fixes/improvements
- Class references returned by JNI now use local references
- Throw InstantiationException not InstantiationError when allocating objects and the class is an interface or abstract
- Reworked JNI global references
- Fix memory leak when expanding list
- Improve performance (optimise case where references are created/deleted in a stack-like manner)
- OpenSolaris/Solaris/x86 port
- GC fixes
- Fix race-condition in registering references with the GC
- Separate "Async GC" thread is now disabled by default. It didn't improve performance, and could increase power-consumption on embedded systems
- Exception handling
- Fix method-skipping when filling in stack trace (methods could be incorrectly excluded from the trace when a class subclassed Throwable)
- Uncaught exceptions in the "main" thread will now use the thread's uncaughtExceptionHandler
- Various compatibility command line options recognised (and ignored). These include -XX:PermSize and XX:MaxPermSize required to build OpenJDK.
- sun.misc.Unsafe
- Object methods (compareAndSwapObject, etc.) fixed on 64-bit machines
- Implemented support for thread park and unpark (removing previous highly inefficient "empty" implementation)
- Use thread-local storage (__thread), if available, instead of pthread keys
- Various minor race-conditions seen while running Dacapo benchmarks
- Strict-aliasing fixes when compiled with GCC 4.3, interpreter stack-caching is enabled, and interpreter inlining is on
- A large amount of code-tidying throughout the VM
- Minimum heap size increased to 16MB
- Various compiler warnings.