This paper shows the implementation and the results of a thread-group based generational garbage collector using a simulated environment. The research was done using a simulator developed by Nasartschuk et al.. The simulator isolates the garbage collector from other components in a virtual machine to permit in-depth analysis and evaluation of new GC techniques. Contrary to other implementations, this approach assigns a heap to each thread, instead of dividing the heap into several regions for every thread. Furthermore, thread groups are assigned so that the simulator does not always have to stop the world to GC specific regions. This technique has shown an improvement in terms of average GC times over more traditional techniques in many applications. This prototype could be implemented in any environment that uses automated memory management, e.g. in a Java Virtual Machine.

Many modern programming languages rely on memory management environments that are responsible for allocation and deallocation of objects. Garbage collection phases are used in order to detect inaccessible objects on the heap so they can be deallocated. The performance of garbage collection techniques depends heavily on the environment, implementation specific parameters and the benchmark used. The contribution of this publication is an extendable memory management simulator, which aims to assist developers in memory management evaluation and research. The simulator is capable of reading operations from a trace file extracted from a virtual machine and simulating the memory management needed by the simulated mutator. The framework aims to provide an isolated experimentation and comparison platform in the field of automatic memory management. New algorithms can be added to the framework in order to compare them to established algorithms.

Memory management is a significant topic in virtual machine research. As allocation and deallocation of objects is performed automatically, garbage collection (GC) has become an important field of research. It aims to speed up and optimize the execution of applications developed in languages such as Java, C#, Python and others. Even though GC techniques have become more sophisticated, automatic memory management is not optimal. Garbage collection techniques, such as reference counting, mark-sweep, mark-compact, copying collection and generational garbage collection build the base of most automated memory management environments. Most GC policies include a stop-the-world phase that is used to detect live objects.The research presented in this paper aims to improve the automatic memory management and application execution by investigating an optimization of the memory layout. The goal of the approach described is to utilize the stop-the-world phase of the garbage collector in order to detect duplicate strings and to deduplicate them before copying them to a different region. The goal of this algorithm is to reduce memory duplication, as well as copying of memory, in order to decrease the heap size and therefore the number of garbage collections required to execute the client application.

Automated memory management systems greatly decrease the complexity of writing computer programs by removing the memory layer from the programmer's perspective. This leads to additional overhead for the programming language as it needs to incorporate mechanics in order to manage the program's memory. All objects that are no longer reachable are considered to be dead. The memory used by dead objects must be freed. This process is referred to as garbage and hence these programming languages usually incorporate a garbage collector which performs the aforementioned tasks. The layout of the objects in memory greatly affects the performance of the program, as some layouts may result in more cache misses. This survey portrays the current state of the art on the topic of object cache locality in automated memory management systems. With the increasing usage of automated memory management systems, such as virtual machines, research has been focused on improving the performance of these systems.

Some Java programs lend themselves to being run many times and create the same fixed objects every time. Many of these common objects are Strings. To exploit this trend, we have modified IBM's J9 Java virtual machine (JVM) to allow the same String objects to share (reuse) their internal char[] (character) arrays in each JVM. The first instance of the Java program runs to completion and then sets up the Strings for sharing, so that subsequent instances of the same program can use the char[] arrays that it created instead of recreating them. String sharing will not provide benefit in all applications, but for those that fit the pattern, as exemplified by the Eclipse and H2 benchmarks, we were able to achieve significant heap saving with negligible impact on performance. Copyright © 2015 John Wiley & Sons, Ltd.

With the Java language and sandboxed environments becoming more and more popular research needs to be conducted into improving the performance of these environments while decreasing their memory footprints. In this paper we present a dynamic approach for growing monitors for objects in order to reduce the memory footprint and improve the execution time of the IBM Java Virtual Machine. According to the Java Language Specification every object needs a monitor, however not all objects require synchronization, thus the monitor can have a negative memory impact. Our new approach grows monitors only when required. The impact of this approach on performance and memory has been evaluated using the SPECjbb2005 benchmark and future work is also discussed. On average a performance increase of 0.47% and a memory reduction of about 5.51% has been achieved with our approach.

In this paper we present the design, implementation, and testing of an evaluation tool for the ongoing development of the Prosthetic Device Communication Protocol (PDCP) which is an open protocol and is featured in the University of New Brunswick's most recent prosthetic limb research project, the UNB Hand System. This prosthetic device utilizes the CAN bus hardware with the PDCP for passing command and data messages between modules within the prosthetic limb system. The PDCP allows abstraction of the underlying bus system and allows different network topologies depending on particular needs. To be able to analyze communication in the CAN layers as well as in the PDCP layer we present our own solutions utilizing an FPGA for CAN bus bandwidth load monitoring and a microcontroller for PDCP monitoring and analysis.