Providing Fair Share Scheduling on Multicore Cloud Servers via Virtual Runtime-based Task Migration Algorithm
While Linux is the most favored operating system for an open source-based cloud data center, it falls short of expectations when it comes to fair share multicore scheduling. The primary task scheduler of the mainline Linux kernel, CFS, cannot provide a desired level of fairness in a multicore system...
Gespeichert in:
Hauptverfasser: | , , , |
---|---|
Format: | Tagungsbericht |
Sprache: | eng |
Schlagworte: | |
Online-Zugang: | Volltext bestellen |
Tags: |
Tag hinzufügen
Keine Tags, Fügen Sie den ersten Tag hinzu!
|
container_end_page | 614 |
---|---|
container_issue | |
container_start_page | 606 |
container_title | |
container_volume | |
creator | Sungju Huh Jonghun Yoo Myungsun Kim Seongsoo Hong |
description | While Linux is the most favored operating system for an open source-based cloud data center, it falls short of expectations when it comes to fair share multicore scheduling. The primary task scheduler of the mainline Linux kernel, CFS, cannot provide a desired level of fairness in a multicore system. CFS uses a weight-based load balancing mechanism to evenly distribute task weights among all cores. Contrary to expectations, this mechanism cannot guarantee fair share scheduling since balancing loads among cores has nothing to do with bounding differences in the virtual runtimes of tasks. To make matters worse, CFS allows a persistent load imbalance among cores. This paper presents a virtual runtime-based task migration algorithm which directly bounds the maximum virtual runtime difference among tasks. For a given pair of cores, our algorithm periodically partitions run able tasks into two groups depending on their virtual runtimes and assigns each group to a dedicated core. In doing so, it bounds the load difference between two cores by the largest weight in the task set and makes the core with larger virtual runtimes receive a larger load and thus run more slowly. It bounds the virtual runtime difference of any pair of tasks running on these cores by a constant. We have implemented the algorithm into the Linux kernel 2.6.38.8. Experimental results show that the maximal virtual runtime difference is 50.53 time units while incurring only 0.14% more run-time overhead than CFS. |
doi_str_mv | 10.1109/ICDCS.2012.33 |
format | Conference Proceeding |
fullrecord | <record><control><sourceid>ieee_6IE</sourceid><recordid>TN_cdi_ieee_primary_6258033</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><ieee_id>6258033</ieee_id><sourcerecordid>6258033</sourcerecordid><originalsourceid>FETCH-LOGICAL-i175t-fa5f1adf1d6ee38d91624086b3ee73cbe1615c17819fbd8daf1eac96bf9ff2fc3</originalsourceid><addsrcrecordid>eNotj81OAjEYRetfIiJLV276AoP9Wvq3JKMoCUTjoFvSmX6F6sCYzgyJby9G7-YkZ3GSS8gNsDEAs3fz_D4vxpwBHwtxQkZWG6aVlRNlpDklAy61zMwE4IxcwURqzbiV9pwMgCmRKcv1JRm17Qc7ThsAbgZk95KaQ_Rxv6EzFxMtti4hLaot-r7-tc2eLvu6i1Vz9Hnd9J4WmA6YWnqIjr7H1PWupq_9vos7zErXoqcr137SZdwk18VjYFpvmhS77e6aXARXtzj655C8zR5W-VO2eH6c59NFFkHLLgtOBnA-gFeIwngLik-YUaVA1KIqERTICo4fbCi98S4AusqqMtgQeKjEkNz-dSMirr9S3Ln0vVZcGiaE-AG8gV9Z</addsrcrecordid><sourcetype>Publisher</sourcetype><iscdi>true</iscdi><recordtype>conference_proceeding</recordtype></control><display><type>conference_proceeding</type><title>Providing Fair Share Scheduling on Multicore Cloud Servers via Virtual Runtime-based Task Migration Algorithm</title><source>IEEE Electronic Library (IEL) Conference Proceedings</source><creator>Sungju Huh ; Jonghun Yoo ; Myungsun Kim ; Seongsoo Hong</creator><creatorcontrib>Sungju Huh ; Jonghun Yoo ; Myungsun Kim ; Seongsoo Hong</creatorcontrib><description>While Linux is the most favored operating system for an open source-based cloud data center, it falls short of expectations when it comes to fair share multicore scheduling. The primary task scheduler of the mainline Linux kernel, CFS, cannot provide a desired level of fairness in a multicore system. CFS uses a weight-based load balancing mechanism to evenly distribute task weights among all cores. Contrary to expectations, this mechanism cannot guarantee fair share scheduling since balancing loads among cores has nothing to do with bounding differences in the virtual runtimes of tasks. To make matters worse, CFS allows a persistent load imbalance among cores. This paper presents a virtual runtime-based task migration algorithm which directly bounds the maximum virtual runtime difference among tasks. For a given pair of cores, our algorithm periodically partitions run able tasks into two groups depending on their virtual runtimes and assigns each group to a dedicated core. In doing so, it bounds the load difference between two cores by the largest weight in the task set and makes the core with larger virtual runtimes receive a larger load and thus run more slowly. It bounds the virtual runtime difference of any pair of tasks running on these cores by a constant. We have implemented the algorithm into the Linux kernel 2.6.38.8. Experimental results show that the maximal virtual runtime difference is 50.53 time units while incurring only 0.14% more run-time overhead than CFS.</description><identifier>ISSN: 1063-6927</identifier><identifier>ISBN: 1457702959</identifier><identifier>ISBN: 9781457702952</identifier><identifier>EISSN: 2575-8411</identifier><identifier>EISBN: 9780769546858</identifier><identifier>EISBN: 0769546854</identifier><identifier>DOI: 10.1109/ICDCS.2012.33</identifier><identifier>CODEN: IEEPAD</identifier><language>eng</language><publisher>IEEE</publisher><subject>cloud server computing ; fair share scheduling ; Linux ; load balancing ; Load management ; multi-core scheduling ; Multicore processing ; Runtime ; Scheduling algorithms ; Servers</subject><ispartof>2012 IEEE 32nd International Conference on Distributed Computing Systems, 2012, p.606-614</ispartof><woscitedreferencessubscribed>false</woscitedreferencessubscribed></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Tsyndetics_thumb_exl</thumbnail><linktohtml>$$Uhttps://ieeexplore.ieee.org/document/6258033$$EHTML$$P50$$Gieee$$H</linktohtml><link.rule.ids>309,310,780,784,789,790,2058,27925,54920</link.rule.ids><linktorsrc>$$Uhttps://ieeexplore.ieee.org/document/6258033$$EView_record_in_IEEE$$FView_record_in_$$GIEEE</linktorsrc></links><search><creatorcontrib>Sungju Huh</creatorcontrib><creatorcontrib>Jonghun Yoo</creatorcontrib><creatorcontrib>Myungsun Kim</creatorcontrib><creatorcontrib>Seongsoo Hong</creatorcontrib><title>Providing Fair Share Scheduling on Multicore Cloud Servers via Virtual Runtime-based Task Migration Algorithm</title><title>2012 IEEE 32nd International Conference on Distributed Computing Systems</title><addtitle>ICDSC</addtitle><description>While Linux is the most favored operating system for an open source-based cloud data center, it falls short of expectations when it comes to fair share multicore scheduling. The primary task scheduler of the mainline Linux kernel, CFS, cannot provide a desired level of fairness in a multicore system. CFS uses a weight-based load balancing mechanism to evenly distribute task weights among all cores. Contrary to expectations, this mechanism cannot guarantee fair share scheduling since balancing loads among cores has nothing to do with bounding differences in the virtual runtimes of tasks. To make matters worse, CFS allows a persistent load imbalance among cores. This paper presents a virtual runtime-based task migration algorithm which directly bounds the maximum virtual runtime difference among tasks. For a given pair of cores, our algorithm periodically partitions run able tasks into two groups depending on their virtual runtimes and assigns each group to a dedicated core. In doing so, it bounds the load difference between two cores by the largest weight in the task set and makes the core with larger virtual runtimes receive a larger load and thus run more slowly. It bounds the virtual runtime difference of any pair of tasks running on these cores by a constant. We have implemented the algorithm into the Linux kernel 2.6.38.8. Experimental results show that the maximal virtual runtime difference is 50.53 time units while incurring only 0.14% more run-time overhead than CFS.</description><subject>cloud server computing</subject><subject>fair share scheduling</subject><subject>Linux</subject><subject>load balancing</subject><subject>Load management</subject><subject>multi-core scheduling</subject><subject>Multicore processing</subject><subject>Runtime</subject><subject>Scheduling algorithms</subject><subject>Servers</subject><issn>1063-6927</issn><issn>2575-8411</issn><isbn>1457702959</isbn><isbn>9781457702952</isbn><isbn>9780769546858</isbn><isbn>0769546854</isbn><fulltext>true</fulltext><rsrctype>conference_proceeding</rsrctype><creationdate>2012</creationdate><recordtype>conference_proceeding</recordtype><sourceid>6IE</sourceid><sourceid>RIE</sourceid><recordid>eNotj81OAjEYRetfIiJLV276AoP9Wvq3JKMoCUTjoFvSmX6F6sCYzgyJby9G7-YkZ3GSS8gNsDEAs3fz_D4vxpwBHwtxQkZWG6aVlRNlpDklAy61zMwE4IxcwURqzbiV9pwMgCmRKcv1JRm17Qc7ThsAbgZk95KaQ_Rxv6EzFxMtti4hLaot-r7-tc2eLvu6i1Vz9Hnd9J4WmA6YWnqIjr7H1PWupq_9vos7zErXoqcr137SZdwk18VjYFpvmhS77e6aXARXtzj655C8zR5W-VO2eH6c59NFFkHLLgtOBnA-gFeIwngLik-YUaVA1KIqERTICo4fbCi98S4AusqqMtgQeKjEkNz-dSMirr9S3Ln0vVZcGiaE-AG8gV9Z</recordid><startdate>201206</startdate><enddate>201206</enddate><creator>Sungju Huh</creator><creator>Jonghun Yoo</creator><creator>Myungsun Kim</creator><creator>Seongsoo Hong</creator><general>IEEE</general><scope>6IE</scope><scope>6IH</scope><scope>CBEJK</scope><scope>RIE</scope><scope>RIO</scope></search><sort><creationdate>201206</creationdate><title>Providing Fair Share Scheduling on Multicore Cloud Servers via Virtual Runtime-based Task Migration Algorithm</title><author>Sungju Huh ; Jonghun Yoo ; Myungsun Kim ; Seongsoo Hong</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-i175t-fa5f1adf1d6ee38d91624086b3ee73cbe1615c17819fbd8daf1eac96bf9ff2fc3</frbrgroupid><rsrctype>conference_proceedings</rsrctype><prefilter>conference_proceedings</prefilter><language>eng</language><creationdate>2012</creationdate><topic>cloud server computing</topic><topic>fair share scheduling</topic><topic>Linux</topic><topic>load balancing</topic><topic>Load management</topic><topic>multi-core scheduling</topic><topic>Multicore processing</topic><topic>Runtime</topic><topic>Scheduling algorithms</topic><topic>Servers</topic><toplevel>online_resources</toplevel><creatorcontrib>Sungju Huh</creatorcontrib><creatorcontrib>Jonghun Yoo</creatorcontrib><creatorcontrib>Myungsun Kim</creatorcontrib><creatorcontrib>Seongsoo Hong</creatorcontrib><collection>IEEE Electronic Library (IEL) Conference Proceedings</collection><collection>IEEE Proceedings Order Plan (POP) 1998-present by volume</collection><collection>IEEE Xplore All Conference Proceedings</collection><collection>IEEE Electronic Library (IEL)</collection><collection>IEEE Proceedings Order Plans (POP) 1998-present</collection></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext_linktorsrc</fulltext></delivery><addata><au>Sungju Huh</au><au>Jonghun Yoo</au><au>Myungsun Kim</au><au>Seongsoo Hong</au><format>book</format><genre>proceeding</genre><ristype>CONF</ristype><atitle>Providing Fair Share Scheduling on Multicore Cloud Servers via Virtual Runtime-based Task Migration Algorithm</atitle><btitle>2012 IEEE 32nd International Conference on Distributed Computing Systems</btitle><stitle>ICDSC</stitle><date>2012-06</date><risdate>2012</risdate><spage>606</spage><epage>614</epage><pages>606-614</pages><issn>1063-6927</issn><eissn>2575-8411</eissn><isbn>1457702959</isbn><isbn>9781457702952</isbn><eisbn>9780769546858</eisbn><eisbn>0769546854</eisbn><coden>IEEPAD</coden><abstract>While Linux is the most favored operating system for an open source-based cloud data center, it falls short of expectations when it comes to fair share multicore scheduling. The primary task scheduler of the mainline Linux kernel, CFS, cannot provide a desired level of fairness in a multicore system. CFS uses a weight-based load balancing mechanism to evenly distribute task weights among all cores. Contrary to expectations, this mechanism cannot guarantee fair share scheduling since balancing loads among cores has nothing to do with bounding differences in the virtual runtimes of tasks. To make matters worse, CFS allows a persistent load imbalance among cores. This paper presents a virtual runtime-based task migration algorithm which directly bounds the maximum virtual runtime difference among tasks. For a given pair of cores, our algorithm periodically partitions run able tasks into two groups depending on their virtual runtimes and assigns each group to a dedicated core. In doing so, it bounds the load difference between two cores by the largest weight in the task set and makes the core with larger virtual runtimes receive a larger load and thus run more slowly. It bounds the virtual runtime difference of any pair of tasks running on these cores by a constant. We have implemented the algorithm into the Linux kernel 2.6.38.8. Experimental results show that the maximal virtual runtime difference is 50.53 time units while incurring only 0.14% more run-time overhead than CFS.</abstract><pub>IEEE</pub><doi>10.1109/ICDCS.2012.33</doi><tpages>9</tpages></addata></record> |
fulltext | fulltext_linktorsrc |
identifier | ISSN: 1063-6927 |
ispartof | 2012 IEEE 32nd International Conference on Distributed Computing Systems, 2012, p.606-614 |
issn | 1063-6927 2575-8411 |
language | eng |
recordid | cdi_ieee_primary_6258033 |
source | IEEE Electronic Library (IEL) Conference Proceedings |
subjects | cloud server computing fair share scheduling Linux load balancing Load management multi-core scheduling Multicore processing Runtime Scheduling algorithms Servers |
title | Providing Fair Share Scheduling on Multicore Cloud Servers via Virtual Runtime-based Task Migration Algorithm |
url | https://sfx.bib-bvb.de/sfx_tum?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2025-01-04T10%3A13%3A33IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-ieee_6IE&rft_val_fmt=info:ofi/fmt:kev:mtx:book&rft.genre=proceeding&rft.atitle=Providing%20Fair%20Share%20Scheduling%20on%20Multicore%20Cloud%20Servers%20via%20Virtual%20Runtime-based%20Task%20Migration%20Algorithm&rft.btitle=2012%20IEEE%2032nd%20International%20Conference%20on%20Distributed%20Computing%20Systems&rft.au=Sungju%20Huh&rft.date=2012-06&rft.spage=606&rft.epage=614&rft.pages=606-614&rft.issn=1063-6927&rft.eissn=2575-8411&rft.isbn=1457702959&rft.isbn_list=9781457702952&rft.coden=IEEPAD&rft_id=info:doi/10.1109/ICDCS.2012.33&rft_dat=%3Cieee_6IE%3E6258033%3C/ieee_6IE%3E%3Curl%3E%3C/url%3E&rft.eisbn=9780769546858&rft.eisbn_list=0769546854&disable_directlink=true&sfx.directlink=off&sfx.report_link=0&rft_id=info:oai/&rft_id=info:pmid/&rft_ieee_id=6258033&rfr_iscdi=true |