Dalvan Griebler

@inproceedings{FAE:ERAD:22,

title = {Aplicação de Vídeo com Flink, Storm e SPar em Multicores},

author = {Leonardo Faé and Dalvan Griebler and Isabel Manssour},

url = {https://doi.org/10.5753/eradrs.2022.19149},

doi = {10.5753/eradrs.2022.19149},

year  = {2022},

date = {2022-04-01},

booktitle = {Anais da XXII Escola Regional de Alto Desempenho da Região Sul},

pages = {13-16},

publisher = {Sociedade Brasileira de Computação},

address = {Curitiba, Brazil},

abstract = {Este trabalho apresenta comparações de desempenho entre as interfaces de programação SPar, Apache Flink e Apache Storm, no que diz respeito à execução de uma aplicação de processamento de vídeo. Os resultados revelam que as versões da SPar apresentam um desempenho superior, enquanto o Apache Storm apresentou o pior desempenho.},

keywords = {},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{MULLER:ERAD:22,

title = {Avaliação da aplicação de paralelismo em classificadores taxonômicos usando Qiime2},

author = {Caetano Müller and Junior Löff and Dalvan Griebler and Eduardo Eizirik},

url = {https://doi.org/10.5753/eradrs.2022.19152},

doi = {10.5753/eradrs.2022.19152},

year  = {2022},

date = {2022-04-01},

booktitle = {Anais da XXII Escola Regional de Alto Desempenho da Região Sul},

pages = {25-28},

publisher = {Sociedade Brasileira de Computação},

address = {Curitiba, Brazil},

abstract = {A classificação de sequências de DNA usando algoritmos de aprendizado de máquina ainda tem espaço para evoluir, tanto na qualidade do resultado quanto na eficiência computacional dos algoritmos. Nesse trabalho, realizou-se uma avaliação de desempenho em dois algoritmos de aprendizado de máquina da ferramenta Qiime2 para classificação de sequências de DNA. Os resultados mostram que o desempenho melhorou em até 9,65 vezes utilizando 9 threads.},

keywords = {},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{LOFF:ERAD:22,

title = {Proposta de Framework para Processamento de Stream Distribuído em C++ utilizando o MPI},

author = {Júnior Löff and Dalvan Griebler and Luiz Gustavo Fernandes},

url = {https://doi.org/10.5753/eradrs.2022.19177},

doi = {10.5753/eradrs.2022.19177},

year  = {2022},

date = {2022-04-01},

booktitle = {Anais da XXII Escola Regional de Alto Desempenho da Região Sul},

pages = {91-92},

publisher = {Sociedade Brasileira de Computação},

address = {Curitiba, Brazil},

abstract = {Este trabalho apresenta uma proposta de framework para processamento de stream distribuído em C++ com MPI. A etapa inicial do estudo aborda a problemática de pesquisa e a concepção da arquitetura do framework.},

keywords = {},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{HOFFMANN:ERAD:22,

title = {Towards Efficient Stream Parallelism for Embedded Devices},

author = {Renato Barreto Hoffmann and Dalvan Griebler and Luiz Gustavo Fernandes},

url = {https://doi.org/10.5753/eradrs.2022.19163},

doi = {10.5753/eradrs.2022.19163},

year  = {2022},

date = {2022-04-01},

booktitle = {Anais da XXII Escola Regional de Alto Desempenho da Região Sul},

pages = {62-64},

publisher = {Sociedade Brasileira de Computação},

address = {Curitiba, Brazil},

abstract = {Stream processing applications process raw data-flows to reveal insightful information. Efficiently coordinating the requirements of these applications is a challenge. We propose investigating high-level software solutions for these applications to achieve efficiency and high performance for embedded devices.},

keywords = {},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{ARAUJO:ERAD:22,

title = {Provendo melhorias na GSParLib},

author = {Gabriell Araujo and Dalvan Griebler and Luiz Gustavo Fernandes},

url = {https://doi.org/10.5753/eradrs.2022.19188},

doi = {10.5753/eradrs.2022.19188},

year  = {2022},

date = {2022-04-01},

booktitle = {Anais da XXII Escola Regional de Alto Desempenho da Região Sul},

pages = {113-114},

publisher = {Sociedade Brasileira de Computação},

address = {Curitiba, Brazil},

abstract = {Neste trabalho são apresentados resultados parciais do estudo que está sendo conduzido para prover melhorias de programabilidade e desempenho no framework de programação para GPUs GSParLib.},

keywords = {},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{SCHEER:ERAD:22,

title = {Encontrando a Configuração de Threads por Bloco para os Kernels NPB-CUDA com Q-Learning},

author = {Claudio Scheer and Gabriell Araujo and Dalvan Griebler and Felipe Meneguzzi and Luiz Gustavo Fernandes},

url = {https://doi.org/10.5753/eradrs.2022.19191},

doi = {10.5753/eradrs.2022.19191},

year  = {2022},

date = {2022-04-01},

booktitle = {Anais da XXII Escola Regional de Alto Desempenho da Região Sul},

pages = {119-120},

publisher = {Sociedade Brasileira de Computação},

address = {Curitiba, Brazil},

abstract = {Este trabalho apresenta um novo método que utiliza aprendizado de máquina para prever a melhor configuração de threads por bloco para aplicações de GPUs. Os resultados foram similares a estratégias manuais.},

keywords = {},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{larcc:FIM:ERAD:22,

title = {Compressão de Dados em Clusters HPC com Flink, MPI e SPar},

author = {Gabriel Fim and Greice Welter and Júnior Löff and Dalvan Griebler},

url = {https://doi.org/10.5753/eradrs.2022.19153},

doi = {10.5753/eradrs.2022.19153},

year  = {2022},

date = {2022-04-01},

booktitle = {Anais da XXII Escola Regional de Alto Desempenho da Região Sul},

pages = {29-32},

publisher = {Sociedade Brasileira de Computação},

address = {Curitiba, Brazil},

abstract = {Este trabalho visa avaliar o desempenho do algoritmo de compressão de dados Bzip2 com as ferramentas de processamento de stream Apache Flink, MPI e SPar utilizando um cluster Beowulf. Os resultados mostram que as versões com maior desempenho em relação ao tempo sequencial são o MPI e SPar com speed-up de 7,6 e 7,2 vezes, respectivamente.},

keywords = {},

pubstate = {published},

tppubtype = {inproceedings}

}

@article{GOMES:IJCSIT:22,

title = {Steam++: An Extensible End-to-end Framework for Developing IoT Data Processing Applications in the Fog},

author = {Márcio Miguel Gomes and Rodrigo Rosa Righi and Cristiano André Costa and Dalvan Griebler},

url = {http://dx.doi.org/10.5121/ijcsit.2022.14103},

doi = {10.5121/ijcsit.2022.14103},

year  = {2022},

date = {2022-02-01},

urldate = {2022-02-01},

journal = {International Journal of Computer Science & Information Technology},

volume = {14},

number = {1},

pages = {31-51},

publisher = {AIRCC},

abstract = {IoT applications usually rely on cloud computing services to perform data analysis such as filtering, aggregation, classification, pattern detection, and prediction. When applied to specific domains, the IoT needs to deal with unique constraints. Besides the hostile environment such as vibration and electricmagnetic interference, resulting in malfunction, noise, and data loss, industrial plants often have Internet access restricted or unavailable, forcing us to design stand-alone fog and edge computing solutions. In this context, we present STEAM++, a lightweight and extensible framework for real-time data stream processing and decision-making in the network edge, targeting hardware-limited devices, besides proposing a micro-benchmark methodology for assessing embedded IoT applications. In real-case experiments in a semiconductor industry, we processed an entire data flow, from values sensing, processing and analysing data, detecting relevant events, and finally, publishing results to a dashboard. On average, the application consumed less than 500kb RAM and 1.0% of CPU usage, processing up to 239 data packets per second and reducing the output data size to 14% of the input raw data size when notifying events.},

keywords = {},

pubstate = {published},

tppubtype = {article}

}

@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 = {78},

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}

}

@article{LOFF:IJPP:22,

title = {DSParLib: A C++ Template Library for Distributed Stream Parallelism},

author = {Júnior Löff and Renato Barreto Hoffmann and Ricardo Pieper and Dalvan Griebler and Luiz Gustavo Fernandes},

url = {https://doi.org/10.1007/s10766-022-00737-2},

doi = {10.1007/s10766-022-00737-2},

year  = {2022},

date = {2022-01-01},

journal = {International Journal of Parallel Programming},

volume = {50},

number = {5},

pages = {454-485},

publisher = {Springer},

abstract = {Stream processing applications deal with millions of data items continuously generated over time. Often, they must be processed in real-time and scale performance, which requires the use of distributed parallel computing resources. In C/C++, the current state-of-the-art for distributed architectures and High-Performance Computing is Message Passing Interface (MPI). However, exploiting stream parallelism using MPI is complex and error-prone because it exposes many low-level details to the programmer. In this work, we introduce a new parallel programming abstraction for implementing distributed stream parallelism named DSParLib. Our abstraction of MPI simplifies parallel programming by providing a pattern-based and building block-oriented development to inter-connect, model, and parallelize data streams found in modern applications. Experiments conducted with five different stream processing applications and the representative PARSEC Ferret benchmark revealed that DSParLib is efficient and flexible. Also, DSParLib achieved similar or better performance, required less coding, and provided simpler abstractions to express parallelism with respect to handwritten MPI programs.},

keywords = {},

pubstate = {published},

tppubtype = {article}

}

@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://doi.org/10.1145/3475061.3475078},

doi = {10.1145/3475061.3475078},

year  = {2021},

date = {2021-10-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}

}

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

year  = {2021},

date = {2021-09-01},

booktitle = {47th Euromicro Conference on Software Engineering and Advanced Applications (SEAA 2021)},

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}

}

@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 = {125},

pages = {743-757},

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{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://doi.org/10.1016/j.cola.2021.101054},

doi = {10.1016/j.cola.2021.101054},

year  = {2021},

date = {2021-07-01},

journal = {Journal of Computer Languages},

volume = {65},

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{GOMES:CEE:21,

title = {Simplifying IoT data stream enrichment and analytics in the edge},

author = {Márcio Miguel Gomes and Rodrigo Rosa Righi and Cristiano André Costa and Dalvan Griebler},

url = {https://doi.org/10.1016/j.compeleceng.2021.107110},

doi = {10.1016/j.compeleceng.2021.107110},

year  = {2021},

date = {2021-06-01},

urldate = {2021-06-01},

journal = {Computers & Electrical Engineering},

volume = {92},

pages = {107110},

publisher = {Elsevier},

abstract = {Edge devices are usually limited in resources. They often send data to the cloud, where techniques such as filtering, aggregation, classification, pattern detection, and prediction are performed. This process results in critical issues such as data loss, high response time, and overhead. On the other hand, processing data in the edge is not a simple task due to devices’ heterogeneity, resource limitations, a variety of programming languages and standards. In this context, this work proposes STEAM, a framework for developing data stream processing applications in the edge targeting hardware-limited devices. As the main contribution, STEAM enables the development of applications for different platforms, with standardized functions and class structures that use consolidated IoT data formats and communication protocols. Moreover, the experiments revealed the viability of stream processing in the edge resulting in the reduction of response time without compromising the quality of results.},

keywords = {},

pubstate = {published},

tppubtype = {article}

}

@article{HOFFMANN:REIC:21,

title = {Geração de Código OpenMP para o Paralelismo deStream},

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}

}

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

}

@incollection{larcc:minicurso:ERAD:21,

title = {Ambiente de Nuvem Computacional Privada paraTeste e Desenvolvimento de Programas Paralelos},

author = {Anderson M. Maliszewski and},

editor = {Andrea Charão and Matheus Serpa},

url = {https://doi.org/10.5753/sbc.6150.4},

doi = {10.5753/sbc.6150.4},

year  = {2021},

date = {2021-06-01},

booktitle = {Minicursos da XXI Escola Regional de Alto Desempenho da Região Sul},

pages = {104-128},

publisher = {Sociedade Brasileira de Computação (SBC)},

address = {Porto Alegre},

chapter = {5},

abstract = {A computação de alto desempenho costuma utilizar agregados de computadores para aexecução de aplicações paralelas. Alternativamente, a computação em nuvem oferecerecursos computacionais distribuídos para processamento com um nível de abstraçãoalém do tradicional, dinâmico e sob-demanda. Este capítulo tem como objetivo intro-duzir conceitos básicos, apresentar noções básicas para implantar uma nuvem privadae demonstrar os benefícios para o desenvolvimento e teste de programas paralelos emnuvem},

keywords = {},

pubstate = {published},

tppubtype = {incollection}

}

@article{VOGEL:Computing:23,

title = {Online and Transparent Self-adaptation of Stream Parallel Patterns},

author = {Adriano Vogel and Gabriele Mencagli and Dalvan Griebler and Marco Danelutto and Luiz Gustavo Fernandes},

url = {https://doi.org/10.1007/s00607-021-00998-8},

doi = {10.1007/s00607-021-00998-8},

year  = {2021},

date = {2021-05-01},

journal = {Computing},

volume = {105},

number = {5},

pages = {1039-1057},

publisher = {Springer},

abstract = {Several real-world parallel applications are becoming more dynamic and long-running, demanding online (at run-time) adaptations. Stream processing is a representative scenario that computes data items arriving in real-time and where parallel executions are necessary. However, it is challenging for humans to monitor and manually self-optimize complex and long-running parallel executions continuously. Moreover, although high-level and structured parallel programming aims to facilitate parallelism, several issues still need to be addressed for improving the existing abstractions. In this paper, we extend self-adaptiveness for supporting autonomous and online changes of the parallel pattern compositions. Online self-adaptation is achieved with an online profiler that characterizes the applications, which is combined with a new self-adaptive strategy and a model for smooth transitions on reconfigurations. The solution provides a new abstraction layer that enables application programmers to define non-functional requirements instead of hand-tuning complex configurations. Hence, we contribute with additional abstractions and flexible self-adaptation for responsiveness at run-time. The proposed solution is evaluated with applications having different processing characteristics, workloads, and configurations. The results show that it is possible to provide additional abstractions, flexibility, and responsiveness while achieving performance comparable to the best static configuration executions.},

keywords = {},

pubstate = {published},

tppubtype = {article}

}

@inproceedings{larcc:cloud_DNA_databases:ERAD:21,

title = {Avaliação de Desempenho para Banco de Dados com Genoma em Nuvem Privada},

author = {Luan Dopke and Dinei André Rockenbach and Dalvan Griebler},

url = {https://doi.org/10.5753/eradrs.2021.14771},

doi = {10.5753/eradrs.2021.14771},

year  = {2021},

date = {2021-04-01},

booktitle = {21th Escola Regional de Alto Desempenho da Região Sul (ERAD-RS)},

pages = {45-48},

publisher = {Sociedade Brasileira de Computação},

address = {Joinville, RS, Brazil},

abstract = {Os bancos de dados são ferramentas particularmente interessantes para a manipulação de dados gerados através do sequenciamento de DNA. Este artigo tem como objetivo avaliar o desempenho de três bancos de dados com cargas relacionadas ao sequenciamento de DNA: PostgreSQL e MySQL como bancos de dados relacionais e MongoDB como banco de dados NoSQL. Os resultados demonstram que o PostgreSQL se sobressai aos demais..},

keywords = {},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{larcc:DL_Classificaiton_MPI:ERAD:21,

title = {Aceleração da Classificação de Lavouras de Milho com MPI e Estratégias de Paralelismo},

author = {Anthony Vanzan and Gabriel Fim and Greice Welter and Dalvan Griebler},

url = {https://doi.org/10.5753/eradrs.2021.14772},

doi = {10.5753/eradrs.2021.14772},

year  = {2021},

date = {2021-04-01},

booktitle = {21th Escola Regional de Alto Desempenho da Região Sul (ERAD-RS)},

pages = {49-52},

publisher = {Sociedade Brasileira de Computação},

address = {Joinville, RS, Brazil},

abstract = {Este trabalho visou acelerar a execução de um algoritmo de classificação de lavouras em imagens áreas. Para isso, foram implementadas diferentes versões paralelas usando a biblioteca MPI na linguagem Python. A avaliação foi conduzida em dois ambientes computacionais. Conclui-se que é possível reduzir o tempo de execução a medida que mais recursos paralelos são usados e a estratégia de distribuição de trabalho dinâmica é mais eficiente.},

keywords = {},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{LOFF:ERAD:21,

title = {Melhorando a Geração Automática de Código Paralelo em Arquiteturas Multi-core na SPar},

author = {Júnior Löff and Dalvan Griebler and Luiz Gustavo Fernandes},

url = {https://doi.org/10.5753/eradrs.2021.14776},

doi = {10.5753/eradrs.2021.14776},

year  = {2021},

date = {2021-04-01},

booktitle = {21th Escola Regional de Alto Desempenho da Região Sul (ERAD-RS)},

pages = {65-68},

publisher = {Sociedade Brasileira de Computação},

address = {Joinville, Brazil},

abstract = {Neste trabalho, a fim de melhorar a eficiência do código paralelo gerado em arquiteturas multi-core, foi estendida a linguagem e o compilador da SPar para permitir a geração automática de padrões paralelos pertencentes aos dois principais domínios de paralelismo, o de stream e de dados. Experimentos mostram que a nova versão da SPar obteve resultados similares, ou até mesmo melhores, que as versões implementadas manualmente.},

keywords = {},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{HOFFMANN:ERAD:21,

title = {Abstraindo o OpenMP no Desenvolvimento de Aplicações de Fluxo de Dados Contínuo},

author = {Renato Barreto Hoffmann and Dalvan Griebler and Luiz Gustavo Fernandes},

url = {https://doi.org/10.5753/eradrs.2021.14777},

doi = {10.5753/eradrs.2021.14777},

year  = {2021},

date = {2021-04-01},

booktitle = {21th Escola Regional de Alto Desempenho da Região Sul (ERAD-RS)},

pages = {69-72},

publisher = {Sociedade Brasileira de Computação},

address = {Joinville, Brazil},

abstract = {OpenMP é complexo quando usado para desenvolver aplicações de fluxo de dados. Com o objetivo de mitigar essa dificuldade, foi utilizada uma metodologia existente, chamada SPar, para aumentar o nível de abstração. Portanto, foram utilizadas anotações mais alto-nível da SPar para gerar código mais baixo-nível de fluxo de dados com OpenMP. Os experimentos revelaram que a SPar teve desempenho 0,86% inferior no caso mais extremo.},

keywords = {},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{MELLO:ERAD:21,

title = {Compressão de Dados em Multicores com Flink ou SPar?},

author = {Fernanda Mello and Dalvan Griebler and Isabel Manssour and Luiz Gustavo Fernandes},

url = {https://doi.org/10.5753/eradrs.2021.14779},

doi = {10.5753/eradrs.2021.14779},

year  = {2021},

date = {2021-04-01},

booktitle = {21th Escola Regional de Alto Desempenho da Região Sul (ERAD-RS)},

pages = {77-80},

publisher = {Sociedade Brasileira de Computação},

address = {Joinville, Brazil},

abstract = {Neste trabalho, foi implementada uma versão do algoritmo de compressão de dados Bzip2 com o framework para processamento de stream Apache Flink, a fim de avaliar seu desempenho em comparação com a versão do Bzip2 já existente na linguagem de domínio específica SPar. Os experimentos revelaram que a versão com SPar possui um desempenho muito superior ao Flink.},

keywords = {},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{larcc:NPB_HPX_MPI:ERAD:21,

title = {Implementação MPIC++ e HPX dos Kernels NPB},

author = {Ricardo Leonarczyk and Dalvan Griebler},

url = {https://doi.org/10.5753/eradrs.2021.14780},

doi = {10.5753/eradrs.2021.14780},

year  = {2021},

date = {2021-04-01},

booktitle = {21th Escola Regional de Alto Desempenho da Região Sul (ERAD-RS)},

pages = {81-84},

publisher = {Sociedade Brasileira de Computação},

address = {Joinville, RS, Brazil},

abstract = {Este artigo apresenta a implementação paralela dos cinco kernels pertencentes ao NAS Parallel Benchmarks (NPB) com MPIC++ e HPX para execução em arquiteturas de cluster. Os resultados demonstraram que o modelo de programação HPX pode ser mais eficiente do que MPIC++ em algoritmos tais como transformada rápida de Fourier, ordenação e Gradiente Conjugado.},

keywords = {},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{ANDRADE:ERAD:21,

title = {Uso de Métricas de Codificação para Avaliar a Programação Paralela nas Aplicações de Stream em Sistemas Multi-core},

author = {Gabriella Andrade and Dalvan Griebler and Rodrigo Santos and Luiz Gustavo Fernandes},

url = {https://doi.org/10.5753/eradrs.2021.14785},

doi = {10.5753/eradrs.2021.14785},

year  = {2021},

date = {2021-04-01},

booktitle = {21th Escola Regional de Alto Desempenho da Região Sul (ERAD-RS)},

pages = {93-94},

publisher = {Sociedade Brasileira de Computação},

address = {Joinville, Brazil},

abstract = {Neste trabalho, sete métricas de codificação são avaliadas considerando quatro aplicações do mundo real implementadas com FastFlow, Pthreads, SPar e TBB. Nossos resultados mostram que SPar apresenta os melhores indicadores de acordo com as métricas utilizadas.},

keywords = {},

pubstate = {published},

tppubtype = {inproceedings}

}

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

}

@inproceedings{ARAUJO:ERAD:21,

title = {Proposta de Suporte à Parametrização no NPB com CUDA},

author = {Gabriell Araujo and Dalvan Griebler and Luiz Gustavo Fernandes},

url = {https://doi.org/10.5753/eradrs.2021.14790},

doi = {10.5753/eradrs.2021.14790},

year  = {2021},

date = {2021-04-01},

booktitle = {21th Escola Regional de Alto Desempenho da Região Sul (ERAD-RS)},

pages = {103-104},

publisher = {Sociedade Brasileira de Computação},

address = {Joinville, Brazil},

abstract = {Este trabalho propõe a introdução de parâmetros configuráveis para GPUs no NPB. A etapa inicial do estudo contemplou a parametrização do número de threads por bloco e seu impacto no desempenho de GPUs.},

keywords = {},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{ROCKENBACH:ERAD:21,

title = {Provendo Abstrações de Alto Nível para GPUs na SPar},

author = {Dinei André Rockenbach and Dalvan Griebler and Luiz Gustavo Fernandes},

url = {https://doi.org/10.5753/eradrs.2021.14793},

doi = {10.5753/eradrs.2021.14793},

year  = {2021},

date = {2021-04-01},

booktitle = {21th Escola Regional de Alto Desempenho da Região Sul (ERAD-RS)},

pages = {109-110},

publisher = {Sociedade Brasileira de Computação},

address = {Joinville, Brazil},

abstract = {O presente trabalho apresenta uma extensão à linguagem SPar para suportar o paralelismo heterogêneo combinado de CPU e GPU através de anotações C++11 em aplicações de processamento de stream. Os testes sugerem melhoras significativas de desempenho com poucas modificações no código.},

keywords = {},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{GARCIA:ERAD:21,

title = {Proposta de um Framework para Avaliar Interfaces de Programação Paralela em Aplicações de Stream},

author = {Adriano Marques Garcia and Dalvan Griebler and Claudio Schepke and Luiz Gustavo Fernandes},

url = {https://doi.org/10.5753/eradrs.2021.14798},

doi = {10.5753/eradrs.2021.14798},

year  = {2021},

date = {2021-04-01},

booktitle = {21th Escola Regional de Alto Desempenho da Região Sul (ERAD-RS)},

pages = {119-120},

publisher = {Sociedade Brasileira de Computação},

address = {Joinville, Brazil},

abstract = {Este trabalho propõe um framework que auxilia no desenvolvimento de benchmarks para avaliar Interfaces de Programação Paralela no domínio de paralelismo de stream em C++.},

keywords = {},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{SCHEER:ERAD:21,

title = {Proposta de Otimização do Tamanho de Batch em Aplicações de Stream para Multicores usando Aprendizado de Máquina},

author = {Claudio Scheer and Dalvan Griebler and Luiz Gustavo Fernandes},

url = {https://doi.org/10.5753/eradrs.2021.14802},

doi = {10.5753/eradrs.2021.14802},

year  = {2021},

date = {2021-04-01},

booktitle = {21th Escola Regional de Alto Desempenho da Região Sul (ERAD-RS)},

pages = {127-128},

publisher = {Sociedade Brasileira de Computação},

address = {Joinville, Brazil},

abstract = {Este trabalho apresenta uma proposta de estudo e avaliação de features e algoritmos de aprendizado de máquina visando melhorar a desempenho através do ajuste/regulagem do tamanho do batch em aplicações paralelas de stream para arquiteturas multicore.},

keywords = {},

pubstate = {published},

tppubtype = {inproceedings}

}

@article{VOGEL:Survey:CCPE:2021,

title = {Self-adaptation on Parallel Stream Processing: A Systematic Review},

author = {Adriano Vogel and Dalvan Griebler and Marco Danelutto and Luiz Gustavo Fernandes},

url = {https://doi.org/10.1002/cpe.6759},

doi = {10.1002/cpe.6759},

year  = {2021},

date = {2021-03-01},

urldate = {2021-03-01},

journal = {Concurrency and Computation: Practice and Experience},

volume = {34},

number = {6},

pages = {e6759},

publisher = {Wiley},

abstract = {A recurrent challenge in real-world applications is autonomous management of the executions at run-time. In this vein, stream processing is a class of applications that compute data flowing in the form of streams (e.g., video feeds, images, and data analytics), where parallel computing can help accelerate the executions. On the one hand, stream processing applications are becoming more complex, dynamic, and long-running. On the other hand, it is unfeasible for humans to monitor and manually change the executions continuously. Hence, self-adaptation can reduce costs and human efforts by providing a higher-level abstraction with an autonomic/seamless management of executions. In this work, we aim at providing a literature review regarding self-adaptation applied to the parallel stream processing domain. We present a comprehensive revision using a systematic literature review method. Moreover, we propose a taxonomy to categorize and classify the existing self-adaptive approaches. Finally, applying the taxonomy made it possible to characterize the state-of-the-art, identify trends, and discuss open research challenges and future opportunities.},

keywords = {},

pubstate = {published},

tppubtype = {article}

}

@inproceedings{VOGEL:PDP:21,

title = {Towards On-the-fly Self-Adaptation of Stream Parallel Patterns},

author = {Adriano Vogel and Gabriele Mencagli and Dalvan Griebler and Marco Danelutto and Luiz Gustavo Fernandes},

url = {https://doi.org/10.1109/PDP52278.2021.00022},

doi = {10.1109/PDP52278.2021.00022},

year  = {2021},

date = {2021-03-01},

booktitle = {29th Euromicro International Conference on Parallel, Distributed and Network-Based Processing (PDP)},

pages = {889-93},

publisher = {IEEE},

address = {Valladolid, Spain},

series = {PDP'21},

abstract = {Stream processing applications compute streams of data and provide insightful results in a timely manner, where parallel computing is necessary for accelerating the application executions. Considering that these applications are becoming increasingly dynamic and long-running, a potential solution is to apply dynamic runtime changes. However, it is challenging for humans to continuously monitor and manually self-optimize the executions. In this paper, we propose self-adaptiveness of the parallel patterns used, enabling flexible on-the-fly adaptations. The proposed solution is evaluated with an existing programming framework and running experiments with a synthetic and a real-world application. The results show that the proposed solution is able to dynamically self-adapt to the most suitable parallel pattern configuration and achieve performance competitive with the best static cases. The feasibility of the proposed solution encourages future optimizations and other applicabilities.},

keywords = {},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{GARCIA:PDP:21,

title = {Introducing a Stream Processing Framework for Assessing Parallel Programming Interfaces},

author = {Adriano Marques Garcia and Dalvan Griebler and Claudio Schepke and Luiz Gustavo Fernandes},

url = {https://doi.org/10.1109/PDP52278.2021.00021},

doi = {10.1109/PDP52278.2021.00021},

year  = {2021},

date = {2021-03-01},

booktitle = {29th Euromicro International Conference on Parallel, Distributed and Network-Based Processing (PDP)},

pages = {84-88},

publisher = {IEEE},

address = {Valladolid, Spain},

series = {PDP'21},

abstract = {Stream Processing applications are spread across different sectors of industry and people's daily lives. The increasing data we produce, such as audio, video, image, and text are demanding quickly and efficiently computation. It can be done through Stream Parallelism, which is still a challenging task and most reserved for experts. We introduce a Stream Processing framework for assessing Parallel Programming Interfaces (PPIs). Our framework targets multi-core architectures and C++ stream processing applications, providing an API that abstracts the details of the stream operators of these applications. Therefore, users can easily identify all the basic operators and implement parallelism through different PPIs. In this paper, we present the proposed framework, implement three applications using its API, and show how it works, by using it to parallelize and evaluate the applications with the PPIs Intel TBB, FastFlow, and SPar. The performance results were consistent with the literature.},

keywords = {},

pubstate = {published},

tppubtype = {inproceedings}

}

@article{VOGEL:SPE:21,

title = {Providing High‐Level Self‐Adaptive Abstractions for Stream Parallelism on Multicores},

author = {Adriano Vogel and Dalvan Griebler and Luiz G. Fernandes},

url = {https://doi.org/10.1002/spe.2948},

doi = {10.1002/spe.2948},

year  = {2021},

date = {2021-01-01},

journal = {Software: Practice and Experience},

volume = {51},

number = {6},

pages = {1194-1217},

publisher = {Wiley},

abstract = {Stream processing applications are common computing workloads that demand parallelism to increase their performance. As in the past, parallel programming remains a difficult task for application programmers. The complexity increases when application programmers must set non-intuitive parallelism parameters, i.e. the degree of parallelism. The main problem is that state-of-the-art libraries use a static degree of parallelism and are not sufficiently abstracted for developing stream processing applications. In this paper, we propose a self-adaptive regulation of the degree of parallelism to provide higher-level abstractions. Flexibility is provided to programmers with two new self-adaptive strategies, one is for performance experts, and the other abstracts the need to set a performance goal. We evaluated our solution using compiler transformation rules to generate parallel code with the SPar domain-specific language. The experimental results with real-world applications highlighted higher abstraction levels without significant performance degradation in comparison to static executions. The strategy for performance experts achieved slightly higher performance than the one that works without user-defined performance goals.},

keywords = {},

pubstate = {published},

tppubtype = {article}

}

@inproceedings{SCHEER:WSCAD:21,

title = {Performance Data Visualization of Linux Events on Multicores},

author = {Claudio Scheer and Renato Hoffmann and Dalvan Griebler and Isabel Manssour and Luiz Fernandes},

url = {https://doi.org/10.5753/wscad.2021.18516},

doi = {10.5753/wscad.2021.18516},

year  = {2021},

date = {2021-01-01},

booktitle = {Anais do XXII Simpósio em Sistemas Computacionais de Alto Desempenho},

pages = {108-119},

publisher = {SBC},

address = {Belo Horizonte},

abstract = {Profiling tools are essential to understand the behavior of parallel applications and assist in the optimization process. However, tools such as Perf generate a large amount of data. This way, they require significant storage space, which also complicates reasoning about this large volume of data. Therefore, we propose VisPerf: a tool-chain and an interactive visualization dashboard for Perf data. The VisPerf tool-chain profiles the application and pre-processes the data, reducing the storage space required by about 50 times. Moreover, we used the visualization dashboard to quickly understand the performance of different events and visualize specific threads and functions of a real-world application.},

keywords = {},

pubstate = {published},

tppubtype = {inproceedings}

}

@article{larcc:DL_solos:REABTIC:21,

title = {Simplificando a Interpretação de Laudos de Análise de Solo com Deep Learning em Nuvem},

author = {Alisson Allebrandt and Diego Henrique Schmidt and Dalvan Griebler},

url = {https://revistas.setrem.com.br/index.php/reabtic/article/view/387},

doi = {10.5281/zenodo.4445204},

year  = {2021},

date = {2021-01-01},

urldate = {2021-01-01},

journal = {Revista Eletrônica Argentina-Brasil de Tecnologias da Informação e da Comunicação (REABTIC)},

volume = {1},

number = {13},

publisher = {SETREM},

address = {Três de Maio, RS, Brazil},

abstract = {Um dos aspectos que interfere em uma boa produtividade agrícolaé o solo, consequentemente, a sua conservação por meio da aplicação corretade nutrientes e adubação é de suma importância. Neste artigo, propõe-se umaarquitetura de software e um aplicativo mobile capaz de auxiliar agricultores eengenheiros agrônomos na interpretação de análises de solo geradas em laboratórios.A arquitetura de software foi concebida para atuar em um ambientede nuvem e o aplicativo mobile é a interface para captura e apresentação dosdados. Inicialmente, foi necessário criar uma base de dados com diferentestipos e configurações de imagens. O dataset foi tratado para eliminar ruídos(tais como luminosidade, sombras e distorções) e usado para avaliação de duassoluções de Deep Learning (Google Vision e Tesseract OCR), onde o TesseractOCR se mostrou mais preciso usando as mesmas imagens. Além de ofertar oaplicativo mobile, que é um primeiro passo, a pesquisa realizada revela váriascarências tecnológicas e oportunidades para inovações na área de ciência dossolos.},

keywords = {},

pubstate = {published},

tppubtype = {article}

}

@article{BORDIN:IEEEAccess:20,

title = {DSPBench: a Suite of Benchmark Applications for Distributed Data Stream Processing Systems},

author = {Maycon Viana Bordin and Dalvan Griebler and Gabriele Mencagli and Claudio F. R. Geyer and Luiz Gustavo Fernandes},

url = {https://doi.org/10.1109/ACCESS.2020.3043948},

doi = {10.1109/ACCESS.2020.3043948},

year  = {2020},

date = {2020-12-01},

urldate = {2020-12-01},

journal = {IEEE Access},

volume = {8},

number = {na},

pages = {222900-222917},

publisher = {IEEE},

abstract = {Systems enabling the continuous processing of large data streams have recently attracted the attention of the scientific community and industrial stakeholders. Data Stream Processing Systems (DSPSs) are complex and powerful frameworks able to ease the development of streaming applications in distributed computing environments like clusters and clouds. Several systems of this kind have been released and currently maintained as open source projects, like Apache Storm and Spark Streaming. Some benchmark applications have often been used by the scientific community to test and evaluate new techniques to improve the performance and usability of DSPSs. However, the existing benchmark suites lack of representative workloads coming from the wide set of application domains that can leverage the benefits offered by the stream processing paradigm in terms of near real-time performance. The goal of this paper is to present a new benchmark suite composed of 15 applications coming from areas like Finance, Telecommunications, Sensor Networks, Social Networks and others. This paper describes in detail the nature of these applications, their full workload characterization in terms of selectivity, processing cost, input size and overall memory occupation. In addition, it exemplifies the usefulness of our benchmark suite to compare real DSPSs by selecting Apache Storm and Spark Streaming for this analysis.},

keywords = {},

pubstate = {published},

tppubtype = {article}

}

@inproceedings{HOFFMANN:SBLP:20,

title = {Stream Parallelism Annotations for Multi-Core Frameworks},

author = {Renato B. Hoffmann and Dalvan Griebler and Marco Danelutto and Luiz G. Fernandes},

url = {https://doi.org/10.1145/3427081.3427088},

doi = {10.1145/3427081.3427088},

year  = {2020},

date = {2020-10-01},

booktitle = {XXIV Brazilian Symposium on Programming Languages (SBLP)},

pages = {48-55},

publisher = {ACM},

address = {Natal, Brazil},

series = {SBLP'20},

abstract = {Data generation, collection, and processing is an important workload of modern computer architectures. Stream or high-intensity data flow applications are commonly employed in extracting and interpreting the information contained in this data. Due to the computational complexity of these applications, high-performance ought to be achieved using parallel computing. Indeed, the efficient exploitation of available parallel resources from the architecture remains a challenging task for the programmers. Techniques and methodologies are required to help shift the efforts from the complexity of parallelism exploitation to specific algorithmic solutions. To tackle this problem, we propose a methodology that provides the developer with a suitable abstraction layer between a clean and effective parallel programming interface targeting different multi-core parallel programming frameworks. We used standard C++ code annotations that may be inserted in the source code by the programmer. Then, a compiler parses C++ code with the annotations and generates calls to the desired parallel runtime API. Our experiments demonstrate the feasibility of our methodology and the performance of the abstraction layer, where the difference is negligible in four applications with respect to the state-of-the-art C++ parallel programming frameworks. Additionally, our methodology allows improving the application performance since the developers can choose the runtime that best performs in their system.},

keywords = {},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{GARCIA:ICCSA:20,

title = {The Impact of CPU Frequency Scaling on Power Consumption of Computing Infrastructures},

author = {Adriano M. Garcia and Matheus Serpa and Dalvan Griebler and Claudio Schepke and Luiz G. L. Fernandes and Philippe O. A. Navaux},

url = {https://doi.org/10.1007/978-3-030-58817-5_12},

doi = {10.1007/978-3-030-58817-5_12},

year  = {2020},

date = {2020-07-01},

booktitle = {International Conference on Computational Science and its Applications (ICCSA)},

volume = {12254},

pages = {142-157},

publisher = {Springer},

address = {Cagliari, Italy},

series = {ICCSA'20},

abstract = {Since the demand for computing power increases, new architectures emerged to obtain better performance. Reducing the power and energy consumption of these architectures is one of the main challenges to achieving high-performance computing. Current research trends aim at developing new software and hardware techniques to achieve the best performance and energy trade-offs. In this work, we investigate the impact of different CPU frequency scaling techniques such as ondemand, performance, and powersave on the power and energy consumption of multi-core based computer infrastructure. We apply these techniques in PAMPAR, a parallel benchmark suite implemented in PThreads, OpenMP, MPI-1, and MPI-2 (spawn). We measure the energy and execution time of 10 benchmarks, varying the number of threads. Our results show that although powersave consumes up to 43.1% less power than performance and ondemand governors, it consumes the triple of energy due to the high execution time. Our experiments also show that the performance governor consumes up to 9.8% more energy than ondemand for CPU-bound benchmarks. Finally, our results show that PThreads has the lowest power consumption, consuming less than the sequential version for memory-bound benchmarks. Regarding performance, the performance governor achieved 3% of performance over the ondemand.},

keywords = {},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{larcc:ieee802.3ad_containers:ICCSA:20,

title = {Performance Impact of IEEE 802.3ad in Container-based Clouds for HPC Applications},

author = {Anderson M. Maliszewski and Eduardo Roloff and Dalvan Griebler and Luciano P. Gaspary and Philippe O. A. Navaux},

url = {https://doi.org/10.1007/978-3-030-58817-5_13},

doi = {10.1007/978-3-030-58817-5_13},

year  = {2020},

date = {2020-07-01},

booktitle = {International Conference on Computational Science and its Applications (ICCSA)},

pages = {158-167},

publisher = {Springer},

address = {Cagliari, Italy},

series = {ICCSA'20},

abstract = {Historically, large computational clusters have supported hardware requirements for executing High-Performance Computing (HPC) applications. This model has become out of date due to the high costs of maintaining and updating these infrastructures. Currently, computing resources are delivered as a service because of the cloud computing paradigm. In this way, we witnessed consistent efforts to migrate HPC applications to the cloud. However, if on the one hand cloud computing offers an attractive environment for HPC, benefiting from the pay-per-use model and on-demand resource allocation, on the other, there are still significant performance challenges to be addressed, such as the known network bottleneck. In this article, we evaluate the use of a Network Interface Cards (NIC) aggregation approach, using the IEEE 802.3ad standard to improve the performance of representative HPC applications executed in LXD container based-cloud. We assessed the aggregation impact using two and four NICs with three distinct transmission hash policies. Our results demonstrated that if the correct hash policy is selected, the NIC aggregation can significantly improve the performance of network-intensive HPC applications by up to 40%.},

keywords = {},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{larcc:network_azure_cost_perf:ISCC:20,

title = {Performance and Cost-Aware in Clouds: A Network Interconnection Assessment},

author = {Anderson M. Maliszewski and Eduardo Roloff and Emmanuell D. Carreño and Dalvan Griebler and Luciano P. Gaspary and Philippe O. A. Navaux},

url = {https://doi.org/10.1109/ISCC50000.2020.9219554},

doi = {10.1109/ISCC50000.2020.9219554},

year  = {2020},

date = {2020-07-01},

booktitle = {IEEE Symposium on Computers and Communications (ISCC)},

pages = {1-6},

publisher = {IEEE},

address = {Rennes, France},

series = {ISCC'20},

abstract = {The availability of computing resources has significantly changed due to the growing adoption of the cloud computing paradigm. Aiming at potential advantages such as cost savings through the pay-per-use method and resource allocation in a scalable/elastic way, we witnessed consistent efforts to execute high-performance computing (HPC) applications in the cloud. Performance in this environment depends heavily upon two main system components: processing power and network interconnection. If, on the one hand, allocating more powerful hardware theoretically boosts performance, on the other hand, it increases the allocation cost. In this paper, we evaluated how the network interconnection impacts on performance and cost efficiency. Our experiments were carried out using NAS Parallel Benchmarks and Alya HPC application on Microsoft Azure public cloud provider, with three different cloud instances/network interconnections. The results revealed that through the use of the accelerated networking approach, which allows the instance to have a high-performance interconnect without additional charges, the performance of HPC applications can be significantly improved with a better cost efficiency.},

keywords = {},

pubstate = {published},

tppubtype = {inproceedings}

}

@article{STEIN:CCPE:20,

title = {Latency‐aware adaptive micro‐batching techniques for streamed data compression on graphics processing units},

author = {Charles M. Stein and Dinei A. Rockenbach and Dalvan Griebler and Massimo Torquati and Gabriele Mencagli and Marco Danelutto and Luiz G. Fernandes},

url = {https://doi.org/10.1002/cpe.5786},

doi = {10.1002/cpe.5786},

year  = {2020},

date = {2020-05-01},

journal = {Concurrency and Computation: Practice and Experience},

volume = {na},

number = {na},

pages = {e5786},

publisher = {Wiley Online Library},

abstract = {Stream processing is a parallel paradigm used in many application domains. With the advance of graphics processing units (GPUs), their usage in stream processing applications has increased as well. The efficient utilization of GPU accelerators in streaming scenarios requires to batch input elements in microbatches, whose computation is offloaded on the GPU leveraging data parallelism within the same batch of data. Since data elements are continuously received based on the input speed, the bigger the microbatch size the higher the latency to completely buffer it and to start the processing on the device. Unfortunately, stream processing applications often have strict latency requirements that need to find the best size of the microbatches and to adapt it dynamically based on the workload conditions as well as according to the characteristics of the underlying device and network. In this work, we aim at implementing latency‐aware adaptive microbatching techniques and algorithms for streaming compression applications targeting GPUs. The evaluation is conducted using the Lempel‐Ziv‐Storer‐Szymanski compression application considering different input workloads. As a general result of our work, we noticed that algorithms with elastic adaptation factors respond better for stable workloads, while algorithms with narrower targets respond better for highly unbalanced workloads.},

keywords = {},

pubstate = {published},

tppubtype = {article}

}

@inproceedings{larcc:network_impact:ERAD:20,

title = {Avaliando o Impacto da Rede no Desempenho e Custo de Execução de Aplicações HPC},

author = {Anderson M. Maliszewski and Eduardo Roloff and Dalvan Griebler and Philippe O. A. Navaux},

url = {https://doi.org/10.5753/eradrs.2020.10786},

doi = {10.5753/eradrs.2020.10786},

year  = {2020},

date = {2020-04-01},

booktitle = {20th Escola Regional de Alto Desempenho da Região Sul (ERAD-RS)},

pages = {159-160},

publisher = {Sociedade Brasileira de Computação},

address = {Santa Maria, RS, Brazil},

abstract = {O desempenho das aplicações HPC depende de dois componentes principais; poder de processamento e interconexão de rede. Este artigo avalia o impacto que a interconexão de rede exerce em programas paralelos usando um cluster homogêneo, em relação a desempenho e custo de execução estimado.},

keywords = {},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{ANDRADE:ERAD:20,

title = {Avaliação da Usabilidade de Interfaces de Programação Paralela para Sistemas Multi-Core em Aplicação de Vídeo},

author = {Gabriella Andrade and Dalvan Griebler and Luiz G. L. Fernandes},

url = {https://doi.org/10.5753/eradrs.2020.10781},

doi = {10.5753/eradrs.2020.10781},

year  = {2020},

date = {2020-04-01},

booktitle = {XX Escola Regional de Alto Desempenho da Região Sul (ERAD-RS)},

pages = {149-150},

publisher = {Sociedade Brasileira de Computação (SBC)},

address = {Santa Maria, BR},

abstract = {Com a ampla variedade de interfaces para a programação paralela em ambientes multi-core é difícil determinar quais destas oferecem a melhor usabilidade. Esse trabalho realiza um experimento comparando a paralelização de uma aplicação de vídeo com as ferramentas FastFlow, SPar e TBB. Os resultados revelaram que a SPar requer menos esforço na paralelização de uma aplicação de vídeo do que as demais interfaces de programação paralela.},

keywords = {},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{GARCIA:ERAD:20,

title = {Proposta de uma Suíte de Benchmarks para Processamento de Stream em Sistemas Multi-Core},

author = {Adriano Marques Garcia and Dalvan Griebler and Luiz G. L. Fernandes},

url = {https://doi.org/10.5753/eradrs.2020.10790},

doi = {10.5753/eradrs.2020.10790},

year  = {2020},

date = {2020-04-01},

booktitle = {XX Escola Regional de Alto Desempenho da Região Sul (ERAD-RS)},

pages = {167-168},

publisher = {Sociedade Brasileira de Computação (SBC)},

address = {Santa Maria, BR},

abstract = {O aumento no volume de dados gerados por sistemas computacionais e a necessidade por processamento rápido desses dados vem alavancando a área de processamento de stream. Entretanto, ainda não existe um benchmark para auxiliar desenvolvedores e pesquisadores. Este trabalho visa propor uma suíte de benchmarks para processamento de stream em arquiteturas multi-core e discute as características necessárias no desenvolvimento dessa suíte.},

keywords = {},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{ARAUJO:ERAD:20,

title = {Implementação CUDA dos Kernels NPB},

author = {Gabriell Alves Araújo and Dalvan Griebler and Luiz G. L. Fernandes},

url = {https://doi.org/10.5753/eradrs.2020.10762},

doi = {10.5753/eradrs.2020.10762},

year  = {2020},

date = {2020-04-01},

booktitle = {XX Escola Regional de Alto Desempenho da Região Sul (ERAD-RS)},

pages = {85-88},

publisher = {Sociedade Brasileira de Computação (SBC)},

address = {Santa Maria, BR},

abstract = {NAS Parallel Benchmarks (NPB) é um conjunto de benchmarks utilizado para avaliar hardware e software, que ao longo dos anos foi portado para diferentes frameworks. Concernente a GPUs, atualmente existem apenas versões OpenCL e OpenACC. Este trabalho contribui com a literatura provendo a primeira implementação CUDA completa dos kernels do NPB, realizando experimentos com carga de trabalho inédita e revelando novos fatos sobre o NPB.},

keywords = {},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{HOFFMANN:ERAD:20,

title = {Geração Automática de Código TBB na SPar},

author = {Renato Barreto Hoffmann and Dalvan Griebler and Luis G. L. Fernandes},

url = {https://doi.org/10.5753/eradrs.2020.10765},

doi = {10.5753/eradrs.2020.10765},

year  = {2020},

date = {2020-04-01},

booktitle = {XX Escola Regional de Alto Desempenho da Região Sul (ERAD-RS)},

pages = {97-100},

publisher = {Sociedade Brasileira de Computação (SBC)},

address = {Santa Maria, BR},

abstract = {Técnicas de programação paralela são necessárias para extrair todo o potencial dos processadores de múltiplos núcleos. Para isso, foi criada a SPar, uma linguagem para abstração do paralelismo de stream. Esse trabalho descreve a implementação da geração de código automática para a biblioteca TBB na SPar, uma vez que gerava-se código para FastFlow. Os testes com aplicações resultaram em tempos de execução até 12,76 vezes mais rápidos.},

keywords = {},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{larcc:NPB_MPI:ERAD:20,

title = {Implementação MPIC++ dos kernels NPB EP, IS e CG},

author = {Ricardo Leonarczyk and Dalvan Griebler},

url = {https://doi.org/10.5753/eradrs.2020.10766},

doi = {10.5753/eradrs.2020.10766},

year  = {2020},

date = {2020-04-01},

booktitle = {20th Escola Regional de Alto Desempenho da Região Sul (ERAD-RS)},

pages = {101-104},

publisher = {Sociedade Brasileira de Computação},

address = {Santa Maria, RS, Brazil},

abstract = {Este trabalho busca contribuir com prévios esforços para disponibilizar os NAS Parallel benchmarks na linguagem C++, focando-se no aspecto memória distribuída com MPI. São apresentadas implementações do CG, EP e IS portadas da versão MPI original do NPB. Os experimentos realizados demonstram que a versão proposta dos benchmarks obteve um desempenho próximo da original.},

keywords = {},

pubstate = {published},

tppubtype = {inproceedings}

}

@inproceedings{LOFF:ERAD:20,

title = {Implementação Paralela do LU no NPB C++ Utilizando um Pipeline Implícito},

author = {Junior Löff and Dalvan Griebler and Luiz G. L. Fernandes},

url = {https://doi.org/10.5753/eradrs.2020.10750},

doi = {10.5753/eradrs.2020.10750},

year  = {2020},

date = {2020-04-01},

booktitle = {XX Escola Regional de Alto Desempenho da Região Sul (ERAD-RS)},

pages = {37-40},

publisher = {Sociedade Brasileira de Computação (SBC)},

address = {Santa Maria, BR},

abstract = {Neste trabalho, um pipeline implícito com o padrão map foi implementado na aplicação LU do NAS Parallel Benchmarks em C++. O LU possui dependência de dados no tempo, o que dificulta a exploração do paralelismo. Ele foi convertido de Fortran para C++, a fim de ser paralelizado com diferentes bibliotecas de sistemas multi-core. O uso desta estratégia com as bibliotecas permitiu ganhos de desempenho de até 10.6% em relação a versão original.},

keywords = {},

pubstate = {published},

tppubtype = {inproceedings}

}