Details
| Originalsprache | Englisch |
|---|---|
| Titel des Sammelwerks | PLOS'19 |
| Untertitel | Proceedings of the 10th Workshop on Programming Languages and Operating Systems |
| Erscheinungsort | New York |
| Seiten | 23-29 |
| Seitenumfang | 7 |
| ISBN (elektronisch) | 9781450370172 |
| Publikationsstatus | Veröffentlicht - 27 Okt. 2019 |
| Veranstaltung | 10th Workshop on Programming Languages and Operating Systems, PLOS 2019: in coIn njunction with the 27th ACM Symposium on Operating Systems Principles, SOSP 2019 - Huntsville, Kanada Dauer: 27 Okt. 2019 → 27 Okt. 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 Sachgebiete
- Informatik (insg.)
- Software
Zitieren
- Standard
- Harvard
- Apa
- Vancouver
- BibTex
- RIS
PLOS'19: Proceedings of the 10th Workshop on Programming Languages and Operating Systems. New York, 2019. S. 23-29.
Publikation: Beitrag in Buch/Bericht/Sammelwerk/Konferenzband › Aufsatz in Konferenzband › Forschung › 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 -