Diploma Thesis Projects 2023-2024
-
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.
-
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.
-
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.
-
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.
-
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.
-
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).
-
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.
-
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.
-
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.
-
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.
-
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
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
JVM: Java static analysis
Develop a static analysis for Java that computes NUMA locality and
object lifetime.
-
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.
-
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.
-
Programming Languages: Contextual effects in Rust
Extend the type system of the Rust compiler to generate
contextual effect constraints.
-
Programming Languages: Locality in the Rust Memory Allocator
Measure locality and object lifetimes in Rust programs.
-
Runtime Systems: Graph Partitioner Selector
Implement a machine learning model to dynamically select among
graph partitioning algorithms in the Spark GraphX
graph-analytics framework.
-
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
-
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.
-
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.
-
Programming Languages: Static Analysis in Rust
Extend the type system of the Rust compiler to generate and
solve constraints to compute a property.
-
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
-
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.
-
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.
-
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.
-
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.
-
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.
-
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.
-
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
-
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.
-
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.
-
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.
-
Streaming Graph Analytics in Flink
Description:
Augment the Graph-Streaming library of Flink with additional
streaming algorithm implementations.
-
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
-
MPI benchmarking
Description:
Write tests and test automation, port existing benchmarks, and
evaluate MPI applications on experimental hardware platforms
with DMA-accelerated MPI.
-
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.
-
Linux Kernel
Description:
Add support for kernel self-extraction during boot for the
RISC-V architecture.
-
Linux Kernel
Description:
Extend the perf tool (implemneting all required in-kernel
support) with additional counters for experimental HPC
architectures.
-
OpenMP tasks in Eclipse
Description:
Learn the Eclipse C internal representation, learn the workings of
an existing static analysis engine and interface the two.
-
Twitter Flu Trends
Calculate the phases of flu epidemics using twitter data.
Diploma Thesis Projects 2017-2018
-
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.
-
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.
-
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
-
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
-
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
-
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.
-
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.
-
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
-
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.