Christos Psarras, M.Sc.

Contact

Christos Psarras
Aachen Institute for Advanced Study in
Computational Engineering Science
Rogowski Building
Schinkelstr. 2
52062 Aachen
Germany

Office: Schinkelstr. 2, room 430
Phone: +49 241 80 90 142
Email:

Research Interests

  • High-Performance and Parallel Computing
  • Numerical Linear Algebra
  • Tensor Algebra Computations
  • Machine Learning
  • Computer Vision

Software

  • CP-CALS: Software for computing the Canonical Polyadic Decomposition (CPD), also known as PARAllel FACtors (PARAFAC), using the Concurrent Alternating Least Squares Algorithm (CALS).
    Role: Designer and main developer.
  • LAMP Benchmark: A series of benchmarks/tests across multiple high-level linear algebra oriented languages/libraries/frameworks that assess to what extent said languages translate high-level linear algebra expressions to high performance code.
    Role: Designer and main developer.
  • Linnea: Linnea is an experimental tool for the automatic generation of optimized code for linear algebra problems. It is developed at the High-Performance and Automatic Computing group at RWTH Aachen University. An online demo of Linnea can be found here.
    Role: Contributor.
  • CodeSummarizer: Summarizing Software Functionality from Source Code. This project was part of my MS thesis.
    Role: Designer and main developer.

Publications

Submitted Papers

  1. Concurrent Alternating Least Squares for multiple simultaneous Canonical Polyadic Decompositions
    Submitted to ACM TOMS, October 2020.
    Tensor decompositions, such as CANDECOMP/PARAFAC (CP), are widely used in a variety of applications, such as chemometrics, signal processing, and machine learning. A broadly used method for computing such decompositions relies on the Alternating Least Squares (ALS) algorithm. When the number of components is small, regardless of its implementation, ALS exhibits low arithmetic intensity, which severely hinders its performance and makes GPU offloading ineffective. We observe that, in practice, experts often have to compute multiple decompositions of the same tensor, each with a small number of components (typically fewer than 20), to ultimately find the best ones to use for the application at hand. In this paper, we illustrate how multiple decompositions of the same tensor can be fused together at the algorithmic level to increase the arithmetic intensity. Therefore, it becomes possible to make efficient use of GPUs for further speedups; at the same time the technique is compatible with many enhancements typically used in ALS, such as line search, extrapolation, and non-negativity constraints. We introduce the Concurrent ALS algorithm and library, which offers an interface to Matlab, and a mechanism to effectively deal with the issue that decompositions complete at different times. Experimental results on artificial and real datasets demonstrate a shorter time to completion due to increased arithmetic intensity.
    abstractwebPDFhide
  2. The Linear Algebra Mapping Problem
    November 2019.
    Submitted to SIAM Review.
    We observe a disconnect between the developers and the end users of linear algebra libraries. On the one hand, the numerical linear algebra and the high-performance communities invest significant effort in the development and optimization of highly sophisticated numerical kernels and libraries, aiming at the maximum exploitation of both the properties of the input matrices, and the architectural features of the target computing platform. On the other hand, end users are progressively less likely to go through the error-prone and time consuming process of directly using said libraries by writing their code in C or Fortran; instead, languages and libraries such as Matlab, Julia, Eigen and Armadillo, which offer a higher level of abstraction, are becoming more and more popular. Users are given the opportunity to code matrix computations with a syntax that closely resembles the mathematical description; it is then a compiler or an interpreter that internally maps the input program to lower level kernels, as provided by libraries such as BLAS and LAPACK. Unfortunately, our experience suggests that in terms of performance, this translation is typically vastly suboptimal. In this paper, we first introduce the Linear Algebra Mapping Problem, and then investigate how effectively a benchmark of test problems is solved by popular high-level programming languages. Specifically, we consider Matlab, Octave, Julia, R, Armadillo (C++), Eigen (C++), and NumPy (Python); the benchmark is meant to test both standard compiler optimizations such as common subexpression elimination and loop-invariant code motion, as well as linear algebra specific optimizations such as optimal parenthesization of a matrix product and kernel selection for matrices with properties. The aim of this study is to give concrete guidelines for the development of languages and libraries that support linear algebra computations.
    abstractwebPDFhide

Journal Article

  1. Linnea: Automatic Generation of Efficient Linear Algebra Programs
    ACM Transactions on Mathematical Software (TOMS), January 2020.
    Accepted.
    @article{Barthels2020:688,
        author  = "Henrik Barthels and Christos Psarras and Paolo Bientinesi",
        title   = "Linnea: Automatic Generation of Efficient Linear Algebra Programs",
        journal = "ACM Transactions on Mathematical Software (TOMS)",
        year    = 2020,
        month   = jan,
        note    = "Accepted",
        url     = "https://arxiv.org/pdf/1912.12924.pdf"
    }
    The translation of linear algebra computations into efficient sequences of library calls is a non-trivial task that requires expertise in both linear algebra and high-performance computing. Almost all high-level languages and libraries for matrix computations (e.g., Matlab, Eigen) internally use optimized kernels such as those provided by BLAS and LAPACK; however, their translation algorithms are often too simplistic and thus lead to a suboptimal use of said kernels, resulting in significant performance losses. In order to combine the productivity offered by high-level languages, and the performance of low-level kernels, we are developing Linnea, a code generator for linear algebra problems. As input, Linnea takes a high-level description of a linear algebra problem; as output, it returns an efficient sequence of calls to high-performance kernels. Linnea uses a custom best-first search algorithm to find a first solution in less than a second, and increasingly better solutions when given more time. In 125 test problems, the code generated by Linnea almost always outperforms Matlab, Julia, Eigen and Armadillo, with speedups up to and exceeding 10x.
    abstractwebPDFbibtexhide

Peer Reviewed Conference Publications

  1. Automatic Generation of Efficient Linear Algebra Programs
    To appear in the Proceedings of the Platform for Advanced Scientific Computing Conference (PASC20), August 2019.
    @inproceedings{Barthels2019:200,
        author    = "Henrik Barthels and Christos Psarras and Paolo Bientinesi",
        title     = "Automatic Generation of Efficient Linear Algebra Programs",
        booktitle = "To appear in the Proceedings of the Platform for Advanced Scientific Computing Conference (PASC20)",
        year      = 2019,
        month     = aug,
        journal   = "CoRR"
    }
    The level of abstraction at which application experts reason about linear algebra computations and the level of abstraction used by developers of high-performance numerical linear algebra libraries do not match. The former is conveniently captured by high-level languages and libraries such as Matlab and Eigen, while the latter expresses the kernels included in the BLAS and LAPACK libraries. Unfortunately, the translation from a high-level computation to an efficient sequence of kernels is a task, far from trivial, that requires extensive knowledge of both linear algebra and high-performance computing. Internally, almost all high-level languages and libraries use efficient kernels; however, the translation algorithms are too simplistic and thus lead to a suboptimal use of said kernels, with significant performance losses. In order to both achieve the productivity that comes with high-level languages, and make use of the efficiency of low level kernels, we are developing Linnea, a code generator for linear algebra problems. As input, Linnea takes a high-level description of a linear algebra problem and produces as output an efficient sequence of calls to high-performance kernels. In 25 application problems, the code generated by Linnea always outperforms Matlab, Julia, Eigen and Armadillo, with speedups up to and exceeding 10x.
    abstractwebbibtexhide
  2. A Mechanism for Automatically Summarizing Software Functionality from Source Code
    Proceedings of the 2019 IEEE 19th International Conference on Software Quality, Reliability and Security (QRS), pp. 121-130, July 2019.
    @inproceedings{Psarras2019:818,
        author = "Christos Psarras and Themistoklis Diamantopoulos and Andreas Symeonidis",
        title  = "A Mechanism for Automatically Summarizing Software Functionality from Source Code",
        year   = 2019,
        pages  = "121--130",
        month  = jul
    }
    When developers search online to find software components to reuse, they usually first need to understand the container projects/libraries, and subsequently identify the required functionality. Several approaches identify and summarize the offerings of projects from their source code, however they often require that the developer has knowledge of the underlying topic modeling techniques; they do not provide a mechanism for tuning the number of topics, and they offer no control over the top terms for each topic. In this work, we use a vectorizer to extract information from variable/method names and comments, and apply Latent Dirichlet Allocation to cluster the source code files of a project into different semantic topics. The number of topics is optimized based on their purity with respect to project packages, while topic categories are constructed to provide further intuition and Stack Exchange tags are used to express the topics in more abstract terms.
    abstractwebbibtexhide
  3. Surface/subsurface mapping with an integrated rover-GPR system: A simulation approach
    George Kouros, Christos Psarras, Ioannis Kostavelis, Dimitrios Giakoumis and Dimitrios Tzovaras
    Proceedings of the 2018 IEEE International Conference on Simulation, Modeling, and Programming for Autonomous Robots (SIMPAR), pp. 15-22, May 2018.
    @inproceedings{Kouros2018:660,
        author = "George Kouros and Christos Psarras and Ioannis Kostavelis and Dimitrios Giakoumis and Dimitrios Tzovaras",
        title  = "Surface/subsurface mapping with an integrated rover-GPR system: A simulation approach",
        year   = 2018,
        pages  = "15--22",
        month  = may
    }
    Autonomous subsurface mapping is a key characteristic of future robots to be realized in the construction domain, since it can be utilized in diverse applications of strategic importance. During the last years, the interest has been steered mainly towards the development of ground-penetrating radar (GPR) devices, rather than on the establishment of holistic subsurface reconstruction methods. To this end, the paper at hand introduces a simulation tool that comprises a) a surface operating rover and b) a sonar-based simulated GPR array capable, seamlessly integrated to build adjunct surface and subsurface maps. Specifically, by exploiting the onboard stereo camera of the robot and the GPR, mounted on a robotic-trailer topology, joint surface and subsurface mapping is performed. Further processing of the simulated GPR data is applied to detect and semantically annotate georeferenced buried utilities, while the localization of surface rover is also employed for the topographic correction of the accumulated B-scans during the robot's exploration. The proposed framework has been developed in the ROS framework and has been evaluated on the realistic simulation environment of Gazebo.
    abstractwebbibtexhide

Supervised Theses

Performance-optimal resource allocation for matrix chain products on multithreaded architectures
Alexander Tyson Reeh, Master's Thesis.

Talks

  1. Achieving the compute bound with CP-CALS
    BLIS Retreat 2020.
    5 October 2020.
  2. Achieving the compute bound with Concurrect Alternating Least Squares for the Canonical Polyadic Decomposition (CP-CALS)
    IRTG Annual Meeting.
    July 2020.
  3. Efficiently Mapping Linear Algebra to High-Performance Code (Poster session)
    TACCSTER 2019.
    September 2019.
  4. The Linear Algebra Mapping Problem
    BLIS Retreat, September 2019.
  5. Model-based Generation of Linear Algebra Software
    IRTG Annual Meeting.
    July 2019.
  6. Harnessing the power of version control - An introduction to Git
    Sustainable Scientific Software Sessions with Snacks, February 2019.
    In the first installement of the "Sustainable Scientific Software Sessions with Snacks" (S5) I present a hands on workshop on Git. Git is a distributed version-control system for tracking changes in source code during software development. In the spirit of the S5, I demonstrate how it can be used to develop and manage scientific source code, both individually and as a team.
    abstracthide