Radio Astronomy and LOFAR / SKA

I contributed to several software packages and modules for the LOFAR radio telescope. These codes are mostly generic, and can be used for other telescopes as well. In most cases, the codes are available in C++ for CPUs, and in Cuda and OpenCL for GPUs.

Polyphase filter banks

  • I wrote the polyphase filter bank generator for LOFAR. This code generates the filter weights for polyphase filter banks with arbitrary numbers of channels and taps, and with configurable windows. The code is a part of the LOFAR real-time central processor (the correlator). The code for the run-time generation of the filter banks is available from GitHub.
  • Together with Karel van der Veldt, Ana Lucia Varbanescu and Chris Jesshope, I worked on A Polyphase Filter For GPUs And Multi-Core Processors. A paper about this implementation was published at the First Workshop on High Performance Computing in Astronomy (AstroHPC 2012). For more details on the implementation, you can also have a look at Karel’s master thesis: A Polyphase Filter For GPUs And Multi-Core Processors. The code runs on Intel CPUs (written in C), NVIDIA (with Cuda) and AMD GPUs (with OpenCL), and on the simulated MicroGrid architecture. The source code is available here.

Beam Forming


Radio Frequency Interference (RFI) Mitigation

  • eAstroVis
  • LOFAR code
  • GPU implementation

Pulsar Search

More details to follow…



Ibis is an open source Java distributed computing software project of the Computer Systems group, which is part of the Computer Science department of the Faculty of Sciences at the VU University, Amsterdam, The Netherlands.

The main goal of the Ibis project is to create an efficient, portable Java-based platform for distributed computing. The Ibis project currently consists of the IPL (a communication library), a variety of programming models, the Java Grid Application Toolkit, and the Zorilla peer-to-peer middleware. All components can be deployed on any compute platform, due to the use of Java.


The Ibis Portability Layer (IPL)

The Ibis Portability layer (IPL) is a communication library specifically designed for usage in a grid environment. It has a number of properties which help to achieve its goal of providing programmers with an easy to use, reliable grid communication infrastructure:

Run anywhere
Ibis, is programmed in Java. Because of this it is possible to use Ibis programs anywhere a Java Virtual machine is available.
In addition to the standard network types available in Java, Ibis is able to use fast local networks such as Myrinet where these are available. If multiple network types are present on a single system, Ibis will automatically select the best type available.
By offering multiple communication models, not only unicast communication, it is possible to express virtually any communication pattern easily and efficiently using Ibis.
Availability of resources in grid system changes constantly as network and hardware fail and new resources get added to a grid. Ibis offers support for keeping track of machines in a computation to address these problems.
The design of the IPL is deliberately kept simple. This makes adding support for new network types easy, and allows for easy adaptation of Ibis as an communication framework.


The Satin Divide-and-Conquer Parallel Programming Model

Satin extends Java with Cilk-like primitives that make it very convenient for the programmer to write divide and conquer style programs. Unlike manager/worker programs, divide-and-conquer algorithms operate by recursively dividing a problem into smaller sub-problems. This recursive subdivision goes on until the remaining sub-problem becomes trivial to solve. After solving sub-problems, their results are recursively recombined until the final solution is assembled. Due to its hierarchical nature, the divide-and-conquer model maps cleanly to extremely large-scale systems, which also tend to have an hierarchical structure. Satin contains a efficient and simple load-balancing algorithm, Cluster-aware Random Stealing (CRS), which outperforms existing load- balancing strategies on large multi-cluster systems. In addition, Satin also provides efficient fault-tolerance, malleability (e.g. the ability to cope with dynamically changing number of processors) and migration in a way that is transparent to the application.


MPJ: MPI for Java

The MPJ programming interface has been defined by the Java Grande forum to provide MPI-like message passing for Java applications. Ibis MPJ is a pure-Java implementation of this interface, and delivers high-performance communication, while being deployable on various platforms, from Myrinet-based clusters to grids. See a paper by Markus Bornemann et. al. for more details.


Efficient Java Remote Method Invocation

We built a Remote Method Invocation (RMI) implementation on top of Ibis. RMI is described here. Ibis boosts RMI performance using several optimizations, especially to avoid the high overhead of runtime type inspection that current RMI implementations have. Earlier projects (e.g., Manta) applied similar optimizations by writing parts of the runtime system in native code (C instead of Java), giving up Java’s high portability. The philosophy behind Ibis is to try to obtain good performance without using any native code, but allow native solutions to further optimize special cases. For example, a Grid application developed with Ibis can use a pure-Java RMI implementation over TCP/IP that will run “everywhere”. However, when the application runs on, say, a Myrinet cluster, the RMI runtime system can request Ibis to load a more efficient communication implementation for Myrinet that partially uses native code.


The Java Grid Application Toolkit (JavaGAT)

The Java Grid Application Toolkit (JavaGAT) offers a set of coordinated, generic and flexible APIs for accessing grid services from application codes, portals, data managements systems, etc.

JavaGAT sits between grid applications and numerous types of grid middleware, such as Globus, Glite, SGE, SSH or Zorilla. JavaGAT lifts the burden of grid application programmers by providing them with a uniform interface that provides file operations, job submission, monitoring, and access to information services. As a result, grid application programmers need only to learn a single API to obtain access to the entire grid. Due to its modular design, JavaGAT can easily be extended with support for other grid middleware layers.