Jose Daniel Garcia
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
Research Interests
Jose Daniel Garcia has a total of 102 co-authors. Here are the top co-authors by number of shared publications:
- Javier Fernandez
Universidad Carlos III de Madrid
21 shared publications - Jesus Carretero
Universidad Carlos III de Madrid
20 shared publications - Manuel F. Dolz
Department of Computer Science and Engineering, Universitat Jaume I, Castellón de la Plana, Spain
9 shared publications Laura Prada
7 shared publications- Alberto Núñez
Software Systems and Computation Department, Complutense University of Madrid, Madrid, Spain
6 shared publications - Alejandro Calderón
Universidad Carlos III de Madrid
6 shared publications
Latest Publications
- Open Access
- 16 March 2026
- Published by Springer Nature in International Journal of Parallel Programming
- Vol. 54 (1-2)
PHI: A Modern C++ Library for Parallel Pattern Composition
This paper presents the design of PHI, a modern C++ library that allows for the composable expression of parallel computation patterns. Building upon the principles of GrPPI, PHI introduces a range-like interface that enables for declarative composition of parallel patterns by means of a pipe-like syntax that better aligns with contemporary C++ idioms. Additionally, PHI’s architecture aims to separate pattern composition from its execution, allowing for backend-agnostic implementations, and the potential to integrate various execution models.
- 16 March 2026
- Published by Springer Nature in International Journal of Parallel Programming
- Vol. 54 (1-2)
Open AccessPHI: A Modern C++ Library for Parallel Pattern Composition
This paper presents the design of PHI, a modern C++ library that allows for the composable expression of parallel computation patterns. Building upon the principles of GrPPI, PHI introduces a range-like interface that enables for declarative composition of parallel patterns by means of a pipe-like syntax that better aligns with contemporary C++ idioms. Additionally, PHI’s architecture aims to separate pattern composition from its execution, allowing for backend-agnostic implementations, and the potential to integrate various execution models.
- Open Access
- 7 November 2025
- Published by Springer Nature in Research Square
PHI: A modern C++ library for parallel pattern composition
This paper presents the design of PHI, a modern C++ library that allows for the composable expression of parallel computation patterns. Building upon the principles of GrPPI, PHI introduces a range-like interface that enables for declarative composition of parallel patterns by means of a pipe-like syntax that better aligns with contemporary C++ idioms. Additionally, PHI's architecture aims to separate pattern composition from its execution, allowing for backend-agnostic implementations, and the potential to integrate various execution models.
- 7 November 2025
- Published by Springer Nature in Research Square
Open AccessPHI: A modern C++ library for parallel pattern composition
This paper presents the design of PHI, a modern C++ library that allows for the composable expression of parallel computation patterns. Building upon the principles of GrPPI, PHI introduces a range-like interface that enables for declarative composition of parallel patterns by means of a pipe-like syntax that better aligns with contemporary C++ idioms. Additionally, PHI's architecture aims to separate pattern composition from its execution, allowing for backend-agnostic implementations, and the potential to integrate various execution models.
- Open Access
- 4 April 2025
- Published by Springer Nature in International Journal of Parallel Programming
- Vol. 53 (3) , 1-22
Code Rejuvenation: From Vector Compiler Intrinsics to Portable Standardized SIMD
Legacy code is hard to refactor, and often times, the effort needed to rejuvenate old code is substantial. In particular, compiler intrinsics are often used for clearly and unambiguously expressing low-level vectorization. It is not uncommon for C++ codebases to make use of compiler intrinsics, especially if high performance is critical. Nevertheless, they can be verbose and hard to debug. The C++ standard library introduces std::simd, which is emerging as a high level abstraction for expressing vectorization, allowing for more readable and portable code. Additionally, many of the transformations from compiler intrinsics to std::simd expressions are straightforward and mechanical. However, refactoring code from compiler intrinsics to std::simd can be time-consuming and bug-prone, especially when unfamiliar with the new syntax. With the help of static analysis techniques, it is possible to automatize the process, and ensure code correctness when applying the transformation. In this paper, we introduce a set of techniques to assist developers in the process of migrating existing code bases to a standardized approach for expressing vectorization that is portable to multiple architectures.
- 4 April 2025
- Published by Springer Nature in International Journal of Parallel Programming
- Vol. 53 (3) , 1-22
Open AccessCode Rejuvenation: From Vector Compiler Intrinsics to Portable Standardized SIMD
Legacy code is hard to refactor, and often times, the effort needed to rejuvenate old code is substantial. In particular, compiler intrinsics are often used for clearly and unambiguously expressing low-level vectorization. It is not uncommon for C++ codebases to make use of compiler intrinsics, especially if high performance is critical. Nevertheless, they can be verbose and hard to debug. The C++ standard library introduces std::simd, which is emerging as a high level abstraction for expressing vectorization, allowing for more readable and portable code. Additionally, many of the transformations from compiler intrinsics to std::simd expressions are straightforward and mechanical. However, refactoring code from compiler intrinsics to std::simd can be time-consuming and bug-prone, especially when unfamiliar with the new syntax. With the help of static analysis techniques, it is possible to automatize the process, and ensure code correctness when applying the transformation. In this paper, we introduce a set of techniques to assist developers in the process of migrating existing code bases to a standardized approach for expressing vectorization that is portable to multiple architectures.
- Open Access
- 26 February 2024
- Published by Springer Nature in The Journal of Supercomputing
- Vol. 80 (9) , 12966-13000
Performance and programmability of GrPPI for parallel stream processing on multi-cores
GrPPI library aims to simplify the burdening task of parallel programming. It provides a unified, abstract, and generic layer while promising minimal overhead on performance. Although it supports stream parallelism, GrPPI lacks an evaluation regarding representative performance metrics for this domain, such as throughput and latency. This work evaluates GrPPI focused on parallel stream processing. We compare the throughput and latency performance, memory usage, and programmability of GrPPI against handwritten parallel code. For this, we use the benchmarking framework SPBench to build custom GrPPI benchmarks and benchmarks with handwritten parallel code using the same backends supported by GrPPI. The basis of the benchmarks is real applications, such as Lane Detection, Bzip2, Face Recognizer, and Ferret. Experiments show that while performance is often competitive with handwritten parallel code, the infeasibility of fine-tuning GrPPI is a crucial drawback for emerging applications. Despite this, programmability experiments estimate that GrPPI can potentially reduce the development time of parallel applications by about three times.
- 26 February 2024
- Published by Springer Nature in The Journal of Supercomputing
- Vol. 80 (9) , 12966-13000
Open AccessPerformance and programmability of GrPPI for parallel stream processing on multi-cores
GrPPI library aims to simplify the burdening task of parallel programming. It provides a unified, abstract, and generic layer while promising minimal overhead on performance. Although it supports stream parallelism, GrPPI lacks an evaluation regarding representative performance metrics for this domain, such as throughput and latency. This work evaluates GrPPI focused on parallel stream processing. We compare the throughput and latency performance, memory usage, and programmability of GrPPI against handwritten parallel code. For this, we use the benchmarking framework SPBench to build custom GrPPI benchmarks and benchmarks with handwritten parallel code using the same backends supported by GrPPI. The basis of the benchmarks is real applications, such as Lane Detection, Bzip2, Face Recognizer, and Ferret. Experiments show that while performance is often competitive with handwritten parallel code, the infeasibility of fine-tuning GrPPI is a crucial drawback for emerging applications. Despite this, programmability experiments estimate that GrPPI can potentially reduce the development time of parallel applications by about three times.
- 1 November 2020
- Published by Elsevier in Future Generation Computer Systems
- Vol. 112, 467-477
Towards enhanced MRI by using a multiple back end programming framework
- 1 November 2020
- Published by Elsevier in Future Generation Computer Systems
- Vol. 112, 467-477
Towards enhanced MRI by using a multiple back end programming framework
- Open Access
- 10 July 2020
- Published by Springer Nature in International Journal of Parallel Programming
- Vol. 48 (4) , 603-625
Refactoring GrPPI: Generic Refactoring for Generic Parallelism in C++
The Generic Reusable Parallel Pattern Interface (GrPPI) is a very useful abstraction over different parallel pattern libraries, allowing the programmer to write generic patterned parallel code that can easily be compiled to different backends such as FastFlow, OpenMP, Intel TBB and C++ threads. However, rewriting legacy code to use GrPPI still involves code transformations that can be highly non-trivial, especially for programmers who are not experts in parallelism. This paper describes software refactorings to semi-automatically introduce instances of GrPPI patterns into sequential C++ code, as well as safety checking static analysis mechanisms which verify that introducing patterns into the code does not introduce concurrency-related bugs such as race conditions. We demonstrate the refactorings and safety-checking mechanisms on four simple benchmark applications, showing that we are able to obtain, with little effort, GrPPI-based parallel versions that accomplish good speedups (comparable to those of manually-produced parallel versions) using different pattern backends.
- 10 July 2020
- Published by Springer Nature in International Journal of Parallel Programming
- Vol. 48 (4) , 603-625
Open AccessRefactoring GrPPI: Generic Refactoring for Generic Parallelism in C++
The Generic Reusable Parallel Pattern Interface (GrPPI) is a very useful abstraction over different parallel pattern libraries, allowing the programmer to write generic patterned parallel code that can easily be compiled to different backends such as FastFlow, OpenMP, Intel TBB and C++ threads. However, rewriting legacy code to use GrPPI still involves code transformations that can be highly non-trivial, especially for programmers who are not experts in parallelism. This paper describes software refactorings to semi-automatically introduce instances of GrPPI patterns into sequential C++ code, as well as safety checking static analysis mechanisms which verify that introducing patterns into the code does not introduce concurrency-related bugs such as race conditions. We demonstrate the refactorings and safety-checking mechanisms on four simple benchmark applications, showing that we are able to obtain, with little effort, GrPPI-based parallel versions that accomplish good speedups (comparable to those of manually-produced parallel versions) using different pattern backends.
- 1 August 2019
- Published by Springer Nature in The Journal of Supercomputing
- Vol. 75 (8) , 3997-4000
Refactoring software to heterogeneous parallel platforms
- 1 August 2019
- Published by Springer Nature in The Journal of Supercomputing
- Vol. 75 (8) , 3997-4000
Refactoring software to heterogeneous parallel platforms
- Open Access
- 8 July 2019
- Published by Institute of Electrical and Electronics Engineers (IEEE) in IEEE Access
- Vol. 7, 91612-91626
A Parallel-Computing Algorithm for High-Energy Physics Particle Tracking and Decoding Using GPU Architectures
Real-time data processing is one of the central processes of particle physics experiments which require large computing resources. The LHCb (Large Hadron Collider beauty) experiment will be upgraded to cope with a particle bunch collision rate of 30 million times per second, producing 10 9 particles/s. 40 Tbits/s need to be processed in real-time to make filtering decisions to store data. This poses a computing challenge that requires exploration of modern hardware and software solutions. We present Compass, a particle tracking algorithm and a parallel raw input decoding optimized for GPUs. It is designed for highly parallel architectures, data-oriented, and optimized for fast and localized data access. Our algorithm is configurable, and we explore the trade-off in computing and physics performance of various configurations. A CPU implementation that delivers the same physics performance as our GPU implementation is presented. We discuss the achieved physics performance and validate it with Monte Carlo simulated data. We show a computing performance analysis comparing consumer and server-grade GPUs, and a CPU. We show the feasibility of using a full GPU decoding and particle tracking algorithm for high-throughput particle trajectories reconstruction, where our algorithm improves the throughput up to 7.4 × compared to the LHCb baseline.
- 8 July 2019
- Published by Institute of Electrical and Electronics Engineers (IEEE) in IEEE Access
- Vol. 7, 91612-91626
Open AccessA Parallel-Computing Algorithm for High-Energy Physics Particle Tracking and Decoding Using GPU Architectures
Real-time data processing is one of the central processes of particle physics experiments which require large computing resources. The LHCb (Large Hadron Collider beauty) experiment will be upgraded to cope with a particle bunch collision rate of 30 million times per second, producing 10 9 particles/s. 40 Tbits/s need to be processed in real-time to make filtering decisions to store data. This poses a computing challenge that requires exploration of modern hardware and software solutions. We present Compass, a particle tracking algorithm and a parallel raw input decoding optimized for GPUs. It is designed for highly parallel architectures, data-oriented, and optimized for fast and localized data access. Our algorithm is configurable, and we explore the trade-off in computing and physics performance of various configurations. A CPU implementation that delivers the same physics performance as our GPU implementation is presented. We discuss the achieved physics performance and validate it with Monte Carlo simulated data. We show a computing performance analysis comparing consumer and server-grade GPUs, and a CPU. We show the feasibility of using a full GPU decoding and particle tracking algorithm for high-throughput particle trajectories reconstruction, where our algorithm improves the throughput up to 7.4 × compared to the LHCb baseline.
- 1 May 2019
- Published by Elsevier in Parallel Computing
- Vol. 84, 24-36
Exploring stream parallel patterns in distributed MPI environments
- 1 May 2019
- Published by Elsevier in Parallel Computing
- Vol. 84, 24-36
Exploring stream parallel patterns in distributed MPI environments
- Open Access
- 8 April 2019
- Published by Springer Nature in The Journal of Supercomputing
- Vol. 76 (7) , 5139-5159
Challenging the abstraction penalty in parallel patterns libraries
- 8 April 2019
- Published by Springer Nature in The Journal of Supercomputing
- Vol. 76 (7) , 5139-5159
Open AccessChallenging the abstraction penalty in parallel patterns libraries