@inproceedings{ALF:ERAD:24,
title = {Tolerância a Falhas para Paralelismo de Stream de Alto Nível},
author = {Lucas Alf and Dalvan Griebler},
url = {https://sol.sbc.org.br/index.php/eradrs/article/view/28022},
doi = {10.5753/eradrs.2024.238679},
issn = {2595-4164},
year = {2024},
date = {2024-04-24},
booktitle = {Anais da XXIV Escola Regional de Alto Desempenho da Região Sul},
pages = {119--120},
publisher = {SBC},
address = {Florianópolis/SC},
abstract = {Dada a necessidade dos sistemas de processamento de stream serem executados por longos períodos de tempo, possivelmente indefinidamente, realizar o reprocessamento de todos os dados em caso de falha pode ser altamente custoso ou até mesmo inviável. Nesta pesquisa, propomos investigar como fornecer mecanismos de tolerância a falhas e garantias de consistência para paralelismo de stream distribuído em alto nível.},
keywords = {},
pubstate = {published},
tppubtype = {inproceedings}
}

@inproceedings{ERAD-RS,
title = {Analisando Paralelismo de Dados em Rust Usando o Método do Gradiente Conjugado},
author = {Lucas Bianchessi and Leonardo Faé and Renato Hoffmann and Dalvan Griebler},
url = {https://sol.sbc.org.br/index.php/eradrs/article/view/27990},
doi = {10.5753/eradrs.2024.238677},
issn = {2595-4164},
year = {2024},
date = {2024-04-24},
booktitle = {Anais da XXIV Escola Regional de Alto Desempenho da Região Sul},
pages = {9--12},
publisher = {SBC},
address = {Florianópolis/SC},
abstract = {Em meio ao ambiente da computação de alto desempenho, a linguagem Rust vem se tornando cada vez mais popular, prometendo segurança, desempenho e um ambiente de desenvolvimento moderno. Afim de analisar a viabilidade e eficiência do Rust, foi utilizado método do gradiente conjugado do NPB benchmarks. Os resultados demonstraram resultados paralelos comparáveis ao C++, e perda de desempenho na versão sequencial.},
keywords = {},
pubstate = {published},
tppubtype = {inproceedings}
}

@inproceedings{FAE:ERAD:24,
title = {Proposta de Pipelines Lineares de Alto Nível em Rust Utilizando GPU},
author = {Leonardo Faé and Dalvan Griebler},
url = {https://sol.sbc.org.br/index.php/eradrs/article/view/28015},
doi = {10.5753/eradrs.2024.238565},
issn = {2595-4164},
year = {2024},
date = {2024-01-01},
booktitle = {Anais da XXIV Escola Regional de Alto Desempenho da Região Sul},
pages = {105--106},
publisher = {SBC},
address = {Florianópolis/SC},
abstract = {Unidades de Processamento Gráfico (GPUs) são unidades de hardware projetadas para processar quantidades massivas de dados em paralelo. Rust é uma nova linguagem de programação de baixo nível com foco em desempenho e segurança. Até o momento, há poucos trabalhos acadêmicos sobre abstrações de alto nível para GPUs em Rust. Propomos uma possível abstração, baseada no padrão de pipeline e implementada utilizando macros procedurais.},
keywords = {},
pubstate = {published},
tppubtype = {inproceedings}
}

@inproceedings{FAE:SBLP:24,
title = {An internal domain-specific language for expressing linear pipelines: a proof-of-concept with MPI in Rust},
author = {Leonardo Faé and Dalvan Griebler},
url = {https://sol.sbc.org.br/index.php/sblp/article/view/30260},
doi = {10.5753/sblp.2024.3691},
year = {2024},
date = {2024-01-01},
booktitle = {Anais do XXVIII Simpósio Brasileiro de Linguagens de Programação},
pages = {81--90},
publisher = {SBC},
address = {Curitiba/PR},
abstract = {Parallel computation is necessary in order to process massive volumes of data in a timely manner. There are many parallel programming interfaces and environments, each with their own idiosyncrasies. This, alongside non-deterministic errors, make parallel programs notoriously challenging to write. Great effort has been put forth to make parallel programming for several environments easier. In this work, we propose a DSL for Rust, using the language’s source-to-source transformation facilities, that allows for automatic code generation for distributed environments that support the Message Passing Interface (MPI). Our DSL simplifies MPI’s quirks, allowing the programmer to focus almost exclusively on the computation at hand. Performance experiments show nearly or no runtime difference between our abstraction and manually written MPI code while resulting in less than half the lines of code. More elaborate code complexity metrics (Halstead) estimate from 4.5 to 14.7 times lower effort for expressing parallelism.},
keywords = {},
pubstate = {published},
tppubtype = {inproceedings}
}

@inproceedings{FAE:SBLP:23,
title = {Source-to-Source Code Transformation on Rust for High-Level Stream Parallelism},
author = {Leonardo G Faé and Renato B Hoffman and Dalvan Griebler},
url = {https://doi.org/10.1145/3624309.3624320},
doi = {10.1145/3624309.3624320},
isbn = {9798400716287},
year = {2023},
date = {2023-11-02},
booktitle = {Proceedings of the XXVII Brazilian Symposium on Programming Languages},
pages = {41–49},
publisher = {Association for Computing Machinery},
address = {Campo Grande, MS, Brazil},
series = {SBLP '23},
abstract = {Utilizing parallel systems to their full potential can be challenging for general-purpose developers. A solution to this problem is to create high-level abstractions using Domain-Specific Languages (DSL). We create a stream-processing DSL for Rust, a growing programming language focusing on performance and safety. To that end, we explore Rust’s macros as a high-level abstraction tool to support an existing DSL language named SPar and perform source-to-source code transformations in the abstract syntax tree. We aim to assess the Rust source-to-source code transformations toolset and its implications. We highlight that Rust macros are powerful tools for performing source-to-source code transformations for abstracting structured stream processing. In addition, execution time and programmability results are comparable to other solutions.},
keywords = {},
pubstate = {published},
tppubtype = {inproceedings}
}