Many of today’s Big Data systems are developed in the Java programming language and require fast object serialization and deserialization for efficient and high-speed message exchange. We address this by introducing Skema, a library providing high-performance serialization of Java objects. Skema works based on Ahead-of-Time schema generation, so that only a minimal number of operations need to be performed at runtime to serialize an object. This approach allows Skema to also serialize individual objects only partially which is a great advantage for network communications with fixed buffer sizes. Furthermore, targeted optimizations, such as caching the size of the serialized form of objects that have a fixed size so that they do not have to be recomputed for each operation, are presented. In addition to a more in-depth explanation of the implemented procedures, this paper also presents benchmark results comparing the Skema library against Kryo, FST and the native Java serialization function. The results of these experiments achieve very good values in comparison with the remaining libraries. For example, one experiment shows that there can be nearly a hundredfold increase in the speed of deserializing objects when compared to the native Java serialization mechanism by using Skema. We also show that deserializing objects using the native Java mechanism requires a large amount of additional memory per operation, which puts a burden on the garbage collector afterwards. Finally, to investigate the scalability of the implemented solution, the benchmarks are also performed using different numbers of threads and the results are presented graphically.

HPC and cloud data centers offer an increasing amount of cores per CPU, GPUs and high-speed networks like InfiniBand with up to 400 Gbit/s. Scaling out big-data computing is mostly limited by the network performance. However, many big data frameworks are written in Java (often using netty), which cannot fully exploit the performance of such networks. The reason is found in Java NIO, which is based on traditional sockets, while InfiniBand provides ibverbs, a totally different interface, to the operating system and applications. This challenge has been addressed by different approaches, providing transparent and non-transparent acceleration via high-speed NICs, many of them no longer maintained.In this paper, we propose hadroNIO, a Java library, providing transparent network acceleration for Java NIO applications, based on Unified Communication X (UCX). The latter is written in C, providing efficient access to different network technologies. hadroNIO has been extended to use Infinileap for efficiently accessing UCX. Infinileap is using the new Foreign Function & Memory APIs of Oracle’s Project Panama to access native code.Our evaluation results show, that hadroNIO allows netty to achieve round-trip times of less than 5 μs on a 100 GBit/s network and efficiently handle hundreds of connections per server. We compare the raw performance of hadroNIO with traditional Java sockets and libvma using a netty microbenchmark and include experiments with gRPC and Apache ZooKeeper. The measurements show, that hadroNIO outperforms existing solutions, while being transparent for applications and developers.

In this paper, we propose Infinileap, a modern networking framework enabling high-performance memory transfer mechanisms like Remote Direct Memory Access (RDMA) for applications written in Java. Infinileap is based on the Open Communication X (UCX) framework, which is accessed from Java. This is accomplished through Oracle's Project Panama, which is currently in the preview phase and aims to significantly improve interoperability between Java and “foreign” languages, such as C. In contrast to often used internal and unsupported JDK APIs, Project Panama's APIs are explicitly intended for use and developers are encouraged to adapt their existing code accordingly. Using Project Panama, we implement an object as well as future-oriented framework based on UCX. Our experiments show that Infinileap and thus Project Panama's innovations work reliably and efficiently under heavy load and also, within benchmarks implemented for this purpose based on the Java Microbenchmark Harness (JMH), achieve very good performance results with over 110 million messages per second and round-trip latencies below two microseconds with a single ConnectX-5 InfiniBand (single-port) network interface controller.

InfiniBand networks with bandwidths up to 400 Gbit/s and sub-microsecond latencies are more and more popular in HPC and cloud data centers. Many big-data frameworks, such as Apache Spark and Cassandra, are written in Java and use Java NIO socket channels, which are designed for Ethernet networks. Rewriting network code for such complex systems is typically not an option and thus, transparent solutions like IP over InfiniBand are used.In this paper, we present hadroNIO, a Java library, that transparently replaces the default NIO implementation, providing support for InfiniBand (as well as Ethernet and other transports) through the Unified Communication X (UCX) library. We compare our library against other transparent network acceleration solutions in an InfiniBand environment and also evaluate the overhead, that is introduced by using hadroNIO versus directly accessing UCX. We show that it is possible to achieve latencies as low as 3.1 μs, while also being able to leverage the full bandwidth of InfiniBand hardware with our fully transparent acceleration solution. In the future we aim at extending hadroNIO, and thus the NIO API, with RDMA directives.

Fast networks like InfiniBand are important for large-scale applications and big data analytics. Current InfiniBand hardware offers bandwidths of up to 200 Gbit/s with latencies of less than two microseconds. While it is mainly used in high performance computing, there are also some applications in the field of big data analytics. In addition, some cloud providers are offering instances equipped with InfiniBand hardware. Many big data applications and frameworks are written using the Java programming language, but the Java Development Kit does not provide native support for InfiniBand. To this end we propose neutrino, a network library providing comfortable and efficient access to InfiniBand hardware in Java as well as epoll based multithreaded connection management. Neutrino supports InfiniBand message passing as well as remote direct memory access, is implemented using the Java Native Interface, and can be used with any Java Virtual Machine. It also provides access to native C structures via a specially developed proxy system, which in turn enables the developer to leverage the InfiniBand hardware's full functionality. Our experiments show that efficient access to InfiniBand hardware from within a Java Virtual Machine is possible while fully utilizing the available bandwidth.

Low-latency network interconnects, such as InfiniBand, are widely used in HPC centers and are becoming available in public cloud offerings, too. For MPI applications accessing InfiniBand is transparent, but many big-data applications are written in Java, which does not provide direct access to InfiniBand networks, but relies on thid-party libraries. In this paper, we present Observatory, a benchmark for evaluating low-level libraries, providing InfiniBand access for Java applications. Observatory can be used for evaluating and comparing socket- and verbs-based libraries regarding throughput and latency. With transparency often traded for performance and vice versa, the benchmark helps developers with studying the pros and cons of each solution and supports them in their decision which solution is more suitable for their existing or new use-case. We also give an overview of existing and maintained InfiniBand libraries for Java and evaluate them with the proposed benchmark.