@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}
}

@article{LOFF:REIC:21,
title = {Melhorando a Geração Automática de Código Paralelo para o Paradigma de Processamento de Stream em Multi-cores},
author = {Júnior Löff and Dalvan Griebler and Luiz Gustavo Fernandes},
url = {https://sol.sbc.org.br/journals/index.php/reic/article/view/2083},
year = {2021},
date = {2021-06-01},
journal = {Revista Eletrônica de Iniciação Científica em Computação},
volume = {19},
number = {2},
pages = {2083},
publisher = {Sociedade Brasileira de Computação (SBC)},
address = {Porto Alegre},
abstract = {A programação paralela ainda é um desafio para desenvolvedores, pois exibe demasiados detalhes de baixo nível e de sistemas operacionais. Programadores precisam lidar com detalhes como escalonamento, balanceamento de carga e sincronizações. Esse trabalho contribui com otimizações para uma abstração de programação paralela para expressar paralelismo de stream em multi-cores. O trabalho estendeu a SPar adicionando dois novos atributos na sua linguagem, e implementou melhorias no seu compilador a fim de proporcionar melhor desempenho ao código paralelo gerado automaticamente. Os experimentos revelaram que a nova versão da SPar consegue abstrair detalhes do paralelismo com desempenho similar às versões paralelizadas manualmente.},
keywords = {},
pubstate = {published},
tppubtype = {article}
}

@article{HOFFMANN:REIC:21,
title = {Geração de Código OpenMP para o Paralelismo de Stream},
author = {Renato Barreto Hoffmann and Dalvan Griebler and Luiz Gustavo Fernandes},
url = {https://sol.sbc.org.br/journals/index.php/reic/article/view/2082},
year = {2021},
date = {2021-06-01},
journal = {Revista Eletrônica de Iniciação Científica em Computação},
volume = {19},
number = {2},
pages = {2082},
publisher = {Sociedade Brasileira de Computação (SBC)},
address = {Porto Alegre},
abstract = {OpenMP é uma interface para a programação paralela padrão e amplamente usada na indústria e academia, porém, torna-se complexa quando usada para desenvolver aplicações paralelas de fluxo de dados ou stream. Para resolver esse problema, foi proposto usar uma interface de programação paralela de alto nível (chamada SPar) e seu compilador para a geração de código estruturado de mais baixo nível com OpenMP em aplicações de fluxo de dados. O objetivo é diminuir a complexidade e verbosidade introduzida pelo OpenMP nas aplicações de stream. Nos experimentos em 4 aplicações, notou-se uma redução no tempo de execução de até 25,42%. Além do mais, requer-se um número de linhas de código fonte menor para expressar o paralelismo.},
keywords = {},
pubstate = {published},
tppubtype = {article}
}

@inproceedings{VOGEL:ERAD:21,
title = {Proposta de Adaptação Dinâmica de Padrões Paralelos},
author = {Adriano Vogel and Dalvan Griebler and Luiz Gustavo Fernandes},
url = {https://doi.org/10.5753/eradrs.2021.14789},
doi = {10.5753/eradrs.2021.14789},
year = {2021},
date = {2021-04-01},
booktitle = {21th Escola Regional de Alto Desempenho da Região Sul (ERAD-RS)},
pages = {101-102},
publisher = {Sociedade Brasileira de Computação},
address = {Joinville, Brazil},
abstract = {Este trabalho apresenta uma perspectiva para adaptar dinamicamente os padrões paralelos em tempo de execução, objetivando abstrair dos programadores a definição de qual padrão paralelo usar e aumentar a flexibilidade. Os resultados preliminares demonstram a eficácia da solução proposta.},
keywords = {},
pubstate = {published},
tppubtype = {inproceedings}
}