From 2744bbe0f4e19003f02d7e5cb739bfe6b8ad818c Mon Sep 17 00:00:00 2001 From: Pradyumna Kaushik Date: Sun, 8 Jan 2017 18:58:00 -0800 Subject: [PATCH] Made sure that the capping happens only if a different cap value has been determined. Otherwise we don't unncessarily cap again. This reduces overhead. --- schedulers/bpswClassMapWattsProacCC.go | 64 +++++++++++++++++++------- 1 file changed, 47 insertions(+), 17 deletions(-) diff --git a/schedulers/bpswClassMapWattsProacCC.go b/schedulers/bpswClassMapWattsProacCC.go index cd21b03..8af0802 100644 --- a/schedulers/bpswClassMapWattsProacCC.go +++ b/schedulers/bpswClassMapWattsProacCC.go @@ -165,22 +165,52 @@ func (s *BPSWClassMapWattsProacCC) Disconnected(sched.SchedulerDriver) { } // go routine to cap the entire cluster in regular intervals of time. -var bpswClassMapWattsCapValue = 0.0 // initial value to indicate that we haven't capped the cluster yet. +var bpswClassMapWattsProacCCCapValue = 0.0 // initial value to indicate that we haven't capped the cluster yet. +var bpswClassMapWattsProacCCNewCapValue = 0.0 // newly computed cap value +//func (s *BPSWClassMapWattsProacCC) startCapping() { +// go func() { +// for { +// select { +// case <-s.ticker.C: +// // Need to cap the cluster to the bpswClassMapWattsCapValue. +// bpswClassMapWattsProacCCMutex.Lock() +// if s.isCapping && bpswClassMapWattsProacCCCapValue > 0.0 { +// for _, host := range constants.Hosts { +// // Rounding capValue to nearest int. +// if err := rapl.Cap(host, "rapl", int(math.Floor(bpswClassMapWattsProacCCCapValue +0.5))); err != nil { +// log.Println(err) +// } +// } +// log.Printf("Capped the cluster to %d", int(math.Floor(bpswClassMapWattsProacCCCapValue +0.5))) +// } +// bpswClassMapWattsProacCCMutex.Unlock() +// } +// } +// }() +//} + func (s *BPSWClassMapWattsProacCC) startCapping() { go func() { for { select { case <-s.ticker.C: - // Need to cap the cluster to the bpswClassMapWattsCapValue. + // Need to cap the cluster only if new cap value different from old cap value. + // This way we don't unnecessarily cap the cluster. bpswClassMapWattsProacCCMutex.Lock() - if bpswClassMapWattsCapValue > 0.0 { - for _, host := range constants.Hosts { - // Rounding capValue to nearest int. - if err := rapl.Cap(host, "rapl", int(math.Floor(bpswClassMapWattsCapValue+0.5))); err != nil { - log.Println(err) + if s.isCapping { + if int(math.Floor(bpswClassMapWattsProacCCNewCapValue +0.5)) != int(math.Floor(bpswClassMapWattsProacCCCapValue +0.5)) { + // updating cap value + bpswClassMapWattsProacCCCapValue = bpswClassMapWattsProacCCNewCapValue + if bpswClassMapWattsProacCCCapValue > 0.0 { + for _, host := range constants.Hosts { + // Rounding cap value to nearest int + if err := rapl.Cap(host, "rapl", int(math.Floor(bpswClassMapWattsProacCCCapValue+0.5))); err != nil { + log.Println(err) + } + } + log.Printf("Capped the cluster to %d", int(math.Floor(bpswClassMapWattsProacCCCapValue+0.5))) } } - log.Printf("Capped the cluster to %d", int(math.Floor(bpswClassMapWattsCapValue+0.5))) } bpswClassMapWattsProacCCMutex.Unlock() } @@ -189,7 +219,7 @@ func (s *BPSWClassMapWattsProacCC) startCapping() { } // go routine to recap the entire cluster in regular intervals of time. -var bpswClassMapWattsRecapValue = 0.0 // The cluster-wide cap value when recapping +var bpswClassMapWattsProacCCRecapValue = 0.0 // The cluster-wide cap value when recapping func (s *BPSWClassMapWattsProacCC) startRecapping() { go func() { for { @@ -197,14 +227,14 @@ func (s *BPSWClassMapWattsProacCC) startRecapping() { case <-s.recapTicker.C: bpswClassMapWattsProacCCMutex.Lock() // If stopped performing cluster wide capping, then we need to recap - if s.isRecapping && bpswClassMapWattsRecapValue > 0.0 { + if s.isRecapping && bpswClassMapWattsProacCCRecapValue > 0.0 { for _, host := range constants.Hosts { // Rounding capValue to the nearest int - if err := rapl.Cap(host, "rapl", int(math.Floor(bpswClassMapWattsRecapValue+0.5))); err != nil { + if err := rapl.Cap(host, "rapl", int(math.Floor(bpswClassMapWattsProacCCRecapValue +0.5))); err != nil { log.Println(err) } } - log.Printf("Recapping the cluster to %d", int(math.Floor(bpswClassMapWattsRecapValue+0.5))) + log.Printf("Recapping the cluster to %d", int(math.Floor(bpswClassMapWattsProacCCRecapValue +0.5))) } // Setting recapping to false s.isRecapping = false @@ -309,7 +339,7 @@ func (s *BPSWClassMapWattsProacCC) ResourceOffers(driver sched.SchedulerDriver, tempCap, err := s.capper.FCFSDeterminedCap(s.totalPower, &task) if err == nil { bpswClassMapWattsProacCCMutex.Lock() - bpswClassMapWattsCapValue = tempCap + bpswClassMapWattsProacCCNewCapValue = tempCap bpswClassMapWattsProacCCMutex.Unlock() } else { log.Println("Failed to determine new cluster-wide cap:") @@ -370,16 +400,16 @@ func (s *BPSWClassMapWattsProacCC) StatusUpdate(driver sched.SchedulerDriver, st // Need to remove the task from the window s.capper.TaskFinished(*status.TaskId.Value) // Determining the new cluster wide recap value + //tempCap, err := s.capper.Recap(s.totalPower, s.taskMonitor, *status.TaskId.Value) tempCap, err := s.capper.CleverRecap(s.totalPower, s.taskMonitor, *status.TaskId.Value) - //tempCap, err := s.capper.CleverRecap(s.totalPower, s.taskMonitor, *status.TaskId.Value) if err == nil { // If new determined cap value is different from the current recap value, then we need to recap - if int(math.Floor(tempCap+0.5)) != int(math.Floor(bpswClassMapWattsRecapValue+0.5)) { - bpswClassMapWattsRecapValue = tempCap + if int(math.Floor(tempCap+0.5)) != int(math.Floor(bpswClassMapWattsProacCCRecapValue +0.5)) { + bpswClassMapWattsProacCCRecapValue = tempCap bpswClassMapWattsProacCCMutex.Lock() s.isRecapping = true bpswClassMapWattsProacCCMutex.Unlock() - log.Printf("Determined re-cap value: %f\n", bpswClassMapWattsRecapValue) + log.Printf("Determined re-cap value: %f\n", bpswClassMapWattsProacCCRecapValue) } else { bpswClassMapWattsProacCCMutex.Lock() s.isRecapping = false