Details
| Original language | English |
|---|---|
| Title of host publication | PLOS'19 |
| Subtitle of host publication | Proceedings of the 10th Workshop on Programming Languages and Operating Systems |
| Place of Publication | New York |
| Pages | 23-29 |
| Number of pages | 7 |
| ISBN (electronic) | 9781450370172 |
| Publication status | Published - 27 Oct 2019 |
| Event | 10th Workshop on Programming Languages and Operating Systems, PLOS 2019, held in conjunction with the 27th ACM Symposium on Operating Systems Principles, SOSP 2019: in coIn njunction with the 27th ACM Symposium on Operating Systems Principles, SOSP 2019 - Huntsville, Canada Duration: 27 Oct 2019 → 27 Oct 2019 |
Abstract
In the operation and maintenance phase of a deployed software component, security and bug-fix updates are regular events. However, for many high-availability services, costly restarts are no acceptable option as the induced downtimes lead to a degradation of the service quality. One solution to this problem are live updates, where we inject the desired software patches directly into the volatile memory of a currently running process. However, before the actual patch gets applied, most live-update methods use a stop-the-world approach to bring the process into a safe state; an operation that is highly disruptive for the execution of multi-threaded programs. In this paper, we present a wait-free approach to inject code changes into a running multi-threaded process. We avoid the disruption of a global barrier synchronization over all threads by first preparing a patched clone of the process’s address space. Into the updated address space, we gradually migrate individual threads at predefined quiescence points while all other threads make uninterrupted progress. In a first case study with a simple network service, we could completely eliminate the impact of applying a live update on the request latency.
ASJC Scopus subject areas
- Computer Science(all)
- Software
Cite this
- Standard
- Harvard
- Apa
- Vancouver
- BibTeX
- RIS
PLOS'19: Proceedings of the 10th Workshop on Programming Languages and Operating Systems. New York, 2019. p. 23-29.
Research output: Chapter in book/report/conference proceeding › Conference contribution › Research › peer review
}
TY - GEN
T1 - Wait-Free Code Patching of Multi-Threaded Processes
AU - Rommel, Florian
AU - Glauer, Lennart
AU - Dietrich, Christian
AU - Lohmann, Daniel
N1 - Funding information: This work has been supported by the German Research Foundation (DFG) under the grants no. LO 1719/3-1 and LO 1719/4-1. We thank the anonymous reviewers for their detailed and helpful feedback.
PY - 2019/10/27
Y1 - 2019/10/27
N2 - In the operation and maintenance phase of a deployed software component, security and bug-fix updates are regular events. However, for many high-availability services, costly restarts are no acceptable option as the induced downtimes lead to a degradation of the service quality. One solution to this problem are live updates, where we inject the desired software patches directly into the volatile memory of a currently running process. However, before the actual patch gets applied, most live-update methods use a stop-the-world approach to bring the process into a safe state; an operation that is highly disruptive for the execution of multi-threaded programs. In this paper, we present a wait-free approach to inject code changes into a running multi-threaded process. We avoid the disruption of a global barrier synchronization over all threads by first preparing a patched clone of the process’s address space. Into the updated address space, we gradually migrate individual threads at predefined quiescence points while all other threads make uninterrupted progress. In a first case study with a simple network service, we could completely eliminate the impact of applying a live update on the request latency.
AB - In the operation and maintenance phase of a deployed software component, security and bug-fix updates are regular events. However, for many high-availability services, costly restarts are no acceptable option as the induced downtimes lead to a degradation of the service quality. One solution to this problem are live updates, where we inject the desired software patches directly into the volatile memory of a currently running process. However, before the actual patch gets applied, most live-update methods use a stop-the-world approach to bring the process into a safe state; an operation that is highly disruptive for the execution of multi-threaded programs. In this paper, we present a wait-free approach to inject code changes into a running multi-threaded process. We avoid the disruption of a global barrier synchronization over all threads by first preparing a patched clone of the process’s address space. Into the updated address space, we gradually migrate individual threads at predefined quiescence points while all other threads make uninterrupted progress. In a first case study with a simple network service, we could completely eliminate the impact of applying a live update on the request latency.
UR - http://www.scopus.com/inward/record.url?scp=85075729353&partnerID=8YFLogxK
U2 - 10.1145/3365137.3365404
DO - 10.1145/3365137.3365404
M3 - Conference contribution
AN - SCOPUS:85075729353
SP - 23
EP - 29
BT - PLOS'19
CY - New York
T2 - 10th Workshop on Programming Languages and Operating Systems, PLOS 2019, held in conjunction with the 27th ACM Symposium on Operating Systems Principles, SOSP 2019
Y2 - 27 October 2019 through 27 October 2019
ER -