To assign

The department currently uses the APGAS library in its research, which extends Java with parallel and distributed programming. For this purpose, APGAS divides the global address space and the processors of a computer cluster and offers the possibility to dynamically create tasks (subtasks that can be executed in parallel). The tasks are managed in a task pool and assigned to free processes or threads for processing. In the current APGAS version, this assignment can be made system-wide, which ensures global load balancing.

The task-based programming model of APGAS opens up new possibilities for handling hardware faults: It is sufficient to merely re-execute the affected tasks, provided that their inputs can be reconstructed from saved information.

The department is currently developing APGAS and error handling in various directions. The following theses are available in the context of this topic:

Further benchmarks are needed to evaluate fault-tolerant task pool algorithms. By this we mean programs that efficiently implement parallel algorithms using task pools. Examples are graph algorithms or game tree search. The selection will be made in consultation with the interested parties. The benchmarks have to be implemented and extensively tested with Java in combination with APGAS.

The Habanero C/C++ (HClib) library has some similarities to the APGAS library. Thus both libraries support the development of distributed programs on basis of tasks. In this Bachelor work the two libraries are to be compared both conceptually and experimentally with one another. As basis for the comparison an existing Benchmark is to be ported from HClib to APGAS. The comparison is to consider on the one hand the usability, thus the own experiences with the training, installation and programming, and on the other hand the performance of the programs. The measurements are to be carried out via ssh on the high-performance computer of the University of Kassel.

The Charm4py-framework implements a parallel programming modell for Python. The framework is based on Charm++ (a C++-extension), but offers a much simpler API. So it connects it the Python advantage of a highn productivity in theprogrammingungwith the C++ advantage performantr applications. Charm4py has some similarities to the APGAS library for Java. For example, both libraries support the development of distributed programs: APGAS by means of asynchronous tasks; and Charm4py by means of cooperating message-driven objects. In this Bachelor work the two librariesboth conceptually and experimentally with each other both conceptually and experimentally. As basis for the comparison an existing benchmark of Charm4py will be ported to APGAS. The comparison should consider on the one hand the usability, i.e. the own experiences with the training, installation and programming, and on the other hand the performance of the programs. The measurements shall be done via ssh on the high performance computer of the University of Kassel.

The topic can alternatively be worked on in a master thesis, if additionally anexisting APGAS benchmarkis ported to Charm4py and an analysis of the different load balancing methods is performed.

Legion is a task-based parallel programming system for high-performance computers currently under development at Stanford University. It thus represents an alternative to the conventional MPI. A special feature is the concept of logical regions, which can be used to describe the distribution of data in the cluster in abstract form. In the bachelor thesis several simple benchmarks (e.g. Pi computation, k-Means, Stencil computation) shall be implemented with Legion and MPI and the programs shall be compared. The comparison should consider on the one hand the usability, i.e. one's own experiences with familiarization, installation and programming, and on the other hand the performance of the programs.

The Loom project aims to bring the concept of so-called Fibers to Java. Fibers are lightweight threads that are managed by the Java Virtual Machine (and not the operating system). So far this functionality is only available in an early access version of an OpenJDK. In the bachelor thesis simple benchmarks (e.g. UTS, NQueens) shall be implemented using Fibers and the traditional fork/join pool concept. After implementation, the performance of the two variants shall be compared and discussed. The measurements are to be performed via ssh on the high-performance computer of the University of Kassel.

GraalVM is a new universal Java Virtual Machine that can run applications in JavaScript, Python, R and Java, but also in C/C++. The common runtime environment enables interoperability of the programming languages. In addition, GraalVM allows Java applications to be compiled into standalone executables. In this bachelor thesis, the performance-critical sections of existing APGAS benchmarks will be ported to C and then the code will be called using GraalVM. After implementation, the performance of the new variant is to be compared with that of the previous pure Java implementation when run with GraalVM or Oracle JDK, and differences discussed. The measurements will be performed via ssh on the high performance computer of the University of Kassel.

Several variants of fault-tolerant task pools have been developed in the field and implemented in APGAS. All variants have in common that they save the task descriptors and previous results of each worker in the working memory of another worker. In case of a worker failure, the data is restored at runtime by another worker. In this master thesis, an already existing scheme is to be modified in such a way that it is more closely oriented to the well-known technique of application-based checkpoint/restart. In particular, this requires writing the relevant data to a distributed file system (instead of to memory). This must be done as efficiently as possible, and the backups must always be kept up-to-date and consistent. These backups should then be used to continue the application: a) automatically in the event of an error, or b) at a later time, for example when the duration of the computation exceeds the maximum time limit of the cluster. For the restart a new start routine has to be implemented within APGAS. After the implementation performance and correctness shall be analyzed. The measurements are to be performed via ssh on the high-performance computer of the University of Kassel.

The fault tolerance schemes developed in the field have so far been tested exclusively for task pools that implement workstealing using the so-called lifeline scheme. Although this is a sophisticated method for load balancing, task pools based on a simpler randomized workstealing scheme are more common. In the master thesis, one to three of the fault tolerance schemes for distributed task pools with randomized workstealing will be re-implemented. Adaptations of the algorithms may be required in the process. The implementation can be done using MPI or the APGAS library, after consultation with the supervisors. Subsequently, the runtime overheads for fault tolerance shall be measured and compared to previous results regarding the lifeline scheme. The measurements are to be performed via ssh on the high-performance computer of the University of Kassel.

Possibly, further topics are possible after consultation, for example on program development and/or parallelization of C++ programs of the Center for Environmental System Research at the University of Kassel. These are concerned with the simulation of the effects of climate change, among other things on land use and the water balance.
 

Proposals for own topics can be submitted, but must be closely related to the research of the field, especially to parallel programming.

If you would like to create your thesis in latex, the latex template can be helpful.

If you are interested, please contact us, write an e-mail to Prof. Dr. Claudia Fohry or come to the office hours on Tuesdays between 2 and 3 pm.