Diploma Thesis Projects 2023-2024

  1. JVM: Dynamic Analysis
    Implement a dynamic analysis in the OpenJDK JVM. The analysis will extend the C1 and C2 JIT compilers inside the JVM to produce instrumented code that tracks read and write accesses, producing a trace. Another tool can then read and analyze the trace to produce statistics about memory access, or detect data races or deadlocks in parallel code.
  2. JVM: Add support for secret bytecode
    The goal of this project is to change the JVM JIT compiler to keep the bytecode secret from external attackers for as long as possible during the program execution. Work involves understanding and modifying the deoptimization path and stack rewriting part of OpenJDK.
  3. JVM: Port the TLA+ language runtime to TeraCache
    TeraCache is an extension of OpenJDK that can place a very large Java Heap on SSD and NVMe devices. The goal of this project is to port the TLA+ engine to TeraCache, so that it is able to store objects in the heap and avoid serialization onto disk files.
  4. JVM: Port the Lucene search engine to TeraCache
    TeraCache is an extension of OpenJDK that can place a very large Java Heap on SSD and NVMe devices. The goal of this project is to port the Lucene search engine to TeraCache, so that it is able to store objects in the heap and avoid serialization onto disk files.
  5. Graph Analytics: Misleading Repurposing Detection
    Misleading repurposing occurs when a malicious user changes the identity of their social media account for a new purpose, while retaining their followers. The goal of this project is to replicate work in the corresponding paper by Elmas and Overdorf (in ICWSM-2023) and apply it to Greek-speaking twitter traffic.
  6. Graph Analytics: Community Detection
    Compare a set of community detection algorithms using Twitter data. Correlate with real-world outcomes (election results, market surveys, official statistics).
  7. MPI Simulator: Efficient Trace Generation
    Supercomputing applications are often simulated before running on actual supercomputers with millions of CPUs. The goal of this work is to augment an existing state-of-the-art MPI simulator with support for generating traces fast, which can then be simulated on different supercomputer configurations. Skills involved include C++, MPI, some statistics, possibly Python.
  8. MPI Simulator: Assess Simulator Accuracy
    The goal of this work is to analyze trace and simulation data, compare with actual supercomputer runs and other simulated results, and estimate the accuracy of the simulator model. It will require some C++, but most of the work will be analyzing data (this includes doing some statistics) using Python and Jupyter notebooks, and investigating where we see deviations.
  9. MPI Simulator: Support for Collectives
    The goal of this work is to extend an existing Supercomputer simulator with support for all-to-all MPI collective operations. Work will involve understanding, porting and developing C++, and some understanding of distributed systems.
  10. MPI Simulator: Topology-aware Job Mapping
    In practice, the resources of a supercomputer are managed by a central system that allocates slices of it to different applications. It is best that different applications do not interfere with each other on the CPU or network links. To do this, the algorithm that allocates resources for each job must know how the compute nodes are connected with each other (topology), and select slices that are convex (i.e., messages do not use network resources outside of that slice).
    This project will start with the fat-tree topology (where an approximate solution should be fairly straight-forward), and then move on to more demanding topologies (torus and dragonfly). It involves work on the algorithmic aspects and a C++ implementation.
  11. Compilers: LLVM Fortran evaluation
    There are two main Fortran frontends for LLVM (the old "classic flang" and the new "f18" flang; both differ from the less used lfortran). The goal of this task is to evaluate the current status of the new f18 front end on RISC-V and AArch64 targets. A comparison of the two front-ends can be done using the Fortran benchmarks of SPEC CPU 2017. Findings, such as workflows to build and use the front-ends or limitations, document the current status.
    Classic flang: flang
    F18 flang: f18

Diploma Thesis Projects 2022-2023

  1. Compilers: LLVM T-Head Ba/Bb/Bs Support
    T-Head has a RISC-V SoC with vendor-specific extensions (see the spec). The goal of this task is to add support for the xtheadba, xtheadbb and xtheadbs extensions to LLVM and evaluate the speedup. Note that these extensions are similar to the RISC-V zb* (zba, zbb, zbc, zbs) extensions, which are already supported in LLVM. Besides implementing the instructions and extending the cost model, a proper integration is required in order to let the compiler optimize provided code and emit these instructions. Adding new test cases to LLVM's test infrastructure ensures future changes won't break the functionality. The evaluation of the speedup can be achieved by comparing the dynamic instruction count of SPEC CPU 2017 benchmarks using QEMU.
  2. Compilers: LLVM T-Head CondMov, Mac Support
    T-Head has a RISC-V SoC with vendor-specific extensions (see the spec). The goal of this task is to add support for the xtheadcondmov and xtheadmac extensions to LLVM and evaluate the speedup. Note, that these extensions are similar to existing instructions in other architectures (Mips has similar conditional move instructions, AArch64 as similar multiply-accumulate instructions), which are already supported in LLVM. Besides implementing the instructions and extending the cost model, a proper integration is required in order to let the compiler optimize provided code and emit these instructions. Adding new test cases to LLVM's test infrastructure ensures future changes won't break the functionality. The evaluation of the speedup can be achieved by comparing the dynamic instruction count of SPEC CPU 2017 benchmarks.
  3. Compilers: LLVM MemPair, MemIdx, FMemIdx Support
    T-Head has a RISC-V SoC with vendor-specific extensions (see the spec). The goal of this task is to add support for the xtheadmempair, xtheadmemidx and xtheadfmemidx extensions to LLVM and evaluate the speedup. Note, that these extensions are similar to similar instructions in AArch64, which are already supported in LLVM. Besides implementing the instructions and extending the cost model, a proper integration is required in order to let the compiler optimize provided code and emit these instructions. Adding new test cases to LLVM's test infrastructure ensures future changes won't break the functionality. The evaluation of the speedup can be achieved by comparing the dynamic instruction count of SPEC CPU 2017 benchmarks.
  4. JVM: Add support for secret bytecode
    The JVM uses a class loader to parse class files and load bytecode to be executed. The goal of this project is to change the class loader to support encrypted class files, aimed to keep the bytecode secret from external attackers. Work includes defining the threat model and possibly working also with the JIT compiler to minimize the attack window, i.e., the time that unencrypted bytecode stays in memory and can be stolen via e.g., a core dump.
  5. JVM: OpenJDK memory performance profiling
    Some JVM garbage collectors occasionaly pause program execution to perform GC tasks atomically. The goal of this project is to augment the JVM with performance counter tracing (using the Perf API) and produce detailed traces of hardware counters for memory events (cache misses, hits, etc.). The traces should be able to separately profile the application memory performance and the GC memory performance.
  6. JVM: Java Garbage Collection
    Extend OpenJDK with support for annotations that control memory placement and lifetime of objects, and adapt the garbage collector to migrate objects accordingly.
  7. JVM: Java static analysis
    Develop a static analysis for Java that computes NUMA locality and object lifetime.
  8. Streaming Analytics: Adaptive Flink Scheduler
    Apache Flink is a framework for streaming big-data analytics. Extend the Flink scheduler to dynamically adapt the precision of computation during execution, depending on latency and cost targets.
  9. Streaming Analytics: Transprecise Analytics Operators
    Apache Flink is a framework for streaming big-data analytics. Implement a transprecise operator for Flink streams, that can change its precision/speed trade-off during execution. Examples may be logistic/linear regressions, graph triangle counts, shortest path, pagerank, k-means, etc. Study the sensitivity to precision of arithmetic representations.
  10. Programming Languages: Contextual effects in Rust
    Extend the type system of the Rust compiler to generate contextual effect constraints.
  11. Programming Languages: Locality in the Rust Memory Allocator
    Measure locality and object lifetimes in Rust programs.
  12. Runtime Systems: Graph Partitioner Selector
    Implement a machine learning model to dynamically select among graph partitioning algorithms in the Spark GraphX graph-analytics framework.
  13. Social Network Analytics: Link Prediction
    Train a Machine Learning or Deep Learning model to predict user interactions on social media.

Diploma Thesis Projects 2021-2022

  1. Social Network Graph Analytics: Find blocking and ghosting
    Description: Design and implement an analysis to infer blocking between social network users, using a large dataset from Twitter. Investigate how blocks parition the graph, discover how information diffusion is limited by users blocking or ghosting other users.
    Further information: Implement an information diffusion analysis on large multilayer graphs, using the Spark-GraphX distributed analytics runtime system. Use special features of the twitter API to infer when users have blocked other users. Based on the inferred block relations, study two existing alternative algorithms for information diffusion in social networks, and discover how the existence of a single block edge limits information diffusion in the full graph on average.
    Related topics: Graph theory, information diffusion (algorithms used in epidemiology), graph analytics, multilayer graphs, statistics.
  2. Social Network Graph Analytics: Predict account bans
    Try to predict account bans on the YouTube or Twitter social network graphs. This project will use graph embedding algorithms to represent evolving graphs and perform machine learning on the embeddings, to predict which nodes in the graph may be deleted in the near future.
  3. Programming Languages: Static Analysis in Rust
    Extend the type system of the Rust compiler to generate and solve constraints to compute a property.
  4. Programming Languages: Static Race Detection Warning Ranking
    Port, maintain, and evaluate the Locksmith static analyzer on a set of C programs. Data race detection produces a large list of warnings of possible races. This project will try to rank these warnings by order of importance, trying and comparing two ranking approaches.

Diploma Thesis Projects 2020-2021

  1. Learn Rust, Parse Rust, Analyze Rust
    Familiarize yourself with existing open-source Rust front-ends, compare and benchmark them and develop a simple static checker for Rust programs in one of the existing front-ends.
  2. LLVM and OpenMP tasks
    Extend LLVM with OpenMP tasks, and link it with the PARTEE task-parallel runtime system. LLVM is a production compiler written in C++. PARTEE is an API and runtime system written in low-level C, targeting distributed DMA-based and shared-memory architectures.
  3. Java Garbage Collection
    Extend one of the OpenJDK JVM Garbage Collectors with support for placing objects on memory pages in a programmable way, in order to achieve better temporal and spatial locality. Then benchmark your GC with different kinds of applications.
  4. Artificial Intelligence on Social Network Graphs
    Extend an existing algorithm for graph embeddings with structural features for shapes other than triangles. Explore applications where such features make an improvement in existing Machine Learning or Deep Learning models, and measure the improvement.
  5. Social Network Graph Analytics: Community Detection
    Description: Analyze twitter traffic on a given topic such as Type 2 Diabetes, and map the involved community. Use community detection analysis to identify users and groups that repeatedly interact with the topic. Calculate usage patterns, correlation with demographic, and geolocation data. Implement your analysis in a scalable analytics framework (Spark or Flink) and calculate performance and scalability.
  6. Social Network Graph Analytics: Information Diffusion
    Description: Design and implement a plugin for a twitter crawler that will discover and report in real time the diffusion graphs produced for specific keywords, memes, or phrases.
    Further information: Information diffusion is the analysis of the propagation of information in networks. Retweets are an exmaple of information diffusion, where an original piece of information may be propagated to users that were not immediately exosed to the original content in the graph, but were eventually able to see the content because of a path of retweets from the original poster to the user.
    The aim of this project is to develop a streaming analysis on streams of data produced by a twitter crawler and subsequently produce a stream of evolving diffusion graphs for selected memes, hashtags, phrases, urls, topics, etc.
    Related topics: Graph theory, information diffusion (algorithms used in epidemiology), graph analytics, multilayer graphs, statistics.
  7. Static Analysis in Infer
    Description: Extend the Infer static analysis system with contextual effects.
    Related information: Infer is an open source tool mainly developed by Facebook that can analyze programs written in C, C++, Objective C, and Java. It models heaps using propositions in separation logic.
    Related reading:
    • Find the Infer repository in github, read its documentation, install and compile it, and use it to analyze example programs.
    • Read on separation logic, starting from the Wikipedia page and the seminal paper by Reynolds.

Diploma Thesis Projects 2019-2020

  1. OpenMP distributed memory allocation
    Description: Extend OpenMP with directives for memory allocation patterns tailored to NUMA or distributed memories.
    Related reading: Region-based memory management, the Legion parallel programming language.
  2. Fault-tolerant PARTEE tasks
    Description: Extend the PARTEE runtime system with support for local and global checkpointing and recovery from both transient and permanent errors. Measure the overhead of fault tolerance on task-parallel programs. This project will use experimental hardware and requires physical presense in FORTH.
  3. Social Network Graph Analytics: Community Detection
    Description: Design and implement an analysis that discovers users speaking about a specific topic in social media, and mines the corresponding graph. Analyze the detected community with respect to placement in the general audience.
  4. Streaming Graph Analytics in Flink
    Description: Augment the Graph-Streaming library of Flink with additional streaming algorithm implementations.
  5. Graph Analytics in Flink
    Description: Reimplement an existing graph analytics computation in the Flink distributed analytics runtime system.
    Further information: Read the TwitterMancer paper and implement feature extraction by modifying the Triangle Count algorithm accordingly.

Diploma Thesis Projects 2018-2019

  1. MPI benchmarking
    Description: Write tests and test automation, port existing benchmarks, and evaluate MPI applications on experimental hardware platforms with DMA-accelerated MPI.
  2. MPI collectives
    Description: Understand the existing implementation of MPI collectives and investigate alternative implementations better tailored for DMA-accelerated communication and very low custom networks in experimental HPC hardware.
  3. Linux Kernel
    Description: Add support for kernel self-extraction during boot for the RISC-V architecture.
  4. Linux Kernel
    Description: Extend the perf tool (implemneting all required in-kernel support) with additional counters for experimental HPC architectures.
  5. OpenMP tasks in Eclipse
    Description: Learn the Eclipse C internal representation, learn the workings of an existing static analysis engine and interface the two.
  6. Twitter Flu Trends
    Calculate the phases of flu epidemics using twitter data.

Diploma Thesis Projects 2017-2018

  1. Benchmarking Kernel Memory Allocators
    Compare kernel allocation accross an off-the-shelf platform based on x86 machines and an experimental ARM-based blade. Develop benchmarks and draw conclusions.
  2. Twitter Graph Analytics for Targetted Marketing
    Parallelize and optimize existing algorithms for distributed analytics. Develop a marketing application for the Twitter graph for the Spark and Spark/GraphX analytics engines.
  3. Graph Analytics for Flink Gelly
    Benchmark Flink Gelly with large social network graphs. Replicate existing anaytics pipelines for twitter in Flink.

Diploma Thesis Projects 2016-2017

  1. Alternative RDD implementations for Spark
    Description: Learn to code in Scala and Spark and write one or more extensions of Spark RDDs optimized for specific algorithms.

Diploma Thesis Projects 2013-2014

  1. LLVM and tasks
    Description: Extend LLVM with a "spawn" keyword that calls a function in parallel, as in Cilk, and link it with the PARTEE task-parallel runtime system.

Diploma Thesis Projects 2012-2013

  1. Task-parallel Fault Tolerance
    Extend the BDDT runtime system with fault-tolerance. Define a realistic fault model for permanent and transient faults on existing multicore computers. Extend the BDDT runtime system with support for local and global checkpointing and recovery from both transient and permanent errors. Measure the overhead of fault tolerance on task-parallel programs.
  2. Runtime Dependencies in Recursively Parallel Programs
    Implement a runtime analysis for dependencies among recursively-parallel tasks, and extend an existing runtime system (e.g., Cilk) with a dependency-aware scheduler.
  3. Static analysis in Eclipse
    Learn the architecture of the Eclipse IDE (for either Java or C programming), including the AST and analysis frameworks, and write an Eclipse interface for an existing static analysis engine.

Internship Topics 2012

  1. A fault-tolerant task parallel runtime
    Positions: 1
    Lab: CARV
    Description: Understand the BDDT runtime and add support for checkpointing of computations, and restoring to an earlier point on fault.