Hierarchical Scheduling for Diverse Datacenter Workloads alig/papers/h-drf.pdf Hierarchical Scheduling

  • Published on

  • View

  • Download


  • Hierarchical Scheduling for Diverse Datacenter Workloads

    Arka A. Bhattacharya1, David Culler1, Eric Friedman2, Ali Ghodsi1, Scott Shenker1, and IonStoica1

    1University of California, Berkeley2International Computer Science Institute, Berkeley

    AbstractThere has been a recent industrial effort to developmulti-resource hierarchical schedulers. However, theexisting implementations have some shortcomings inthat they might leave resources unallocated or starvecertain jobs. This is because the multi-resource settingintroduces new challenges for hierarchical schedulingpolicies. We provide an algorithm, which we imple-ment in Hadoop, that generalizes the most commonlyused multi-resource scheduler, DRF [1], to support hi-erarchies. Our evaluation shows that our proposed algo-rithm, H-DRF, avoids the starvation and resource ineffi-ciencies of the existing open-source schedulers and out-performs slot scheduling.

    Categories and Subject DescriptorsD.4.1 [Process Management]: Scheduling;

    KeywordsMulti-resource, Data Center, Fairness

    1 IntroductionCloud computing frameworks tailored for managing andanalyzing big datasets are powering ever larger clustersof computers. Efficient use of cluster resources is an im-portant cost factor for many organizations, and the effi-ciency of these clusters is largely determined by schedul-

    Copyright 2013 by the Association for Computing Machinery, Inc.(ACM). Permission to make digital or hard copies of all or part of thiswork for personal or classroom use is granted without fee provided thatcopies are not made or distributed for profit or commercial advantageand that copies bear this notice and the full citation on the first page.Copyrights for components of this work owned by others than the au-thor(s) must be honored. Abstracting with credit is permitted. To copyotherwise, or republish, to post on servers or to redistribute to lists,requires prior specific permission and/or a fee. Request permissionsfrom permissions@acm.org.

    SoCC13, 13 Oct. 2013, Santa Clara, California, USA.ACM 978-1-4503-2428-1. http://dx.doi.org/10.1145/2523616.2523637


    ads (60%)

    prod (70%) test (30%)

    dev (40%)

    prod (50%) test (50%)

    Figure 1: Simple Organizational Hierarchy.

    ing decisions taken by these frameworks. For this rea-son, much research has gone into improving datacen-ter schedulers [2, 3, 4, 5, 6, 7, 8]. A key feature ofall production cloud schedulers is hierarchical schedul-ing, which enables scheduling resources to reflect orga-nizational priorities. Most production schedulers todaysupport hierarchical scheduling (e.g., Hadoop CapacityScheduler [6] and Hadoop Fair Scheduler [9]). As anexample of hierarchical scheduling, an organization (seeFigure 1) might dedicate 60% of its resources to the addepartment, and 40% to the dev department. Within eachdepartment, the resources are further split, for example70% for production jobs, and 30% for test jobs. The keyfeature of hierarchical schedulingwhich is absent inflat or non-hierarchical schedulingis that if some nodein the hierarchy is not using its resources they are re-distributed among that nodes sibling nodes, as opposedto all leaf nodes. For example, if there are no test jobs inthe ads department, those resources are allocated to prodjobs in that department. Most organizations that we havespoken toincluding Facebook, Yahoo, and Clouderause hierarchical scheduling to allocate resources accord-ing to organizational structures and priority concerns.

    Recently, there has been a surge of research onmulti-resource scheduling [10, 11, 12, 13]. It has beenshown that workloads in data centers tend to be di-verse [14], containing a mix of jobs that are CPU-intensive, memory-intensive, or I/O intensive [15, 16].Therefore, efficient scheduling in datacenters requirestaking multiple resource types into account. Otherwise,

  • the scheduler might make allocations based on irrelevantresources (e.g., CPU), ignoring the actual resource needsof jobs (e.g., memory), ultimately leading to poor per-formance isolation and low throughput for jobs. To han-dle multi-resource workloads, a new scheduler, calledDominant Resource Fairness (DRF), was recently pro-posed [1] and shipped with the open source resourcemanager Mesos [17]. Since DRFs introduction, a stringof follow-up papers have analyzed, improved, and ex-tended DRF [10, 11, 12, 13]. Unfortunately, DRF doesnot have support for hierarchical scheduling.

    The need for multi-resource scheduling with the addi-tional requirement of supporting hierarchical schedulingis crucial and has, therefore, led to an industrial effortto provide multi-resource hierarchical scheduling. TheCapacity scheduler [18] was rewritten for Hadoop Next-Generation (YARN) [19] to provide multi-resource DRFallocations. Furthermore, work is underway to extendthe Fair Scheduler to support DRF [20]. These effortshave been initiated and led by the companies Horton-Works and Cloudera independently of this work.

    However, the combination of hierarchical and multi-resource scheduling brings new challenges that do notexist in the traditional single-resource hierarchical set-ting, and are not fully addressed by these productionefforts. Naive implementations of multi-resource hierar-chical schedulers can lead to the starvation of some jobs,certain sub-trees in the hierarchy not receiving their fairresource share, or some resources being left unallocated(3). Identifying the shortcomings is a start, but comingup with an algorithm that avoids these pitfalls is a largerchallenge.

    In this paper we introduce an online multi-resourcescheduler, called H-DRF, that supports hierarchicalscheduling. H-DRF guarantees that each node in the hi-erarchy at least gets its prescribed fair share of resources,regardless of how others behave. We refer to this as thehierarchical share guarantee, which is an important iso-lation property. It implies that no job will starve, butalso that each group in the organization gets its allottedshare, two desirable outcomes not provided by other ap-proaches. Finally, H-DRF is group-strategyproof, whichmeans that no group of users can increase their usefulallocation as a whole by artificially inflating or changingtheir resource consumption. This property is trivially sat-isfied when there is a single resource, but becomes non-trivial to satisfy in multi-resource settings.

    We have implemented our H-DRF algorithm forHadoop 2.0.2-alpha (YARN) [21]. Evaluations showthat H-DRF outperforms the existing implementation ofthe Capacity Scheduler [6] in terms of efficiency andjob starvation. Also, through simulations on a Face-book cluster trace and example workloads on our pro-totype, we show that H-DRF outperforms hierarchical


    n1 (1)

    n1,1 (1)

    n2 (1)

    n2,1 (1) n2,2 (2)

    n2,2,1 (1)

    n2,3 (2)

    Figure 2: Example hierarchy, with node notation and weightsin parenthesis.

    slot schedulers by better packing of jobs and achieving ahigher throughput.

    2 BackgroundWe begin by providing background on hierarchicalscheduling and multi-resource fairness.

    2.1 Hierarchical SchedulingNotation. A hierarchical scheduler is configured witha weighted tree, such that each node in the tree has a pos-itive weight value (see Figure 2). The weights denote rel-ative importance and do not have to sum to 1. The leavesin the tree denote the jobs (or users)1 that are ultimatelyto be allocated resources, whereas the internal nodes rep-resent organizational or hierarchical groups. We assumeeach job/user submits a set of tasks, whose demands arenot necessarily known in advance.

    A node in the tree is denoted nL where L is a listof numbers that describe how the node can be foundwhen starting at the top of the tree and going down, leftto right. The root node of the tree is nr. For examplen2,1,4 is found by starting at the root, picking its sec-ond (from left) child, picking that childs first child, andthat childs fourth child. We denote the weight of nodenLs weight by wL. The parent of a node is given by P(),i.e., P(2,2,1) = 2,2. We write Pi(L) to refer to thei:th predecessor of node nL, i.e., P3(L) = P(P(P(L))).Similarly, the set of children of a node is given by C().We mostly only care about the set of nodes that are cur-rently demanding more resources. A leaf node is de-manding if it asks for more resources than are allocatedto it, whereas an internal node is demanding if any of itschildren are demanding. The function A() takes a set ofnodes in a tree and returns the subset of those nodes thatcurrently are demanding.

    Hierarchical Share Guarantee. The main idea be-hind hierarchical scheduling is to assign to each node inthe tree some guaranteed share of the resources. A nodein the hierarchy is entitled a fraction of resources from

    1We use the terms job and user interchangeably to denote a leafnode in the hierarchy

  • its parent proportional to the ratio of its weight to that ofits demanding siblings including itself. That is, a nodenL is guaranteed to get a fraction of resources from itsparent nP(L) of at least:

    wLiA(C(P(L))) wi

    In the example in Figure 2, assume there are 480 slots2

    in a cluster, and that all nodes are demanding. Then, n1and n2 should get 240 slots each, as they have the sameweight, 1. One level down, the children of n1 should geta number of slots from their parents allocation propor-tional to their weights, i.e., n2,1 should get 48 (= 240/5),while n2,2 and n2,3 should get 96 (= 2402/5) each.

    The above hierarchical share guarantee captures a keyfeature that hierarchical scheduling provides, called sib-ling sharing, which enables resources to stay withina sub-organization in the hierarchy when jobs finishwithin that sub-organization. Sibling sharing guaranteesthat if a node in the tree leaves, its resources are givento its demanding siblings in proportion to their weights.If it has no demanding siblings, the resources are givento its parent, which recursively gives it to the parentssiblings. For example, if all nodes are demanding andn2,3 leaves, then its 96 slots are split 32 and 64 to n2,1and n2,2, respectively. Unlike flat scheduling, nothing isgiven to n1 or its children, unless there are no demandingnodes in the subtree of n2.

    2.2 Dominant Resource Fairness (DRF)Many datacenters exhibit a diverse workload, contain-ing a mix of jobs that can be CPU-intensive, memory-intensive, or I/O intensive [15, 1]. A multi-resource fair-ness mechanism known as Dominant Resource Fairness(DRF) [1] introduced the concept of a jobs (users) dom-inant resource, which is the resource that the job needsthe highest share of. DRF seeks to equalize the dominantshares across all jobs (users) in a cluster. A jobs domi-nant share is simply the share of its dominant resourcethat it is currently allocated.

    For example, if a cluster has 100 GB of memory, and100 CPUs and each of a jobs task requires 3 GB ofmemory and 2 CPUs to run, memory is the jobs dom-inant resource because each of its tasks requires 3% ofthe entire cluster memory whereas it only requires 2%of the entire cluster CPUs.

    If the same cluster runs two jobs whose task require-ments are 3GB, 2CPUs, and 2GB, 3CPUs, each jobreceives a dominant share of 60100 = 0.6 (or 60%) asshown in Figure 3. This is unlike single-resource fair-ness, in which the sum of all jobs dominant shares can

    2A slot is a fixed fraction of a server, e.g., 1 core, 4 GB memory,and 10 GB disk [9].

    never be more than 1.0 (or 100%). We call this phe-nomenon of jobs having complimentary dominant re-sources leading to the sum of dominant shares beingmore than 1.0 as dovetailing.

    Note that one of the important aspects of multi-resource fairness, as identified in DRF [1], is that somejob might have zero demand for some resources. For in-stance, some jobs might not need to use GPUs or spe-cialized hardware accelerators. This is likely to increaseas more resources are accounted for by schedulers.

    Job 1

    Job 2

    Memory(100 GB total)

    CPU(100 CPUs total)




    40 GB 60 CPUs

    60 GB 40 CPUs

    Figure 3: DRF allocation shares for two jobs whose tasks havethe resource requirements shown in angular brackets. Note thatthe share of Job 2s dominant resource (CPU) is equal to theshare of Job 1s dominant resource (Memory)


    3 Hierarchical DRF (H-DRF)We first adapt the definition of static dominant share al-location in DRF [1] to support hierarchies (3.1). Weshall call such allocations Static H-DRF allocations.However, achieving the static H-DRF allocations in adynamic system is non-trivial. 3.2 and 3.3 describethe shortcomings of two existing approaches that couldbe used to achieve the static H-DRF allocations in adynamic setting Collapsed hierarchies and Naive H-DRF. Finally, we propose our solution Dynamic H-DRF in 3.4.

    Although we assume in this section, for simplicity,that all nodes have the same weight, our discussion canbe generalized to multiple weights in a straightforwardfashion (c.f., [1]).

    3.1 Static H-DRF AllocationsWe develop a static version of DRF to handle hierar-chies. The static definition is not meant to be used forscheduling, but rather to define the allocation. The dy-namic algorithm is instead used to schedule resources toachieve the static allocation.

    The main aim of static H-DRF allocations is to equal-ize the dominant resource share between each pair ofsibling nodes in the hierarchy. Given a set of nodes(jobs)

  • R = r1, ,rm . total resource capacitiesC = c1, ,cm . consumed resources, initially 0nr . root node in hierarchy treeC(n) . children of any node nP = P1(ni),P2(ni) . List of nis parentssi (i = 1. . .n) . node nis dominant shares, initially 0Ui = ui,1, ,ui,m (i = 1. . .n) . resources given to

    node ni, initially0

    P = /0ni = nrwhile resources exist to allocate more tasks do

    while ni is not a leaf node (job) doP = Pnin j = node with lowest dominant share s j in

    C(ni), which also has a task in its subtreethat can be scheduled using the currentfree resources in the cluster

    ni = n jDi = max j{Ti, j}Ti, s.t. Ti is nis task demand vectorC =C+Di . update consumed vectorfor each node k in niP do

    Uk =Uk +Di . update allocation vectorssk = maxmj=1{Ui, j/r j} . update Dominant

    Resource shares

    Algorithm 1: Static H-DRF Allocation

    with demands and a set of resources, static Hierarchi-cal DRF (H-DRF) starts with every job being allocatedzero resources, and then repeatedly increasing each jobsallocation with a thin sliver () of resources until nomore resources can be assigned to any node. The finalassignment constitutes the static H-DRF allocation forthe given nodes demands and total available resources.

    More precisely, at each moment, record the amountof resources assigned to each leaf node (job) in the hier-archy. Internal, non-leaf, nodes (sub-organizations) aresimply assigned the sum of all the resources assignedto their immediate children. Start at the root of the tree,and traverse down to a leaf, at each step picking the de-manding (c.f., 2.1) child that has the smallest dominantshare. In case of tie, randomly pick a node. Then allocatethe leaf node an amount of its resource demands, i.e.,the resource demand vector of that node is resized suchthat that nodes dominant share is increased by .3 Al-gorithm 1 shows pseudocode for how static allocationsare computed.

    For example, the H-DRF allocation for the hierarchyin Figure 4(a) can be computed as follows in a systemwith 10 CPUs and 10 GPUs. Node n1,1 is first assigned

    3e.g a if a node demands 1CPU,2GPU, with equal amounts ofboth resources in the cluster, the node is allocated 2CPU,GPU

    ,0. This makes n1s dominant share . Thereafter, n2is traversed, since it has a lower dominant share thann1, picking n2,1, which is assigned ,0. Next, n2,2 as-signed 0,. This puts n2 at ,, which gives it adominant share of . This process is repeated by as-signing tasks until some resource is completely ex-hausted, which in this case will be CPU. At this point,nodes n1,1 and n2,1 become non-demanding as they can-not be allocated more resources, as all 10 CPU re-sources have been allocated. Thereafter, the process con-tinues by assigning 0, tasks to n2,2 until all GPUshave been assigned. This defines the H-DRF alloca-tion to be 5 CPUs,0 GPUs to n1,1 and n2,1 each, and0 CPUs,10 GPUs to n2,2 (Figure 4(b) depicts the allo-cation).

    However, in a cluster, tasks finish and new ones arelaunched. Re-calculating the static H-DRF allocationsfor each of the leaves from scratch at the arrival of eachnew task is computationally infeasible. The followingsubsections will formulate an algorithm that achieves thestatic-HDRF allocations in such dynamic settings.

    3.2 First attempt: Collapsed HierarchiesOne well-known approach, which we call collapsed hi-erarchies [22], converts a hierarchical scheduler into aflat one. The idea is to take the hierarchical specifica-tion and compute what the corresponding weights foreach leaf node would be if the hierarchy was flattened.These weights are then used with a flat scheduler, suchas the original weighted DRF algorithm [1]. Each timejobs are added, removed, or change their demand-status,the weights are recalculated. For simplicity, we ignorehow recalculation is done as this approach breaks downeven without recalculation.

    This approach always works when only one resourceis involved. Interestingly, the approach fails to workwhen multiple resources are scheduled. In particular, itwill violate the hierarchical share guarantee for internalnodes in the hierarchy if they dovetail.

    Consider a slight modification to the example hierar-chy in Figure 4(a), where n1,1 instead wants to run taskswith demands 1 CPU, 1 GPU:


    n1 50%

    n1,1 1,1100%

    n2 50%

    n2,1 1,050% n2,2 0,150%

    The hierarchy is flattened by assigning to each nodea weight that corresponds to the product of its weightedshares in the hierarchy from the leaf to the root. Nodesn2,1 and n2,2 are each assigned 0.50.5 = 0.25, sincethey each are entitled to half of their parents allocation,

  • (a) Hierarchy with two organizations


    n1 50%

    n1,1 1 CPU,0 GPUs100%

    n2 50%

    n2,1 1 CPU,0 GPUs50% n2,2 0 CPUs,1 GPU50%

    (b) Static H-DRF allocation for (a)



    0% CPUs GPUs

    Job n1,1 50%

    Job n2,1 50%

    Job n2,2 100%

    Figure 4: Simple hierarchy and its static H-DRF allocation

    which is entitled to half of the cluster. Node n1,1 is simi-larly assigned 0.51.0 = 0.5. These weights accuratelycapture the share guarantee for each leaf node.

    We now run the original non-hierarchical DRF algo-rithm [1] configured with these weights and get the fol-lowing allocation:



    0% CPUs GPUs

    Job n2,1 33%

    Job n1,1 66%

    Job n2,2 33%

    Job n1,1 66%

    Since n1,1 has twice the weight of the rest of theleaves, DRF will increase its dominant share at twicethe rate of those other nodes. Both resources, CPU andGPU, will then saturate when n1,1 is allocated 23 of theCPUs and GPUs, and n2,1 and n2,2 are allocated 13 oftheir respectively demanded resource. While each leafnodes hierarchical share guarantee has been satisfied,the internal node n2 has only gotten 33% of resourcesas opposed to its entitled 50%, violating the hierarchicalshare guarantee.

    The above problem is new in the multi-resource set-ting. Consider a modification to the problem that turns itinto a single-resource problem. Assume that n2,2 wouldhave demanded 1 CPU,0 GPUs, thus making all jobsonly demand CPU:


    n1 50%

    n1,1 1,0100%

    n2 50%

    n2,1 1,050% n2,2 1,050%

    Then the above method would allocate 50% of theCPUs to n1,1, and 25% each to jobs n2,1 and n2,2, sat-isfying the hierarchical share guarantees for all nodes inthe hierarchy. The problem in the multi-resource settingis that dove-tailing of resource demands, i.e., that jobs

    have complementary resource demands (n2,1s 1,0 andn2,2s 0,1 in the example) punishes the parent nodes.

    3.3 Second Attempt: Naive H-DRF

    We now turn to a natural adaptation of the original DRFto the hierarchical setting and show that it can lead tostarvation. In particular, we show how the hierarchicalshare guarantee is violated for leaf nodes. In fact, thecurrent Hadoop implementations, which implement hi-erarchical DRF [18], take this approach and, hence, suf-fer from starvation as we show in the evaluation (5.2).Consider a dynamic algorithmwhich we call Naive H-DRFthat simply assigns a task in a similar mannerto how the static H-DRF allocation is computed eachtime resources become available i.e., traverse the treefrom root to leaf, at each step pick the demanding childwith smallest dominant share, until a leaf node (job) isreached and allocate one task to that leaf node.

    To see how starvation can occur, consider the examplehierarchy given in Figure 4(a), and assume 10 CPUs, 10GPUs, and three demanding leaf nodes.

    The algorithm will initially allocate 5 CPUs each ton1,1 and n2,1, and 10 GPUs to n2,2, as illustrated in Fig-ure 4(b). The problem occurs when when tasks finishand new ones are launched. Consider when job n2,1 fin-ishes a task, which has dimension 1 CPU,0 GPUs. Thedynamic algorithms traverses the tree, but notes that theinternal node n2 has a dominant share of 100% (10 GPUsout of 10 total). It will therefore pick n1 and finally al-locate a task to n1,1. This will repeat itself until job n2,1is completely starved and 10 CPUs have been allocatedto n1,1 and 10 GPUs to n2,2. At this point, the algorithmhas equalized and allocated a dominant share of 100%to each group n1 and n2, but has violated the hierarchi-cal sharing guarantee for node n2,2, which is allocatedzero resources. This leads to the following allocation:

  • 100%


    0% CPUs GPUs

    Job n1,1 100%

    Job n2,2 100%

    3.4 Our solution : Dynamic HierarchicalDRF

    We now derive the Dynamic Hierarchical DRF algo-rithm, H-DRF. We do so in two steps, combining twoideas that together achieve static H-DRF allocations, donot suffer from starvation, and satisfy the hierarchicalshare guarantee.

    Rescaling to Minimum Nodes. Starvation happens inthe Naive H-DRF algorithm because of the way the algo-rithm attributes resource consumption to internal nodes.In the example of Figure 4(b), node n2 is attributed tohave a dominant share of 100% since one of its jobs(n2,2) has a dominant share of 100%. Naive H-DRFkeeps punishing n2,1 as long as n2,2 has a higher dom-inant share than n1,1. We therefore change how resourceconsumption is attributed at internal nodes.

    To compute the resource consumption of an internalnode, proceed in three steps. First, find the demand-ing child with minimum dominant share, M. Second,rescale every childs resource consumption vector so thatits dominant share becomes M, i.e., each element of aresource consumption vector with dominant share D ismultiplied with MD . Third, add all the childrens rescaledvectors to get the internal nodes resource consumptionvector.

    Consider, for example, how n2s resource consump-tion vector is computed in the example given in Figure 4.First, the children of n2 have dominant shares 0.5 and1.0, respectively, yielding the minimum M = 0.5. Sec-ond, we rescale each childs whole resource consump-tion vector to have a dominant share of 0.5. This meansthat n2,1s vector is rescaled to 0.50.5 0.5,0 = 0.5,0.Similarly, n2,2 is rescaled to 0.51.00,1= 0,0.5. Third,the internal node n2s resource consumption is the sumof those vectors, i.e., 0.5,0.5, yielding a dominantshare of 0.5 for n2.

    The above method avoids the previously given star-vation scenario. Consider the allocation given by Fig-ure 4(b). If n2,1 finishes a task, it will be allocated a newtask since its dominant share will go below 50%, makingthe parents dominant share gothrough rescalingbelow 50% as well. Similarly, if any other job finishesa task, the resources are offered back to it.

    While rescaling helps the above example, it alone isnot enough to achieve static H-DRF allocations, as min-imization can give an unfair advantage to certain nodes

    as the following example shows. The hierarchy in Fig-ure 5(a) has the static H-DRF allocation given by Fig-ure 5(b). The first resource is the most demanded andwill saturate first. At that point, every leaf is allocated13 of its dominant share. Thereafter, only leaves n3,2 andn4,1 can still run more tasks, so the rest of the secondresource is split evenly between them.

    H-DRF with rescaling only (the algorithm describedthus far) will, however, yield the following allocation:



    0% CPUs GPUs

    Job n1,1 33%

    Job n2,1 33%

    Job n3,1 33%

    Job n4,1 33%

    Job n3,2 66%

    It allocates tasks similarly until the first resource be-comes saturated. But rescaling will always normalizen3,2s dominant share to that of n3,1, i.e., to 13 . As soonas another task is assigned to n4,1, n4s dominant sharewill be higher than n3s, resulting in all remaining GPUresources being repeatedly allocated to n3,2. Thus, in thefinal allocation n3,2 gets 23 of GPUs, while n4,1 gets only13 of the GPUs. We address this problem next.

    Ignoring Blocked Nodes. When rescaling to attributeinternal node consumption, dynamic H-DRF shouldonly consider non-blocked nodes for rescaling. A leafnode (job) is blocked if either (i) any of the resources itrequires are saturated, or (ii) the node is non-demanding,i.e., does not have more tasks to launch. Recall, that aresource is saturated when it is fully utilized. An inter-nal node is blocked if all of its children are blocked.The three aforementioned steps required to compute aninternal nodes resource consumption vector are modi-fied as follows. First, pick the minimum dominant share,M, among non-blocked nodes. Second, only every non-blocked nodes resource consumption vector is rescaledsuch that its dominant share is M. Third, all nodesblocked as well as non-blockedvectors are added toget the parents resource consumption vector. Further-more, we ignore saturated resources when computingthe dominant share of any internal node.

    The above modification will now ensure that the ex-ample in Figure 5(a) is correct, i.e., the algorithm willyield the static H-DRF allocation given in Figure 5(b).To see this, the algorithm will behave the same until thefirst saturation point, as there will be no blocked jobs.When the first resource saturates, every job has a domi-nant share of 13 . Since n3,1 is blocked on CPU, its dom-inant share will not be used during rescaling. Thus, n3sdominant share will thereafter be equal to n3,2s. There-fore, the remainder of GPUs will be equally allocatedto n3,2 and n4, yielding the static H-DRF allocation in

  • (a) Hierarchy for which rescaling breaks.



    n1,1 1,0


    n2,1 1,0


    n3,1 1,0 n3,2 0,1


    n4,1 0,1

    (b) Static H-DRF allocation for(a)



    0% CPUs GPUs

    Job n1,1 33%

    Job n2,1 33%

    Job n3,1 33%

    Job n4,1 50%

    Job n3,2 50%

    Figure 5: Hierarchy that breaks rescaling and its static H-DRF allocation. The demand vector i, j represents i CPUs and j GPUs.

    Figure 5(b).Just ignoring blocked nodes, without rescaling, will

    not be sufficient to achieve static H-DRF allocations.To see this, consider the example in Figure 4(a), wherejob n2,1 eventually gets starved because its resources aregiven to n1,1 in a dynamic system. Recall that the prob-lem was that the internal node n2 was attributed to have adominant share of 100%. Ignoring blocked nodes indeedwill ensure that n2,1 is not starved, as n2,2 is blocked, giv-ing n2 a dominant share equal to that of n2,1. If we, how-ever, modify the example so that n2,1 demands 1,, ig-noring blocked nodes alone will no longer suffice. Eachtime n2,1 finishes a task 1,, some amount of both re-sources is released. Thus, n2,2 is no longer blocked asthere are no saturated resources. Thus, n2s dominantshare will again be close to 100%. Rescaling will, how-ever, remedy the problem as n2,2 is scaled back to n2,1,ensuring that CPUs are split equally between n1,1 andn2,1.

    Final Dynamic H-DRF Algorithm Algorithm 2 putstogether the ideas that were derived in this section,i.e., naive H-DRF modified with rescaling to minimumnodes, and ignoring blocked nodes. It begins by recur-sively computing the rescaled dominant shares based onthe demanding leaves (Algorithm 3) and then applies thesame allocation procedure as in the static version basedon the rescaled dominant shares (Algorithm 4). Note thatthe recompilation of the rescaled dominant shares canbe simplified when the set of available resources has notchanged; however for simplicity of presentation we ig-nore this below.

    To compare the static and the dynamic H-DRF, con-sider a simple dynamic model of system behavior. Beginwith no resources assigned and run the dynamic H-DRFwhere tasks can complete at arbitrary times and when-ever there are resources available they are iteratively al-located according to dynamic H-DRF. We assume thattasks are small since allocations are done by small slices.We then compare dynamic H-DRF with the static alloca-tion at times when there are no excess resources, exceptthose which are not useful to any of the leaves. Under

    R = r1, ,rm . total resource capacitiesC = c1, ,cm . current consumed resourcesW resources to allocate . Assumption:RC >WY set of nonzero resources in WA (demanding), set of leaf nodes that use only re-sources in Y or parents of demanding nodesnr . root node in hierarchy treeC(n) . children of any node nsi (i = 1. . .n) . dominant sharesUi = ui,1, ,ui,m (i = 1. . .n) . resource

    consumption of node iRecompute s: U pdateS(nr)Allocate the resources: Alloc(W)

    Algorithm 2: Dynamic H-DRF Algorithm

    function (recursive) UpdateS(ni)if ni is a leaf node then

    si = maxUi j/R j for j Yreturn Ui

    elseQ = set of U js from UpdateS(n j) for children of

    nif = minimum dominant share from Q restricting

    to nodes in A and resources in YRescale demanding vectors in Q by fUi = sum of vectors in Qsi = maxUi, j/R j for j Y

    return UiAlgorithm 3: Dynamic H-DRF Rescaling Function

    this model, we can show the following.

    Theorem 1 Static H-DRF allocations agree with dy-namic H-DRF allocations whenever resources are fullyallocated.

    To see why this result holds, we first note that by themonotonicity of the static allocations of resources (dis-cussed in more detail after Theorem 2), for the initialallocation of resources, before any tasks complete, the

  • function Alloc(W)ni = nrwhile ni is not a leaf node (job) do

    n j = node with lowest dominant share s j inC(ni), which also has a task in its subtreethat can be scheduled using W

    ni = n jDi =

    Wimax j{Ti, j}Ti, s.t. Ti is nis task demand vector

    C =C+Di . update consumed vectorUi =Ui +Di . update leaf only

    Algorithm 4: Dynamic H-DRF Allocation Function

    dynamic and the static version algorithms are identical,as no rescaling is necessary.

    To complete the analysis we need to show that whena (very small) task completes it is reallocated to the leafthat completed it. It is clear that this occurs for any taskthat has the same set of resources as the last task allo-cated in the static H-DRF. It is also true for other com-pleted tasks.

    To see why, consider a leaf that was one of the first tobe blocked in the static H-DRF allocation by the com-plete allocation of a resource r. Define s to be the domi-nant resource shares for the nodes at that instant, s to bethe shares after the release of the task and s the sharesat the completion of the static H-DRF. Since the staticH-DRF allocation is monotonic, s s. However, if weconsider the final allocation under static H-DRF but as-sume that r is demanding, then by the rescaling rule thedominant resource shares will be s. This implies that sis smaller than s for all parents of the leaf that com-pleted the task and unchanged for all other nodes, whichimplies that the algorithm will allocate the task back tothe node that released it. One can apply this argumentinductively to show that it works in general.

    4 Allocation PropertiesThe previous section showed that a simple approach tosupporting hierarchies in DRF failed to provide certainguarantees and proposed H-DRF, which satisfies those.This section discusses several important properties of H-DRF and provides intuitions behind these properties.

    The reasoning of H-DRF will be based on the staticversion of H-DRF which is easier to analyze and aswe discussed in the previous section, the static and dy-namic versions of H-DRF lead to the same allocations.The key idea behind the analysis of the static H-DRFallocation procedure is that it can be viewed as a wa-ter filling algorithm, with multiple types of water andcarefully adjusted flow rates at each node. Then we usethe monotonicity of water filling, since as the algorithmruns, the allocation of leaf nodes is increased monotoni-

    cally. Since dominant shares are being equalized when-ever possible, the sooner a leaf becomes blocked thelower its dominant share will be.

    The static H-DRF algorithm does not depend onthe scaling of a leafs requirements, 3GB, 2CPUs istreated the same as 6GB, 4CPUs, so we can simplifyour analysis by assuming that the requirement for everydominant resource is 1 and also that the total amount ofeach resource is 1.

    4.1 Hierarchical Share GuaranteesIn the previous section we saw job starvation with naiveH-DRF and that both naive H-DRF and Collapsed Hier-archies violated the group guarantees for internal nodesin the hierarchy. The Hierarchical Share Guarantee (de-fined in Section 2) precludes such violations. We nowshow that static (and hence dynamic) H-DRF satisfiesthese.

    Theorem 2 Static H-DRF allocations satisfy the Hier-archical Share Guarantee property.

    This guarantee implies that the allocation satisfies theso-called Sharing incentive, which implies that everynode prefers the H-DRF allocation to splitting the en-tire system among the nodes. For example, given the hi-erarchy in Figure 4, both n1 and n2 prefer the H-DRFallocation to receiving half of the total resources.

    To see why this result is true, consider a modifiedproblem where we add a single additional resource withdemand 1 to all the leaves. Now, consider running thestatic algorithm until the first time where this resourceis fully utilized. At this instant it is easy to see recur-sively that every node has received exactly its hierarchi-cal share guarantee. Now, compare this allocation to thatwithout the extra resource. Until the point where the ex-tra resource is fully utilized, the allocations on the otherresources are unchanged. Thus, by monotonicity of thewater filling, each node will end up with as good or bet-ter an allocation than the modified one.

    4.2 Group StrategyproofnessSomewhat surprisingly, the original DRF [1] papershowed that in the multi-resource setting users can ma-nipulate schedulers by artificially using more resources.This is a problem that does not occur in single-resourcesettings, but is an important concern in the multi-resource setting.

    In the context of hierarchical scheduling, other ma-nipulations become natural. For example, users withinan organization could collude, coordinating their manip-ulations. To prevent these problems we require that theallocation mechanism satisfy group strategyproofness, ahierarchical extension of group strategyproofness.

  • Definition An allocation mechanism is group strate-gyproof if no group of users can misrepresent their re-source requirements in such a way that all of them areweakly better off4 and at least one of them is strictlybetter off.

    Theorem 3 H-DRF allocations satisfy group strate-gyproofness.

    To understand this result, again consider stopping thestatic H-DRF algorithm at the time where the first re-source becomes saturated. If one of the leaves that isblocked at this point were to decrease its requirement forsome of its non-dominant resources then the blockingtime would not change and that leaf would receive lessof the resources with the decreased requirements lead-ing to a decrease in number of jobs. Alternatively, theleaf node could try to increase its requirement for someof its non-dominant resources. Two cases are possiblein this scenario either this would not change the firstblocking time and the leaf would get more resources, butwould not be able to utilize them as their allocation oftheir dominant resource would be unchanged, or alterna-tively, one of these non-dominant resources might blockfirst, but then the leaf would get even less of their dom-inant resource. Thus we see that one of the first blockedleaves can not increase its allocation by lying about itsrequirements. One can also see that no group of firstblocked leaves can lie so that all get better allocationsby the same reasoning. Lastly, combining the recursivenature of the algorithm with the time monotonicity of thewater filling it is straightforward to show that the samereasoning applies to all leaves independent of their firstblocking time.

    4.3 Other propertiesThe previous sections covered the most important prop-erties of H-DRF. Here we briefly mention two otherproperties: recursive scheduling and population mono-tonicity.

    Recursive Scheduling.

    Definition Recursive scheduling: It should be possibleto replace any sub-tree in the hierarchy tree with anotherscheduler.

    Recursive scheduling is useful in many ways and al-lows one to modify a procedure by changing the algo-rithm on specified nodes of the tree. This allows any sub-organizations the autonomy to use alternative allocationrules e.g., FIFO, Fair, etc if they so wish.

    Theorem 4 H-DRF allocations satisfy Recursivescheduling.

    4By weakly better off we mean that no one is worse off.





    n2,11,1 n2,21,3

    Figure 6: Example showing that H-DRF does not satisfy pop-ulation monotonicity. The demand vector i, j represents iCPUs and j GPUs.

    The replacement of H-DRF at some internal nodewith some other allocation rule may clearly impact thesharing incentive and strategy proofness for all childrenof that node, but does not in the other parts of the tree.

    Population Monotonicity.

    Definition Population monotonicity: Any node exitingthe system should not decrease the resource allocationto any other node in the hierarchy tree.

    In other words, in a shared cluster, any job comple-tion should not affect the dominant resource share of anyother node or job. This is important because job comple-tions are frequent in a large cluster. Unfortunately, thisdoes not hold for H-DRF. But this is because populationmonotonicity is incompatible with the share guarantee.

    Theorem 5 H-DRF allocations do not satisfy Popula-tion monotonicity.

    Job n1



    0% CPUs GPUs

    30% 30%

    60% 40%

    Job n2,1 Job n2,2



    0% CPUs GPUs

    50% 50%

    50% 33%

    10% 30%

    Figure 7: Resource allocations to the leaf nodes in Figure 6,when all three leaf nodes - n1,1, n2,1 and n2,2 are demanding(left), and when only n1,1 and n2,1 is demanding (right)

    Thus, when a user or organization in the hierarchytree becomes non-demanding, other nodes may receive alower share of their dominant resource. Let us considerthe simple hierarchy shown in Figure 6. HDRF gives

  • n1 60% share of its dominant resource (CPUs) when allthree leaf nodes are demanding (Figure 7). If n2,2 were tobecome non-demanding, the dominant resource share ofn1 reduces to 50%, since both queues n1 and n2 now havethe same dominant resource. The intuition behind whyH-DRF is not population monotonic is that the dominantresource of an internal node might change when any ofits children nodes becomes non-demanding resulting inreduction of dovetailing.

    5 EvaluationWe evaluate H-DRF by deploying a prototype on a 50-server EC2 cluster running hadoop-2.0.2-alpha [21] andthrough trace-driven simulations. We modify hadoop-2.0.2-alpha to add support for GPUs as a resource.The H-DRF implementation in our prototype is single-threaded and centralized. H-DRF maintains a headroomequal to the size of the largest task on each server, toensure that large tasks do not get starved out.

    We first demonstrate fair sharing in H-DRF througha simple experiment. Then, we compare the perfor-mance of H-DRF to the Capacity Scheduler provided inHadoop [6]. Finally, we compare the job performancemetrics of H-DRF to that of hierarchical slot-based fairschedulers ( [9]) through an example workload on ourprototype, and through a simulation of a 10-day Face-book trace.

    Notation: Jobs are only submitted to the leaf nodes inthe shown hierarchies. Every job has the same resourcerequirements for all its tasks. In this section, the notationi, j,k denotes i GB of memory, j CPUs and k GPUs.

    5.1 Hierarchical Sharing



    n1,11,1,0 n1,21,0,1


    n2,11,1,0 n2,21,1,0

    Figure 8: Hierarchy to demonstrate the working of H-DRF andfair allocation of resources

    We illustrate fair share allocation by H-DRF on asimple example. Consider the hierarchy tree shownin Figure 8. We use 49 Amazon EC2 servers in thisexperiment, configuring hadoop to use 16GB memoryand 4 CPUs and 4 GPUs on each server. The weightsof parent nodes n1:n2 as 4:1. The weights for all othernodes are equal to 1. One long running job (2000 tasks)is submitted to each of the leaves in the hierarchy. Eachtask in the jobs submitted to n1,1, n1,2, n2,1 and n2,2 have






    200 300 400 500 600 700



    t Res


    e Sh


    Time (s)

    n-{1,1} n-{1,2} n-{2,1} n-{2,2} n1,1 n1,2 n2,1 n2,2

    Figure 9: Resource sharing between the leaf nodes shown inFigure 8

    resource requirements 1,1,0, 1,0,1, 1,1,0 and1,1,0 respectively. Thus, the dominant resource ofn1,1, n2,1 and n2,2 is CPU, while the dominant resourceof n1,2 is GPU. Figure 9 shows the dominant shareallocated by H-DRF to the various leaf nodes in thehierarchy across time. Between 200-300s all leaf nodesare active. The job submitted to n1,1 ends at 350s, n2,2 at400s, n2,1 at 550s and finally n1,2 at 600s.

    Weighted proportional fair sharing of dominantresources: The 4:1 ratio of weights between n1 and n2requires that all children of n1 combined should receive0.8 share of the cluster. When all four leaf nodes inthe hierarchy are active (between 200-300s), this isindeed the case. n1,1 gets 0.8 share of the CPUs (itsdominant resource) , while n2,1 and n2,2 receive a shareof 0.1 each, making the total share of CPUs receivedby parent n2 0.2 ( i.e., exactly 1/4th that of n1). Thus,H-DRF delivers proportional dominant resource sharingbetween all sibling nodes in this hierarchy. Also notethat instead of n1,2 receiving a 0.8 share of the GPUs inthe cluster (its dominant resource), it receives a share of1.0 because no other node in the hierarchy is contendingfor the clusters GPUs. All the CPUs and GPUs in thecluster consumed by tasks demonstrates that H-DRFachieves a pareto-efficient5 allocation.

    Normalization in H-DRF: n1,2s dominant share of1.0 does not affect the sharing between n1,1, n2,1 andn2,2. H-DRF normalizes the share of n1,2 to 0.8 tocalculate the total allocation vector of n1.

    5pareto efficiency implies that no node in the hierarchy can be al-located an extra task on the cluster without reducing the share of someother node

  • Sharing of resources between sibling queues: Oncen1,1 completes at 300s, its resources are taken over byn2,1 and n2,2, taking their dominant resource (CPU)share to 0.5 each. The share of n1,2 remains 1.0 becausenone of the other nodes require GPUs. This demon-strates the sibling sharing property where a node canincrease its share to take advantage of a non-demandingsibling. This property is also exhibited when n2,2finishes at 400s, and n2,1 increases its share to use allthe CPUs in the cluster.

    5.2 Comparison to existing Hadoop multi-resource schedulers



    n1,1 n1,2


    n2,1 n2,2 n2,3



    Figure 10: Hierarchy used in 5.2

    In this section, we show that starvation does indeedoccur when current open-source schedulers are used.We do so by running a workload and comparing theperformance of the H-DRF prototype implementationto the Capacity scheduler implemented in Hadoop2.0.2-alpha [6]. The Capacity scheduler performshierarchical multi-resource scheduling in Hadoop in themanner described in 3.3. Our cluster consists of 50Amazon EC2 servers, each configured to have 6 GBmemory, 4 CPU cores and 1 GPU (Total 300GB, 200cores and 50 GPUs). We run three schedulers - (i) anunchanged implementation of the Capacity Scheduler(henceforth named C.S-Current, and which is not paretoefficient), (ii) the pareto-efficient implementation of thesame scheduler (Pareto-Efficient-C.S) and (iii) H-DRF,on the same workload and compare throughput and jobresponse times.

    Hierarchy Tree: The hierarchy tree chosen for this ex-periment is based on typical hierarchies seen by Cloud-era, a cloud-based company with hundreds of customersrunning hierarchical scheduling, and is shown in Figure10.

    Input Workload: The input job schedule has thesame job size distribution as a 10-day Facebook trace(collected in 2010). Table 1 shows the job sizes of theinput job schedule in our experiment and the Facebooktrace. We create a 100-job schedule by sampling job

    sizes6 from the enterprise trace. If the sampled job hasmemory as its dominant resource in the Facebook trace,it is configured to use 1.5 GB memory per task, else itis configured to use 1 GB memory per task. All jobsrequest one CPU core and no GPUs per task, except thejobs submitted to n1,2 which request one GPU core andno CPU. The 100 jobs are divided into six groups to besubmitted to each of the leaf nodes in the hierarchy. Theten large jobs (>500 tasks) are divided between nodesn1,1, n1,2 and n3,1, while the smaller jobs (

  • (a) Throughput of leaf nodes under the current implementation of the Capacity Scheduler (C.S-Current),Capacity Scheduler modified to be Pareto-efficient(Pareto-Efficient-C.S), and H-DRF for the hierarchytree in Figure 10.



    6 11 6




    9 14 8

    84 79

    21 9 14 7













    ks ru


    g sim




    Leaf Nodes

    Pareto-Efficient C.S HDRF C.S-Current

    n1,1 n1,2 n2,1 n2,2 n2,3 n3,1



    (b) Percentage Improvement in Job Response Times on using H-DRF as compared to C.S-Current andPareto-Efficient-C.S









    6 16 31 10









    % Im



    t in






    Leaf Nodes

    Pareto-Efficient C.S C.S-Current



    n1,1 n1,2 n2,1 n2,2 n2,3 n3,1

    Figure 11

    C.S-current stops scheduling tasks of n1,2 (which usesGPUs) even though there are enough resources in thecluster for it to increase its share. Thus, n1,2, whosedominant resource share is 21/50 = 0.42, is pinneddown to roughly the dominant resource share of n1,1(dominant share of 79/200 0.40) (see Figure 11a).H-DRF, on the other hand, is Pareto-efficient and allowsn1,2 to increase its dominant share beyond that of n1,1.The throughput of the remaining nodes are roughlyequal for both schedulers. H-DRF improves its jobresponse times for n1,2 by almost 250% on the average(Figure 11b). 9

    Comparison against Pareto-Efficient-C.S: We thenmodified C.S-Current to enable pareto-efficiency byadding support for non-usage of an available resource,by removing task reservations on servers, and by con-tinuing scheduling tasks if there exists leaf nodes thatdo not demand the saturated resources. On each serverwe maintain a headroom equal to the resources requiredby the largest task10 to ensure that a task with large re-source demands does not get starved out by tasks with

    9Note that C.S-current behaves exactly like H-DRF and is pareto-efficient when every task uses at least some portion of every clusterresource.

    10In this case 1.5,1,1

    smaller demands (the reason for task reservations in theC.S-Current). Figure 11a shows that in Pareto-Efficient-C.S (which is now exactly the naive H-DRF techniquein 3.3), n1,2s share increases beyond its siblings shareto use almost all the GPUs in the cluster. However, theincrease in n1,2s share also increases the dominant re-source share of its parent node n1 to 1.0. In an attempt toraise n2 and n3s dominant share to match that of n1,Pareto-Efficient-C.S allocates any new CPU cores va-cated by a finishing task of n1,1 to a leaf node of n2 orn3. The starvation of n1,1 gets so dire that its medianthroughput in Pareto-Efficient-C.S drops to just 1 task,with its fair share being divided among the remainingleaf nodes. The increased share for the leaf nodes of n2and n3 leads to an improvement in their job responsetimes over H-DRF. n1,1 only achieves its fair share onceall jobs of n1,2 finish, resulting in H-DRF finishing jobs413% faster.

    5.3 Comparison to hierarchical slot-basedFairness: Prototype and SimulationResults

    Slot-based schedulers divide a servers resources equallyinto a pre-defined number of slots, and assign one taskto each slot with the objective of equalizing the num-ber of tasks allocated to any pair of sibling nodes. As-

  • signing a task to a slot without enforcing that the tasksresource requirements be lesser than the slot size, canlead to under or over-subscription of server resources de-pending on the slot count per server and the task sizes (asshown in [1]). Over-subscription of memory on a servermay lead to thrashing which will dramatically reducethroughput and job response times. In section 5.3.1 wequantify the benefits of H-DRF over slot-based sched-ulers through our prototype implementation, and in sec-tion 5.3.2 through simulation.

    5.3.1 Prototype results

    0 4 33



    129 112



    289 275







    0-20 20-149 150-499 >500

    % Im



    t in






    Bins (# Tasks)

    4 Slots 5 slots 6 slots

    Figure 12: Improvement of average job response times by H-DRF against hierarchical slot-based scheduling on our imple-mented prototype

    We use a 50-server Amazon EC2 cluster, each serverhaving 7 GB memory and 8 CPUs. We configure eachserver to use 6 GB of memory ( leaving 1 GB to beused by the Operating System). Each server is config-ured to behave as having 4 CPUs and 4 GPUs. We usethe same job schedule and node hierarchy as the previoussection (5.2) and use the same definition of percentageimprovement in job response time, except that we setthe weight of n3 to 2 in each run. We compare H-DRFagainst three possible configurations of the hierarchicalslot scheduler - with 4, 5 and 6 slots per server.

    The job schedule completes execution in 1379 , 1446,1514 and 1732 seconds for H-DRF, 4-slot, 5-slot and 6-slot scheduling respectively. Figure 12 shows the per-centage improvement in job response times obtainedby H-DRF over slot scheduling. H-DRF can more effi-ciently pack jobs in a cluster, ensuring superior through-put and resulting in jobs finishing quicker. The 4-slotcase gets worse for larger jobs because its through-put is lower than that of H-DRF. Since small jobs fin-ish in a single wave, the increased throughput in H-DRF does not play a significant role in the comparisonagainst 4-slots. From 5-slots onwards, small jobs (a ma-jority of which use 1.5 GB memory for each of their

    tasks) encounter thrashing due to the slot scheduler over-committing the amount of memory on the server. The 6-slot scheduler also encounters thrashing for smaller jobs,but by virtue of packing more tasks per server, its perfor-mance improves for larger jobs.

    5.3.2 Simulation results

    83 82 80 80

    68 67 65 64

    48 47 47 44







    0-20 20-149 150-499 >500 %



    ent i

    n Jo

    b Re




    e Bins (# Tasks)

    10 slots 12 slots 14 slots

    Figure 13: Improvement in job response times of H-DRFagainst hierarchical slot-based scheduling while simulating theFacebook trace

    We also use a trace-driven simulator to compare H-DRF to slot scheduling. We use the same configurationas reported in [23]. The input to the simulator was a10-day trace from a 2000-server cluster at Facebook.We simulate the trace on a 1200-node cluster in orderto achieve high utilization and make fairness a relevantconcern. The simulator re-creates the exact resource us-age and time taken by each job in the Facebook trace.

    In the trace, we found that memory requirements ofeach job could vary up to 9 GB, and CPU requirementsup to 3 cores. Each server was configured to have 32GB memory, 16 CPUs, in addition to which 200 of theservers had 16 GPUs. We use the same hierarchy asshown in Figure 10. Each leaf node was assumed to have25 users submitting a mixed workload (small jobs andlarge jobs), with inter-arrival times sampled from theFacebook trace. The time of submission of a job waskept the same across all the experiments. If jobs gotqueued at a leaf node, they were served in a first-in-first-out manner. The simulation was stopped at 604800 sec-onds (or 1 week) , and the improvement in job responsetime achieved by H-DRF among completed jobs as com-pared to the slot scheduler with 10, 12 and 14 slots wascomputed. As shown in Figure 13, H-DRF improved theresponse times over hierarchical slot scheduling by 44-83% by achieving higher utilization.

  • 6 Related WorkOur work builds on the notion of Dominant ResourceFairness [1]. DRF guarantees multi-resource fairnessonly for non-hierarchical systems, and has been ex-tended to other non-hierarchical settings such as in[10, 11, 12, 13]. H-DRF extends the concept of Dom-inant Resource Fairness to the hierarchical setting, andprovides new properties such as group-strategy proof-ness.

    Hierarchical scheduling has been studied in manyfields of Computer Science such as in networking [24]to allocate bandwidth between different classes of flows,in Operating Systems [25, 26] to support isolation andperformance guarantees to different classes of applica-tions. Ensuring storage performance requirements fordifferent sub-organizations in a company arranged in ahierarchical fashion has been studied in [27]. Hierar-chical scheduling has also been studied in grid com-puting for multi-grid resource allocation and manage-ment [28, 29]. Hierarchical schedulers such as Fair [9]and Capacity [6] have been implemented in Hadoop. TheHadoop Fair scheduler assigns resources at the slot gran-ularity, which might lead to underutilization or oversub-scription of resources on a server. H-DRF considers mul-tiple resources during its allocation decisions, and henceavoids these issues.

    Finally, the Hadoop Next-Generation (YARN) [19]has recently added multi-resource DRF support to itsCapacity scheduler [18]. Furthermore, there is a recentJIRA from Cloudera on implementing a new DRF-basedfair scheduler [20]. As we showed in our evaluation,the hierarchical implementation of DRF in YARN canleave resources unallocated and sometimes starve jobs.Our implementation of H-DRF in YARN does not sufferfrom these problems.

    7 Conclusion and Future WorkHierarchical scheduling is an essential policy that issupported by most cloud schedulers. Recently, multi-resource fairness has emerged as an important additionalrequirement for job scheduling to deal with heteroge-neous workloads. For this reason, industry has devel-oped two separate hierarchical schedulers for HadoopYARN. Unfortunately, we show that they suffer from ei-ther job starvation or leave some resource unallocateddespite demand. This is because multi-resource fairnessintroduces new challenges for hierarchical scheduling.We have proposed H-DRF, which is a hierarchical multi-resource scheduler for Hadoop. Our evaluation showsthat it outperforms the traditional slot scheduling, anddoes not suffer from starvation and inefficiencies.

    H-DRF presents several areas for future research.First, H-DRF does not deal with issues arising out of

    task placement constraints. The notion of dominant re-source fairness under placement constraints is still anopen question. Second, H-DRFs allocation vector up-date step may require recomputing the dominant sharesof every other node in the hierarchy. This might be com-putationally expensive in a hierarchy with a large num-ber of nodes. Third, pre-emptions could be added toH-DRF to enable nodes achieve their dominant sharesfaster.

    8 AcknowledgmentsWe would like to thank Ganesh Ananthanarayananand our shepherd Ajay Gulati for their valuable feed-back. This research is supported in part by NSF CNS-1161813, NSF CNS-0931843, NSF CISE Expeditionsaward CCF-1139158, DARPA XData Award FA8750-12-2-0331, National Science Foundation under GrantsCNS-0931843 (CPS-ActionWebs) and gifts from Ama-zon Web Services, Google, SAP, Cisco, Clearstory Data,Cloudera, Ericsson, Facebook, FitWave, General Elec-tric, Hortonworks, Intel, Microsoft, NetApp, Oracle,Samsung, Splunk, VMware and Yahoo!

    References[1] A. Ghodsi, M. Zaharia, B. Hindman, A. Konwin-

    ski, I. Stoica, and S. Shenker. Dominant resourcefairness: Fair allocation of multiple resource types.In NSDI, 2011.

    [2] Michael Isard, Vijayan Prabhakaran, Jon Currey,Udi Wieder, Kunal Talwar, and Andrew Goldberg.Quincy: Fair scheduling for distributed computingclusters. In SOSP, 2009.

    [3] Matei Zaharia, Dhruba Borthakur, JoydeepSen Sarma, Khaled Elmeleegy, Scott Shenker,and Ion Stoica. Delay Scheduling: A SimpleTechnique for Achieving Locality and Fairness inCluster Scheduling. In EuroSys, 2010.

    [4] T. A. Henzinger, A. V. Singh, V. Singh, T. Wies,and D. Zufferey. Static scheduling in clouds. InHotCloud, June 2011.

    [5] Matei Zaharia, Andy Konwinski, Anthony D.Joseph, Randy Katz, and Ion Stoica. ImprovingMapReduce Performance in Heterogeneous Envi-ronments. In Proc. OSDI, December 2008.

    [6] Hadoop Capacity Scheduler. http://hadoop.apache.org/docs/current/hadoop-yarn/


    [7] Malte Schwarzkopf, Andy Konwinski, MichaelAbd-El-Malek, and John Wilkes. Omega: flexi-ble, scalable schedulers for large compute clusters.

  • In Proceedings of the 8th ACM European Confer-ence on Computer Systems, pages 351364. ACM,2013.

    [8] Alexey Tumanov, James Cipar, Gregory R Ganger,and Michael A Kozuch. alsched: Algebraicscheduling of mixed workloads in heterogeneousclouds. In Proceedings of the Third ACM Sympo-sium on Cloud Computing. ACM, 2012.

    [9] Hadoop Fair Scheduler. http://hadoop.apache.org/common/docs/r0.20.2/fair_scheduler.html.

    [10] Carlee Joe-Wong, Soumya Sen, Tian Lan, andMung Chiang. Multi-resource allocation: Fairness-efficiency tradeoffs in a unifying framework. InINFOCOM, pages 12061214, 2012.

    [11] Avital Gutman and Noam Nisan. Fair AllocationWithout Trade. In AAMAS, June 2012.

    [12] David C. Parkes, Ariel D. Procaccia, and NisargShah. Beyond Dominant Resource Fairness: Ex-tensions, Limitations, and Indivisibilities. In ACMEC, 2012.

    [13] Ali Ghodsi, Vyas Sekar, Matei Zaharia, and IonStoica. Multi-resource fair queueing for packetprocessing. In SIGCOMM, 2012.

    [14] Charles Reiss, Alexey Tumanov, Gregory R.Ganger, Randy H. Katz, and Michael A. Kozuch.Heterogeneity and dynamicity of clouds at scale:Google trace analysis. In ACM Symposium onCloud Computing (SoCC), San Jose, CA, USA,October 2012.

    [15] Bikash Sharma, Ramya Prabhakar, Seung-HwanLim, Mahmut T. Kandemir, and Chita R. Das.Mrorchestrator: A fine-grained resource orchestra-tion framework for mapreduce clusters. In IEEECLOUD, pages 18, 2012.

    [16] R. Boutaba, L. Cheng, and Q. Zhang. On cloudcomputational models and the heterogeneity chal-lenge. J. Internet Services and Applications,3(1):7786, 2012.

    [17] B. Hindman, A. Konwinski, M. Zaharia, A. Gh-odsi, A. D. Joseph, R. H. Katz, S. Shenker, andI. Stoica. Mesos: A platform for fine-grained re-source sharing in the data center. In NSDI, 2011.

    [18] YARN DRF extension to the Capacity Scheduler.https://issues.apache.org/jira/browse/YARN-2.

    [19] The Next Generation of Apache Hadoop MapRe-duce. http://developer.yahoo.com/blogs/hadoop/posts/2011/02/mapreduce-nextgen.

    [20] YARN DRF extension to the Fair Scheduler.https://issues.apache.org/jira/browse/YARN-326.

    [21] Hadoop Yarn 2.0.2-alpha. http://hadoop.apache.org/docs/current/.

    [22] Abhishek Chandra and Prashant Shenoy. Hierar-chical scheduling for symmetric multiprocessors.IEEE Transactions on Parallel and DistributedSystems, 19:418431, 2008.

    [23] Ali Ghodsi, Matei Zaharia, Benjamin Hindman,Andrew Konwinski, Scott Shenker, and Ion Stoica.Dominant resource fairness: Fair allocation of mul-tiple resource types. Technical Report UCB/EECS-2011-18, EECS Department, University of Califor-nia, Berkeley, Mar 2011.

    [24] Jon C. R. Bennett and Hui Zhang. Hier-archical packet fair queueing algorithms. InIEEE/ACM Transactions on Networking, pages143156, 1997.

    [25] Pawan Goyal, Xingang Guo, and Harrick M. Vin.A Hierarchical CPU Scheduler for Multimedia Op-erating Systems. In OSDI, pages 107121, 1996.

    [26] C. A. Waldspurger. Lottery and Stride Schedul-ing: Flexible Proportional Share Resource Man-agement. PhD thesis, MIT, Laboratory of Com-puter Science, September 1995. MIT/LCS/TR-667.

    [27] Ajay Gulati, Ganesha Shanmuganathan, XuechenZhang, and Peter Varman. Demand based hierar-chical QoS using storage resource pools. In Pro-ceedings of the Annual USENIX Technical Confer-ence, 2012.

    [28] Volker Hamscher, Uwe Schwiegelshohn, AchimStreit, and Ramin Yahyapour. Evaluation of job-scheduling strategies for grid computing. In GridComputingGRID 2000, pages 191202. Springer,2000.

    [29] V. Subramani, R. Kettimuthu, S. Srinivasan, andS. Sadayappan. Distributed job scheduling on com-putational grids using multiple simultaneous re-quests. In High Performance Distributed Com-puting, 2002. HPDC-11 2002. Proceedings. 11thIEEE International Symposium on, pages 359 366, 2002.