@article{HOFFMANN:Jsuper:2022,
title = {OpenMP as runtime for providing high-level stream parallelism on multi-cores},
author = {Renato Barreto Hoffmann and Júnior Löff and Dalvan Griebler and Luiz Gustavo Fernandes},
url = {https://doi.org/10.1007/s11227-021-04182-9},
doi = {10.1007/s11227-021-04182-9},
year = {2022},
date = {2022-01-01},
journal = {The Journal of Supercomputing},
volume = {1},
number = {1},
pages = {7655–7676},
publisher = {Springer},
address = {New York, United States},
abstract = {OpenMP is an industry and academic standard for parallel programming. However, using it for developing parallel stream processing applications is complex and challenging. OpenMP lacks key programming mechanisms and abstractions for this particular domain. To tackle this problem, we used a high-level parallel programming framework (named SPar) for automatically generating parallel OpenMP code. We achieved this by leveraging SPar's language and its domain-specific code annotations for simplifying the complexity and verbosity added by OpenMP in this application domain. Consequently, we implemented a new compiler algorithm in SPar for automatically generating parallel code targeting the OpenMP runtime using source-to-source code transformations. The experiments in four different stream processing applications demonstrated that the execution time of SPar was improved up to 25.42% when using the OpenMP runtime. Additionally, our abstraction over OpenMP introduced at most 1.72% execution time overhead when compared to handwritten parallel codes. Furthermore, SPar significantly reduces the total source lines of code required to express parallelism with respect to plain OpenMP parallel codes.},
keywords = {},
pubstate = {published},
tppubtype = {article}
}

@inproceedings{ANDRADE:SEAA:21,
title = {Assessing Coding Metrics for Parallel Programming of Stream Processing Programs on Multi-cores},
author = {Gabriella Andrade and Dalvan Griebler and Rodrigo Santos and Marco Danelutto and Luiz Gustavo Fernandes},
url = {https://doi.org/10.1109/SEAA53835.2021.00044},
doi = {10.1109/SEAA53835.2021.00044},
isbn = {978-1-6654-2705-0},
year = {2021},
date = {2021-09-01},
booktitle = {2021 47th Euromicro Conference on Software Engineering and Advanced Applications (SEAA)},
pages = {291-295},
publisher = {IEEE},
address = {Pavia, Italy},
series = {SEAA'21},
abstract = {From the popularization of multi-core architectures, several parallel APIs have emerged, helping to abstract the programming complexity and increasing productivity in application development. Unfortunately, only a few research efforts in this direction managed to show the usability pay-back of the programming abstraction created, because it is not easy and poses many challenges for conducting empirical software engineering. We believe that coding metrics commonly used in software engineering code measurements can give useful indicators on the programming effort of parallel applications and APIs. These metrics were designed for general purposes without considering the evaluation of applications from a specific domain. In this study, we aim to evaluate the feasibility of seven coding metrics to be used in the parallel programming domain. To do so, five stream processing applications implemented with different parallel APIs for multi-cores were considered. Our experiments have shown COCOMO II is a suitable model for evaluating the productivity of different parallel APIs targeting multi-cores on stream processing applications while other metrics are restricted to the code size.},
keywords = {},
pubstate = {published},
tppubtype = {inproceedings}
}

@inproceedings{LOFF:SBLP:21,
title = {High-Level Stream and Data Parallelism in C++ for Multi-Cores},
author = {Júnior Löff and Renato Barreto Hoffmann and Dalvan Griebler and Luiz G Fernandes},
url = {https://dl.acm.org/doi/10.1145/3475061.3475078},
doi = {10.1145/3475061.3475078},
year = {2021},
date = {2021-09-01},
booktitle = {XXV Brazilian Symposium on Programming Languages (SBLP)},
pages = {41-48},
publisher = {ACM},
address = {Joinville, Brazil},
series = {SBLP'21},
abstract = {Stream processing applications have seen an increasing demand with the increased availability of sensors, IoT devices, and user data. Modern systems can generate millions of data items per day that require to be processed timely. To deal with this demand, application programmers must consider parallelism to exploit the maximum performance of the underlying hardware resources. However, parallel programming is often difficult and error-prone, because programmers must deal with low-level system and architecture details. In this work, we introduce a new strategy for automatic data-parallel code generation in C++ targeting multi-core architectures. This strategy was integrated with an annotation-based parallel programming abstraction named SPar. We have increased SPar’s expressiveness for supporting stream and data parallelism, and their arbitrary composition. Therefore, we added two new attributes to its language and improved the compiler parallel code generation. We conducted a set of experiments on different stream and data-parallel applications to assess the efficiency of our solution. The results showed that the new SPar version obtained similar performance with respect to handwritten parallelizations. Moreover, the new SPar version is able to achieve up to 74.9x better performance with respect to the original ones due to this work.},
keywords = {},
pubstate = {published},
tppubtype = {inproceedings}
}

@article{PIEPER:COLA:21,
title = {High-level and Efficient Structured Stream Parallelism for Rust on Multi-cores},
author = {Ricardo Pieper and Júnior Löff and Renato Berreto Hoffmann and Dalvan Griebler and Luiz Gustavo Fernandes},
url = {https://www.sciencedirect.com/science/article/pii/S2590118421000332},
doi = {10.1016/j.cola.2021.101054},
issn = {2590-1184},
year = {2021},
date = {2021-08-01},
journal = {Journal of Computer Languages},
volume = {65},
number = {na},
pages = {101054},
publisher = {Elsevier},
abstract = {This work aims at contributing with a structured parallel programming abstraction for Rust in order to provide ready-to-use parallel patterns that abstract low-level and architecture-dependent details from application programmers. We focus on stream processing applications running on shared-memory multi-core architectures (i.e, video processing, compression, and others). Therefore, we provide a new high-level and efficient parallel programming abstraction for expressing stream parallelism, named Rust-SSP. We also created a new stream benchmark suite for Rust that represents real-world scenarios and has different application characteristics and workloads. Our benchmark suite is an initiative to assess existing parallelism abstraction for this domain, as parallel implementations using these abstractions were provided. The results revealed that Rust-SSP achieved up to 41.1% better performance than other solutions. In terms of programmability, the results revealed that Rust-SSP requires the smallest number of extra lines of code to enable stream parallelism..},
keywords = {},
pubstate = {published},
tppubtype = {article}
}

@article{LOFF:FGCS:21,
title = {The NAS parallel benchmarks for evaluating C++ parallel programming frameworks on shared-memory architectures},
author = {Júnior Löff and Dalvan Griebler and Gabriele Mencagli and Gabriell Araujo and Massimo Torquati and Marco Danelutto and Luiz Gustavo Fernandes},
url = {https://doi.org/10.1016/j.future.2021.07.021},
doi = {10.1016/j.future.2021.07.021},
year = {2021},
date = {2021-07-01},
journal = {Future Generation Computer Systems},
volume = {na},
number = {na},
pages = {na},
publisher = {Elsevier},
abstract = {The NAS Parallel Benchmarks (NPB), originally implemented mostly in Fortran, is a consolidated suite containing several benchmarks extracted from Computational Fluid Dynamics (CFD) models. The benchmark suite has important characteristics such as intensive memory communications, complex data dependencies, different memory access patterns, and hardware components/sub-systems overload. Parallel programming APIs, libraries, and frameworks that are written in C++ as well as new optimizations and parallel processing techniques can benefit if NPB is made fully available in this programming language. In this paper we present NPB-CPP, a fully C++ translated version of NPB consisting of all the NPB kernels and pseudo-applications developed using OpenMP, Intel TBB, and FastFlow parallel frameworks for multicores. The design of NPB-CPP leverages the Structured Parallel Programming methodology (essentially based on parallel design patterns). We show the structure of each benchmark application in terms of composition of few patterns (notably Map and MapReduce constructs) provided by the selected C++ frameworks. The experimental evaluation shows the accuracy of NPB-CPP with respect to the original NPB source code. Furthermore, we carefully evaluate the parallel performance on three multi-core systems (Intel, IBM Power and AMD) with different C++ compilers (gcc, icc and clang) by discussing the performance differences in order to give to the researchers useful insights to choose the best parallel programming framework for a given type of problem.},
keywords = {},
pubstate = {published},
tppubtype = {article}
}