A DSM protocol aware of both thread migration and memory constraints (Best Paper) - Veldema, Ronald; Larsen, Bradford; Philippsen, Michael (Proceedings of the 20th IASTED International Conference on Parallel and Distributed Computing and Systems (PDCS'08), 2008)
UnivIS-Import:2015-04-16:Pub.2008.tech.IMMD.IMMD2.adsmpr

A Hybrid Functional and Object-Oriented Language for a Multi-Core Future - Veldema, Ronald; Philippsen, Michael (it - Information Technology, 2011)
Current (heterogeneous) multi-core environments such as GPU architectures are hard to program with normal imperative and object-oriented (OO) languages because of race-conditions and general side-effects that code may have. We propose that both problems can be solved with a hybrid language that combines both Functional Programming (FP) and OO programming. By auto-parallelization in the FP-core, all loops and non-dependent calls can be executed in parallel. FP is to be used to write computationally intensive code with safe concurrent memory access. OO is to be used for I/O and management related tasks. In this article, we propose a new clean way to integrate the two language cores that even grants some restricted means to read and write arrays and objects from within FP mode. For the proposed new language features we have developed a compiler prototype that transparently parallelizes code to target both Cuda and multi-core machines (without annotations from the programmer) and that obtains good speedups.
UnivIS-Import:2015-03-09:Pub.2011.tech.IMMD.IMMD2.ahybri

An Automatic Cost-based Framework for Seamless Application Migration in Grid Environments - Klemm, Michael; Veldema, Ronald; Philippsen, Michael (Proceedings of the 20th IASTED International Conference on Parallel and Distributed Computing and Systems (PDCS'08), 2008)
Grid computing promises to seamlessly deliver computing power to computational scientists. However, scientists are faced with the problem of finding computing resources for their application and they have to cope with the systems' batch operation mode that causes premature termination of applications if they exceed the reserved resource limits. In this paper, we propose a middleware layer (OGRE) for a seamless Grid environment. OGRE automates the process of resource discovery and performs resource selection. Resource selection uses a cost-based migration strategy that allocates free computing resources on accessible clusters, i. e., OGRE automatically checkpoints, transfers the snapshot from one cluster to the next, and restarts the application there. A Grid-wide file system handles data accesses of migrated applications. OGRE can easily be adapted to new requirements due to its component-based architecture.
UnivIS-Import:2015-04-16:Pub.2008.tech.IMMD.IMMD2.anauto
Keywords: Cluster migration; Grid computing; High performance computing

Annotation Support for Generic Patches - Dotzler, Georg; Veldema, Ronald; Philippsen, Michael (Proceedings of the Third International Workshop on Recommendation Systems for Software Engineering (RSSE 12), 2012)
In large projects parallelization of existing programs or refactoring of source code is time consuming as well as error-prone and would benefit from tool support. However, existing automatic transformation systems are not extensively used because they either require tedious definitions of source code transformations or they lack general adaptability. In our approach, a programmer changes code inside a project, resulting in before and after source code versions. The difference (the generated transformation) is stored in a database. When presented with some arbitrary code, our tool mines the database to determine which of the generalized transformations possibly apply. Our system is different from a pure compiler based (semantics preserving) approach as we only suggest code modifications. Our contribution is a set of generalizing annotations that we have found by analyzing recurring patterns in open source projects. We show the usability of our system and the annotations by finding matches and applying generated transformations in real-world applications. © 2012 IEEE.
UnivIS-Import:2015-04-16:Pub.2012.tech.IMMD.IMMD2.annota
Keywords: Recommendation; Patches; Refactoring; Annotations

A Proposal for OpenMP for Java - Klemm, Michael; Veldema, Ronald; Bezold, Matthias; Philippsen, Michael (OpenMP Shared Memory Parallel Programming, International Workshops IWOMP 2005 and IWOMP 2006, 2008)
The current OpenMP 2.5 specification does not include a binding for Java. However, Java is a wide-spread programming language that is even used for HPC programming. We propose an adaptation of OpenMP to Java by retrofitting the basic OpenMP directives to Java and further propose some new concepts to make OpenMP fit into Java’s language philosophy. We discuss how Java’s memory model matches OpenMP’s memory model and how the OpenMP bindings for Java and C++ differ. We also suggest how to achieve flexibility of an OpenMP implementation by allowing both Java threads (java.lang.Thread) and Java tasks (java.util.concurrent.FutureTask) as an underlying means of parallelization. Support for object-orientation is added to allow OpenMP to better suit the Java programming model. For example, we suggest a parallel for-each loop over Java collections, OO-based reductions, and object-cloning semantics to adapt data-sharing clauses to Java. Also, we suggest a minimal runtime library to allow object-pooling to circumvent any implicit synchronization involved in object allocations. Finally, we present some performance numbers for a reference implementation in a research compiler.
UnivIS-Import:2015-04-16:Pub.2008.tech.IMMD.IMMD2.apropo

Cluster Research at the Programming Systems Group - Klemm, Michael; Veldema, Ronald; Philippsen, Michael (2008)
UnivIS-Import:2015-03-09:Pub.2008.tech.IMMD.IMMD2.cluste

Combining Lock Inference with Lock-Based Software Transactional Memory - Kempf, Stefan; Veldema, Ronald; Philippsen, Michael (Languages and Compilers for Parallel Computing, 26th International Workshop, LCPC 2013, 2014)
An atomic block is a language construct that simplifies the programming of critical sections. In the past, software transactional memory (STM) and lock inference have been used to implement atomic blocks. Both approaches have strengths and weaknesses. STM provides fine-grained locking but has high overheads due to logging and potential rollbacks. Lock inference is a static analysis that computes which locks an atomic block must acquire in order to guarantee atomicity. Lock inference avoids both logging overhead and rollbacks, but with a growing number of variables accessed in an atomic block, locking becomes coarse-grained and hence reduces parallelism. The first contribution of this paper is an approach that combines these advantages without the drawbacks. A compiler analysis determines if lock inference can achieve a fine-grained synchronization or if STM is better for an atomic block. The generated code then either uses lock inference, STM, or a combination of both that allows the atomic block to switch from STM to lock inference during its execution. The second contribution are two optimizations that remove some of the limits of state-of-theart static lock inference analysis and therefore extend its applicability. These optimizations make more atomic blocks amenable to fine-grained lock inference. We use the STAMP benchmark suite to prove the practicability of our work. The reduced contention due to fine-grained locking and less transactional overhead lead to execution times that are between 1.1 and 6.0 times faster than a pure STM or lock inference implementation.
UnivIS-Import:2015-04-16:Pub.2014.tech.IMMD.IMMD2.combin

Compiler-Guided Identification of Critical Sections in Parallel Code - Kempf, Stefan; Veldema, Ronald; Philippsen, Michael (Compiler Construction, 22nd International Conference, CC 2013, 2013)
There is a huge body of sequential legacy code that needs to be refactored for multicore processors. Especially for control code for embedded systems it is often easy to split the program into multiple threads. But it is difficult to identify critical sections to avoid data races as the legacy code hides its synchronization in a static schedule, priorities and interrupts. To ease refactoring, this paper presents a new static data-dependence analysis that identifies necessary critical sections in thread-parallel code that does not yet contain any synchronization between threads. A novel optimization pass then breaks up and shrinks the identified critical sections to maximize parallelism while preserving correctness. Our technique proved to be successful in refactoring sequential assembly-like legacy codes in an industry-sponsored project. But as refactoring projects are hard to evaluate quantitatively and as the domain specific low-level language is of limited interest, we use a standard benchmark suite for which the optimum, i.e., the minimal set of the necessary atomic block annotations is known. We removed the annotations and let the compiler attempt to rediscover them. For 5 out of 7 benchmarks, our compiler identified the same critical sections as the original programmers did by hand. For the other two benchmarks, the compiler found slightly larger (but also correct) critical sections. In all cases, the versions of the benchmarks that the compiler annotated achieved the original run-time performance. © 2013 Springer-Verlag.
UnivIS-Import:2015-04-16:Pub.2013.tech.IMMD.IMMD2.compil
Keywords: Compiler; Critical Section; Parallel

Compiler Optimized Remote Method Invocation - Veldema, Ronald; Philippsen, Michael (Proc. 5th IEEE Conf. on Cluster Computing, 2003)
We further increase the efficiency of Java RMI programs. Where other optimizing re-implementations of RMI use pre-processors to create stubs and skeletons and to create class specific serializers and deserializers, this paper demonstrates that with transformations based on compile time analysis, an additional 18% performance gain can be achieved over class specific serializers alone for a simple scientific application. A novel and RMI-specific version of static heap analysis is used to derive information about objects that are passed as arguments of remote method invocations. This knowledge of objects and their interrelations is used for three optimizations. First, dynamic introspection and/or (recursive) dynamic invocations of object specific serializers is slow. With knowledge from our heap analysis, the marshaling of graphs of argument objects can be inlined at the call site. Hence, many method table lookups and skeleton indirections of previous approaches can be avoided and less protocol information is sent over the network. Secondly, because object graphs may be passed as RMI arguments, cyclic references need to be detected. With our heap analysis, we can detect if there is no potential for cycles and hence, cycle detection code can be left out of the serialization and marshaling codes. Finally, object arguments to remote methods cause object creation and garbage collection. Heap analysis and an RMI-specific version of escape analysis allows the reuse of object graphs created in earlier remote invocations.
UnivIS-Import:2015-04-16:Pub.2003.tech.IMMD.IMMD2.compil
Keywords: cluster computing; compilers; program analysis

Efficient Inspected Critical Sections in Data-Parallel GPU Codes - Blaß, Thorsten; Philippsen, Michael; Veldema, Ronald (Proceedings of the 30th International Workshop on Languages and Compilers for Parallel Computing (LCPC 2017), 2019)
Optimistic concurrency control and STMs rely on the assumption of sparse conflicts. For data-parallel GPU codes with many or with dynamic data dependences, a pessimistic and lock-based approach may be faster, if only GPUs would offer hardware support for GPU-wide fine-grained synchronization. Instead, current GPUs inflict dead- and livelocks on attempts to implement such synchronization in software. The paper demonstrates how to build GPU-wide non-hanging critical sections that are as easy to use as STMs but also get close to the performance of traditional fine-grained locks. Instead of sequentializing all threads that enter a critical section, the novel programmer-guided Inspected Critical Sections (ICS) keep the degree of parallelism up. As in optimistic approaches threads that are known not to interfere, may execute the body of the inspected critical section concurrently.
UnivIS-Import:2017-12-18:Pub.2017.tech.IMMD.IMMD2.effici
Keywords: GPGPU; CUDA; SIMT; Critical section; Mutual exclusion

Efficient Java RMI for Parallel Programming - Maassen, Jason; van Nieuwpoort, Rob; Veldema, Ronald; Bal, Henri; Kielmann, Thilo; Jakobs, Ceriel; Hofmann, Rutger (Acm Transactions on Programming Languages and Systems, 2001)
Java offers interesting opportunities for parallel computing. In particular, Java Remote Method Invocation (RMI) provides a flexible kind of remote procedure call (RPC) that supports polymorphism. Sun's RMI implementation achieves this kind of flexibility at the cost of a major runtime overhead. The goal of this article is to show that RMI can be implemented efficiently, while still supporting polymorphism and allowing interoperability with Java Virtual Machines (JVMs). We study a new approach for implementing RMI, using a compiler-based Java system called Manta. Manta uses a native (static) compiler instead of a just-in-time compiler. To implement RMI efficiently, Manta exploits compile-time type information for generating specialized serializers. Also, it uses an efficient RMI protocol and fast low-level communication protocols. A difficult problem with this approach is how to support polymorphism and interoperability. One of the consequences of polymorphism is that an RMI implementation must be able to download remote classes into an application during runtime. Manta solves this problem by using a dynamic bytecode compiler, which is capable of compiling and linking bytecode into a running application. To allow interoperability with JVMs, Manta also implements the Sun RMI protocol (i.e., the standard RMI protocol), in addition to its own protocol. We evaluate the performance of Manta using benchmarks and applications that run on a 32-node Myrinet cluster. The time for a null-RMI (without parameters or a return value) of Manta is 35 times lower than for the Sun JDK 1.2, and only slightly higher than for a C-based RPC protocol. This high performance is accomplished by pushing almost all of the runtime overhead of RMI to compile time. We study the performance differences between the Manta and the Sun RMI protocols in detail. The poor performance of the Sun RMI protocol is in part due to an inefficient implementation of the protocol. To allow a fair comparison, we compiled the applications and the Sun RMI protocol with the native Manta compiler. The results show that Mania's null-RMI latency is still eight times lower than for the compiled Sun RMI protocol and that Manta's efficient RMI protocol results in 1.8 to 3.4 times higher speedups for four out of six applications.
UnivIS-Import:2015-03-09:Pub.2001.tech.IMMD.IMMD2.effici
Keywords: D.1.3 [Programming Techniques]: Concurrent Programming - distributed programming; parallel programming; D.3.2. [Programming Languages]: Language Classifications-concurrent; distributed; and parallel languages; D.3.4; Object-oriented languages

Enabling Multiple Accelerator Acceleration for Java/OpenMP - Veldema, Ronald; Blaß, Thorsten; Philippsen, Michael (Proceedings 3rd USENIX Workshop on Hot Topics in Parallelism (HotPar '11), 2011)
UnivIS-Import:2015-04-16:Pub.2011.tech.IMMD.IMMD2.enabli

Evaluation of RDMA opportunities in an Object-Oriented DSM - Veldema, Ronald; Philippsen, Michael (Languages and Compilers for Parallel Computing, 20th International Workshop, LCPC 2007, 2008)
Remote Direct Memory Access (RDMA) is a technology to update a remote machine's memory without intervention at the receiver side. We evaluate where RDMA can be usefully applied and where it is a loss in Object-Oriented DSM systems. RDMA is difficult to use in modern OO-DSMs due to their support for large address spaces, advanced protocols, and heterogeneity. First, a communication pattern that is based on objects reduces the applicability of bulk RDMA. Second, large address spaces (meaning far larger than that of a single machine) and large numbers of machines require an address space translation scheme to map an object at different addresses on different machines. Finally, RDMA usage is hard since without polling (which would require source code modifications), incoming RDMA messages are hard to notice on time. Our results show that even with RDMA, update protocols are slower than invalidation protocols. But RDMA can be successfully applied to fetching of objects in an invalidation protocol and improves performance by 20.6%. © 2008 Springer-Verlag Berlin Heidelberg.
UnivIS-Import:2015-04-16:Pub.2008.tech.IMMD.IMMD2.evalua

FREACSIM - A Framework for Creating and Simulating Real-Time Capable Network on Chip Systems and Applications - Schönwetter, Dominik; Veldema, Ronald; Fey, Dietmar (Proceedings of the 8th EAI International Conference on Simulation Tools and Techniques (SIMUTOOLS'16), 2015)
UnivIS-Import:2015-10-26:Pub.2015.tech.IMMD.IMMD2.freacs

Improved DSM Efficiency, Flexibility, and Correctness - Veldema, Ronald (2010)
A collection of research topics that together help improve distributed shared memory systems. Contents: Java/OpenMP as a language for cluster and grid computing. The Tapir language as a functional/parallel language to allow both model-checking and parallel-execution for DSM middlewares and general applications.

Is There Hope for Automatic Parallelization of Legacy Industry Automation Applications? - Kempf, Stefan; Veldema, Ronald; Philippsen, Michael (Parallel-Algorithmen und Rechnerstrukturen (PARS 2011), 2011)
UnivIS-Import:2015-04-16:Pub.2011.tech.IMMD.IMMD2.isther

Iterative data-parallel mark & sweep on a GPU - Veldema, Ronald; Philippsen, Michael (Proceedings of the International Symposium on Memory Management (ISMM'11), 2011)
Automatic memory management makes programming easier. This is also true for general purpose GPU computing where currently no garbage collectors exist. In this paper we present a parallel mark-and-sweep collector to collect GPU memory on the GPU and tune its performance. Performance is increased by: (1) data-parallel marking and sweeping of regions of memory, (2) marking all elements of large arrays in parallel, (3) trading recursion over parallelism to match deeply linked data structures. (1) is achieved by coarsely processing all potential objects in a region of memory in parallel. When during (1) a large array is detected, it is put aside and a parallel-for is later issued on the GPU to mark its elements. For a data-structure that is a large linked list, we dynamically switch to a marking version with less overhead by performing a few recursive steps sequentially (and multiple lists in parallel). The collector achieves a speedup of a factor of up-to 11 over a sequential collector on the same GPU. © 2011 ACM.
UnivIS-Import:2015-04-16:Pub.2011.tech.IMMD.IMMD2.iterat
Keywords: garbage collection; GPU; mark and sweep; parallel

JaMP: An Implementation of OpenMP for a Java DSM - Klemm, Michael; Bezold, Matthias; Veldema, Ronald; Philippsen, Michael (Proceedings of the 12th Workshop on Compilers for Parallel Computers, 2006)
UnivIS-Import:2015-04-16:Pub.2006.tech.IMMD.IMMD2.jampan
Keywords: OpenMP; JaMP; Java; DSM; Jackal; Cluster; Rechnerbündel

JaMP: An Implementation of OpenMP for a Java DSM - Klemm, Michael; Bezold, Matthias; Veldema, Ronald; Philippsen, Michael (Concurrency and Computation-Practice & Experience, 2007)
Although OpenMP is a widely agreed-upon standard for the C/C++ and Fortran programming languages for the semi-automatic parallelization of programs for shared memory machines, not much has been done on the binding of OpenMP to Java that targets clusters with distributed memory. This paper presents three major contributions: (1) JaMP is an adaptation of the OpenMP standard to Java that implements a large subset of the OpenMP specification with an expressiveness comparable to that of OpenMP; (2) we suggest a set of extensions that allow a better integration of OpenMP into the Java language; (3) we present our prototype implementation of JaMP in the research compiler Jackal, a software-based distributed shared memory implementation for Java. We evaluate the performance of JaMP with a set of micro-benchmarks and with OpenMP versions of the parallel Java Grande Forum (JGF) benchmarks. The micro-benchmarks show that OpenMP for Java can be implemented without much overhead. The JGF benchmarks achieve a good speed-up of 5-8 on eight nodes. Copyright © 2007 John Wiley & Sons, Ltd.
UnivIS-Import:2015-03-09:Pub.2007.tech.IMMD.IMMD2.jampan
Keywords: Cluster; Java; OpenMP

JCudaMP: OpenMP/Java on CUDA - Dotzler, Georg; Veldema, Ronald; Klemm, Michael (Proceedings of the Third International Workshop on Multicore Software Engineering (IWMSE10), 2010)
We present an OpenMP framework for Java that can exploit an available graphics card as an application accelerator. Dynamic languages (Java, C#, etc.) pose a challenge here because of their write-once-run-everywhere approach. This renders it impossible to make compile-time assumptions on whether and which type of accelerator or graphics card might be available in the system at run-time. We present an execution model that dynamically analyzes the running environment to find out what hardware is attached. Based on the results it dynamically rewrites the bytecode and generates the necessary gpGPU code on-the-fly. Furthermore, we solve two extra problems caused by the combination of Java and CUDA. First, CUDA-capable hardware usually has little memory (compared to main memory). However, as Java is a pointer-free language, array data can be stored in main memory and buffered in GPU memory. Second, CUDA requires one to copy data to and from the graphics card's memory explicitly. As modern languages use many small objects, this would involve many copy operations when done naively. This is exacerbated because Java uses arrays-of-arrays to implement multi-dimensional arrays. A clever copying technique and two new array packages allow for more efficient use of CUDA. © 2010 ACM.
UnivIS-Import:2015-04-16:Pub.2010.tech.IMMD.IMMD2.jcudam
Keywords: OpenMP; Java; CUDA

Language and Runtime Techniques for better Model Checking Efficiency of Parallel Programs - Veldema, Ronald; Philippsen, Michael (Proceedings of the 26th International Workshop on Languages and Compilers for Parallel Computing (LCPC 2013), 2013)
UnivIS-Import:2015-04-16:Pub.2013.tech.IMMD.IMMD2.langua

Latency Reduction in Software-DSMs by Means of Dynamic Function Splicing - Klemm, Michael; Veldema, Ronald; Philippsen, Michael (Proceedings of the 16th IASTED International Conference on Parallel and Distributed Computing and Systems, 2004)
We present a compiler-based technique to automatically identify and extract Remote Procedure Calls, so-called Function Splices, out of potentially arbitrary sequences of Java code compiled for a software DSM. The goal is to lower communication latencies and message traffic by replacing data shipping by function shipping. Dynamic Function Splicing dynamically decides at runtime whether to invoke a function splice on the local machine or to execute it remotely on the home node of the requested data. On proof-of-concept micro-benchmarks Dynamic Function Splicing reduces the execution wall time by approximately 29 %; about 25 % of the messages can be saved.
UnivIS-Import:2015-04-16:Pub.2004.tech.IMMD.IMMD2.latenc
Keywords: Automatic Compiler Optimization; DSM; Jackal; Java

Model Checking a Cache Coherence Protocol for a Java DSM Implementation - Pang, Jun; Fokkink, Wan; Hofmann, Rutger; Veldema, Ronald (Proceedings of 17th International Parallel and Distributed Processing Symposium (IPDPS), 2003)
Jackal is a fine-grained distributed shared memory implementation of the Java programming language. It aims to implement Java's memory model and allows multithreaded Java programs to run unmodified on a distributed memory system. It employs a multiple-writer cache coherence protocol. In this paper, we report on our analysis of this protocol. We present its formal specification in μCRL, and discuss the abstractions that were made to avoid state explosion. Requirements were formulated and model checked with respect to several configurations. Our analysis revealed two errors in the implementation.
UnivIS-Import:2015-04-16:Pub.2003.tech.IMMD.IMMD2.modeli

Near Overhead-free Heterogeneous Thread-migration - Veldema, Ronald; Philippsen, Michael (Proceedings of the 2005 IEEE International Conference on Cluster Coomputing, 2005)
Thread migration moves a single call-stack to another machine to improve either load balancing or locality. Current approaches for checkpointing and thread migration are either not heterogeneous or they introduce large runtime overhead. In general, previous approaches add overhead by instrumenting each function in a program. The instrumentation costs are then even incurred when no thread migration is performed. In this respect our system is near-overhead free: nearly no overhead is caused if no migration is performed. Our implementation instead generates metafunctions for each location in the code where a function is called. These functions portably save and rebuild activation records to and from a machine-independent format. Each variable of an activation record is described in terms of its usages in a machine-independent 'Usage Descriptor String' to enable heterogeneous, near overhead free thread migration with as few as possible changes to a compiler. Our resulting thread migration solution is, for example, able to move a thread between an x86 machine (few registers, 32 bits) and an Itanium machine (many registers, 64 bits). Furthermore, we (optionally) move the decision on when and where to migrate to the application programmer instead of implementing a fixed 'fits-all' heuristics as in previous approaches.
UnivIS-Import:2015-04-16:Pub.2005.tech.IMMD.IMMD2.nearov

Object Combining: A new aggressive optimization for Object Intensive Programs - Veldema, Ronald; Jakobs, Ceriel; Hofmann, Rutger; Bal, Henri (Proceeding JGI '02 Proceedings of the 2002 joint ACM-ISCOPE conference on Java Grande, 2002)
Object combining tries to put objects together that have roughly the same life times in order to reduce strain on the memory manager and to reduce the number of pointer indirections during a program's execution. Object combining works by appending the fields of one object to another, allowing allocation and freeing of multiple objects with a single heap (de)allocation. Unlike object in-lining, which will only optimize objects where one has a (unique) pointer to another, our optimization also works if there is no such relation. Object inlining also directly replaces the pointer by the inlined object's fields. Object combining leaves the pointer in place to allow more combining. Elimination of the pointer accesses is implemented in a separate compiler optimization pass. Unlike previous object inlining systems, reference field overwrites are allowed and handled, resulting in much more aggressive optimization. Our object combining heuristics also allow unrelated objects to be combined, for example those allocated inside a loop; recursive data structures (linked lists, trees) can be allocated several at a time and objects that are always used together can be combined. The main focus of object combining in this paper is on reducing object (de)allocation overhead, by reducing both garbage collection work and the number of object allocations. Reduction of memory management overhead causes execution time to be reduced by up to 35%. Indirection removal further reduces execution time by up to 6%.
UnivIS-Import:2015-04-16:Pub.2002.tech.IMMD.IMMD2.object
Keywords: object; intensive; program; aggressive optimization

Object Support for OpenMP-style Programming of GPU Clusters in Java - Wolf, Carolin; Dotzler, Georg; Veldema, Ronald; Philippsen, Michael (Proceedings of the 27th International Conference on Advanced Information Networking and Applications Workshops (WAINA 2013), 2013)
For scientists, it is advantageous to use a high level of abstraction for programming their simulations, so that they can focus on the problem at hand instead of struggling with low-level details. However, current HPC clusters with multiple GPUs per node only offer explicit communication to and from the GPUs, require manual work to keep the data consistent, and often need explicit kernel programming. Moreover, knownGPU programming frameworks are limited to a single GPUor a single machine and also rarely support objects. Our system removes the above restrictions. With a slight but necessary change in Java's semantics, we achieve automatic distribution and efficient use of objects and arrays of objects on multiple GPUs in a cluster. On benchmarks that distribute arrays of objects over five machines with 10 GPUs, we achieve speedups of up to 4.9 compared to one node. © 2013 IEEE.
UnivIS-Import:2015-04-16:Pub.2013.tech.IMMD.IMMD2.object
Keywords: OpenMP; Java; Parallelism; GPU; Cluster computing

Optimizing Java specific overheads, Java at the speed of C? - Veldema, Ronald; Kielmann, Thilo; Bal, Henri (High-Performance Computing and Networking - 9th International Conference, HPCN Europe 2001, 2001)
Manta is a highly optimizing compiler that translates Java source code to binary executables. In this paper, we discuss four Java-specific code optimizations and their impact on application performance. We assess the execution time of three application kernels, comparing Manta with the IBM JIT 1.3.0, and with C-versions of the codes, compiled with GCC. With all three kernels, Manta generates faster code than the IBM JIT. With two kernels, the Manta versions are even faster than their C counterparts.
UnivIS-Import:2015-04-16:Pub.2001.tech.IMMD.IMMD2.optimi_4
Keywords: optimize; Java; speed; C

Parallel Memory Defragmentation on a GPU - Veldema, Ronald; Philippsen, Michael (Proceedings of the 2012 ACM SIGPLAN Workshop on Memory Systems Performance and Correctness (MSPC'12), 2012)
High-throughput memory management techniques such as malloc/free or mark-and-sweep collectors often exhibit memory fragmentation leaving allocated objects interspersed with free memory holes. Memory defragmentation removes such holes by moving objects around in memory so that they become adjacent (compaction) and holes can be merged (coalesced) to form larger holes. However, known defragmentation techniques are slow. This paper presents a parallel solution to best-effort partial defragmentation that makes use of all available cores. The solution not only speeds up defragmentation times significantly, but it also scales for many simple cores. It can therefore even be implemented on a GPU. One problem with compaction is that it requires all references to moved objects to be retargeted to point to their new locations. This paper further improves existing work by a better identification of the parts of the heap that contain references to objects moved by the compactor and only processes these parts to find the references that are then retargeted in parallel. To demonstrate the performance of the new memory defragmentation algorithm on many-core processors, we show its performance on a modern GPU. Parallelization speeds up compaction 40 times and coalescing up to 32 times. After compaction, our algorithm only needs to process 2%-4% of the total heap to retarget references. Copyright 2012 ACM.
UnivIS-Import:2015-04-16:Pub.2012.tech.IMMD.IMMD2.parall
Keywords: GPU; garbage collection; mark and sweep; parallel

Reduktion von False-Sharing in Software-Transactional-Memory - Kempf, Stefan; Veldema, Ronald; Philippsen, Michael (Parallel-Algorithmen und Rechnerstrukturen (PARS 2013), 2013)
UnivIS-Import:2015-04-16:Pub.2013.tech.IMMD.IMMD2.redukt

Reparallelization and Migration of OpenMP Programs - Klemm, Michael; Bezold, Matthias; Gabriel, Stefan; Veldema, Ronald; Philippsen, Michael (Proceedings of the 7th International Symposium on Cluster Computing and the Grid (CCGrid '07), 2007)
Typical computational grid users target only a single cluster and have to estimate the runtime of their jobs. Job schedulers prefer short-running jobs to maintain a high system utilization. If the user underestimates the runtime, premature termination causes computation loss; overestimation is penalized by long queue times. As a solution, we present an automatic reparallelization and migration of OpenMP applications. A reparallelization is dynamically computed for an OpenMP work distribution when the number of CPUs changes. The application can be migrated between clusters when an allocated time slice is exceeded. Migration is based on a coordinated, heterogeneous checkpointing algorithm. Both reparallelization and migration enable the user to freely use computing time at more than a single point of the grid. Our demo applications successfully adapt to the changed CPU setting and smoothly migrate between, for example, clusters in Erlangen, Germany, and Amsterdam, the Netherlands, that use different processors. Benchmarks show that reparallelization and migration impose average overheads of about 4% and 2%. © 2007 IEEE.
UnivIS-Import:2015-04-16:Pub.2007.tech.IMMD.IMMD2.repara

Reparallelization Techniques for Migrating OpenMP Codes in Computational Grids - Klemm, Michael; Bezold, Matthias; Gabriel, Stefan; Veldema, Ronald; Philippsen, Michael (Concurrency and Computation-Practice & Experience, 2009)
Typical computational grid users target only a single cluster and have to estimate the runtime of their jobs. Job schedulers prefer short-running jobs to maintain a high system utilization. If the user underestimates the runtime, premature termination causes computation loss; overestimation is penalized by long queue times. As a solution, we present an automatic reparallelization and migration of OpenMP applications. A reparallelization is dynamically computed for an OpenMP work distribution when the number of CPUs changes. The application can be migrated between clusters when an allocated time slice is exceeded. Migration is based on a coordinated, heterogeneous checkpointing algorithm. Both reparallelization and migration enable the user to freely use computing time at more than a single point of the grid. Our demo applications successfully adapt to the changed CPU setting and smoothly migrate between, for example, clusters in Erlangen, Germany, and Amsterdam, the Netherlands, that use different kinds and numbers of processors. Benchmarks show that reparallelization and migration impose average overheads of about 4 and 2%, respectively. Copyright © 2008 John Wiley & Sons, Ltd.
UnivIS-Import:2015-03-09:Pub.2009.tech.IMMD.IMMD2.repara

Runtime Optimizations for a Java DSM Implementation - Veldema, Ronald; Bhoedjang, Raoul; Hofmann, Rutger; Bal, Henri; et al. (Proceeding JGI '01 Proceedings of the 2001 joint ACM-ISCOPE conference on Java Grande, 2001)
Jackal is a fine-grained distributed shared memory implementation of the Java programming language. Jackal implements Java's memory model and allows multithreaded Java programs to run unmodified on distributed-memory systems. This paper focuses on Jackal's runtime system, which implements a multiple-writer, home-based consistency protocol. Protocol actions are triggered by software access checks that Jackal's compiler inserts before object and array references. We describe optimizations for Jackal's runtime system, which mainly consist of discovering opportunities to dispense with flushing of cached data. We give performance results for different runtime optimizations, and compare their impact with the impact of one compiler optimization. We find that our run-time optimizations are necessary for good Jackal performance, but only in conjunction with the Jackal compiler optimizations described in [24]. As a yardstick, we compare the performance of Java applications run on Jackal with the performance of equivalent applications that use a fast implementation of Java's Remote Method Invocation (RMI) instead of shared memory.
UnivIS-Import:2015-04-16:Pub.2001.tech.IMMD.IMMD2.runtim
Keywords: runtime; optimizate; Java DSM; implementation

Safe and Familiar Multi-core Programming by means of a Hybrid Functional and Imperative Language - Veldema, Ronald; Philippsen, Michael (Languages and Compilers for Parallel Computing, 22nd International Workshop, LCPC 2009, 2010)
Current (heterogeneous) multi-core environments such as gpGPU architectures are hard to program with normal imperative and object-oriented (OO) languages. There are two basic problems to tackle: (1) it is too easy to program race conditions and dead-locks with the available synchronization primitives, and (2) these environments do not support (or support inefficiently) the instructions required for efficient execution of OO programs, e.g., because function pointers and pointer arithmetic are lacking. We address both problems with a new language that comprises both Functional Programming (FP) and OO programming. We solve problem (1) by auto-parallelization in the functional core where all loops and non-dependent calls can be executed in parallel. FP is to be used to write computational intensive code with safe concurrent memory access. An alternative object model that does neither use pointer arithmetic nor function pointers but smart pointers/proxies (to implement polymorphism) as well as mixins and templates (to implement OO like code reuse) solves problem (2). To cleanly integrate the two language cores, we propose a new integration model that even grants some restricted ways to access state from within FP mode. With the new language and prototype compiler we can transparently parallelize code to target both Cuda and multi-core machines (without annotations from the programmer) and obtain good speedups. © 2010 Springer-Verlag.
UnivIS-Import:2015-04-16:Pub.2010.tech.IMMD.IMMD2.safean

Simultaneous inspection: Hiding the overhead of inspector-executor style dynamic parallelization - Brinkers, Daniel; Philippsen, Michael; Veldema, Ronald (Languages and Compilers for Parallel Computing, 27th International Workshop, LCPC 2014, 2015)
A common approach for dynamic parallelization of loops at runtime is the inspector-executor pattern. The inspector first runs the loop without any (side) effects to analyze whether there are data dependences that would prevent parallel execution. Only if no such dependences are found, does the executor phase actually run the loop iterations in parallel. In previous works, the overhead of the inspection must either be amortized by the parallel execution or is completely wasted if the loop turns out to be non-parallelizable. In this paper we propose to run the inspection phase simultaneous to an instrumented sequential version of the loop. This way we can reduce and hide the overhead in case of a non-parallelizable loop. We discuss what needs to be done so that the sequentially executed iterations do not invalidate the inspector’s concurrent work (in which case sequential execution is needed for the whole loop). Our measurements show that if a loop cannot be executed in parallel there is an overhead below 1.6 % compared to the runtime of the original sequential loop. If the loop is parallelizable, we see speedups of up to a factor of 3.6 on a quad core processor.
UnivIS-Import:2015-04-16:Pub.2013.tech.IMMD.IMMD2.double
Keywords: multi-core; parallelization; compilers; program analysis

Source Code Transformations to Increase the Performance of Software Transactional Memory - Kempf, Dieter; Veldema, Ronald; Philippsen, Michael (Languages and Compilers for Parallel Computing, 24th International Workshop, LCPC 2011, 2013)

Source-Level Global Optimizations for Fine-Grain Distributed Shared Memory Systems - Veldema, Ronald; Hofmann, Rutger; Bhoedjang, Raoul; Jakobs, Ceriel; Bal, Henri (Proceedings of the 8th ACM SIGPLAN symposium on Principles and practices of parallel programming (PPoPP 2001), 2001)
This paper describes and evaluates the use of aggressive static analysis in Jackal, a fine-grain Distributed Shared Memory (DSM) system for Java. Jackal uses an optimizing, source-level compiler rather than the binary rewriting techniques employed by most other fine-grain DSM systems. Source-level analysis makes existing access-check optimizations (e.g., access-check batching) more effective and enables two novel fine-grain DSM optimizations: object-graph aggregation and automatic computation migration. The compiler detects situations where an access to a root object is followed by accesses to subobjects. Jackal attempts to aggregate all access checks on objects in such object graphs into a single check on the graph's root object. If this check fails, the entire graph is fetched. Object-graph aggregation can reduce the number of network roundtrips and, since it is an advanced form of access-check batching, improves sequential performance. Computation migration (or function shipping) is used to optimize critical sections in which a single processor owns both the shared data that is accessed and the lock that protects the data. It is usually more efficient to execute such critical sections on the processor that holds the lock and the data than to incur multiple roundtrips for acquiring the lock, fetching the data, writing the data back, and releasing the lock. Jackal's compiler detects such critical sections and optimizes them by generating single-roundtrip computation-migration code rather than standard data-shipping code. Jackal's optimizations improve both sequential and parallel application performance. On average, sequential execution times of instrumented, optimized programs are within 10% of those of uninstrumented programs. Application speedups usually improve significantly and several Jackal applications perform as well as hand-optimized message-passing programs. Copyright 2001 ACM.
UnivIS-Import:2015-04-16:Pub.2001.tech.IMMD.IMMD2.source
Keywords: source-level; global optimization; memory system

Supporting Huge Address Spaces in a Virtual Machine for Java on a Cluster - Veldema, Ronald; Philippsen, Michael (Languages and Compilers for Parallel Computing, 20th International Workshop, LCPC 2007, 2008)
To solve problems that require far more memory than a single machine can supply, data can be swapped to disk in some manner, it can be compressed, and/or the memory of multiple parallel machines can be used to provide enough memory and storage space. Instead of implementing either functionality anew and specific for each application, or instead of relying on the operating system's swapping algorithms (which are inflexible, not algorithm-aware, and often limited in their fixed storage capacity), our solution is a Large Virtual Machine (LVM) that transparently provides a large address space to applications and that is more flexible and efficient than operating system approaches. LVM is a virtual machine for Java that is designed to support large address spaces for billions of objects. It swaps objects out to disk, compresses objects where needed, and uses multiple parallel machines in a Distributed Shared Memory (DSM) setting. The latter is the main focus of this paper. Allocation and collection performance is similar to well-known JVMs if no swapping is needed. With swapping and clustering, we are able to create a list containing 1.2×108 elements far faster than other JVMs. LVM's swapping is up to 10 times faster than OS-level swapping. A swap-aware GC algorithm helps by a factor of 3. © 2008 Springer-Verlag Berlin Heidelberg.
UnivIS-Import:2015-04-16:Pub.2008.tech.IMMD.IMMD2.suppor

Tapir: Language Support to Reduce the State Space in Model-Checking - Veldema, Ronald; Philippsen, Michael (Informatik 2009 - Im Focus das Leben, 2009)
Model-checking is a way of testing the correctness of concurrent programs. To do so, a model of the program is proven to match properties and constraints specified by the programmer. The model itself is created by disregarding irrelevant program details. The biggest problem in model-checking is the number of program states that need to be tested. Tapir, a simple but familiar object-oriented language and accompanying tool chain, addresses this problem in two ways. First, the programmer can provide application specific program transformations that reduce the state space. Second, for selected classes and methods, the programmer can provide an alternative implementation: a slim black box version for use in model-checking that abstracts away many details of the full fledged implementation. Tapir's aspect-oriented test case generation combined with black-boxing allows model-checking of low-level library code.
UnivIS-Import:2015-04-16:Pub.2009.tech.IMMD.IMMD2.tapirl

Using Object Combining for Object Prefetching in DSM Systems - Veldema, Ronald; Philippsen, Michael (Proceedings of the 11th Workshop on Compilers for Parallel Computers (CPC 2004), 2004)
UnivIS-Import:2015-04-16:Pub.2004.tech.IMMD.IMMD2.usingo