2.9 release 12 (beta) - New class com.aicas.jamaica.lang.Profile: This class provided a command line tool such that a profile can be written out on a request from an network connection: If you start an application on the target via > jamaicavmp -Djamaica.profile_request_port= Main Then you can request writing a profile at any time: > jamaicavm com.aicas.jamaica.lang.Profile 2.9 release 11 (beta) - Fixed makefile for jamaicavm* commands to include native code required for package com.aicas.jamaica.lang... (class LowLevelRTSJ could not be used fully) 2.9 release 10 (beta) - New option -closed for the builder. If set, the builder performs optimizations that are legal only for closed applications, i.e., applications that have all their classes built-in and that do not use dynamic class loading. By default, this option is not set. Enabling it via -closed=true may improve the performance of method calls since dynamic binding and inlining may be used instead of virtual calls. 2.9 release 9 (beta) - New options for jamaicavm* commands: -Xms/-ms set initial Java heap size, default 2M -Xmx/-mx set maximum Java heap size, default 256M -Xmi/-mi set heap size increment, default 4M -Xss/-ss set stack size (native and interpreter) -Xjs/-js set interpreter stack size, default 64K -Xns/-ns set native stack size, default 64K -Xprof collect simple profile sample 2.9 release 8 (beta) - Performance improvement of object de-serialization. 2.9 release 7 (beta) - Set default of build option -XenableZip to true. Renamed options -enablesZip and -excludeLongerThan as -XenableZip and -XexcludeLongerThan. Made deprecated options -notSmart, -numDyncamicTypes, -numDyncamicTypesFromEnv, -large, -noCompaction, -stackSize, -stackSizeFromEnv internal options. - Fixed behaviour for period javax.realtime.RealtimeThreads: the thread now starts immediately, and the first call to waitForNextPeriod waits for the first release (before, the thread was started at the first release time and waitForNextPeriod waited for the second release). 2.9 release 6 (beta) - New default values for the Jamaica Builder: -heapSize=2m -maxHeapSize=256m -heapSizeIncrement=4m -immortalMemorySize=0 -scopedMemorySize=0 -javaStackSize=16k -nativeStackSize=64k -numThreads=2 -maxNumThreads=511 -finalizerPri=10 -lazy=true These defaults result in a more dynamic VM (heap and threads increase dynamically, lazy class linking is used), which makes it easier to run arbitrary Java applications. However, applications that require more predictable behavior need to be build using stricter options. - Builder options -smart, -notSmart, -large, -numDynamicTypes and -numDynamicTypesFromEnv are deprecated. Smart linking is now used by default, to avoid smart linking for a classes, -includeClasses or -includJAR needs to be used for the affected class. Also, the large memory model is now used by default, so there is no more need for the -large option or for specifying the maximum number of types permitted in the small memory model. - New set of jamaicavm* commands: jamaicavmdi_bin run jamaica using the debug interface. The normal commands (jamaicavm_slim etc.) automatically use the debug variant if a debug agent is specified. - New internal builder option -XdebugInterface to enable JVMTI and debug agent when building a VM - Made builder option -debug an internal option. - New internal option -XfullStackTrace to force generation of full Java stack trace in exception even for compiled methods. No stack trace is created for inlined methods, so for full traces, you need to use -inline=0 in conjunction with -XfullStackTrace. - Added cost monitoring for javax.realtime.PeriodicParameters, javax.realtime.SporadicParameters, javax.realtime.AperidodicParameters, and javax.realtime.ProcessingGroupParameters. If an overrun handler is provided to these parameters, the handler will be fired when the budget is exceeded. The accuracy of the cost enforcement can be specified in nanoseconds via the property COST_MONITORING_ACCURACY. The default value is 5000000, i.e., 5milliseconds. - Significant performance improvement in Object serialization and deserialization by avoiding redundant reflection code. Serialization and Deserialization are up to 10 times faster with these changes. - Added property GCTHREAD_PRIORITY: If set to a value larger than 0, a GC thread running at this priority is created. This thread performs garbage collection work constantly. This thread can be used in a system that has sufficient idle time. In such a system, GC overhead is reduced (in dynamic GC mode) or the likelyhood of blocking through GC is reduced (in stop-the-world GC mode) . - Reduced aggressivity of WeakReference reclamation: These reference are now freed when less than 20% of the total memory is free (in contrast to 50% that where used before). Soft reference are freed when less than 10% is free. These values can now be set via properties: WEAKREF_MINFREE and SOFTREF_MINFREE, e.g. "jamaicavm -DWEAKREF_MINFREE=1" to force the VM to keep weak references until memory is nearly exhausted. However, it must be ensured that the finalizer thread or any other thread executing Runtime.runFinalization obtains sufficient CPU time to actually clear these references before the system runs out of memory. - JDK 1.4 compatible java.lang, java.lang.ref, java.lang.reflect packages. Included method declarations for new JDK 1.5 methods such that systems compiled with javac 1.5 can be build/run, as long as they do not call any of the new methods (which would result in a NYIException). - Extended options -constGCwork and -constGCworkFromEnv such that the value -1 is permitted. If the const GC work is set to -1, then the GC is run as if it was a blocking GC, i.e., no GC work is performed until just before the heap is fully filled. - Added support for dynamic addition of threads. New builder options -maxNumThreads and -maxNumThreadsFromEnv permit to set the maximum number of threads. If this number is larger than the values specified via -numThreads, threads will be added dynamically. - The prebuilt VM commands (jamaicavm, jamaicavm_slim, jamaicavmp, etc.) use dynamic thread creation now. The maximum number of threads can be set via the environment variable JAMAICAVM_MAXNUMTHREADS. - Added support for dynamically increasing heap memory size. New builder options -maxHeapSize and -heapSizeIncrement permit to control this feature: setting -maxHeapSize to a value larger than -heapSize enables dynamic growth of the heap, shilw -heapSizeIncrement specifies the size of additional memory chunks that are added whenever the system's heap memory runs low. Via -maxHeapSizeFromEnv and -heapSizeIncrementFromEnv, these values can be speciefied from environment variables. - The prebuilt VM commands (jamaicavm, jamaicavm_slim, jamaicavmp, etc.) use dynamically increasing heap memory now. The maximum heap size and the heap size increment can be set via environment variables JAMAICAVM_MAXHEAPSIZE and JAMAICAVM_HEAPSIZEINCREMENT, respectively. - The Jamaica distribution now contains its own Java compiler jamaicac. It is based on the Eclipse Java compiler version 3.1.1. - Improved resource allocation and error handling in VM startup code, more details error messages if startup fails, e.g., due to lack of memory. - Improved debug output facilities: output can be redirected to a file, an UDP socket or a stream socket. - Implemented timeout in network functions for most Unix systems and some embedded realtime OS (see manual). - Fully reworked the garbage collector: reduced memory overhead of GC by up to 9%, simplified write-barrier code for smaller code size, and better cache locality. - The Builder and VM now requires setting of the size of the memory to be used for javax.realtime.LTMemory and javax.realtime.VTMemory areas. The new options -scopedMemorySize and -scopedMemorySizeFromEnv can be used to set the size of this area in the Builder, while the VM expects the environment variable JAMAICAVM_SCOPEDSIZE to be set. - Improved error handling in case of OutOfMemoryError (fix for bug#547): When an OutOfMemoryError is propagated, a flag indicates the GC that it should make an attempt to free as much memory as possible on the next allocation if we are still in a low memory situation. This will cause the GC to stop the VM for a complete GC cycle, so realtime code that performs an allocation will be stopped by GC, but an allocation performed in this situation will otherwise fail anyway. 2.8 / 2.7 (beta) - fixed bug#562: javax.realtime.WaitFreeReadQueue.waitForData did not block when no data was available, but blocked if data was available. - Builder now also accept spaces in filenames - renamed entry code function name under VxWorks: now the general name is either 'jvm' or 'jvm_' where is the name used with the Builder option -destination. - Deprecated option -ignoreClassNotFound. -lazy is a safer alternative that does not need to introduce dummy-code. - Extended support for -lazy by the builder: classes, methods and fields that are not found by the builder will be ignored when -lazy is set. The resulting appliction will create a LinkageError during runtime when such classes, methods or fields will be accessed. - Optimization of array representation in memory reducing the memory required for arrays that are allocated in non-fragmented memory (e.g., during VM startup). Results in heap size reduction of up to 10% or performance improvement of up to 4%. - use of reverse stubs for more efficient context switch between compiled and interpreted/JNI code. Up to 8% code size reduction for compiled applications. - significant performance improvement in reflection API (Method.invoke, Class.getMethod, Class.getMethods, Class.getField, Class.getFields, Method.getName, Field.getName, Constructor.getName, etc.) 2.6 / 2.5 (beta) - smart linking does no more remove non-transient instance fields and writeObject/readObject methods from serializable classes. Serialization now works in conjunction with -smart without the need to exclude serialized classes using -notSmart. - jamaicavm* commands now perform lazy loading of classes, i.e., an application that references classes that are not available will no more fail immediately, but only when the referenced class is actually used at runtime. - Builder supports generating ELF files. Class file data is now directly written to ELF files. This significantly reduces the size of the generated C files and the build process time. - New Builder options -lazy and -lazyFromEnv to enable lazy class loading. - New Builder option -includeJAR. Forces the inclusion of all classes and all resources contained in the archive file or directory, even if smart linking is enabled. - New Builder option -XkeepTemporaryFiles. Setting this option will not delete the generated intermediate files (c,h,o-files) after building an application. - Option -noCompaction is deprecated. The Builder detects the cases that require -noCompation automatically now. - Fixed bugs in compacting class files: Builder caused NullPointer when -resource was used and application crashed with AbstractMethodError. - Option -physicalMemoryRange now accept 63bit addresses. Values can be provided in hexadecimal format, too. - New Builder and VM option -XprofileFilename to specify profile data output file - Packages java.lang, java.lang.ref and java.lang.reflect support JDK 1.4 compatible APIs. - Serialization of classes in package java.lang is compatible with JDK 1.4 now. - Project-specific graphics support via a limited AWT and graphics frameworks (e.g. XWeb by Xcc) is possible. Please contact aicas for details. - Exception stack traces for classes that are not built into an application by the Builder now contains line numbers. - Loading of dynamic libraries for JNI function is now possible on Linux/x86 systems. 2.4 / 2.3 (beta): - Updated RTSJ implementation to incorporate clarifications made for RTSJ specification V1.0.1. - Updated standard classes to the latest release of CLASSPATH - Added support for profiling of compiled code. It is now possible to combine Builder option -profile with compilation via options -compile or -useProfile. When generating a profile, one is consequently not forced to use slow interpreted mode only. - Added support to combine options -profile and -debug for low-level debugging even when profiling is enabled. - Significant improvement of turn-around time with jamaica: Compilation within the Builder can now be performed package-wise. Packages that did not change since the last compilation will automatically be detected and will not be recompiled. To enable this incremental compilation use the Builder option -incrementalCompilation - Significantly improved startup time of built applications. - Added support for priority ceiling protocol. - Builder automatically sets option -large if needed. - The option -verbose now expects the level as an argument (0..2). - New Builder option -XbackendStep to restart compiler, linker or strip without complete build process. - New Builder option -incrementalCompilation to activate/deactivate incremental compilation. - New Builder option -XdefineProperty / -XdefinePropertyFromEnv for user definable system properties. - The Builder now accepts "@file"-notation for options that contain lists. If a file is given, every non-empty line will be appended to the list as if the file content was given on the argument line. - Fixed problem with server sockets under QNX. - The name of the entry function under VxWorks is now equal to the name of the main class. 2.2 / 2.1 (beta): - Added automatic detection of code sequences generated for ".class". Classes that are referenced this way are automatically added to the list of classes specified through builder option -includeClasses. - Extended profiling to find classes accessed via reflection (Class.forName() etc.). When profiling information is used via builder option -useProfile, these classes will automatically be treated as if they were specified as arguments to option -includeClasses. - Added support for serial communication (UART) with package java.javax.comm for targets: Linux vxWorks - Added support for Java assert()-statements - Updated the Java System classes to the upcoming GNU Classpath Version 0.0.6 - Fixes * added missing dependencies in jamaica-dependency.conf * fixed check of VxWorks version * fixed javac 1.4 problem with references to interface methods in sub-interfaces - VxWorks: WIND_BASE is now a property and used to find the VxWorks system files (e. g. header files) - Builder use environment variable CLASSPATH if no classpath given at command line (like JamaicaVM) - Makefile scripts are not needed any longer for building an application. Builder now directly invokes cc, linker, and strip. - Builder settings (see option -showSettings) are now printed out in sorted order. - Manpages for jamaica and jamaicah - Smart linking searches methods in super class now, if they cannot be found in the explicitly named class. - Builder now accepts arguments like -include.linux-gnu-i686+=/home/bob/tmp/includes The value of the option now is the value given on the commandline plus the corresponding value from the jamaica.conf file. - Builder reads jamaica.conf from directory /.jamaica/ if provided. Otherwise, the default configuration file in /etc/jamaica.conf is used (see also new option -configuration). - Builder now accepts '=' for separating optionname and value (e.g.: -classpath=myclasses) - Added support for ScopedMemory and checks for IllegalAssignmentError in compiled and smart linked code. - Reduced memory demand for ROMed classes - Added optimization of Exceptions array stored within the JamaicaVM. This safes about 2.5% of the RAM used for internal data of of the VM. - Extended profiling and inlining. - Enhanced profiling to count number of calls at all call sites. - Extended profiling to determine the number of threads used. If this number is higher than the argument -numThreads, the Builder gives a warning. - Small optimizations to improve interpreter performance and class loading time. - Several optimizations in interpreter. - Optimized representation of fields and methods that are defined in a class. This reduces the internal memory demand by 6.8%. - New alias names for options -classpath, -cp - Significantly reduced RAM memory demand for classes in ROM or built application. - Reduced stack memory demand for class loading/linking. - New options in Builder: -setLibraries Choose set of libraries to be included in the target application if used. Library sets are used for features such as supported encodings, protocols, locales, etc. -javaStackSize Set the stack size to be used for the Java runtime. -javaStackSizeFromEnv Create an application that reads its Java stack size from an environment variable. -nativeStackSize Set the stack size to be used for the native runtime stacks of all Java threads in the built application. -nativeStackSizeFromEnv Create an application that reads its native stack size from an environment variable. -physicalMemoryRanges Give a list of physical memory ranges that can be accessed by the application. Each memory range is a pair of start and end addresses separated by "..". -includeClasses Force inclusion of the listed classes and packages into the application. The listed classes and all their methods and fields will be included even if smart linking is enabled. -large Force use of large object model. The large object model is required if smart linking is used (see option -smart) for an application that uses reflection. -saveSettings Like -showSettings, but writes output into a file. -configuration Use a specific configuration file. -optimize Select optimization mode (none,size,speed,all). -XlinkStaticPrefix If the linker is being invoked indirectly via a compiler driver (e. g., gcc), this prefix is used to tell the compiler driver the prefix to use to link a library statically to the created executable. -XlinkDynamicPrefix If the linker is being invoked indirectly via a compiler driver (e. g., gcc), this prefix is used to tell the compiler driver the prefix to use to link a library dynamically to the created executable. -XstaticLibraries Statically link with the specified libraries. This results in a larger executable which is independent of these libraries on the target system. -XobjectFormat Set the object format, e. g. 'none' or 'ELF'. -XobjectByteOrder Set the byte-ordering in the object output, e. g. 'little-endian' or 'big-endian'. -XobjectGenerateCode Set the type of generated code in output object, e. g. 'C', 'i386' or 'sparc'. -large Force use of large object model. The large object model is required if smart linking is used (see option -smart) for an application that uses reflection. -XnoRuntimeChecks New extended builder option to disable runtime checks within compiled code. - New deprecated options in Builder: -loadPath Use -includeClasses instead. -stackSize Use -javaStackSize and/or -nativeStackSize instead. -stackSizeFromEnv Use -javaStackSizeFromEnv and/or -nativeStackSizeFromEnv instead. -XO Use compiler-independent -optimize instead. - No longer supported options in Builder: -blockSize -XobjectByteOrder -linkerPrefix (replaced by -linkDynamicPrefix and -linkStaticPrefix) - New options in Jamaicah: -d Specify the output directory for the header files. -o Specify the name of the header file. -saveSettings Like -showSettings, but writes output into a file. -XjamaicaHome Specifies the path to the Jamaica directory. 1.9 (beta): - Support for Real-Time Specification for Java APIs (excluding PhysicalMemory classes, but including RawMemory). - Extended Standard classes support - Support for JAR/ZIP files. 1.2 (stable release): - smaller bugfixes. 1.0.5 (beta): - Support for new RTOSes: VxWorks and QNX 6.1 - Support for new architectures: StrongARM and PowerPC - Direct support for touchscreen and mouse pointer displays - New Builder option -priMap to provide arbitrary mapping of Java thread priorities to system thread priorities. - new Builder option -finalizerPri to select the priority of the finalizer thread. A priority of 0 indicates that there shall be no finalizer thread. - new Builder option -timeSliceNanos to select the size of a round-robin time slice. Setting this value to 0 indicates that round robin scheduling of threads of equal priority is not needed. In this case, no synchronization thread is used. - flexible support for cross-platform development using Builder option -target to specify target OS and architecture to build an application for. - efficient support for priority inheritance for Java monitors. - new Builder option -cldc to include all the classes, methods and fields in the CLDC configuration in the target application. 1.0.4: - Support for most classes in the java.awt package. - Significant reduction of binary file size through better smart linking and classfile compaction. - Smaller RAM requirements through more compact runtime data structures and direct access of classfile information in ROM/FLASH memory. - Improved compiler optimizations. - StackOverflowError is now thrown on a stack overflow of the Java stack or the C runtime stack. - command 'jamaicavm' now contains all boot classes and precompiled methods. The boot classes are hence not loaded from disk, startup time is significantly reduced and performance of interpreted code is enhanced through precompiled libraries. - New command `jamaicavm_slim` loads boot classes from the boot classpath and does not contain precompiled code. - New builder options -numDynamicTypes and -numDynamicTypesFromEnv to set the maximum number of types that might be loaded dynamically when -smart is set. - New builder option -Xstaticlib links (system) libraries statically instead of dynamically. This is useful if the target system doesn't have all libraries installed. 1.0.2: - enhanced options for the builder utility: * use of environment variables for configuration of application (heap size, etc.) * loadPath to include all classes of one directory tree - support for 16-bit CPUs with no 64-bit arithmetic. - nicer error handling in low memory situations: Stacktrace for OutOfMemoryError, better error message if startup fails due to low memory. - enhancements to standard packages java.io, java.util and java.lang. - new standard package java.lang.ref supported: weak, soft and phantom references. - new standard package java.net partially supported (sockets etc.) - system properties are now provided. - automatic support for different target configurations (endianess, unix libraries, etc.) - improved efficiency of interpreter - better optimization and smaller code generated by compiler. - bug fixes. 1.0.0: First public release of Jamaica