Wait-Free Code Patching of Multi-Threaded Processes

Research output: Chapter in book/report/conference proceedingConference contributionResearchpeer review

Authors

  • Florian Rommel
  • Lennart Glauer
  • Christian Dietrich
  • Daniel Lohmann
View graph of relations

Details

Original languageEnglish
Title of host publicationPLOS'19
Subtitle of host publicationProceedings of the 10th Workshop on Programming Languages and Operating Systems
Place of PublicationNew York
Pages23-29
Number of pages7
ISBN (electronic)9781450370172
Publication statusPublished - 27 Oct 2019
Event10th 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 201927 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

Cite this

Wait-Free Code Patching of Multi-Threaded Processes. / Rommel, Florian; Glauer, Lennart; Dietrich, Christian et al.
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 proceedingConference contributionResearchpeer review

Rommel, F, Glauer, L, Dietrich, C & Lohmann, D 2019, Wait-Free Code Patching of Multi-Threaded Processes. in PLOS'19: Proceedings of the 10th Workshop on Programming Languages and Operating Systems. New York, pp. 23-29, 10th Workshop on Programming Languages and Operating Systems, PLOS 2019, held in conjunction with the 27th ACM Symposium on Operating Systems Principles, SOSP 2019, Huntsville, Ontario, Canada, 27 Oct 2019. https://doi.org/10.1145/3365137.3365404
Rommel, F., Glauer, L., Dietrich, C., & Lohmann, D. (2019). Wait-Free Code Patching of Multi-Threaded Processes. In PLOS'19: Proceedings of the 10th Workshop on Programming Languages and Operating Systems (pp. 23-29). https://doi.org/10.1145/3365137.3365404
Rommel F, Glauer L, Dietrich C, Lohmann D. Wait-Free Code Patching of Multi-Threaded Processes. In PLOS'19: Proceedings of the 10th Workshop on Programming Languages and Operating Systems. New York. 2019. p. 23-29 doi: 10.1145/3365137.3365404
Rommel, Florian ; Glauer, Lennart ; Dietrich, Christian et al. / Wait-Free Code Patching of Multi-Threaded Processes. PLOS'19: Proceedings of the 10th Workshop on Programming Languages and Operating Systems. New York, 2019. pp. 23-29
Download
@inproceedings{93e4feb66a6e4dc7850269eb44fc5d8f,
title = "Wait-Free Code Patching of Multi-Threaded Processes",
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{\textquoteright}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.",
author = "Florian Rommel and Lennart Glauer and Christian Dietrich and Daniel Lohmann",
note = "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.; 10th Workshop on Programming Languages and Operating Systems, PLOS 2019, held in conjunction with the 27th ACM Symposium on Operating Systems Principles, SOSP 2019 ; Conference date: 27-10-2019 Through 27-10-2019",
year = "2019",
month = oct,
day = "27",
doi = "10.1145/3365137.3365404",
language = "English",
pages = "23--29",
booktitle = "PLOS'19",

}

Download

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 -