Tiago Carvalho
Current Organizations / Institutes
The organizations/institutes from the scholar's latest article
Previous Organizations / Institutes
The organizations / institutes from the scholar's other articles in the past ten years
Research Subjects
Tiago Carvalho has a total of 46 co-authors. Here are the top co-authors by number of shared publications:
- Joao Manuel Paiva Cardoso
Faculty of Engineering, University of Porto, Porto, Portugal
15 shared publications Pedro C. Diniz
INESC-ID, Rua Alves Redol, 9, Lisboa, Portugal
10 shared publications- Ricardo Nobre
Inesc-ID, Instituto Superior Técnico, Universidade de Lisboa, Lisboa, Portugal
8 shared publications Wayne Luk
Department of Computing Imperial College London 180 Queen's Gate SW7 2BZ London UK
8 shared publicationsZlatko Petrov
Honeywell International s.r.o Turanka 100 627 00 Brno Czech Republic
8 shared publicationsSujit Bhattacharya
Imperial College London, IMP
5 shared publications
Latest Publications
- Open Access
- 2 July 2026
- Published by Elsevier in Journal of Systems Architecture
- Vol. 179
Task-to-accelerator mapping for predictable OpenMP applications
- 2 July 2026
- Published by Elsevier in Journal of Systems Architecture
- Vol. 179
Open AccessTask-to-accelerator mapping for predictable OpenMP applications
- Open Access
- 29 October 2024
- Published by Association for Computing Machinery (ACM) in ACM Transactions on Embedded Computing Systems
Towards a Rust-Like Borrow Checker for C
Memory safety issues in C are the origin of various vulnerabilities that can compromise a program’s correctness or safety from attacks. We propose an approach to tackle memory safety by replicating Rust’s Mid-level Intermediate Representation (MIR) Borrow Checker. Our solution uses static analysis and successive source-to-source code transformations to be composed upstream of the compiler, ensuring maximal compatibility with existing build systems. This allows us to apply the memory safety guarantees of the rustc compiler to C code with fewer changes than a rewrite in Rust. In this work, we present a comprehensive study of Rust’s efforts towards ensuring memory safety, and describe the theoretical basis for a C borrow checker, alongside a proof-of-concept that was developed to demonstrate its potential. We have evaluated the prototype on the CHStone and bzip2 benchmarks. This prototype correctly identified violations of the ownership and aliasing rules, and exposed incompatibilities between such rules and common C patterns, which can be addressed in future work.
- 29 October 2024
- Published by Association for Computing Machinery (ACM) in ACM Transactions on Embedded Computing Systems
Open AccessTowards a Rust-Like Borrow Checker for C
Memory safety issues in C are the origin of various vulnerabilities that can compromise a program’s correctness or safety from attacks. We propose an approach to tackle memory safety by replicating Rust’s Mid-level Intermediate Representation (MIR) Borrow Checker. Our solution uses static analysis and successive source-to-source code transformations to be composed upstream of the compiler, ensuring maximal compatibility with existing build systems. This allows us to apply the memory safety guarantees of the rustc compiler to C code with fewer changes than a rewrite in Rust. In this work, we present a comprehensive study of Rust’s efforts towards ensuring memory safety, and describe the theoretical basis for a C borrow checker, alongside a proof-of-concept that was developed to demonstrate its potential. We have evaluated the prototype on the CHStone and bzip2 benchmarks. This prototype correctly identified violations of the ownership and aliasing rules, and exposed incompatibilities between such rules and common C patterns, which can be addressed in future work.
- Open Access
- 20 June 2024
- Published by Association for Computing Machinery (ACM)
- p. 155-165
Foundations for a Rust-Like Borrow Checker for C
- 20 June 2024
- Published by Association for Computing Machinery (ACM)
- p. 155-165
Open AccessFoundations for a Rust-Like Borrow Checker for C
- Open Access
- 1 June 2015
- Published by Association for Computing Machinery (ACM)
- p. 3-11
Programming Strategies for Contextual Runtime Specialization
Runtime adaptability is expected to adjust the application and the mapping of computations according to usage contexts, operating environments, resources availability, etc. However, extending applications with adaptive features can be a complex task, especially due to the current lack of programming models and compiler support. One of the run-time adaptability possibilities is the use of specialized code according to data workloads and environments. Traditional approaches use multiple code versions generated offline and, during runtime, a strategy is responsible to select a code version. Moving code generation to runtime can achieve important improvements but may impose unacceptable overhead. This paper presents an aspect-oriented programming approach for runtime adaptability. We focus on a separation of concerns (strategies vs. application) promoted by a domain-specific language for programming runtime strategies. Our strategies allow runtime specialization based on contextual information. We use a template-based runtime code generation approach to achieve program specialization. We demonstrate our approach with examples from image processing, which depict the benefits of runtime specialization and illustrate how several factors need to be considered to efficiently adapt the application.
- 1 June 2015
- Published by Association for Computing Machinery (ACM)
- p. 3-11
Open AccessProgramming Strategies for Contextual Runtime Specialization
Runtime adaptability is expected to adjust the application and the mapping of computations according to usage contexts, operating environments, resources availability, etc. However, extending applications with adaptive features can be a complex task, especially due to the current lack of programming models and compiler support. One of the run-time adaptability possibilities is the use of specialized code according to data workloads and environments. Traditional approaches use multiple code versions generated offline and, during runtime, a strategy is responsible to select a code version. Moving code generation to runtime can achieve important improvements but may impose unacceptable overhead. This paper presents an aspect-oriented programming approach for runtime adaptability. We focus on a separation of concerns (strategies vs. application) promoted by a domain-specific language for programming runtime strategies. Our strategies allow runtime specialization based on contextual information. We use a template-based runtime code generation approach to achieve program specialization. We demonstrate our approach with examples from image processing, which depict the benefits of runtime specialization and illustrate how several factors need to be considered to efficiently adapt the application.
- 11 December 2014
- Published by Wiley in Software: Practice and Experience
- Vol. 46 (2) , 251-287
Performance‐driven instrumentation and mapping strategies using the LARA aspect‐oriented programming approach
Summary: The development of applications for high‐performance embedded systems is a long and error‐prone process because in addition to the required functionality, developers must consider various and often conflicting nonfunctional requirements such as performance and/or energy efficiency. The complexity of this process is further exacerbated by the multitude of target architectures and mapping tools. This article describes LARA, an aspect‐oriented programming language that allows programmers to convey domain‐specific knowledge and nonfunctional requirements to a toolchain composed of source‐to‐source transformers, compiler optimizers, and mapping/synthesis tools. LARA is sufficiently flexible to target different tools and host languages while also allowing the specification of compilation strategies to enable efficient generation of software code and hardware cores (using hardware description languages) for hybrid target architectures – a unique feature to the best of our knowledge not found in any other aspect‐oriented programming language. A key feature of LARA is its ability to deal with different models of join points, actions, and attributes. In this article, we describe the LARA approach and evaluate its impact on code instrumentation and analysis and on selecting critical code sections to be migrated to hardware accelerators for two embedded applications from industry. Copyright © 2014 John Wiley & Sons, Ltd.
- 11 December 2014
- Published by Wiley in Software: Practice and Experience
- Vol. 46 (2) , 251-287
Performance‐driven instrumentation and mapping strategies using the LARA aspect‐oriented programming approach
Summary: The development of applications for high‐performance embedded systems is a long and error‐prone process because in addition to the required functionality, developers must consider various and often conflicting nonfunctional requirements such as performance and/or energy efficiency. The complexity of this process is further exacerbated by the multitude of target architectures and mapping tools. This article describes LARA, an aspect‐oriented programming language that allows programmers to convey domain‐specific knowledge and nonfunctional requirements to a toolchain composed of source‐to‐source transformers, compiler optimizers, and mapping/synthesis tools. LARA is sufficiently flexible to target different tools and host languages while also allowing the specification of compilation strategies to enable efficient generation of software code and hardware cores (using hardware description languages) for hybrid target architectures – a unique feature to the best of our knowledge not found in any other aspect‐oriented programming language. A key feature of LARA is its ability to deal with different models of join points, actions, and attributes. In this article, we describe the LARA approach and evaluate its impact on code instrumentation and analysis and on selecting critical code sections to be migrated to hardware accelerators for two embedded applications from industry. Copyright © 2014 John Wiley & Sons, Ltd.
- Open Access
- 20 January 2014
- Published by Association for Computing Machinery (ACM)
- p. 7-12
On Expressing Strategies for Directive-Driven Multicore Programing Models
A common migration path for applications to high-performance multicore architectures relies on code annotations with concurrent semantics. Some annotations, however, are very target architecture specific and thus highly non-portable. In this paper we describe a source-to-source code transformation system that allows programmers to specify transformations using an aspect-oriented domain specific language - LARA. LARA allows programmers to specify strategies to search large code transformation design spaces while preserving the original source code. As the experimental results reveal, this approach leads to a substantial reduction in code maintenance costs, and promotes the portability of both programmers and performance.
- 20 January 2014
- Published by Association for Computing Machinery (ACM)
- p. 7-12
Open AccessOn Expressing Strategies for Directive-Driven Multicore Programing Models
A common migration path for applications to high-performance multicore architectures relies on code annotations with concurrent semantics. Some annotations, however, are very target architecture specific and thus highly non-portable. In this paper we describe a source-to-source code transformation system that allows programmers to specify transformations using an aspect-oriented domain specific language - LARA. LARA allows programmers to specify strategies to search large code transformation design spaces while preserving the original source code. As the experimental results reveal, this approach leads to a substantial reduction in code maintenance costs, and promotes the portability of both programmers and performance.
- 1 November 2013
- Published by Elsevier in Microprocessors and Microsystems
- Vol. 37 (8) , 1073-1089
Controlling a complete hardware synthesis toolchain with LARA aspects
- 1 November 2013
- Published by Elsevier in Microprocessors and Microsystems
- Vol. 37 (8) , 1073-1089
Controlling a complete hardware synthesis toolchain with LARA aspects
- 1 August 2013
- Published by Elsevier in Journal of Systems Architecture
- Vol. 59 (7) , 412-428
Enriching MATLAB with aspect-oriented features for developing embedded systems
- 1 August 2013
- Published by Elsevier in Journal of Systems Architecture
- Vol. 59 (7) , 412-428
Enriching MATLAB with aspect-oriented features for developing embedded systems
- 1 July 2013
- Published by Institute of Electrical and Electronics Engineers (IEEE)
- No. 19354576,p. 602-608
The MATISSE MATLAB compiler
This paper describes MATISSE, a MATLAB to C compiler targeting embedded systems that is based on Strategic and Aspect-Oriented Programming concepts. MATISSE takes as input: (1) MATLAB code and (2) LARA aspects related to types and shapes, code insertion/removal, and specialization based directives defining default variable values. In this paper we also illustrate the use of MATISSE in leveraging data types and shapes to generate customized C code suitable for high-level hardware synthesis tools. The preliminary experimental results presented here reveal the described approach to yield performance results for the resulting hardware and software references implementations that are comparable in terms of performance with hand-crafted solutions but derived automatically at a fraction of the cost.
- 1 July 2013
- Published by Institute of Electrical and Electronics Engineers (IEEE)
- No. 19354576,p. 602-608
The MATISSE MATLAB compiler
This paper describes MATISSE, a MATLAB to C compiler targeting embedded systems that is based on Strategic and Aspect-Oriented Programming concepts. MATISSE takes as input: (1) MATLAB code and (2) LARA aspects related to types and shapes, code insertion/removal, and specialization based directives defining default variable values. In this paper we also illustrate the use of MATISSE in leveraging data types and shapes to generate customized C code suitable for high-level hardware synthesis tools. The preliminary experimental results presented here reveal the described approach to yield performance results for the resulting hardware and software references implementations that are comparable in terms of performance with hand-crafted solutions but derived automatically at a fraction of the cost.