AT
A.J.T.P. Trijbels
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>
1 records found
1
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.