The Cost of Garbage Collection for State Machine Replication

State Machine Replication (SMR) protocols form the backbone of many distributed systems. Enterprises and startups increasingly build their distributed systems on the cloud due to its many advantages, such as scalability and cost-effectiveness. One of the first technical questions companies face when...

Ausführliche Beschreibung

Gespeichert in:
Bibliographische Detailangaben
Hauptverfasser: Liang, Zhiying, Jabrayilov, Vahab, Charapko, Aleksey, Aghayev, Abutalib
Format: Artikel
Sprache:eng
Schlagworte:
Online-Zugang:Volltext bestellen
Tags: Tag hinzufügen
Keine Tags, Fügen Sie den ersten Tag hinzu!
container_end_page
container_issue
container_start_page
container_title
container_volume
creator Liang, Zhiying
Jabrayilov, Vahab
Charapko, Aleksey
Aghayev, Abutalib
description State Machine Replication (SMR) protocols form the backbone of many distributed systems. Enterprises and startups increasingly build their distributed systems on the cloud due to its many advantages, such as scalability and cost-effectiveness. One of the first technical questions companies face when building a system on the cloud is which programming language to use. Among many factors that go into this decision is whether to use a language with garbage collection (GC), such as Java or Go, or a language with manual memory management, such as C++ or Rust. Today, companies predominantly prefer languages with GC, like Go, Kotlin, or even Python, due to ease of development; however, there is no free lunch: GC costs resources (memory and CPU) and performance (long tail latencies due to GC pauses). While there have been anecdotal reports of reduced cloud cost and improved tail latencies when switching from a language with GC to a language with manual memory management, so far, there has not been a systematic study of the GC overhead of running an SMR-based cloud system. This paper studies the overhead of running an SMR-based cloud system written in a language with GC. To this end, we design from scratch a canonical SMR system -- a MultiPaxos-based replicated in-memory key-value store -- and we implement it in C++, Java, Rust, and Go. We compare the performance and resource usage of these implementations when running on the cloud under different workloads and resource constraints and report our results. Our findings have implications for the design of cloud systems.
doi_str_mv 10.48550/arxiv.2405.11182
format Article
fullrecord <record><control><sourceid>arxiv_GOX</sourceid><recordid>TN_cdi_arxiv_primary_2405_11182</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><sourcerecordid>2405_11182</sourcerecordid><originalsourceid>FETCH-LOGICAL-a672-4a44d1c49f48672885f11b2f480c86e6e16e69d5e03e0df1aaa8b0cdfaa8bd503</originalsourceid><addsrcrecordid>eNotj0-LwjAUxHPxILofwJP5Aq15bVIjeJHiP1AE7b28Ji8aqFZikd1vv627lxl-DAwzjE1AxFIrJWYYvv07TqRQMQDoZMiWxY143rxa3ji-xVDhtee6JtP65sFdE_ilxZb4Ec3NP4if6Vl7g306ZgOH9Yu-_n3Eis26yHfR4bTd56tDhNk8iSRKacHIhZO6Y62VA6iSjoTRGWUEnSysIpGSsA4QUVfCWNe7VSIdself7Wd--Qz-juGn7G-UnxvpL0H1Qfw</addsrcrecordid><sourcetype>Open Access Repository</sourcetype><iscdi>true</iscdi><recordtype>article</recordtype></control><display><type>article</type><title>The Cost of Garbage Collection for State Machine Replication</title><source>arXiv.org</source><creator>Liang, Zhiying ; Jabrayilov, Vahab ; Charapko, Aleksey ; Aghayev, Abutalib</creator><creatorcontrib>Liang, Zhiying ; Jabrayilov, Vahab ; Charapko, Aleksey ; Aghayev, Abutalib</creatorcontrib><description>State Machine Replication (SMR) protocols form the backbone of many distributed systems. Enterprises and startups increasingly build their distributed systems on the cloud due to its many advantages, such as scalability and cost-effectiveness. One of the first technical questions companies face when building a system on the cloud is which programming language to use. Among many factors that go into this decision is whether to use a language with garbage collection (GC), such as Java or Go, or a language with manual memory management, such as C++ or Rust. Today, companies predominantly prefer languages with GC, like Go, Kotlin, or even Python, due to ease of development; however, there is no free lunch: GC costs resources (memory and CPU) and performance (long tail latencies due to GC pauses). While there have been anecdotal reports of reduced cloud cost and improved tail latencies when switching from a language with GC to a language with manual memory management, so far, there has not been a systematic study of the GC overhead of running an SMR-based cloud system. This paper studies the overhead of running an SMR-based cloud system written in a language with GC. To this end, we design from scratch a canonical SMR system -- a MultiPaxos-based replicated in-memory key-value store -- and we implement it in C++, Java, Rust, and Go. We compare the performance and resource usage of these implementations when running on the cloud under different workloads and resource constraints and report our results. Our findings have implications for the design of cloud systems.</description><identifier>DOI: 10.48550/arxiv.2405.11182</identifier><language>eng</language><subject>Computer Science - Distributed, Parallel, and Cluster Computing</subject><creationdate>2024-05</creationdate><rights>http://arxiv.org/licenses/nonexclusive-distrib/1.0</rights><oa>free_for_read</oa><woscitedreferencessubscribed>false</woscitedreferencessubscribed></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Tsyndetics_thumb_exl</thumbnail><link.rule.ids>228,230,781,886</link.rule.ids><linktorsrc>$$Uhttps://arxiv.org/abs/2405.11182$$EView_record_in_Cornell_University$$FView_record_in_$$GCornell_University$$Hfree_for_read</linktorsrc><backlink>$$Uhttps://doi.org/10.48550/arXiv.2405.11182$$DView paper in arXiv$$Hfree_for_read</backlink></links><search><creatorcontrib>Liang, Zhiying</creatorcontrib><creatorcontrib>Jabrayilov, Vahab</creatorcontrib><creatorcontrib>Charapko, Aleksey</creatorcontrib><creatorcontrib>Aghayev, Abutalib</creatorcontrib><title>The Cost of Garbage Collection for State Machine Replication</title><description>State Machine Replication (SMR) protocols form the backbone of many distributed systems. Enterprises and startups increasingly build their distributed systems on the cloud due to its many advantages, such as scalability and cost-effectiveness. One of the first technical questions companies face when building a system on the cloud is which programming language to use. Among many factors that go into this decision is whether to use a language with garbage collection (GC), such as Java or Go, or a language with manual memory management, such as C++ or Rust. Today, companies predominantly prefer languages with GC, like Go, Kotlin, or even Python, due to ease of development; however, there is no free lunch: GC costs resources (memory and CPU) and performance (long tail latencies due to GC pauses). While there have been anecdotal reports of reduced cloud cost and improved tail latencies when switching from a language with GC to a language with manual memory management, so far, there has not been a systematic study of the GC overhead of running an SMR-based cloud system. This paper studies the overhead of running an SMR-based cloud system written in a language with GC. To this end, we design from scratch a canonical SMR system -- a MultiPaxos-based replicated in-memory key-value store -- and we implement it in C++, Java, Rust, and Go. We compare the performance and resource usage of these implementations when running on the cloud under different workloads and resource constraints and report our results. Our findings have implications for the design of cloud systems.</description><subject>Computer Science - Distributed, Parallel, and Cluster Computing</subject><fulltext>true</fulltext><rsrctype>article</rsrctype><creationdate>2024</creationdate><recordtype>article</recordtype><sourceid>GOX</sourceid><recordid>eNotj0-LwjAUxHPxILofwJP5Aq15bVIjeJHiP1AE7b28Ji8aqFZikd1vv627lxl-DAwzjE1AxFIrJWYYvv07TqRQMQDoZMiWxY143rxa3ji-xVDhtee6JtP65sFdE_ilxZb4Ec3NP4if6Vl7g306ZgOH9Yu-_n3Eis26yHfR4bTd56tDhNk8iSRKacHIhZO6Y62VA6iSjoTRGWUEnSysIpGSsA4QUVfCWNe7VSIdself7Wd--Qz-juGn7G-UnxvpL0H1Qfw</recordid><startdate>20240518</startdate><enddate>20240518</enddate><creator>Liang, Zhiying</creator><creator>Jabrayilov, Vahab</creator><creator>Charapko, Aleksey</creator><creator>Aghayev, Abutalib</creator><scope>AKY</scope><scope>GOX</scope></search><sort><creationdate>20240518</creationdate><title>The Cost of Garbage Collection for State Machine Replication</title><author>Liang, Zhiying ; Jabrayilov, Vahab ; Charapko, Aleksey ; Aghayev, Abutalib</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-a672-4a44d1c49f48672885f11b2f480c86e6e16e69d5e03e0df1aaa8b0cdfaa8bd503</frbrgroupid><rsrctype>articles</rsrctype><prefilter>articles</prefilter><language>eng</language><creationdate>2024</creationdate><topic>Computer Science - Distributed, Parallel, and Cluster Computing</topic><toplevel>online_resources</toplevel><creatorcontrib>Liang, Zhiying</creatorcontrib><creatorcontrib>Jabrayilov, Vahab</creatorcontrib><creatorcontrib>Charapko, Aleksey</creatorcontrib><creatorcontrib>Aghayev, Abutalib</creatorcontrib><collection>arXiv Computer Science</collection><collection>arXiv.org</collection></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext_linktorsrc</fulltext></delivery><addata><au>Liang, Zhiying</au><au>Jabrayilov, Vahab</au><au>Charapko, Aleksey</au><au>Aghayev, Abutalib</au><format>journal</format><genre>article</genre><ristype>JOUR</ristype><atitle>The Cost of Garbage Collection for State Machine Replication</atitle><date>2024-05-18</date><risdate>2024</risdate><abstract>State Machine Replication (SMR) protocols form the backbone of many distributed systems. Enterprises and startups increasingly build their distributed systems on the cloud due to its many advantages, such as scalability and cost-effectiveness. One of the first technical questions companies face when building a system on the cloud is which programming language to use. Among many factors that go into this decision is whether to use a language with garbage collection (GC), such as Java or Go, or a language with manual memory management, such as C++ or Rust. Today, companies predominantly prefer languages with GC, like Go, Kotlin, or even Python, due to ease of development; however, there is no free lunch: GC costs resources (memory and CPU) and performance (long tail latencies due to GC pauses). While there have been anecdotal reports of reduced cloud cost and improved tail latencies when switching from a language with GC to a language with manual memory management, so far, there has not been a systematic study of the GC overhead of running an SMR-based cloud system. This paper studies the overhead of running an SMR-based cloud system written in a language with GC. To this end, we design from scratch a canonical SMR system -- a MultiPaxos-based replicated in-memory key-value store -- and we implement it in C++, Java, Rust, and Go. We compare the performance and resource usage of these implementations when running on the cloud under different workloads and resource constraints and report our results. Our findings have implications for the design of cloud systems.</abstract><doi>10.48550/arxiv.2405.11182</doi><oa>free_for_read</oa></addata></record>
fulltext fulltext_linktorsrc
identifier DOI: 10.48550/arxiv.2405.11182
ispartof
issn
language eng
recordid cdi_arxiv_primary_2405_11182
source arXiv.org
subjects Computer Science - Distributed, Parallel, and Cluster Computing
title The Cost of Garbage Collection for State Machine Replication
url https://sfx.bib-bvb.de/sfx_tum?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2024-12-15T10%3A17%3A55IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-arxiv_GOX&rft_val_fmt=info:ofi/fmt:kev:mtx:journal&rft.genre=article&rft.atitle=The%20Cost%20of%20Garbage%20Collection%20for%20State%20Machine%20Replication&rft.au=Liang,%20Zhiying&rft.date=2024-05-18&rft_id=info:doi/10.48550/arxiv.2405.11182&rft_dat=%3Carxiv_GOX%3E2405_11182%3C/arxiv_GOX%3E%3Curl%3E%3C/url%3E&disable_directlink=true&sfx.directlink=off&sfx.report_link=0&rft_id=info:oai/&rft_id=info:pmid/&rfr_iscdi=true