From f5ddc56f2752023add9a7ba47258ce4b144797c2 Mon Sep 17 00:00:00 2001 From: Pradyumna Kaushik Date: Fri, 10 Feb 2017 16:39:13 -0500 Subject: [PATCH] changed the name of takeOffer(...) to takeOfferBinPack(...) and then created another function called takeOfferFirstFit(...). Made sure that these functions are called instead of inlining code. --- schedulers/bottomHeavy.go | 22 ++++++++++++++-------- schedulers/topHeavy.go | 33 ++++++++++++++++++++++++++------- 2 files changed, 40 insertions(+), 15 deletions(-) diff --git a/schedulers/bottomHeavy.go b/schedulers/bottomHeavy.go index 6ec542d..38d6b66 100644 --- a/schedulers/bottomHeavy.go +++ b/schedulers/bottomHeavy.go @@ -26,7 +26,7 @@ BinPacking has the most effect when co-scheduling of tasks is increased. Large t co-scheduling them has a great impact on the total power utilization. */ -func (s *BottomHeavy) takeOffer(offer *mesos.Offer, totalCPU, totalRAM, totalWatts, +func (s *BottomHeavy) takeOfferBinPack(offer *mesos.Offer, totalCPU, totalRAM, totalWatts, wattsToConsider float64, task def.Task) bool { offerCPU, offerRAM, offerWatts := offerUtils.OfferAgg(offer) @@ -40,6 +40,17 @@ func (s *BottomHeavy) takeOffer(offer *mesos.Offer, totalCPU, totalRAM, totalWat } +func (s *BottomHeavy) takeOfferFirstFit(offer *mesos.Offer, wattsConsideration float64, task def.Task) bool { + offerCPU, offerRAM, offerWatts := offerUtils.OfferAgg(offer) + + //TODO: Insert watts calculation here instead of taking them as a parameter + if (!s.wattsAsAResource || (offerWatts >= wattsConsideration)) && + (offerCPU >= task.CPU) && (offerRAM >= task.RAM) { + return true + } + return false +} + // electronScheduler implements the Scheduler interface type BottomHeavy struct { base // Type embedded to inherit common functions @@ -199,7 +210,7 @@ func (s *BottomHeavy) pack(offers []*mesos.Offer, driver sched.SchedulerDriver) // Does the task fit // OR lazy evaluation. If ignore watts is set to true, second statement won't // be evaluated. - if s.takeOffer(offer, totalCPU, totalRAM, totalWatts, wattsConsideration, task) { + if s.takeOfferBinPack(offer, totalCPU, totalRAM, totalWatts, wattsConsideration, task) { offerTaken = true totalWatts += wattsConsideration totalCPU += task.CPU @@ -245,7 +256,6 @@ func (s *BottomHeavy) spread(offers []*mesos.Offer, driver sched.SchedulerDriver } tasks := []*mesos.TaskInfo{} - offerCPU, offerRAM, offerWatts := offerUtils.OfferAgg(offer) taken := false for i := 0; i < len(s.smallTasks); i++ { task := s.smallTasks[i] @@ -253,14 +263,10 @@ func (s *BottomHeavy) spread(offers []*mesos.Offer, driver sched.SchedulerDriver if err != nil { // Error in determining wattsConsideration log.Fatal(err) - } else { - // Logging the watts consideration - log.Printf("Watts Considered for host[%s], task[%s] = %f\n", *offer.Hostname, task.Name, wattsConsideration) } // Decision to take the offer or not - if (!s.wattsAsAResource || (offerWatts >= wattsConsideration)) && - (offerCPU >= task.CPU) && (offerRAM >= task.RAM) { + if s.takeOfferFirstFit(offer, wattsConsideration, task) { taken = true tasks = append(tasks, s.createTaskInfoAndLogSchedTrace(offer, task)) log.Printf("Starting %s on [%s]\n", task.Name, offer.GetHostname()) diff --git a/schedulers/topHeavy.go b/schedulers/topHeavy.go index 39ffe03..e42b527 100644 --- a/schedulers/topHeavy.go +++ b/schedulers/topHeavy.go @@ -26,6 +26,30 @@ This was done to give a little more room for the large tasks (power intensive) f starvation of power intensive tasks. */ +func (s *TopHeavy) takeOfferBinPack(offer *mesos.Offer, totalCPU, totalRAM, totalWatts, + wattsToConsider float64, task def.Task) bool { + offerCPU, offerRAM, offerWatts := offerUtils.OfferAgg(offer) + + //TODO: Insert watts calculation here instead of taking them as a parameter + if (!s.wattsAsAResource || (offerWatts >= (totalWatts + wattsToConsider))) && + (offerCPU >= (totalCPU + task.CPU)) && + (offerRAM >= (totalRAM + task.RAM)) { + return true + } + return false +} + +func (s *TopHeavy) takeOfferFirstFit(offer *mesos.Offer, wattsConsideration float64, task def.Task) bool { + offerCPU, offerRAM, offerWatts := offerUtils.OfferAgg(offer) + + //TODO: Insert watts calculation here instead of taking them as a parameter + if (!s.wattsAsAResource || (offerWatts >= wattsConsideration)) && + (offerCPU >= task.CPU) && (offerRAM >= task.RAM) { + return true + } + return false +} + // electronScheduler implements the Scheduler interface type TopHeavy struct { base // Type embedded to inherit common functions @@ -169,7 +193,6 @@ func (s *TopHeavy) pack(offers []*mesos.Offer, driver sched.SchedulerDriver) { } tasks := []*mesos.TaskInfo{} - offerCPU, offerRAM, offerWatts := offerUtils.OfferAgg(offer) totalWatts := 0.0 totalCPU := 0.0 totalRAM := 0.0 @@ -186,9 +209,7 @@ func (s *TopHeavy) pack(offers []*mesos.Offer, driver sched.SchedulerDriver) { // Does the task fit // OR lazy evaluation. If ignore watts is set to true, second statement won't // be evaluated. - if (!s.wattsAsAResource || (offerWatts >= (totalWatts + wattsConsideration))) && - (offerCPU >= (totalCPU + task.CPU)) && - (offerRAM >= (totalRAM + task.RAM)) { + if s.takeOfferBinPack(offer, totalCPU, totalRAM, totalWatts, wattsConsideration, task) { taken = true totalWatts += wattsConsideration totalCPU += task.CPU @@ -234,7 +255,6 @@ func (s *TopHeavy) spread(offers []*mesos.Offer, driver sched.SchedulerDriver) { } tasks := []*mesos.TaskInfo{} - offerCPU, offerRAM, offerWatts := offerUtils.OfferAgg(offer) offerTaken := false for i := 0; i < len(s.largeTasks); i++ { task := s.largeTasks[i] @@ -245,8 +265,7 @@ func (s *TopHeavy) spread(offers []*mesos.Offer, driver sched.SchedulerDriver) { } // Decision to take the offer or not - if (!s.wattsAsAResource || (offerWatts >= wattsConsideration)) && - (offerCPU >= task.CPU) && (offerRAM >= task.RAM) { + if s.takeOfferFirstFit(offer, wattsConsideration, task) { offerTaken = true tasks = append(tasks, s.createTaskInfoAndLogSchedTrace(offer, task)) log.Printf("Starting %s on [%s]\n", task.Name, offer.GetHostname())