Thermal Aware Automated Load Balancing For HPC Applications
Thermal Aware Automated Load Balancing for HPCApplicationsHarshitha Menon, Bilge Acun, Simon Garcia De Gonzalo, Osman Sarood and Laxmikant KaléDepartment of Computer ScienceUniversity of Illinois at Urbana-Champaign, Urbana, IllinoisE-mail: {gplkrsh2, acun2, grcdgnz2, sarood1, kale}@illinois.eduAbstract—As we move towards the exascale era, power andenergy have become major challenges. Some of the supercomputers draw more than 10 megawatts, leading to high energy bills.A significant portion of this energy is spent in cooling. In thispaper, we propose an adaptive control system that minimizes thecooling energy by using Dynamic Voltage and Frequency Scalingto control the temperature and performing load balancing. Thisframework, which is a part of the adaptive runtime system,monitors the system and application characteristics and triggersmechanism to limit the temperature. It also performs loadbalancing whenever imbalance is detected and load balancingis beneficial. We demonstrate, using a set of applications andbenchmarks, that the proposed framework can control thetemperature of the cores effectively and reduce the timing penaltyautomatically without any support from the user.Keywords—energy consumption, load balancing, run-time system, dvfs, automated, parallel applicationsI.I NTRODUCTIONWith the move towards exascale, power and energy consumption have become important issues in high performancecomputing. Recent studies show that HPC systems are drawingenormous amounts of electrical power. In the U.S., data centersuse 59-megawatt hours of electricity per year, which costs4.1 billion dollars and generates 864 million metric tons ofcarbon dioxide emissions [1]. Exascale computing systems areexpected to draw in power ranging from 60-130 megawattsin 2016-2018 [2]. The increase in the number of cores andclock speed results in heat generation and increase in coretemperatures. This makes the hardware more vulnerable toboth transient and permanent faults. Therefore, cooling isnecessary to prevent overheating of the core. However, coolingalso takes large amounts of energy. 40% to 50% of the energyconsumed by a data center is spent in running the computerroom at a low temperature [3].In order to reduce the cooling energy, the computerroom air conditioning (CRAC) temperature can be set at ahigher value. But this will result in high ambient temperatureand possible overheating of the cores. To avoid overheating,modern day microprocessors are equipped with an on-chiptemperature sensor and mechanisms to control the dynamicvoltage and frequency using DVFS. Dynamic voltage andfrequency scaling, DVFS, is commonly used to reduce powerand the amount of heat generated by the chip by adjustingthe frequency of the microprocessor. Running a processor ata lower frequency reduces the amount of heat generated andconserves power. Therefore, setting a high CRAC temperature978-1-4799-0898-1/13/ 31.00 c 2013 IEEEand controlling the chip temperature using DVFS can be apossible solution to reduce the cooling energy, which accountsfor a significant part of the power consumption.However, using DVFS to control temperature has its drawbacks. Reducing the frequency may incur a timing penalty.Since the processors may overheat at different times, theymay be running at different frequencies. The timing penaltyis not just due to the lower frequency but also due to theload imbalance created by the different processor speeds.In HPC applications, where there is an interdependence oftasks across processors, if one processor is slowed down, theentire application may consequently be slowed down. Even ifthere are no such dependencies, there will be load imbalancebetween the processors. As a result, decreasing the frequencywill result in degradation of performance and increase inthe total execution time. In order to minimize the timingpenalty, load balancing can be employed to improve the systemutilization. This technique has been shown to be effective inreducing the cooling energy [4], [5].In a recent work [4], a temperature-aware dynamic loadbalancing strategy was proposed which controls the chiptemperature using DVFS and uses load balancing to reducethe timing penalty. This scheme performs periodic temperaturechecks, applies DVFS on cores that are hotter or colder thanthe threshold temperature and invokes the load balancer. Thisapproach puts the burden on the application programmer tospecify the period to control the temperature and invoke theload balancer. If the user performs frequent temperature checksand load balancing, it may lead to loss of performance due tooverhead. But if the user specifies long interval to check andload balance, then the temperature of the core may exceedthe specified temperature threshold leading to overheating.Moreover, invoking a load balancer also incurs overhead. Thus,if the user invokes the load balancer frequently, then theoverhead of load balancing may exceed the benefit. But ifthe load balancer is invoked infrequently, then it may result inloss of performance due to load imbalance. Putting the burdenon the user to specify an ideal temperature check and loadbalancing period may be inefficient.In this paper, we propose a framework, MetaTempController, which will automatically control the temperatureof cores and perform load balancing without any supportfrom the user. In this framework, which will be a part ofthe adaptive runtime system, the run time system will monitor the application characteristics and the core temperaturesasynchronously. To minimize the cooling energy we increase
the CRAC temperature, use DVFS to limit the processortemperature and perform load balancing automatically basedon the information collected by the runtime system. This workextends the cool load balancer approach [4] and builds uponon the concept of an automated load balancing framework [6].The key contributions of this paper are: We introduce a generic technique that can be used toautomatically control the temperature of the processors and avoid hot-spots. We demonstrate that our dynamic technique has lesstiming penalty and can be used with a wide range ofapplications having different characteristics. We present an implementation of our concept asMetaTempController in C HARM runtime systemwhich executes in the background and is transparentto the application programmer.II.BACKGROUNDOur approach to saving cooling energy involves setting ahigh CRAC temperature value. But to prevent overheating andformation of hot spots, we use DVFS to control the temperatureof each chip. In order to efficiently control the temperature andminimize the timing penalty, we rely on an adaptive runtimesystem with the capability for load balancing. We chose theC HARM parallel programming system for this purpose.A. Charm and its Load Balancing FrameworkC HARM [7] is a message driven parallel programmingmodel which has parallel entities called objects or chares.Chares form the basic unit of computation. Programmer divides the computation into chares which are distributed amongprocessors by the runtime system. It hinges on the idea of overdecomposition, i.e. dividing the problem into more work unitsthan the total number of processors in the system. In turn, thisover-decomposition improves the performance by overlappingcommunication and computation. Each of these tasks or charesis a migratable C object that can reside on any processor andcan be migrated to any processor. This migratable nature ofchares provides the capability for load balancing. When thereis an imbalance of load, migrating the objects from overloadedprocessors to underloaded processors helps achieve balanceand improve the performance of the application. C HARM runtime system records the computation load and the communication pattern of these chares and use this information forload balancing. The load balancing framework in C HARM isbased on a heuristic known as the principle of persistence [8]which states that the recent past is a good indication of thefuture. C HARM provides the application programmer witha suite of load balancers and the capability to add new customload balancing strategies. These load balancers can be easilyplugged in to the application at runtime. The key advantage ofthis approach is that it is application independent.B. Temperature Control using DVFSDynamic voltage frequency scaling (DVFS) is a widelyused technique to automatically adjust the frequency of aprocessor either to conserve power or to reduce the amount ofheat generated. Several manufacturers have developed processors capable of global dynamic frequency and voltage scaling.This ability can be used to conserve energy using the simpleprinciple that the frequency and power are directly proportionalto the minimum operational voltage, which is also proportionalto the square of voltage.Algorithms using DVFS have shown dramatic energy savings while providing the necessary peak computation power ingeneral-purpose systems [9]. Fine-grained DVFS has emergedas a popular way for designers to exploit growing transistorbudgets [10] in chip-multiprocessors (CMPs). The decrease intemperature allows the system to decrease the power dedicatedfor cooling or, if possible, to be turned off entirely increasingthe overall system power savings.However, reducing the frequency level slows down thecomputation. Ideally, DVFS techniques are used to manage thefrequency and/or voltage so as to provide the minimum speedthe processor needs to manage its workload while maintainingcomputational time constraints or throughput constraints andthereby reducing its energy consumption [11].III.R ELATED W ORKMinimizing energy consumption has become an importantsubject for research in HPC. Cooling energy optimizationshave been primarily addressed for data centers [12], [13].In general, these techniques involve placing the most heatgenerating jobs in the coolest areas of the data center. This particular solution can not be applied to our current work becausedifferent tasks in a HPC application behave very similarly andthus consume the same amount of energy and produce the sameamount of heat. Another approach to reducing total energyconsumption presented in [14] limits the temperature of thecores by turning the different nodes on and off as needed.This solution is problematic when applied to HPC because ofthe high interdependence between tasks, and the time penaltyin execution time it would incur.In HPC, controlling CPU frequency and voltage to reducethe energy have been studied before. For example, a previouswork showed significant energy savings by using DVFS tochange the frequency of the cores during the communicationphase of an MPI application [15]. The major drawback ofthis approach is the time penalty incurred in the executiontime of the application. Another interesting work proposedin [16] creates a schedule for when DVFS should be run fora particular HPC application. The schedule tries minimize thetiming penalty for a given power limit. In [17] a kernel-levelDVFS governor is proposed that would try to determine anoptimal frequency for a particular workload.The closest work to the present paper is the ‘Cool’ loadbalancer by co-author Sarood [4]. In that work, an approachwas proposed for saving cooling energy by constraining coretemperature while minimizing the associated timing penaltyusing task migration. It uses DVFS and a temperature-awareload balancer to achieve this task. Although this scheme hasshown substantial energy reduction for HPC applications at thecost of some modest timing penalty in the computation time,it relies on the user to specify a fixed period for temperaturecheck and load balancing. Our approach, which is a part of therun time system, will automatically and dynamically perform
1:2:3:4:5:6:7:8:9:10:11:Enforce a global barrierfor all pi P doif T emppi T thenDecrease the frequency of pielseif T emppi T thenIncrease the frequency of piend ifend ifend forInvoke the load balancerthe task of temperature check and load balancing without anyinput from the user.IV.L IMITATIONS OF P ERIODIC A PPROACHAlthough the recent work proposed in [4] is successful inreducing the cooling energy significantly, it has certain shortcomings. In this scheme, a temperature-aware load balancingstrategy is proposed which is invoked periodically at the userspecified interval. At the specified period, a global barrier isenforced and temperature-aware load balancing is performedat the central location. As a part of the load balancingframework, the temperature of each processor is checked and ifit exceeds the pre-set threshold, the frequency of that processoris decreased. If the temperature is below the threshold, then thefrequency is increased. Adjustment of frequencies can result inload imbalance and to handle that, the load balancer is invoked.This scheme is depicted in Algorithm 1.In this section, we will highlight the drawbacks of thisscheme. Notice that the temperature check is triggered periodically every p seconds, where p is specified by the user.After the global barrier, DVFS is used to limit the temperature of cores and load balancing is performed to reduce thetiming penalty due to load imbalance. Here, the applicationprogrammer has the responsibility of identifying the periodfor temperature checks and load balancing. This becomesincreasingly a burden as the period is application and systemdependent. This not only puts the burden on the applicationprogrammer but also may result in not being able to controlthe temperature in a dynamic environment. Processors tendto have higher temperatures in computation intensive applications, while some applications with lower system utilizationgenerate less heat. This indicates that the ideal temperaturecheck and load balancing period is application dependent.Further, invoking the load balancer also incurs overhead. If theload balancing cost exceeds the benefit, it results in increasingthe total execution time.Figure 1 shows the maximum temperature and timingpenalty using this algorithm with different user specifiedperiods for a run of wave2D on 128 cores. The CRAC is setto 74 F and the threshold temperature is 50 C. Details of the140090Execution timeMax temp85120080100075800706006540060200550BaseLB 1mLB 20sLB 10sLB 5sMaximum temperature (C)At user specified period pExecution time and Max temperature1600Total execution time (s)Algorithm 1 Periodic temperature-aware dynamic load balancingInput:P - Set of processorsT - Temperature thresholdT emppi - Temperature of processor pi50Fig. 1. Comparison for maximum temperature and timing penalty for varioususer specified periodapplication and the experimental setup are described in Section VI. If the temperature check is performed frequently, theoverhead due to barriers and load balancing may increase thetiming penalty. Whereas if the temperature check is performedinfrequently, it could result in overheating of cores. Leaving itto the application programmer to manually identify the periodin a dynamic application is inefficient.V.M ETAT EMP C ONTROLLERMetaTempController framework is implemented as a partof the C HARM adaptive runtime system. The generic idea ofthis framework is to let the runtime system monitor the systemtemperature and application characteristics, and based on thecollected information, make decisions to adjust the frequenciesor invoke the load balancer. We choose to implement thisframework in C HARM , however it is possible to implementthis approach in any other programming models. MetaTempController consists of two major components, namely, automatic temperature control and automatic load balancing.A. Temperature ControlIf the CRAC temperature is increased to reduce the coolingenergy, it may result in overheating of the processors. Toensure that the processors are not over heated and hot spots arenot created, the temperature of the chip needs to be controlled.Temperature control plays an important part in reducing thecooling energy. In order to control the temperature effectively,MetaTempController collects the temperature information foreach core in a distributed fashion. Temperature measurementsfor all the cores on a chip is collected frequently and decisions to control the temperature are made. Note that in thisscheme, the temperature control is done independently on eachprocessor, whereas in [4] there is a global barrier. Since thecomputer hardware in the cluster does not allow frequencychange of a single core, DVFS is applied to the entire chip.Also, the hardware has discrete voltage and frequency levelsbuilt into it, called the ’P-states’. The chip frequencies canbe set only to those discrete operating points. Whenever thetemperature of a core exceeds the specified threshold, theMetaTempController identifies this and triggers mechanism tolimit the temperature. It uses DVFS to lower the frequency byone step (increase P-state by one level). Running the processor
B. Load BalancingEven though DVFS limits the processor temperature andeliminates hot spots, it incurs timing penalty. This timingpenalty can occur due to: 1) processors operating at lowerfrequency 2) load imbalance due to different processor speeds.In order to reduce the timing penalty, load balancing needs tobe performed. But performing load balancing entails overheadswhich includes the time spent on collecting load balancingstatistics, finding a new mapping and migrating the objectsbased on the mapping. Since the load balancer incurs overhead,it becomes necessary to determine whether invoking the loadbalancer is profitable. If the load balancer is invoked toofrequently, the overhead of load balancing may exceed thebenefit and result in increased execution time. A commonpractice is to invoke the load balancer periodically at a periodspecified by the user. But this prevents load balancing fromadapting to the dynamic application and system characteristics.MetaTempController relies on the concept of an automatedload balancing framework [6]. This framework collects aminimum set of load balancing statistics in an asynchronousmanner via a reduction tree. Once the aggregate information isavailable, it determines whether there is any load imbalance. Ifthere is load imbalance, it may lead to performance loss. Butif the overhead of load balancing is more than the benefit,performing load balancing won’t be beneficial. MetaTempController identifies an ideal load balancing period based onthe application characteristics and the cost of load balancing.VI.R ESULTSIn this section, we present an evaluation of the effectivenessof MetaTempController and compare it with other schemesusing three applications wave2D, leanMD and kNeighbor. Weshow that MetaTempController is able to constrain the coretemperature to a specified threshold, invoke the load balancerwhenever beneficial and extract the best performance for theapplication automatically at run time.A. Experimental SetupThe experiments were run on a cluster with 160 cores(40 nodes). Each node of the cluster is a single socket DellT5500 machine with a quad-core Intel Xeon E5520 chip. TheIntel Xeon E5520 chip supports seven different frequenciesranging from 1.6GHz to 2.53GHz through Intel’s Turbo BoostTechnology. The cpufreq module which is available in Ubuntu10.04 allows us to step up or down the frequency by 0.13GHzin each step. A frequency shift from one level to another takesa processor a few microseconds. For all our runs, we use 128cores out of the 160 cores.For all the experiments, the computer room air conditioningtemperature was set to 74 F and the threshold temperaturewas fixed at 50 C. These are independent variables whichPer Processor Max Temperature90BaseNaive DVFS 1minNaive DVFS 20sNaive DVFS 10s80Temperature (C)at a lower frequency reduces the amount of heat generatedand helps reducing the machine and cooling energy. But ifall the cores on a chip have temperatures below the specifiedthreshold, then the frequency of the chip is increased byone step. Since the temperature statistics are collected in adistributed manner without enforcing a barrier, this schemeincurs very little overhead.Naive DVFS Fig. 2.Maximum Temperature of the Processors for wave2Dcan effect the power reduction greatly. The effect of thoseto power reduction is discussed in detail in our previouswork [4]. The focus of this paper is not to study their effect,hence we evaluate the proposed strategy with a fixed set ofCRAC temperature and threshold. However, we expect similarbehavior with different configuration of threshold and coolingtemperature.B. Applicationswave2D is a computation-intensive finite differencing application. It is implemented using a 2-D mesh structure. Ourruns execute 25, 000 iterations with a mesh of size 128 16.leanMD is a molecular dynamics application written inCharm , that simulates the behavior of atoms based on theLennard-Jones potential. The computations performed in thisprogram are similar to the force calculation in NAMD [18].The simulation is in a three-dimensional space consisting ofatoms which are divided into cells. In each iteration, forcecalculations are done for all pairs of nearby atoms. Oncethe force calculation is performed by the computes, the cellsupdate the acceleration, velocity and position of the atomswithin their space. We benchmark leanMD on a system of128, 000 atoms for 500 iterations.kNeighbor is a micro-benchmark with a near-neighborcommunication pattern. In this benchmark, each object exchanges 16KB sized messages with a fixed set of fourteenneighbors in every iteration. We evaluate this benchmark byexecuting 25, 000 iterations.All the above applications do not have any inherent loadimbalance. Thus, any imbalance that occurs is a result ofchanges to processor frequencies.C. Experimental ResultsWe use the following metrics to evaluate the effectivenessand behavior of MetaTempController: 1) Temperature Control,2) Timing Penalty 3), Frequency, 4) Overhead, 5) Power andEnergy1) Temperature Control: wave2D: wave2D being computation intensive benchmark, results in an increase in coretemperature and hot-spots. Figure 3 shows that for a runof wave2D without any temperature control, the maximumtemperature on any core reaches 82 C . Figure 2 indicates
Cluster Maximum 2001400401600050100150200time (s)Fig. 3.Fig. 5.Temperature (C)Naive DVFS 5sMetaTempThresholdBaseNaive DVFS 1minNaive DVFS 20sNaive DVFS 10s7570Temperature (C)BaseNaive DVFS 1minNaive DVFS 20sNaive DVFS 10s5550400Naive DVFS 0CoresFig. 4.350Per Processor Max Temperature8060300Maximum Temperature of the Processors Over Time for kNeighborPer Processor Max Temperature65250time (s)Maximum Temperature of the Processors Over Time for wave2D7040Naive DVFS 5sMetaTempThresholdBaseNaive DVFS 1minNaive DVFS 20sNaive DVFS 10s65Temperature (C)Temperature (C)Naive DVFS 5sMetaTempThresholdBaseNaive DVFS 1minNaive DVFS 20sNaive DVFS 10s90Cluster Maximum Temperature70Maximum Temperature of the Processors for kNeighborthat some of the cores are hot-spots. Core temperatures arechecked periodically and DVFS is used to keep the temperatureof a core within the threshold of 50 C. Figure 3 showsthe maximum temperature of any core over time for varioustemperature check period. A period of 1 min is able to bring themaximum temperature down to 62 C but it is insufficient tokeep the temperature within the threshold. Temperature checkwith 20s period is able to reduce the temperature further but itis still above the threshold. For this application, a periodicity of5 seconds is necessary to ensure that the maximum temperatureof any core is within the threshold. MetaTempController is ableto automatically control the temperature using DVFS and keepit within the threshold.kNeighbor: Unlike wave2D or leanMD, kNeighbor is acommunication intensive benchmark because of which thetemperature of the cores reaches a maximum of 61 C withoutany temperature control as shown in Figure 5. Again Figure 4indicates the formation of hot-spots. A periodicity of 1 minfor temperature check is not sufficient to keep the temperaturewithin threshold of 50 C. Whereas a periodicity of 10or 5 seconds controls the temperature. MetaTempControllersuccessfully controls the temperature to within the specifiedthreshold of 50 C. The key thing to note here is that the idealperiod to control the temperature is application dependent. Forwave2D the ideal period was 5 seconds whereas for kNeighborit is 10 seconds. MetaTempController automatically adjusts the020406080100120140CoresFig. 6. Maximum core temperature for the entire run for leanMD. Thisindicates region of hot-spots.temperature without any support from the user.leanMD: Figure 7 shows the maximum temperature forany core in the system for the entire run of leanMD usingvarious periodicity for temperature control. It can be seen thatfor the run of leanMD without any temperature control, themaximum temperature goes up to 73 C. This is above thethreshold of 50 C. Figure 6 indicates that there are few hotspots created resulting in high temperature. A periodicity of1 min is able to control the temperature to a certain extendbut still causes the temperature to reach 59 C. This indicatesthat periodicity of 1 min is not frequent enough to keep thetemperature within the threshold. For leanMD, a periodicity of10 seconds is required to ensure that the maximum temperatureof any core in the system is within the threshold. We find that,MetaTempController is successful in keeping the temperaturewithin the threshold of 50 C.2) Timing Penalty: wave2D: Using DVFS to control temperature results in load imbalance which leads to low systemutilization. Figure 8 shows the average system utilization whenthe temperature is controlled. The system utilization dropsfrom 89% to 60% during the run. The frequency of thecores which are hot-spots are reduced which results in loadimbalance. Figure 8 shows the average system utilization whenload balancing is performed. It can be seen that the loadbalancer is successful in improving the utilization and attains
7010006580060600554005020045040BaseNaive DVFS LB 10sLB 5sMetaTemp300552005010045040BaseNaive DVFS LB 10sLB 5s(b) Naive DVFS LB 10sLB 5sMetaTemp40(c) leanMDControlling the temperature using DVFS keeps the temperaturewithin the threshold but the execution time increases by 40%to 1499 seconds. Performing load balancing frequently incursoverhead which may overshoot the gains from load balancing.A periodic load balancer with a period of 5 seconds hasan execution time of 1477 seconds and therefore does notprovide much benefit. A period of 10 seconds is insufficient tokeep the temperature within threshold and causes temperatureto rise till 57 C. MetaTempController successfully controlsthe temperature and removes hot-spots using DVFS and alsoreduces the timing penalty by 10%.Naive DVFS 5sMetaTempThresholdBaseNaive DVFS 1minNaive DVFS 20sNaive DVFS 10s80Temperature (C)500Execution timeMax tempExecution time and temperature for different strategies9070605040050100150200250300350400time (s)Fig. 7. Maximum temperature on any core over time for leanMD. Withoutany control, temperature reaches 73 C and MetaTempController keeps itwithin threshold.1wave2D Naive DVFS 5swave2D MetaTempleanMD Naive DVFS 10sleanMD MetaTemp0.9Average utilization6560Cluster Maximum Temperature0.80.70.60.5Fig. 8.600400(a) wave2DFig. 9.70Total execution time (s)751200500Total execution time (s)Total execution time (s)801400LeanMDExecution timeMax temp85Maximum temperature (C)Execution timeMax temp1600600Maximum temperature (C)kNeighbor90Maximum temperature (C)Wave2D1800TimekNeighbor: kNeighbor being communication intensive, itscharacteristics is different from wave2D or leanMD. Figure 9shows the maximum temperature and the total execution timefor various schemes including no temperature control, temperature control, periodic load balancing and MetaTempController.Without any temperature control, the execution time is 368seconds and the maximum temperature is 61 C. It can beseen that controlling the temperature with DVFS results in aslowdown of only 4%. This indicates that there is no significantload imbalance. Therefore, performing load balancing veryoften will not yield any benefit and instead will incur moreoverhead. Figure 9 shows that the periodic load balancer incurmore overhead and increases the total execution time by 13%in comparison to the no temperature control run and 8% to thetemperature control run. MetaTempController automaticallycalls the load balancer only if the benefit of load balancingexceeds the overhead. It identifies that load balancing doesnot improve and hence invokes load balancing only once.The timing penalty of MetaTempController is 4% over theno temperature control run. Thus MetaTempController is ableto automatically control the temperature within the thresholdas well as minimize the timing penalty depending on theapplication characteristics.Average utilization over time with and without MetaTempControlera minimum utilization of 73%.Load balancing incurs overhead which includes the time forfinding a new assignment of objects to processors as well as thetime for migration. Figure 9 compares various schemes including no temperature control, temperature control without loadbalancing, periodic load balancing and MetaTempController.In the no temperature control case, the total execution timeis 1069 seconds but the core temperature reaches 82 C.leanMD: In order to control the temperature, the frequencyof the chip is adjusted using DVFS. Decreasing the frequencyresults in load imbalance which leads to lower system utilization. Figure 8 shows the average utilization of the system whenthe temperature is controlled using DVFS. In the beginning of
load balancing. The load balancing framework in CHARM is based on a heuristic known as the principle of persistence [8] which states that the recent past is a good indication of the future. CHARM provides the application programmer with a suite of load balancers and the capability to add new custom load balancing strategies. These load .
8. Load Balancing Lync Note: It's highly recommended that you have a working Lync environment first before implementing the load balancer. Load Balancing Methods Supported Microsoft Lync supports two types of load balancing solutions: Domain Name System (DNS) load balancing and Hardware Load Balancing (HLB). DNS Load Balancing
load balancing degree and the total time till a balanced state is reached. Existing load balancing methods usually ignore the VM migration time overhead. In contrast to sequential migration-based load balancing, this paper proposes using a network-topology aware parallel migration to speed up the load balancing process in a data center.
Load Balancing can also be of centralized load balancing and distributed load balancing. Centralized load balancing typically requires a head node that is responsible for handling the load distribution. As the no of processors increases, the head node quickly becomes a bottleneck, causing signi cant performance degradation. To solve this problem,
Internal Load Balancing IP: 10.10.10.10, Port: 80 Web Tier Internal Tier Internal Load Balancing IP: 10.20.1.1, Port: 80 asia-east-1a User in Singapore Database Tier Database Tier Database Tier External Load Balancing Global: HTTP(S) LB, SSL Proxy Regional: Network TCP/UDP LB Internal Load Balancing ILB Use Case 2: Multi-tier apps
It is used for Balancing the load according to controller and according to flow of Data as well. Data Plane handle Link Load Balancing and Server Load Balancing. The Distributed multiple control architecture is subcategorized into Flat Architecture and hierarchical Architecture. It helps to explore new dimensions of load balancing. Figure 4.
Figure 1: Load Balancing Model based on [4]. 2.2 Load Balancing As cloud computing continues to grow, load balancing is essential to ensure that the quality of service isn't compro-mised for end users [4]. Load balancing is the process of distributing workload amongst a collection of servers in a data center.
leverage various load balancing mechanisms with DNS servers. DNS load balancing is a way to distribute client requests for host names across multiple IP addresses without needing client interaction. Generally, DNS load balancing is performed by round-robin. Load balancing can also be performed through third-
MS Exemplar Unit English Language Arts Grade 2 Edition 1 Design Overview The MS CCRS Exemplar Units for ELA and mathematics address grade-level specific standards for Pre-Kindergarten-8th grade, as well as for Algebra, English I, and English II. The overall unit plan is described in the first section of the ELA and math units. This section .
