Intra-process Caching and Reuse of Threads

Creating and destroying threads on modern Linux systems incurs high latency, absent concurrency, and fails to scale as we increase concurrency. To address this concern we introduce a process-local cache of idle threads. Specifically, instead of destroying a thread when it terminates, we cache and th...

Full description

Saved in:
Bibliographic Details
Main Authors Dice, Dave, Kogan, Alex
Format Journal Article
LanguageEnglish
Published 16.05.2021
Subjects
Computer Science - Distributed, Parallel, and Cluster Computing
Online AccessGet full text

Cover

Abstract Creating and destroying threads on modern Linux systems incurs high latency, absent concurrency, and fails to scale as we increase concurrency. To address this concern we introduce a process-local cache of idle threads. Specifically, instead of destroying a thread when it terminates, we cache and then recycle that thread in the context of subsequent thread creation requests. This approach shows significant promise in various applications and benchmarks that create and destroy threads rapidly and illustrates the need for and potential benefits of improved concurrency infrastructure. With caching, the cost of creating a new thread drops by almost an order of magnitude. As our experiments demonstrate, this results in significant performance improvements for multiple applications that aggressively create and destroy numerous threads.
AbstractList Creating and destroying threads on modern Linux systems incurs high latency, absent concurrency, and fails to scale as we increase concurrency. To address this concern we introduce a process-local cache of idle threads. Specifically, instead of destroying a thread when it terminates, we cache and then recycle that thread in the context of subsequent thread creation requests. This approach shows significant promise in various applications and benchmarks that create and destroy threads rapidly and illustrates the need for and potential benefits of improved concurrency infrastructure. With caching, the cost of creating a new thread drops by almost an order of magnitude. As our experiments demonstrate, this results in significant performance improvements for multiple applications that aggressively create and destroy numerous threads.
Author Kogan, Alex
Dice, Dave
Author_xml – sequence: 1
  givenname: Dave
  surname: Dice
  fullname: Dice, Dave
– sequence: 2
  givenname: Alex
  surname: Kogan
  fullname: Kogan, Alex
BackLink https://doi.org/10.48550/arXiv.2105.07497$$DView paper in arXiv
BookMark eNotzstKxDAUgOEsdDGOPsCszFpoTXJOLl1K8TIwMCDdl5MmcQqaDomKvr04uvp3P98FO8tLjoxtpGjRaS1uqXzNn62SQrfCYmdX7Gab3ws1x7JMsVbe03SY8wunHPhz_KiRL4kPhxIp1Et2nui1xqv_rtnwcD_0T81u_7jt73YNGWsbTIDOghRRuqgU-C5oZZwxEDxYE5CsRjH5ZNErnFLnAniQsTPCYUoB1uz6b3vCjscyv1H5Hn_R4wkNP1WfPEk
ContentType Journal Article
Copyright http://creativecommons.org/licenses/by-nc-nd/4.0
Copyright_xml – notice: http://creativecommons.org/licenses/by-nc-nd/4.0
DBID AKY
GOX
DOI 10.48550/arxiv.2105.07497
DatabaseName arXiv Computer Science
arXiv.org
DatabaseTitleList
Database_xml – sequence: 1
  dbid: GOX
  name: arXiv.org
  url: http://arxiv.org/find
  sourceTypes: Open Access Repository
DeliveryMethod fulltext_linktorsrc
ExternalDocumentID 2105_07497
GroupedDBID AKY
GOX
ID FETCH-LOGICAL-a677-4f3487310e18e223b9d5268663db376d4a7540cbf74b24cf98d3b31e96084ffd3
IEDL.DBID GOX
IngestDate Mon Jan 08 05:49:22 EST 2024
IsDoiOpenAccess true
IsOpenAccess true
IsPeerReviewed false
IsScholarly false
Language English
LinkModel DirectLink
MergedId FETCHMERGED-LOGICAL-a677-4f3487310e18e223b9d5268663db376d4a7540cbf74b24cf98d3b31e96084ffd3
OpenAccessLink https://arxiv.org/abs/2105.07497
ParticipantIDs arxiv_primary_2105_07497
PublicationCentury 2000
PublicationDate 2021-05-16
PublicationDateYYYYMMDD 2021-05-16
PublicationDate_xml – month: 05
  year: 2021
  text: 2021-05-16
  day: 16
PublicationDecade 2020
PublicationYear 2021
Score 1.8017201
SecondaryResourceType preprint
Snippet Creating and destroying threads on modern Linux systems incurs high latency, absent concurrency, and fails to scale as we increase concurrency. To address this...
SourceID arxiv
SourceType Open Access Repository
SubjectTerms Computer Science - Distributed, Parallel, and Cluster Computing
Title Intra-process Caching and Reuse of Threads
URI https://arxiv.org/abs/2105.07497
hasFullText 1
inHoldings 1
isFullTextHit
isPrint
link http://utb.summon.serialssolutions.com/2.0.0/link/0/eLvHCXMwdV1NS8QwEB129-RFFJX1kxw8CdGmTdP0KIvrKqggFXor-QQvumx3F3--k6SiF6_NXGbC8N5Lpi8Al0YK5W2WYadlmnLDFZWFkLTQSEcRUYWNRtpPz2Lxxh_bsh0B-fkXRq2-3rfJH1j3N6hHymsEuboawzjPw8jW_UubLiejFdcQ_xuHHDN--gMS8z3YHdgduU3bsQ8j93EAVw_hAJUu00g-maXxRYISnry6Te_IpycNllTZ_hCa-V0zW9DhiQKqRFVR7gsk_MiQHJMOgVbXNtinIIpbjZ1ruaqQERntK65zbnwtbaEL5lA2SO69LY5ggirfTYEwpQ0rZW4cBjPmVOkcUh8ssGcGW-8YpjGxbplcKLqQcxdzPvl_6RR28jCEEexGxRlM1quNO0cUXeuLWMpv-8hwFA
link.rule.ids 228,230,786,891
linkProvider Cornell University
openUrl ctx_ver=Z39.88-2004&ctx_enc=info%3Aofi%2Fenc%3AUTF-8&rfr_id=info%3Asid%2Fsummon.serialssolutions.com&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&rft.genre=article&rft.atitle=Intra-process+Caching+and+Reuse+of+Threads&rft.au=Dice%2C+Dave&rft.au=Kogan%2C+Alex&rft.date=2021-05-16&rft_id=info:doi/10.48550%2Farxiv.2105.07497&rft.externalDocID=2105_07497