Revisitando Clássicos da Concorrência: Implementação e Avaliação em OpenMP, Rust e Go
Resumo
Este artigo apresenta um estudo em que foram comparadas a expressividade de OpenMP, Rust e Go na implementação de cinco problemas clássicos de programação concorrente. As soluções, baseadas em abordagens idiomáticas, foram avaliadas quanto ao esforço de implementação, segurança e desempenho, utilizando o método Goal Question Metric (GQM). Os resultados revelam os pontos fortes e limitações de cada linguagem em diferentes contextos de sincronização e compartilhamento de recursos, oferecendo subsídios para a escolha de ferramentas no desenvolvimento de sistemas multithread.Referências
Abhinav et al. (2020). Concurrency analysis of go and java. In 5th Int. Conf. on Computing, Communication and Security, pages 1–6.
Adams, J. C., Koning, E. R., and Hazlett, C. D. (2019). Visualizing classic synchronization problems: Dining philosophers, producers-consumers, and readers-writers. In Proc. of the 50th ACM Technical Symposium on Computer Science Education, page 934–940, New York. ACM.
Chapman, B., Jost, G., and van der Pas, R. (2007). Using OpenMP: Portable Shared Memory Parallel Programming. MIT Press, Cambridge.
Basili, V. R., Caldiera, G., and Rombach, D. H. (1994). The Goal Question Metric Approach, volume I. John Wiley & Sons.
Besozzi, V. (2024). Ppl: Structured parallel programming meets Rust. In 32nd Euromicro Int. Conf. on Parallel, Distributed and Network-Based Processing, pages 78–87.
Qin et al. (2020). Understanding memory and thread safety practices and issues in real-world Rust programs. In Proc. of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI), pages 492–506. ACM.
Hoare, C. A. R. (1981). Communicating sequential processes. In Proc. of the Int. Colloq. on Formalization of Programming Concepts, pages 413–425. Springer.
Capel, M. I., Tomeu, A. J., and Salguero, A. G. (2018). A set of patterns for concurrent and parallel programming teaching. In Euro-Par 2017: Parallel Processing Workshops, pages 203–215, Cham. Springer International Publishing.
Costanzo et al. (2021). Performance vs programming effort between Rust and C on multicore architectures: Case study in n-body. In XLVII Latin American Computing Conference, pages 1–10.
D. Jardim et al. (2021). An extension for transactional memory in OpenMP. In 25th Brazilian Symposium on Prog. Languages, page 58–65, New York. ACM.
Di Domenico, D. (2022). A Model for Software Measurement Aiming to Guide Evaluations and Comparisons between Programming Tools to Implement GPU Applications. PhD thesis, Federal University of Pelotas.
Di Domenico, D. and Cavalheiro, G. G. H. (2020). JAMPI: A C++ parallel programming interface allowing the implementation of custom and generic scheduling mechanisms. In 32nd Int. Symp. Comput. Archit. High Perform. Comput., pages 273–280.
Downey, A. B. (2008). The Little Book of Semaphores. Green Tea Press, Needham.
Martins et al. (2025). NPB-Rust: NAS Parallel Benchmarks in Rust.
Hernandes et al. (2012). Using gqm and tam to evaluate start – a tool that supports systematic review. CLEI Electronic Journal, 15.
Kasielke et al. (2019). Exploring loop scheduling enhancements in OpenMP: An llvm case study. In 18th Int. Symp. on Parallel and Distributed Computing, pages 131–138.
Lewis et al. (2025). Parallel n-body performance comparison: Julia, Rust, and more. In Paral. and Distribut. Processing Techniques, pages 20–31. Springer Nature.
Matsakis, N. D. and Klock, F. S. (2014). The Rust Language. In Proc. of the 2014 ACM Annual Conf. on High Integrity Language Technology (HILT ’14), pages 103–104.
Matsakis, N. D. and II, F. S. K. (2014). The rust language. ACM SIGAda Ada Letters, 34(3):103–104.
Setiawan, R., Rasjid, Z. E., and Effendi, A. (2018). Design metric indicator to improve quality software development (study case: Student desk portal). Procedia Computer Science, 135:616–623. The 3rd Int. Conf. on Comp. Science and Comput. Intelligence.
Pieper et al. (2021). High-level and efficient structured stream parallelism for rust on multi-cores. Journal of Computer Languages, 65:101054.
Silberschatz, A., Gagne, G., and Galvin, P. B. (2018). Operating System Concepts. Wiley, Hoboken, NJ, USA, 10th edition.
Tanenbaum, A. S. and Bos, H. (2014). Modern Operating Systems. Pearson, Upper Saddle River, NJ, 4 edition.
Tipirneni, D. S. (2022). An empirical study of concurrent feature usage in go. Master’s thesis, East Carolina University.
Tu et al. (2019). Understanding real-world concurrency bugs in go. In Proc. of the 24 Int. Conf. on Architectural Support for Programming Languages and Operating Systems, page 865–878, New York. ACM.
Pankratius, V., Adl-Tabatabai, A.-R., and Garzaran, M. J. (2009). Software engineering for multicore systems: An experience report. IEEE Software, 26(6):20–29.
Whitney, J., Gifford, C., and Pantoja, M. (2019). Distributed execution of communicating sequential process-style concurrency: Golang case study. J. Supercomput., 75(3):1396–1409.
Yakes, A. and Foley, S. S. (2021). A tool for visualizing classic concurrency problems. In Proc. of the 52nd ACM Technical Symposium on Computer Science Education, page 1375, New York. ACM.
Youssef et al. (2021). GQM-based tree model for automatic recommendation of design pattern category. In Proc. of the 9th Int. Conf. on Software and Information Engineering, page 126–130, New York. ACM.
Zhang et al. (2023). Towards understanding the runtime performance of rust. In Proc. of the 37th IEEE/ACM Int. Conf. on Automated Software Engineering. ACM.
Liu et al. (2021). Automatically detecting and fixing concurrency bugs in go software systems. In Proc. of the 26th ACM Int. Conf. on Architectural Support for Programming Languages and Operating Systems, pages 875–888.
Adams, J. C., Koning, E. R., and Hazlett, C. D. (2019). Visualizing classic synchronization problems: Dining philosophers, producers-consumers, and readers-writers. In Proc. of the 50th ACM Technical Symposium on Computer Science Education, page 934–940, New York. ACM.
Chapman, B., Jost, G., and van der Pas, R. (2007). Using OpenMP: Portable Shared Memory Parallel Programming. MIT Press, Cambridge.
Basili, V. R., Caldiera, G., and Rombach, D. H. (1994). The Goal Question Metric Approach, volume I. John Wiley & Sons.
Besozzi, V. (2024). Ppl: Structured parallel programming meets Rust. In 32nd Euromicro Int. Conf. on Parallel, Distributed and Network-Based Processing, pages 78–87.
Qin et al. (2020). Understanding memory and thread safety practices and issues in real-world Rust programs. In Proc. of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI), pages 492–506. ACM.
Hoare, C. A. R. (1981). Communicating sequential processes. In Proc. of the Int. Colloq. on Formalization of Programming Concepts, pages 413–425. Springer.
Capel, M. I., Tomeu, A. J., and Salguero, A. G. (2018). A set of patterns for concurrent and parallel programming teaching. In Euro-Par 2017: Parallel Processing Workshops, pages 203–215, Cham. Springer International Publishing.
Costanzo et al. (2021). Performance vs programming effort between Rust and C on multicore architectures: Case study in n-body. In XLVII Latin American Computing Conference, pages 1–10.
D. Jardim et al. (2021). An extension for transactional memory in OpenMP. In 25th Brazilian Symposium on Prog. Languages, page 58–65, New York. ACM.
Di Domenico, D. (2022). A Model for Software Measurement Aiming to Guide Evaluations and Comparisons between Programming Tools to Implement GPU Applications. PhD thesis, Federal University of Pelotas.
Di Domenico, D. and Cavalheiro, G. G. H. (2020). JAMPI: A C++ parallel programming interface allowing the implementation of custom and generic scheduling mechanisms. In 32nd Int. Symp. Comput. Archit. High Perform. Comput., pages 273–280.
Downey, A. B. (2008). The Little Book of Semaphores. Green Tea Press, Needham.
Martins et al. (2025). NPB-Rust: NAS Parallel Benchmarks in Rust.
Hernandes et al. (2012). Using gqm and tam to evaluate start – a tool that supports systematic review. CLEI Electronic Journal, 15.
Kasielke et al. (2019). Exploring loop scheduling enhancements in OpenMP: An llvm case study. In 18th Int. Symp. on Parallel and Distributed Computing, pages 131–138.
Lewis et al. (2025). Parallel n-body performance comparison: Julia, Rust, and more. In Paral. and Distribut. Processing Techniques, pages 20–31. Springer Nature.
Matsakis, N. D. and Klock, F. S. (2014). The Rust Language. In Proc. of the 2014 ACM Annual Conf. on High Integrity Language Technology (HILT ’14), pages 103–104.
Matsakis, N. D. and II, F. S. K. (2014). The rust language. ACM SIGAda Ada Letters, 34(3):103–104.
Setiawan, R., Rasjid, Z. E., and Effendi, A. (2018). Design metric indicator to improve quality software development (study case: Student desk portal). Procedia Computer Science, 135:616–623. The 3rd Int. Conf. on Comp. Science and Comput. Intelligence.
Pieper et al. (2021). High-level and efficient structured stream parallelism for rust on multi-cores. Journal of Computer Languages, 65:101054.
Silberschatz, A., Gagne, G., and Galvin, P. B. (2018). Operating System Concepts. Wiley, Hoboken, NJ, USA, 10th edition.
Tanenbaum, A. S. and Bos, H. (2014). Modern Operating Systems. Pearson, Upper Saddle River, NJ, 4 edition.
Tipirneni, D. S. (2022). An empirical study of concurrent feature usage in go. Master’s thesis, East Carolina University.
Tu et al. (2019). Understanding real-world concurrency bugs in go. In Proc. of the 24 Int. Conf. on Architectural Support for Programming Languages and Operating Systems, page 865–878, New York. ACM.
Pankratius, V., Adl-Tabatabai, A.-R., and Garzaran, M. J. (2009). Software engineering for multicore systems: An experience report. IEEE Software, 26(6):20–29.
Whitney, J., Gifford, C., and Pantoja, M. (2019). Distributed execution of communicating sequential process-style concurrency: Golang case study. J. Supercomput., 75(3):1396–1409.
Yakes, A. and Foley, S. S. (2021). A tool for visualizing classic concurrency problems. In Proc. of the 52nd ACM Technical Symposium on Computer Science Education, page 1375, New York. ACM.
Youssef et al. (2021). GQM-based tree model for automatic recommendation of design pattern category. In Proc. of the 9th Int. Conf. on Software and Information Engineering, page 126–130, New York. ACM.
Zhang et al. (2023). Towards understanding the runtime performance of rust. In Proc. of the 37th IEEE/ACM Int. Conf. on Automated Software Engineering. ACM.
Liu et al. (2021). Automatically detecting and fixing concurrency bugs in go software systems. In Proc. of the 26th ACM Int. Conf. on Architectural Support for Programming Languages and Operating Systems, pages 875–888.
Publicado
28/10/2025
Como Citar
ARAÚJO, Lucas Braatz; DOMENICO, Daniel Di; BOIS, André Rauber Du; CAVALHEIRO, Gerson Geraldo H..
Revisitando Clássicos da Concorrência: Implementação e Avaliação em OpenMP, Rust e Go. In: SIMPÓSIO EM SISTEMAS COMPUTACIONAIS DE ALTO DESEMPENHO (SSCAD), 26. , 2025, Bonito/MS.
Anais [...].
Porto Alegre: Sociedade Brasileira de Computação,
2025
.
p. 1-12.
DOI: https://doi.org/10.5753/sscad.2025.14353.
