Cookies Policy
The website need some cookies and similar means to function. If you permit us, we will use those means to collect data on your visits for aggregated statistics to improve our service. Find out More
Accept Reject
  • Menu
About
Download Photo HD

About

I'm a post-doctoral researcher at the SPeCS lab in the Faculty of Engineering, University of Porto. My area of expertise is source-to-source compilers and code generation, and I have done work both in high-level languages, such as MATLAB and C++, and low-level languages, such as assembly and VHDL.

From 2012 to 2015, my main line of research was MATLAB to C compilation, and I was the creator and main developer of the tool MATISSE (specs.fe.up.pt/tools/matisse). Currently I am working on Clava (specs.fe.up.pt/tools/clava), a C++ source-to-source transformation tool based on Clang, as part of the H2020 project ANTAREX (antarex-project.eu) which focus on strategies for autotunning and energy efficiency in HPC.

Previous work includes translation of Perl-Compatible Regular Expressions (PCRE) to HDL, and automatic runtime migration of loops found in MicroBlaze assembly traces to customized hardware (the subject of the PhD thesis).

I've received a Bachelor's degree in Computer Systems and Informatics from the Univ. of Algarve in July 2006, and in July 2012 received the Ph.D. degree from Instituto Superior Técnico (IST), Lisbon, with the thesis “Mapping Runtime-Detected Loops from Microprocessors to Reconfigurable Processing Units”.

Interest
Topics
Details

Details

Publications

2020

Source-to-source compilation targeting OpenMP-based automatic parallelization of C applications

Authors
Arabnejad, H; Bispo, J; Cardoso, JMP; Barbosa, JG;

Publication
Journal of Supercomputing

Abstract
Directive-driven programming models, such as OpenMP, are one solution for exploring the potential parallelism when targeting multicore architectures. Although these approaches significantly help developers, code parallelization is still a non-trivial and time-consuming process, requiring parallel programming skills. Thus, many efforts have been made toward automatic parallelization of the existing sequential code. This article presents AutoPar-Clava, an OpenMP-based automatic parallelization compiler which: (1) statically detects parallelizable loops in C applications; (2) classifies variables used inside the target loop based on their access pattern; (3) supports reduction clauses on scalar and array variables whenever it is applicable; and (4) generates a C OpenMP parallel code from the input sequential version. The effectiveness of AutoPar-Clava is evaluated by using the NAS and Polyhedral Benchmark suites and targeting a x86-based computing platform. The achieved results are very promising and compare favorably with closely related auto-parallelization compilers, such as Intel C/C++ Compiler (icc), ROSE, TRACO and CETUS. © 2019, Springer Science+Business Media, LLC, part of Springer Nature.

2020

Exploration of FPGA-Based Hardware Designs for QR Decomposition for Solving Stiff ODE Numerical Methods Using the HARP Hybrid Architecture

Authors
de Souza, CAO; Bispo, J; Cardoso, JMP; Diniz, PC; Marques, E;

Publication
ELECTRONICS

Abstract
In this article, we focus on the acceleration of a chemical reaction simulation that relies on a system of stiff ordinary differential equation (ODEs) targeting heterogeneous computing systems with CPUs and field-programmable gate arrays (FPGAs). Specifically, we target an essential kernel of the coupled chemistry aerosol-tracer transport model to the Brazilian developments on the regional atmospheric modeling system (CCATT-BRAMS). We focus on a linear solve step using the QR factorization based on the modified Gram-Schmidt method as the basis of the ODE solver in this application. We target Intel hardware accelerator research program (HARP) architecture with the OpenCL programming environment for these early experiments. Our design exploration reveals a hardware design that is up to 4 times faster than the original iterative Jacobi method used in this solver. Still, even with hardware support, the overall performance of our QR-based hardware is lower than its original software version.

2020

Executing ARMv8 Loop Traces on Reconfigurable Accelerator via Binary Translation Framework

Authors
Paulino, N; Ferreira, JC; Bispo, J; Cardoso, JMP;

Publication
30th International Conference on Field-Programmable Logic and Applications, FPL 2020, Gothenburg, Sweden, August 31 - September 4, 2020

Abstract

2020

Clava: C/C plus plus source-to-source compilation using LARA

Authors
Bispo, J; Cardoso, JMP;

Publication
SOFTWAREX

Abstract
This article presents Clava, a Clang-based source-to-source compiler, that accepts scripts written in LARA, a JavaScript-based DSL with special constructs for code queries, analysis and transformations. Clava improves Clang's source-to-source capabilities by providing a more convenient and flexible way to analyze, transform and generate C/C++ code, and provides support for building strategies that capture run-time behavior. We present the Clava framework, its main capabilities, and how it can been used. Furthermore, we show that Clava is sufficiently robust to analyze, instrument and test a set of large C/C++ application codes, such as GCC. (C) 2020 The Authors. Published by Elsevier B.V.

2020

Pegasus: Performance Engineering for Software Applications Targeting HPC Systems

Authors
Pinto, P; Bispo, J; Cardoso, J; Barbosa, JG; Gadioli, D; Palermo, G; Martinovic, J; Golasowski, M; Slaninova, K; Cmar, R; SILVANO, C;

Publication
IEEE Transactions on Software Engineering

Abstract
Developing and optimizing software applications for high performance and energy efficiency is a very challenging task, even when considering a single target machine. For instance, optimizing for multicore-based computing systems requires in-depth knowledge about programming languages, application programming interfaces, compilers, performance tuning tools, and computer architecture and organization. Many of the tasks of performance engineering methodologies require manual efforts and the use of different tools not always part of an integrated toolchain. This paper presents Pegasus, a performance engineering approach supported by a framework that consists of a source-to-source compiler, controlled and guided by strategies programmed in a Domain-Specific Language, and an autotuner. Pegasus is a holistic and versatile approach spanning various decision layers composing the software stack, and exploiting the system capabilities and workloads effectively through the use of runtime autotuning. The Pegasus approach helps developers by automating tasks regarding the efficient implementation of software applications in multicore computing systems. These tasks focus on application analysis, profiling, code transformations, and the integration of runtime autotuning. Pegasus allows developers to program their strategies or to automatically apply existing strategies to software applications in order to ensure the compliance of non-functional requirements, such as performance and energy efficiency. We show how to apply Pegasus and demonstrate its applicability and effectiveness in a complex case study, which includes tasks from a smart navigation system. IEEE

Supervised
thesis

2020

Recommendation Engine for Parallel Loops

Author
José Luís Oliveira da Cunha

Institution
UP-FEUP

2020

An Exploration of FPGAs as Accelerators for Graph Analysis via High-Level Synthesis

Author
Pedro Filipe Vilhena de Campos Oliveira e Silva

Institution
UP-FEUP

2020

Generating Hardware Modules via Binary Translation of RISC-V Binaries

Author
João Miguel Curado Conceição

Institution
UP-FEUP

2020

Restructuring C code for High-Level Synthesis Targeting FPGAs

Author
Renato Alexandre Sousa Campos

Institution
UP-FEUP

2020

Acceleration of Applications with FPGA-based Computing Machines: Code Restructuring

Author
Tiago Lascasas dos Santos

Institution
UP-FEUP