RB
R.W. Backx
info
Please Note
<p>This page displays the records of the person named above and is not linked to a unique person identifier. This record may need to be merged to a profile.</p>
5 records found
1
Message Passing in Rust Applications
An exploratory analysis of channel primitives, architectural patterns, and communication roles
Rust promotes message-passing concurrency through channels, yet little is known about how message passing is used in real-world Rust applications. This study investigates message-passing usage in open-source Rust applications through a combination of repository classification and template-guided manual analysis.
Repositories were selected from the Awesome Rust applications collection and classified according to four communication categories. The resulting repositories were then analysed using an automated channel-count analysis to identify message-passing primitives, followed by template-guided manual analysis to identify communication structures and message-passing roles.
The results show that Rust applications employ a diverse range of message-passing primitives and communication patterns. Message passing is commonly organised around dedicated receiving components and is primarily used for data transport, event propagation, and coordination between concurrent tasks. Rather than relying on a single communication pattern, applications frequently combine multiple communication structures and roles within the same codebase.
This work provides an exploratory empirical analysis of message passing in Rust applications and introduces a structured methodology for analysing message-passing usage in software systems. ...
Repositories were selected from the Awesome Rust applications collection and classified according to four communication categories. The resulting repositories were then analysed using an automated channel-count analysis to identify message-passing primitives, followed by template-guided manual analysis to identify communication structures and message-passing roles.
The results show that Rust applications employ a diverse range of message-passing primitives and communication patterns. Message passing is commonly organised around dedicated receiving components and is primarily used for data transport, event propagation, and coordination between concurrent tasks. Rather than relying on a single communication pattern, applications frequently combine multiple communication structures and roles within the same codebase.
This work provides an exploratory empirical analysis of message passing in Rust applications and introduces a structured methodology for analysing message-passing usage in software systems. ...
Rust promotes message-passing concurrency through channels, yet little is known about how message passing is used in real-world Rust applications. This study investigates message-passing usage in open-source Rust applications through a combination of repository classification and template-guided manual analysis.
Repositories were selected from the Awesome Rust applications collection and classified according to four communication categories. The resulting repositories were then analysed using an automated channel-count analysis to identify message-passing primitives, followed by template-guided manual analysis to identify communication structures and message-passing roles.
The results show that Rust applications employ a diverse range of message-passing primitives and communication patterns. Message passing is commonly organised around dedicated receiving components and is primarily used for data transport, event propagation, and coordination between concurrent tasks. Rather than relying on a single communication pattern, applications frequently combine multiple communication structures and roles within the same codebase.
This work provides an exploratory empirical analysis of message passing in Rust applications and introduces a structured methodology for analysing message-passing usage in software systems.
Repositories were selected from the Awesome Rust applications collection and classified according to four communication categories. The resulting repositories were then analysed using an automated channel-count analysis to identify message-passing primitives, followed by template-guided manual analysis to identify communication structures and message-passing roles.
The results show that Rust applications employ a diverse range of message-passing primitives and communication patterns. Message passing is commonly organised around dedicated receiving components and is primarily used for data transport, event propagation, and coordination between concurrent tasks. Rather than relying on a single communication pattern, applications frequently combine multiple communication structures and roles within the same codebase.
This work provides an exploratory empirical analysis of message passing in Rust applications and introduces a structured methodology for analysing message-passing usage in software systems.
Rust provides performance, memory safety, and the promise of “fearless concurrency,” owing to its robust ownership system. Rayon has become a widespread library for data parallelism within Rust, enabling programmers to incorporate concurrency into their programs seamlessly.
This work presents the most common Rayon usages across the top 1000 open-source Rust repositories on Github, measured by stargazer count and filtered for usage of Rayon. We perform a manual analysis on 5 repositories, identifying themes within selected instances.
We contextualise these themes to characterize how Rayon is used for complex workloads, where unsafe code is combined with Rayon, and where parallel iterators are insufficient. ...
This work presents the most common Rayon usages across the top 1000 open-source Rust repositories on Github, measured by stargazer count and filtered for usage of Rayon. We perform a manual analysis on 5 repositories, identifying themes within selected instances.
We contextualise these themes to characterize how Rayon is used for complex workloads, where unsafe code is combined with Rayon, and where parallel iterators are insufficient. ...
Rust provides performance, memory safety, and the promise of “fearless concurrency,” owing to its robust ownership system. Rayon has become a widespread library for data parallelism within Rust, enabling programmers to incorporate concurrency into their programs seamlessly.
This work presents the most common Rayon usages across the top 1000 open-source Rust repositories on Github, measured by stargazer count and filtered for usage of Rayon. We perform a manual analysis on 5 repositories, identifying themes within selected instances.
We contextualise these themes to characterize how Rayon is used for complex workloads, where unsafe code is combined with Rayon, and where parallel iterators are insufficient.
This work presents the most common Rayon usages across the top 1000 open-source Rust repositories on Github, measured by stargazer count and filtered for usage of Rayon. We perform a manual analysis on 5 repositories, identifying themes within selected instances.
We contextualise these themes to characterize how Rayon is used for complex workloads, where unsafe code is combined with Rayon, and where parallel iterators are insufficient.
Asynchronous Programming in Rust
An Empirical Analysis on the Usage of Asynchronous Code by Rust Developers
Asynchronous programming in Rust introduces challenges regarding correctness, synchronization and concurrency. Existing literature has focused on uncovering bugs and providing verification techniques to mitigate these. However, further research within this field is still required and to the best of our knowledge, limited empirical data exists analyzing why asynchronous Rust is used in practice and the prominence of different runtimes.
In this paper, we present Rustc-Analysis, an automated analysis tool for discovering and extracting underlying structural information of asynchronous Rust code. We subsequently use this tool to analyze runtime adoption and characterize the functionality provided by asynchronous APIs.
Our analysis shows that asynchronous APIs are mainly used for I/O-related tasks, particularly networking and file-system operations, as well as synchronization between concurrent tasks. Furthermore, we find tokio to be the most widely adopted runtime, followed by futures, async-std and smol. ...
In this paper, we present Rustc-Analysis, an automated analysis tool for discovering and extracting underlying structural information of asynchronous Rust code. We subsequently use this tool to analyze runtime adoption and characterize the functionality provided by asynchronous APIs.
Our analysis shows that asynchronous APIs are mainly used for I/O-related tasks, particularly networking and file-system operations, as well as synchronization between concurrent tasks. Furthermore, we find tokio to be the most widely adopted runtime, followed by futures, async-std and smol. ...
Asynchronous programming in Rust introduces challenges regarding correctness, synchronization and concurrency. Existing literature has focused on uncovering bugs and providing verification techniques to mitigate these. However, further research within this field is still required and to the best of our knowledge, limited empirical data exists analyzing why asynchronous Rust is used in practice and the prominence of different runtimes.
In this paper, we present Rustc-Analysis, an automated analysis tool for discovering and extracting underlying structural information of asynchronous Rust code. We subsequently use this tool to analyze runtime adoption and characterize the functionality provided by asynchronous APIs.
Our analysis shows that asynchronous APIs are mainly used for I/O-related tasks, particularly networking and file-system operations, as well as synchronization between concurrent tasks. Furthermore, we find tokio to be the most widely adopted runtime, followed by futures, async-std and smol.
In this paper, we present Rustc-Analysis, an automated analysis tool for discovering and extracting underlying structural information of asynchronous Rust code. We subsequently use this tool to analyze runtime adoption and characterize the functionality provided by asynchronous APIs.
Our analysis shows that asynchronous APIs are mainly used for I/O-related tasks, particularly networking and file-system operations, as well as synchronization between concurrent tasks. Furthermore, we find tokio to be the most widely adopted runtime, followed by futures, async-std and smol.
Understanding Shared-Memory Concurrency Usage in Rust Systems
A Qualitative Study of Concurrency Primitives, Thread Organisation Models, Workloads, and Functional Roles
Rust provides strong guarantees for memory safety and concurrency correctness, but relatively little is known about how shared-memory concurrency is used in real-world Rust systems. While existing research has largely focused on Rust’s safety guarantees and performance, fewer studies have examined how developers use shared-memory concurrency mechanisms in practice. This work investigates how shared-memory concurrency is used in Rust systems that make extensive use of concurrency. A qualitative thematic analysis was conducted on concurrency-related files from a selection of open-source Rust repositories. The analysis examined the use of shared-memory concurrency primitives, thread organisation models, workload types, functional roles, and implementation trade-offs.
The results show that a small set of primitives, namely Arc, Mutex, and RwLock, accounts for most observed concurrency usage, while specialised primitives appear comparatively rarely. Shared-state concurrency appeared to be the dominant thread organisation model, although actor/message-passing approaches were also commonly used. Across the analysed files, concurrency-related code was primarily used for coordination-heavy responsibilities such as runtime management, resource coordination, event dispatch, request handling, and state management rather than computational work. The findings further show that higher-level architectural patterns frequently rely on shared-memory mechanisms, even when message passing forms the primary organisational model. Several trade-offs were identified between simplicity, scalability, modularity, and coordination complexity. Overall, the study suggests that shared ownership in Rust is used primarily to coordinate access to shared state and resources, and that shared ownership and synchronised access remain foundational despite the availability of other concurrency abstractions. The findings provide insights into how shared-memory concurrency is applied in native Rust systems and provide a foundation for future research on concurrency design practices in Rust software. ...
The results show that a small set of primitives, namely Arc, Mutex, and RwLock, accounts for most observed concurrency usage, while specialised primitives appear comparatively rarely. Shared-state concurrency appeared to be the dominant thread organisation model, although actor/message-passing approaches were also commonly used. Across the analysed files, concurrency-related code was primarily used for coordination-heavy responsibilities such as runtime management, resource coordination, event dispatch, request handling, and state management rather than computational work. The findings further show that higher-level architectural patterns frequently rely on shared-memory mechanisms, even when message passing forms the primary organisational model. Several trade-offs were identified between simplicity, scalability, modularity, and coordination complexity. Overall, the study suggests that shared ownership in Rust is used primarily to coordinate access to shared state and resources, and that shared ownership and synchronised access remain foundational despite the availability of other concurrency abstractions. The findings provide insights into how shared-memory concurrency is applied in native Rust systems and provide a foundation for future research on concurrency design practices in Rust software. ...
Rust provides strong guarantees for memory safety and concurrency correctness, but relatively little is known about how shared-memory concurrency is used in real-world Rust systems. While existing research has largely focused on Rust’s safety guarantees and performance, fewer studies have examined how developers use shared-memory concurrency mechanisms in practice. This work investigates how shared-memory concurrency is used in Rust systems that make extensive use of concurrency. A qualitative thematic analysis was conducted on concurrency-related files from a selection of open-source Rust repositories. The analysis examined the use of shared-memory concurrency primitives, thread organisation models, workload types, functional roles, and implementation trade-offs.
The results show that a small set of primitives, namely Arc, Mutex, and RwLock, accounts for most observed concurrency usage, while specialised primitives appear comparatively rarely. Shared-state concurrency appeared to be the dominant thread organisation model, although actor/message-passing approaches were also commonly used. Across the analysed files, concurrency-related code was primarily used for coordination-heavy responsibilities such as runtime management, resource coordination, event dispatch, request handling, and state management rather than computational work. The findings further show that higher-level architectural patterns frequently rely on shared-memory mechanisms, even when message passing forms the primary organisational model. Several trade-offs were identified between simplicity, scalability, modularity, and coordination complexity. Overall, the study suggests that shared ownership in Rust is used primarily to coordinate access to shared state and resources, and that shared ownership and synchronised access remain foundational despite the availability of other concurrency abstractions. The findings provide insights into how shared-memory concurrency is applied in native Rust systems and provide a foundation for future research on concurrency design practices in Rust software.
The results show that a small set of primitives, namely Arc, Mutex, and RwLock, accounts for most observed concurrency usage, while specialised primitives appear comparatively rarely. Shared-state concurrency appeared to be the dominant thread organisation model, although actor/message-passing approaches were also commonly used. Across the analysed files, concurrency-related code was primarily used for coordination-heavy responsibilities such as runtime management, resource coordination, event dispatch, request handling, and state management rather than computational work. The findings further show that higher-level architectural patterns frequently rely on shared-memory mechanisms, even when message passing forms the primary organisational model. Several trade-offs were identified between simplicity, scalability, modularity, and coordination complexity. Overall, the study suggests that shared ownership in Rust is used primarily to coordinate access to shared state and resources, and that shared ownership and synchronised access remain foundational despite the availability of other concurrency abstractions. The findings provide insights into how shared-memory concurrency is applied in native Rust systems and provide a foundation for future research on concurrency design practices in Rust software.
Concurrency and Async Practices in Real-World Rust
How are lock-free and atomic-based concurrency techniques used in Rust crates?
Rust provides strong safety guarantees and supports several forms of concurrency, including atomic-based techniques. In this paper, we study how such techniques are used in crates that provide and use atomic-based functionality. We observed that these techniques mainly support communication between threads, shared access to data, and coordination of work. We also observed that they appear at different abstraction levels, from low-level memory management to higher-level data structures. These results help explain how atomic-based concurrency is used in real-world Rust code.
...
Rust provides strong safety guarantees and supports several forms of concurrency, including atomic-based techniques. In this paper, we study how such techniques are used in crates that provide and use atomic-based functionality. We observed that these techniques mainly support communication between threads, shared access to data, and coordination of work. We also observed that they appear at different abstraction levels, from low-level memory management to higher-level data structures. These results help explain how atomic-based concurrency is used in real-world Rust code.