Optimal heap limits for reducing browser memory use
Garbage-collected language runtimes carefully tune heap limits to reduce garbage collection time and memory usage. However, there's a trade-off: a lower heap limit reduces memory use but increases garbage collection time. Classic methods for setting heap limits include manually tuned heap limit...
Uloženo v:
| Vydáno v: | Proceedings of ACM on programming languages Ročník 6; číslo OOPSLA2; s. 986 - 1006 |
|---|---|
| Hlavní autoři: | , , |
| Médium: | Journal Article |
| Jazyk: | angličtina |
| Vydáno: |
New York, NY, USA
ACM
31.10.2022
|
| Témata: | |
| ISSN: | 2475-1421, 2475-1421 |
| On-line přístup: | Získat plný text |
| Tagy: |
Přidat tag
Žádné tagy, Buďte první, kdo vytvoří štítek k tomuto záznamu!
|
| Abstract | Garbage-collected language runtimes carefully tune heap limits to reduce garbage collection time and memory usage. However, there's a trade-off: a lower heap limit reduces memory use but increases garbage collection time. Classic methods for setting heap limits include manually tuned heap limits and multiple-of-live-size rules of thumb, but it is not clear when one rule is better than another or how to compare them. We address this problem with a new framework where heap limits are set for multiple heaps at once. Our key insight is that every heap limit rule induces a particular allocation of memory across multiple processes, and this allocation can be sub-optimal. We use our framework to derive an optimal "square-root" heap limit rule, which minimizes total memory usage for any amount of total garbage collection time. Paradoxically, the square-root heap limit rule achieves this coordination without communication: it allocates memory optimally across multiple heaps without requiring any communication between those heaps. To demonstrate that this heap limit rule is effective, we prototype it for V8, the JavaScript runtime used in Google Chrome, Microsoft Edge, and other browsers, as well as in server-side frameworks like node.js and Deno. On real-world web pages, our prototype achieves reductions of approximately 16.0% of memory usage while keeping garbage collection time constant. On memory-intensive benchmarks, reductions of up to 30.0% of garbage collection time are possible with no change in total memory usage. |
|---|---|
| AbstractList | Garbage-collected language runtimes carefully tune heap limits to reduce garbage collection time and memory usage. However, there's a trade-off: a lower heap limit reduces memory use but increases garbage collection time. Classic methods for setting heap limits include manually tuned heap limits and multiple-of-live-size rules of thumb, but it is not clear when one rule is better than another or how to compare them. We address this problem with a new framework where heap limits are set for multiple heaps at once. Our key insight is that every heap limit rule induces a particular allocation of memory across multiple processes, and this allocation can be sub-optimal. We use our framework to derive an optimal "square-root" heap limit rule, which minimizes total memory usage for any amount of total garbage collection time. Paradoxically, the square-root heap limit rule achieves this coordination without communication: it allocates memory optimally across multiple heaps without requiring any communication between those heaps. To demonstrate that this heap limit rule is effective, we prototype it for V8, the JavaScript runtime used in Google Chrome, Microsoft Edge, and other browsers, as well as in server-side frameworks like node.js and Deno. On real-world web pages, our prototype achieves reductions of approximately 16.0% of memory usage while keeping garbage collection time constant. On memory-intensive benchmarks, reductions of up to 30.0% of garbage collection time are possible with no change in total memory usage. Garbage-collected language runtimes carefully tune heap limits to reduce garbage collection time and memory usage. However, there's a trade-off: a lower heap limit reduces memory use but increases garbage collection time. Classic methods for setting heap limits include manually tuned heap limits and multiple-of-live-size rules of thumb, but it is not clear when one rule is better than another or how to compare them. We address this problem with a new framework where heap limits are set for multiple heaps at once. Our key insight is that every heap limit rule induces a particular allocation of memory across multiple processes, and this allocation can be sub-optimal. We use our framework to derive an optimal "square-root" heap limit rule, which minimizes total memory usage for any amount of total garbage collection time. Paradoxically, the square-root heap limit rule achieves this coordination without communication: it allocates memory optimally across multiple heaps without requiring any communication between those heaps. To demonstrate that this heap limit rule is effective, we prototype it for V8, the JavaScript runtime used in Google Chrome, Microsoft Edge, and other browsers, as well as in server-side frameworks like node.js and Deno. On real-world web pages, our prototype achieves reductions of approximately 16.0% of memory usage while keeping garbage collection time constant. On memory-intensive benchmarks, reductions of up to 30.0% of garbage collection time are possible with no change in total memory usage. |
| ArticleNumber | 160 |
| Author | Shenoy, Pranav Panchekha, Pavel Kirisame, Marisa |
| Author_xml | – sequence: 1 givenname: Marisa orcidid: 0000-0002-3418-4835 surname: Kirisame fullname: Kirisame, Marisa email: marisa@cs.utah.edu organization: University of Utah, USA – sequence: 2 givenname: Pranav orcidid: 0000-0002-4365-5192 surname: Shenoy fullname: Shenoy, Pranav email: pranav.shenoy@utah.edu organization: University of Utah, USA – sequence: 3 givenname: Pavel orcidid: 0000-0003-2621-3592 surname: Panchekha fullname: Panchekha, Pavel email: pavpan@cs.utah.edu organization: University of Utah, USA |
| BookMark | eNpNj8FLwzAYxYNMcM7h3VNunqr58iVtc5ShUxjsoueSpF-10rQl6ZD99042xdN78H483rtks37oibFrEHcASt-jzhElnrG5VIXOQEmY_fMXbJnSpxACDKoSzZzhdpzaYDv-QXbkXRvaKfFmiDxSvfNt_85dHL4SRR4oDHHPd4mu2Hlju0TLky7Y29Pj6-o522zXL6uHTWYlmimzNVrReCtJ28IUIJ0FV-fkFWgncuEEFNqbkgCcobLWKm9q9EqUQin0iAt2e-z1cUgpUlON8bA17isQ1c_d6nT3QN4cSevDH_QbfgPO40_4 |
| Cites_doi | 10.1145/2887746.2754180 10.1145/2661088.2661089 10.1145/1029873.1029881 10.1145/1103845.1094836 10.1145/3133876 10.1109/SP46214.2022.9833711 10.1145/2980983.2908106 10.1145/1133956.1133979 10.1145/1993478.1993487 10.1145/2983990.2984028 10.1145/1152649.1152652 10.1145/98457.98753 10.1145/143103.143143 10.1145/1065010.1065028 10.1145/3276521 10.1145/367177.367199 10.1145/3315573.3329978 10.1145/3447786.3456256 |
| ContentType | Journal Article |
| Copyright | Owner/Author |
| Copyright_xml | – notice: Owner/Author |
| DBID | AAYXX CITATION |
| DOI | 10.1145/3563323 |
| DatabaseName | CrossRef |
| DatabaseTitle | CrossRef |
| DatabaseTitleList | CrossRef |
| DeliveryMethod | fulltext_linktorsrc |
| Discipline | Computer Science |
| EISSN | 2475-1421 |
| EndPage | 1006 |
| ExternalDocumentID | 10_1145_3563323 3563323 |
| GrantInformation_xml | – fundername: Google funderid: http://dx.doi.org/10.13039/100006785 – fundername: National Science Foundation grantid: 2119939 funderid: http://dx.doi.org/10.13039/100000001 |
| GroupedDBID | AAKMM AAYFX ACM ADPZR AIKLT ALMA_UNASSIGNED_HOLDINGS GUFHI LHSKQ M~E OK1 ROL AAYXX AEFXT AEJOY AKRVB CITATION |
| ID | FETCH-LOGICAL-a239t-ad3a0fca2e5a79712ba1bd6ec415b060b0175c98e11b9e8d546fd3c4080443c33 |
| ISICitedReferencesCount | 3 |
| ISICitedReferencesURI | http://www.webofscience.com/api/gateway?GWVersion=2&SrcApp=Summon&SrcAuth=ProQuest&DestLinkType=CitingArticles&DestApp=WOS_CPL&KeyUT=001083750200037&url=https%3A%2F%2Fcvtisr.summon.serialssolutions.com%2F%23%21%2Fsearch%3Fho%3Df%26include.ft.matches%3Dt%26l%3Dnull%26q%3D |
| ISSN | 2475-1421 |
| IngestDate | Sat Nov 29 07:46:47 EST 2025 Mon Feb 24 21:14:28 EST 2025 |
| IsDoiOpenAccess | true |
| IsOpenAccess | true |
| IsPeerReviewed | true |
| IsScholarly | true |
| Issue | OOPSLA2 |
| Keywords | memory management web browser garbage collection JavaScript heap limit |
| Language | English |
| License | This work is licensed under a Creative Commons Attribution 4.0 International License. |
| LinkModel | OpenURL |
| MergedId | FETCHMERGED-LOGICAL-a239t-ad3a0fca2e5a79712ba1bd6ec415b060b0175c98e11b9e8d546fd3c4080443c33 |
| ORCID | 0000-0002-4365-5192 0000-0003-2621-3592 0000-0002-3418-4835 |
| OpenAccessLink | https://dl.acm.org/doi/10.1145/3563323 |
| PageCount | 21 |
| ParticipantIDs | crossref_primary_10_1145_3563323 acm_primary_3563323 |
| PublicationCentury | 2000 |
| PublicationDate | 2022-10-31 |
| PublicationDateYYYYMMDD | 2022-10-31 |
| PublicationDate_xml | – month: 10 year: 2022 text: 2022-10-31 day: 31 |
| PublicationDecade | 2020 |
| PublicationPlace | New York, NY, USA |
| PublicationPlace_xml | – name: New York, NY, USA |
| PublicationTitle | Proceedings of ACM on programming languages |
| PublicationTitleAbbrev | ACM PACMPL |
| PublicationYear | 2022 |
| Publisher | ACM |
| Publisher_xml | – name: ACM |
| References | Richard Jones, Antony Hosking, and Eliot Moss. 2012. The Garbage Collection Handbook (1 ed.). Chapman and Haii/CRC, Taylor and Francis Group, 6000 Broken Sound Parkway NW, Suite 300 Boca Raton, FL 33487-2742. Preston Briggs, Keith D. Cooper, and Linda Torczon. 1992. Rematerialization. SIGPLAN Not., 27, 7 (1992), jul, 311–321. issn:0362-1340 https://doi.org/10.1145/143103.143143 10.1145/143103.143143 Marisa Kirisame, Steven Lyubomirsky, Altan Haan, Jennifer Brennan, Mike He, Jared Roesch, Tianqi Chen, and Zachary Tatlock. 2021. Dynamic Tensor Rematerialization. In International Conference on Learning Representations. 31 pages. https://doi.org/10.48550/ARXIV.2006.09616 John McCarthy. 1960. Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I. Commun. ACM, 3, 4 (1960), apr, 184–195. issn:0001-0782 https://doi.org/10.1145/367177.367199 10.1145/367177.367199 Matthew Flatt. 2022. cs: experiment with a revised major-GC trigger. https://github.com/racket/racket/commit/157b1f30a1501d53d310cbe0d9bb999a81c689e7 Ting Yang, Matthew Hertz, Emery D. Berger, Scott F. Kaplan, and J. Eliot B. Moss. 2004. Automatic Heap Sizing: Taking Real Memory into Account. In Proceedings of the 4th International Symposium on Memory Management (ISMM ’04). Association for Computing Machinery, New York, NY, USA. 61–72. isbn:1581139454 https://doi.org/10.1145/1029873.1029881 10.1145/1029873.1029881 Ulan Degenbaev, Jochen Eisinger, Manfred Ernst, Ross McIlroy, and Hannes Payer. 2016. Idle Time Garbage Collection Scheduling. SIGPLAN Not., 51, 6 (2016), Jun, 570–583. issn:0362-1340 https://doi.org/10.1145/2980983.2908106 10.1145/2980983.2908106 Diogenes Nunez, Samuel Z. Guyer, and Emery D. Berger. 2016. Prioritized garbage collection: explicit GC support for software caches. In Proceedings of the 2016 ACM SIGPLAN International Conference on Object-Oriented Programming, Systems, Languages, and Applications, OOPSLA 2016, part of SPLASH 2016, Amsterdam, The Netherlands, October 30 - November 4, 2016, Eelco Visser and Yannis Smaragdakis (Eds.). ACM, 695–710. https://doi.org/10.1145/2983990.2984028 10.1145/2983990.2984028 David Lion, Adrian Chiu, and Ding Yuan. 2021. M3: End-to-End Memory Management in Elastic System Software Stacks. In Proceedings of the Sixteenth European Conference on Computer Systems (EuroSys ’21). Association for Computing Machinery, New York, NY, USA. 507–522. isbn:9781450383349 https://doi.org/10.1145/3447786.3456256 10.1145/3447786.3456256 Raphael Alonso and Andrew W. Appel. 1990. An Advisor for Flexible Working Sets. SIGMETRICS ’90. Association for Computing Machinery, New York, NY, USA. 153–162. isbn:0897913590 https://doi.org/10.1145/98457.98753 10.1145/98457.98753 Martin Aigner, Thomas Hütter, Christoph M Kirsch, Alexander Miller, Hannes Payer, and Mario Preishuber. 2014. ACDC-JS: explorative benchmarking of javascript memory management. ACM SIGPLAN Notices, 50, 2 (2014), 67–78. https://doi.org/10.1145/2661088.2661089 10.1145/2661088.2661089 Xinli Shang. 2020. Tricks of the trade: Tuning JVM memory for large-scale services. https://eng.uber.com/jvm-tuning-garbage-collection Ulan Degenbaev, Michael Lippautz, and Hannes Payer. 2019. Concurrent Marking of Shape-Changing Objects. ISMM 2019. Association for Computing Machinery, New York, NY, USA. 89–102. isbn:9781450367226 https://doi.org/10.1145/3315573.3329978 10.1145/3315573.3329978 Matthew Hertz, Yi Feng, and Emery D. Berger. 2005. Garbage Collection without Paging. In Proceedings of the 2005 ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’05). Association for Computing Machinery, New York, NY, USA. 143–153. isbn:1595930566 https://doi.org/10.1145/1065010.1065028 10.1145/1065010.1065028 Mythri Alle, Dan Elphick, and Ross McIlroy. 2019. A Lighter V8. https://v8.dev/blog/v8-lite Ulan Degenbaev, Jochen Eisinger, Kentaro Hara, Marcel Hlopko, Michael Lippautz, and Hannes Payer. 2018. Cross-Component Garbage Collection. Proc. ACM Program. Lang., 2, OOPSLA (2018), Article 151, oct, 24 pages. https://doi.org/10.1145/3276521 10.1145/3276521 Chengliang Zhang, Kirk Kelsey, Xipeng Shen, Chen Ding, Matthew Hertz, and Mitsunori Ogihara. 2006. Program-Level Adaptive Memory Management. In Proceedings of the 5th International Symposium on Memory Management (ISMM ’06). Association for Computing Machinery, New York, NY, USA. 174–183. isbn:1595932216 https://doi.org/10.1145/1133956.1133979 10.1145/1133956.1133979 Ulan Degenbaev, Michael Lippautz, and Hannes Payer. 2018. Concurrent marking in V8. https://v8.dev/blog/concurrent-marking Matthew Flatt and PLT. 2010. Reference: Racket. PLT Design Inc.. https://racket-lang.org/tr1 Mozilla. 2022. FireFox MemBalancer. https://bugzilla.mozilla.org/show_bug.cgi?id=1770763 Ayush Agarwal, Sioli O’Connell, Jason Kim, Shaked Yehezkel, Daniel Genkin, Eyal Ronen, and Yuval Yarom. 2022. Spook.js: Attacking Chrome Strict Site Isolation via Speculative Execution. In 43rd IEEE Symposium on Security and Privacy (S&P’22). 93–101. https://doi.org/10.1109/SP46214.2022.9833711 10.1109/SP46214.2022.9833711 Ayush Vij. 2022. Reduce chrome memory usage and make it use less Ram. https://www.thewindowsclub.com/reduce-chrome-memory-usage-make-it-use-less-ram Matthew Hertz, Stephen Kane, Elizabeth Keudel, Tongxin Bai, Chen Ding, Xiaoming Gu, and Jonathan E. Bard. 2011. Waste Not, Want Not: Resource-Based Garbage Collection in a Shared Environment. In Proceedings of the International Symposium on Memory Management (ISMM ’11). Association for Computing Machinery, New York, NY, USA. 65–76. isbn:9781450302630 https://doi.org/10.1145/1993478.1993487 10.1145/1993478.1993487 Tim Brecht, Eshrat Arjomandi, Chang Li, and Hang Pham. 2006. Controlling Garbage Collection and Heap Growth to Reduce the Execution Time of Java Applications. ACM Trans. Program. Lang. Syst., 28, 5 (2006), sep, 908–941. issn:0164-0925 https://doi.org/10.1145/1152649.1152652 10.1145/1152649.1152652 Callum Cameron, Jeremy Singer, and David Vengerov. 2015. The Judgment of Forseti: Economic Utility for Dynamic Heap Sizing of Multiple Runtimes. SIGPLAN Not., 50, 11 (2015), jun, 143–156. issn:0362-1340 https://doi.org/10.1145/2887746.2754180 10.1145/2887746.2754180 Mozilla. 2020. Are We Slim Yet. http://udn.realityripple.com/docs/Mozilla/Performance/AWSY Matthew Hertz and Emery D. Berger. 2005. Quantifying the Performance of Garbage Collection vs. Explicit Memory Management. SIGPLAN Not., 40, 10 (2005), Oct, 313–326. issn:0362-1340 https://doi.org/10.1145/1103845.1094836 10.1145/1103845.1094836 Edd Barrett, Carl Friedrich Bolz-Tereick, Rebecca Killick, Vincent Knight, Sarah Mount, and Laurence Tratt. 2017. Virtual Machine Warmup Blows Hot and Cold. In OOPSLA. ACM, 27 pages. https://doi.org/10.1145/3133876 10.1145/3133876 Oracle. 2015. Java Platform, Standard Edition HotSpot Virtual Machine Garbage Collection Tuning Guide. https://docs.oracle.com/javase/8/docs/technotes/guides/vm/gctuning Flatt Matthew (e_1_2_1_14_1) 2010 Jones Richard (e_1_2_1_18_1) e_1_2_1_20_1 e_1_2_1_23_1 e_1_2_1_24_1 e_1_2_1_21_1 e_1_2_1_22_1 e_1_2_1_27_1 e_1_2_1_28_1 e_1_2_1_25_1 e_1_2_1_26_1 e_1_2_1_29_1 Kirisame Marisa (e_1_2_1_19_1) 2021 e_1_2_1_7_1 e_1_2_1_8_1 e_1_2_1_5_1 e_1_2_1_6_1 e_1_2_1_3_1 e_1_2_1_12_1 e_1_2_1_4_1 e_1_2_1_13_1 e_1_2_1_1_1 e_1_2_1_10_1 e_1_2_1_2_1 e_1_2_1_11_1 e_1_2_1_16_1 e_1_2_1_17_1 e_1_2_1_15_1 e_1_2_1_9_1 |
| References_xml | – reference: Ayush Agarwal, Sioli O’Connell, Jason Kim, Shaked Yehezkel, Daniel Genkin, Eyal Ronen, and Yuval Yarom. 2022. Spook.js: Attacking Chrome Strict Site Isolation via Speculative Execution. In 43rd IEEE Symposium on Security and Privacy (S&P’22). 93–101. https://doi.org/10.1109/SP46214.2022.9833711 10.1109/SP46214.2022.9833711 – reference: Matthew Flatt and PLT. 2010. Reference: Racket. PLT Design Inc.. https://racket-lang.org/tr1/ – reference: Ayush Vij. 2022. Reduce chrome memory usage and make it use less Ram. https://www.thewindowsclub.com/reduce-chrome-memory-usage-make-it-use-less-ram – reference: Callum Cameron, Jeremy Singer, and David Vengerov. 2015. The Judgment of Forseti: Economic Utility for Dynamic Heap Sizing of Multiple Runtimes. SIGPLAN Not., 50, 11 (2015), jun, 143–156. issn:0362-1340 https://doi.org/10.1145/2887746.2754180 10.1145/2887746.2754180 – reference: Oracle. 2015. Java Platform, Standard Edition HotSpot Virtual Machine Garbage Collection Tuning Guide. https://docs.oracle.com/javase/8/docs/technotes/guides/vm/gctuning/ – reference: Richard Jones, Antony Hosking, and Eliot Moss. 2012. The Garbage Collection Handbook (1 ed.). Chapman and Haii/CRC, Taylor and Francis Group, 6000 Broken Sound Parkway NW, Suite 300 Boca Raton, FL 33487-2742. – reference: Xinli Shang. 2020. Tricks of the trade: Tuning JVM memory for large-scale services. https://eng.uber.com/jvm-tuning-garbage-collection/ – reference: Ulan Degenbaev, Jochen Eisinger, Manfred Ernst, Ross McIlroy, and Hannes Payer. 2016. Idle Time Garbage Collection Scheduling. SIGPLAN Not., 51, 6 (2016), Jun, 570–583. issn:0362-1340 https://doi.org/10.1145/2980983.2908106 10.1145/2980983.2908106 – reference: Matthew Hertz and Emery D. Berger. 2005. Quantifying the Performance of Garbage Collection vs. Explicit Memory Management. SIGPLAN Not., 40, 10 (2005), Oct, 313–326. issn:0362-1340 https://doi.org/10.1145/1103845.1094836 10.1145/1103845.1094836 – reference: Mythri Alle, Dan Elphick, and Ross McIlroy. 2019. A Lighter V8. https://v8.dev/blog/v8-lite – reference: John McCarthy. 1960. Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I. Commun. ACM, 3, 4 (1960), apr, 184–195. issn:0001-0782 https://doi.org/10.1145/367177.367199 10.1145/367177.367199 – reference: Matthew Hertz, Yi Feng, and Emery D. Berger. 2005. Garbage Collection without Paging. In Proceedings of the 2005 ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’05). Association for Computing Machinery, New York, NY, USA. 143–153. isbn:1595930566 https://doi.org/10.1145/1065010.1065028 10.1145/1065010.1065028 – reference: Ulan Degenbaev, Michael Lippautz, and Hannes Payer. 2018. Concurrent marking in V8. https://v8.dev/blog/concurrent-marking – reference: Ulan Degenbaev, Michael Lippautz, and Hannes Payer. 2019. Concurrent Marking of Shape-Changing Objects. ISMM 2019. Association for Computing Machinery, New York, NY, USA. 89–102. isbn:9781450367226 https://doi.org/10.1145/3315573.3329978 10.1145/3315573.3329978 – reference: Martin Aigner, Thomas Hütter, Christoph M Kirsch, Alexander Miller, Hannes Payer, and Mario Preishuber. 2014. ACDC-JS: explorative benchmarking of javascript memory management. ACM SIGPLAN Notices, 50, 2 (2014), 67–78. https://doi.org/10.1145/2661088.2661089 10.1145/2661088.2661089 – reference: Diogenes Nunez, Samuel Z. Guyer, and Emery D. Berger. 2016. Prioritized garbage collection: explicit GC support for software caches. In Proceedings of the 2016 ACM SIGPLAN International Conference on Object-Oriented Programming, Systems, Languages, and Applications, OOPSLA 2016, part of SPLASH 2016, Amsterdam, The Netherlands, October 30 - November 4, 2016, Eelco Visser and Yannis Smaragdakis (Eds.). ACM, 695–710. https://doi.org/10.1145/2983990.2984028 10.1145/2983990.2984028 – reference: Mozilla. 2020. Are We Slim Yet. http://udn.realityripple.com/docs/Mozilla/Performance/AWSY – reference: Mozilla. 2022. FireFox MemBalancer. https://bugzilla.mozilla.org/show_bug.cgi?id=1770763 – reference: Matthew Flatt. 2022. cs: experiment with a revised major-GC trigger. https://github.com/racket/racket/commit/157b1f30a1501d53d310cbe0d9bb999a81c689e7 – reference: Ulan Degenbaev, Jochen Eisinger, Kentaro Hara, Marcel Hlopko, Michael Lippautz, and Hannes Payer. 2018. Cross-Component Garbage Collection. Proc. ACM Program. Lang., 2, OOPSLA (2018), Article 151, oct, 24 pages. https://doi.org/10.1145/3276521 10.1145/3276521 – reference: Matthew Hertz, Stephen Kane, Elizabeth Keudel, Tongxin Bai, Chen Ding, Xiaoming Gu, and Jonathan E. Bard. 2011. Waste Not, Want Not: Resource-Based Garbage Collection in a Shared Environment. In Proceedings of the International Symposium on Memory Management (ISMM ’11). Association for Computing Machinery, New York, NY, USA. 65–76. isbn:9781450302630 https://doi.org/10.1145/1993478.1993487 10.1145/1993478.1993487 – reference: Raphael Alonso and Andrew W. Appel. 1990. An Advisor for Flexible Working Sets. SIGMETRICS ’90. Association for Computing Machinery, New York, NY, USA. 153–162. isbn:0897913590 https://doi.org/10.1145/98457.98753 10.1145/98457.98753 – reference: Preston Briggs, Keith D. Cooper, and Linda Torczon. 1992. Rematerialization. SIGPLAN Not., 27, 7 (1992), jul, 311–321. issn:0362-1340 https://doi.org/10.1145/143103.143143 10.1145/143103.143143 – reference: David Lion, Adrian Chiu, and Ding Yuan. 2021. M3: End-to-End Memory Management in Elastic System Software Stacks. In Proceedings of the Sixteenth European Conference on Computer Systems (EuroSys ’21). Association for Computing Machinery, New York, NY, USA. 507–522. isbn:9781450383349 https://doi.org/10.1145/3447786.3456256 10.1145/3447786.3456256 – reference: Edd Barrett, Carl Friedrich Bolz-Tereick, Rebecca Killick, Vincent Knight, Sarah Mount, and Laurence Tratt. 2017. Virtual Machine Warmup Blows Hot and Cold. In OOPSLA. ACM, 27 pages. https://doi.org/10.1145/3133876 10.1145/3133876 – reference: Ting Yang, Matthew Hertz, Emery D. Berger, Scott F. Kaplan, and J. Eliot B. Moss. 2004. Automatic Heap Sizing: Taking Real Memory into Account. In Proceedings of the 4th International Symposium on Memory Management (ISMM ’04). Association for Computing Machinery, New York, NY, USA. 61–72. isbn:1581139454 https://doi.org/10.1145/1029873.1029881 10.1145/1029873.1029881 – reference: Chengliang Zhang, Kirk Kelsey, Xipeng Shen, Chen Ding, Matthew Hertz, and Mitsunori Ogihara. 2006. Program-Level Adaptive Memory Management. In Proceedings of the 5th International Symposium on Memory Management (ISMM ’06). Association for Computing Machinery, New York, NY, USA. 174–183. isbn:1595932216 https://doi.org/10.1145/1133956.1133979 10.1145/1133956.1133979 – reference: Marisa Kirisame, Steven Lyubomirsky, Altan Haan, Jennifer Brennan, Mike He, Jared Roesch, Tianqi Chen, and Zachary Tatlock. 2021. Dynamic Tensor Rematerialization. In International Conference on Learning Representations. 31 pages. https://doi.org/10.48550/ARXIV.2006.09616 – reference: Tim Brecht, Eshrat Arjomandi, Chang Li, and Hang Pham. 2006. Controlling Garbage Collection and Heap Growth to Reduce the Execution Time of Java Applications. ACM Trans. Program. Lang. Syst., 28, 5 (2006), sep, 908–941. issn:0164-0925 https://doi.org/10.1145/1152649.1152652 10.1145/1152649.1152652 – ident: e_1_2_1_8_1 doi: 10.1145/2887746.2754180 – ident: e_1_2_1_2_1 doi: 10.1145/2661088.2661089 – ident: e_1_2_1_28_1 doi: 10.1145/1029873.1029881 – ident: e_1_2_1_15_1 doi: 10.1145/1103845.1094836 – ident: e_1_2_1_5_1 doi: 10.1145/3133876 – ident: e_1_2_1_27_1 – ident: e_1_2_1_1_1 doi: 10.1109/SP46214.2022.9833711 – ident: e_1_2_1_9_1 doi: 10.1145/2980983.2908106 – volume-title: Reference: Racket year: 2010 ident: e_1_2_1_14_1 – ident: e_1_2_1_23_1 – ident: e_1_2_1_26_1 – ident: e_1_2_1_29_1 doi: 10.1145/1133956.1133979 – ident: e_1_2_1_17_1 doi: 10.1145/1993478.1993487 – ident: e_1_2_1_24_1 doi: 10.1145/2983990.2984028 – ident: e_1_2_1_6_1 doi: 10.1145/1152649.1152652 – ident: e_1_2_1_4_1 doi: 10.1145/98457.98753 – ident: e_1_2_1_7_1 doi: 10.1145/143103.143143 – ident: e_1_2_1_16_1 doi: 10.1145/1065010.1065028 – volume-title: The Garbage Collection Handbook (1 ed.) ident: e_1_2_1_18_1 – ident: e_1_2_1_10_1 doi: 10.1145/3276521 – ident: e_1_2_1_25_1 – ident: e_1_2_1_21_1 doi: 10.1145/367177.367199 – ident: e_1_2_1_3_1 – ident: e_1_2_1_22_1 – ident: e_1_2_1_11_1 – ident: e_1_2_1_12_1 doi: 10.1145/3315573.3329978 – ident: e_1_2_1_13_1 – ident: e_1_2_1_20_1 doi: 10.1145/3447786.3456256 – volume-title: Dynamic Tensor Rematerialization. In International Conference on Learning Representations. 31 pages. https://doi.org/10 year: 2021 ident: e_1_2_1_19_1 |
| SSID | ssj0001934839 |
| Score | 2.220871 |
| Snippet | Garbage-collected language runtimes carefully tune heap limits to reduce garbage collection time and memory usage. However, there's a trade-off: a lower heap... |
| SourceID | crossref acm |
| SourceType | Index Database Publisher |
| StartPage | 986 |
| SubjectTerms | Browsers Information systems Runtime environments Software and its engineering |
| SubjectTermsDisplay | Information systems -- Browsers Software and its engineering -- Runtime environments |
| Title | Optimal heap limits for reducing browser memory use |
| URI | https://dl.acm.org/doi/10.1145/3563323 |
| Volume | 6 |
| WOSCitedRecordID | wos001083750200037&url=https%3A%2F%2Fcvtisr.summon.serialssolutions.com%2F%23%21%2Fsearch%3Fho%3Df%26include.ft.matches%3Dt%26l%3Dnull%26q%3D |
| hasFullText | 1 |
| inHoldings | 1 |
| isFullTextHit | |
| isPrint | |
| journalDatabaseRights | – providerCode: PRVHPJ databaseName: ROAD: Directory of Open Access Scholarly Resources customDbUrl: eissn: 2475-1421 dateEnd: 99991231 omitProxy: false ssIdentifier: ssj0001934839 issn: 2475-1421 databaseCode: M~E dateStart: 20170101 isFulltext: true titleUrlDefault: https://road.issn.org providerName: ISSN International Centre |
| link | http://cvtisr.summon.serialssolutions.com/2.0.0/link/0/eLvHCXMwtV3PT9swFLYG24ELbMAEDJAPu1VhTezE8bGqQBzoDwkm9VbZjiOqraFqSwUX_va9FztpQJU2DrtEkRtXjd_X5_eev_ceId_znGkTaRnkMo8DLrgJZKayACkXWmcqMarsWnIj-v10NJJDTytalO0ERFGkT09y9l9FDWMgbEydfYe46y-FAbgHocMVxA7XfxL8AJTA1GU4zlq_MX-pLLnQmmORVgwMaPC84Ze0pkiyfW49Ll6xgYb1jlaSPDrdHp4neBrXFOdXIc71MdAEK_W6dus9bGpYq_rbe1v4YB_siWq1PrAqACy_3GHTUK08b99HH8BxXavtUklFXMRByF2W84XdMOa1bNIA02AwvL3pRA29Kat62DPXCLesQrBBvXOshMHihDGXpfy6gPabja2mG7rk63jsJ26Rj5GIJRIAey-NiJxkPC1bz9Uv4LKsce4PPxeNGDNtGDENa-TuM9n1bgTtOPF_IR9ssU_2qhYd1GvsA8I8GiiigTo0UEADrdBAPRqoQwMFNBySn1eXd93rwPfJCFTE5DJQGVPt3KjIxkpIEUZahTpLrAHjTLcTDHWL2MjUhqGWNs1inuQZMxycBc6ZYewr2S4eCntEaGRSqwX8nZTQ6Asr3c7y3KY6CVMF9s4x2YfXH89cJZRqQY8JrZaj_ujNmp_8_ZFvZGeNsFOyvZw_2jPyyayWk8X8vJTVH3IMWLk |
| linkProvider | ISSN International Centre |
| 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=Optimal+heap+limits+for+reducing+browser+memory+use&rft.jtitle=Proceedings+of+ACM+on+programming+languages&rft.au=Kirisame%2C+Marisa&rft.au=Shenoy%2C+Pranav&rft.au=Panchekha%2C+Pavel&rft.date=2022-10-31&rft.issn=2475-1421&rft.eissn=2475-1421&rft.volume=6&rft.issue=OOPSLA2&rft.spage=986&rft.epage=1006&rft_id=info:doi/10.1145%2F3563323&rft.externalDBID=n%2Fa&rft.externalDocID=10_1145_3563323 |
| thumbnail_l | http://covers-cdn.summon.serialssolutions.com/index.aspx?isbn=/lc.gif&issn=2475-1421&client=summon |
| thumbnail_m | http://covers-cdn.summon.serialssolutions.com/index.aspx?isbn=/mc.gif&issn=2475-1421&client=summon |
| thumbnail_s | http://covers-cdn.summon.serialssolutions.com/index.aspx?isbn=/sc.gif&issn=2475-1421&client=summon |