Merged in schedulerAttributesConsolidation (pull request #11)

SchedulerAttributesConsolidation

Approved-by: Renan DelValle
Approved-by: ajain13

powerCapping/proactiveclusterwidecappers.go

@@ -3,7 +3,7 @@ Cluster wide dynamic capping
 
 This is a capping strategy that can be used with schedulers to improve the power consumption.
 
-Note: This capping strategy doesn't currently considered task.Watts to power class mapping with classMapWatts is enabled.
+Note: This capping strategy doesn't currently consider task.Watts to power class mapping when classMapWatts is enabled.
 */
 package powerCapping
 

schedulers/base.go

@@ -1,12 +1,37 @@
 package schedulers
 
 import (
+	"bitbucket.org/sunybingcloud/electron/def"
 	mesos "github.com/mesos/mesos-go/mesosproto"
 	sched "github.com/mesos/mesos-go/scheduler"
 	"log"
 )
 
-type base struct{}
+type base struct {
+	tasksCreated     int
+	tasksRunning     int
+	tasks            []def.Task
+	metrics          map[string]def.Metric
+	running          map[string]map[string]bool
+	wattsAsAResource bool
+	classMapWatts    bool
+
+	// First set of PCP values are garbage values, signal to logger to start recording when we're
+	// about to schedule a new task
+	RecordPCP bool
+
+	// This channel is closed when the program receives an interrupt,
+	// signalling that the program should shut down.
+	Shutdown chan struct{}
+	// This channel is closed after shutdown is closed, and only when all
+	// outstanding tasks have been cleaned up
+	Done chan struct{}
+
+	// Controls when to shutdown pcp logging
+	PCPLog chan struct{}
+
+	schedTrace *log.Logger
+}
 
 func (s *base) OfferRescinded(_ sched.SchedulerDriver, offerID *mesos.OfferID) {
 	log.Printf("Offer %s rescinded", offerID)

schedulers/binPackSortedWattsSortedOffers.go

@@ -33,30 +33,7 @@ func (s *BinPackSortedWattsSortedOffers) takeOffer(offer *mesos.Offer, task def.
 }
 
 type BinPackSortedWattsSortedOffers struct {
-	base             // Type embedded to inherit common functions
-	tasksCreated     int
-	tasksRunning     int
-	tasks            []def.Task
-	metrics          map[string]def.Metric
-	running          map[string]map[string]bool
-	wattsAsAResource bool
-	classMapWatts    bool
-
-	// First set of PCP values are garbage values, signal to logger to start recording when we're
-	// about to schedule a new task
-	RecordPCP bool
-
-	// This channel is closed when the program receives an interrupt,
-	// signalling that the program should shut down.
-	Shutdown chan struct{}
-	// This channel is closed after shutdown is closed, and only when all
-	// outstanding tasks have been cleaned up
-	Done chan struct{}
-
-	// Controls when to shutdown pcp logging
-	PCPLog chan struct{}
-
-	schedTrace *log.Logger
+	base // Type embedded to inherit common functions
 }
 
 // New electron scheduler
@@ -70,15 +47,17 @@ func NewBinPackSortedWattsSortedOffers(tasks []def.Task, wattsAsAResource bool,
 	}
 
 	s := &BinPackSortedWattsSortedOffers{
-		tasks:            tasks,
-		wattsAsAResource: wattsAsAResource,
-		classMapWatts:    classMapWatts,
-		Shutdown:         make(chan struct{}),
-		Done:             make(chan struct{}),
-		PCPLog:           make(chan struct{}),
-		running:          make(map[string]map[string]bool),
-		RecordPCP:        false,
-		schedTrace:       log.New(logFile, "", log.LstdFlags),
+		base: base{
+			tasks:            tasks,
+			wattsAsAResource: wattsAsAResource,
+			classMapWatts:    classMapWatts,
+			Shutdown:         make(chan struct{}),
+			Done:             make(chan struct{}),
+			PCPLog:           make(chan struct{}),
+			running:          make(map[string]map[string]bool),
+			RecordPCP:        false,
+			schedTrace:       log.New(logFile, "", log.LstdFlags),
+		},
 	}
 	return s
 }

schedulers/binpackedpistoncapping.go

@@ -26,35 +26,11 @@ import (
   corresponding to the load on that node.
 */
 type BinPackedPistonCapper struct {
-	base             // Type embedded to inherit common functions
-	tasksCreated     int
-	tasksRunning     int
-	tasks            []def.Task
-	metrics          map[string]def.Metric
-	running          map[string]map[string]bool
-	taskMonitor      map[string][]def.Task
-	totalPower       map[string]float64
-	wattsAsAResource bool
-	classMapWatts    bool
-	ticker           *time.Ticker
-	isCapping        bool
-
-	// First set of PCP values are garbage values, signal to logger to start recording when we're
-	// about to schedule the new task.
-	RecordPCP bool
-
-	// This channel is closed when the program receives an interrupt,
-	// signalling that the program should shut down.
-	Shutdown chan struct{}
-
-	// This channel is closed after shutdown is closed, and only when all
-	// outstanding tasks have been cleaned up.
-	Done chan struct{}
-
-	// Controls when to shutdown pcp logging.
-	PCPLog chan struct{}
-
-	schedTrace *log.Logger
+	base        // Type embedded to inherit common functions
+	taskMonitor map[string][]def.Task
+	totalPower  map[string]float64
+	ticker      *time.Ticker
+	isCapping   bool
 }
 
 // New electron scheduler.
@@ -67,19 +43,21 @@ func NewBinPackedPistonCapper(tasks []def.Task, wattsAsAResource bool, schedTrac
 	}
 
 	s := &BinPackedPistonCapper{
-		tasks:            tasks,
-		wattsAsAResource: wattsAsAResource,
-		classMapWatts:    classMapWatts,
-		Shutdown:         make(chan struct{}),
-		Done:             make(chan struct{}),
-		PCPLog:           make(chan struct{}),
-		running:          make(map[string]map[string]bool),
-		taskMonitor:      make(map[string][]def.Task),
-		totalPower:       make(map[string]float64),
-		RecordPCP:        false,
-		ticker:           time.NewTicker(5 * time.Second),
-		isCapping:        false,
-		schedTrace:       log.New(logFile, "", log.LstdFlags),
+		base: base{
+			tasks:            tasks,
+			wattsAsAResource: wattsAsAResource,
+			classMapWatts:    classMapWatts,
+			Shutdown:         make(chan struct{}),
+			Done:             make(chan struct{}),
+			PCPLog:           make(chan struct{}),
+			running:          make(map[string]map[string]bool),
+			RecordPCP:        false,
+			schedTrace:       log.New(logFile, "", log.LstdFlags),
+		},
+		taskMonitor: make(map[string][]def.Task),
+		totalPower:  make(map[string]float64),
+		ticker:      time.NewTicker(5 * time.Second),
+		isCapping:   false,
 	}
 	return s
 }

schedulers/binpacksortedwatts.go

@@ -34,30 +34,7 @@ func (s *BinPackSortedWatts) takeOffer(offer *mesos.Offer, task def.Task) bool {
 }
 
 type BinPackSortedWatts struct {
-	base             // Type embedded to inherit common functions
-	tasksCreated     int
-	tasksRunning     int
-	tasks            []def.Task
-	metrics          map[string]def.Metric
-	running          map[string]map[string]bool
-	wattsAsAResource bool
-	classMapWatts    bool
-
-	// First set of PCP values are garbage values, signal to logger to start recording when we're
-	// about to schedule a new task
-	RecordPCP bool
-
-	// This channel is closed when the program receives an interrupt,
-	// signalling that the program should shut down.
-	Shutdown chan struct{}
-	// This channel is closed after shutdown is closed, and only when all
-	// outstanding tasks have been cleaned up
-	Done chan struct{}
-
-	// Controls when to shutdown pcp logging
-	PCPLog chan struct{}
-
-	schedTrace *log.Logger
+	base // Type embedded to inherit common functions
 }
 
 // New electron scheduler
@@ -70,15 +47,17 @@ func NewBinPackSortedWatts(tasks []def.Task, wattsAsAResource bool, schedTracePr
 	}
 
 	s := &BinPackSortedWatts{
-		tasks:            tasks,
-		wattsAsAResource: wattsAsAResource,
-		classMapWatts:    classMapWatts,
-		Shutdown:         make(chan struct{}),
-		Done:             make(chan struct{}),
-		PCPLog:           make(chan struct{}),
-		running:          make(map[string]map[string]bool),
-		RecordPCP:        false,
-		schedTrace:       log.New(logFile, "", log.LstdFlags),
+		base: base{
+			tasks:            tasks,
+			wattsAsAResource: wattsAsAResource,
+			classMapWatts:    classMapWatts,
+			Shutdown:         make(chan struct{}),
+			Done:             make(chan struct{}),
+			PCPLog:           make(chan struct{}),
+			running:          make(map[string]map[string]bool),
+			RecordPCP:        false,
+			schedTrace:       log.New(logFile, "", log.LstdFlags),
+		},
 	}
 	return s
 }

schedulers/bottomHeavy.go

@@ -54,30 +54,7 @@ func (s *BottomHeavy) takeOfferFirstFit(offer *mesos.Offer, wattsConsideration f
 // electronScheduler implements the Scheduler interface
 type BottomHeavy struct {
 	base                   // Type embedded to inherit common functions
-	tasksCreated           int
-	tasksRunning           int
-	tasks                  []def.Task
-	metrics                map[string]def.Metric
-	running                map[string]map[string]bool
-	wattsAsAResource       bool
-	classMapWatts          bool
 	smallTasks, largeTasks []def.Task
-
-	// First set of PCP values are garbage values, signal to logger to start recording when we're
-	// about to schedule a new task
-	RecordPCP bool
-
-	// This channel is closed when the program receives an interrupt,
-	// signalling that the program should shut down.
-	Shutdown chan struct{}
-	// This channel is closed after shutdown is closed, and only when all
-	// outstanding tasks have been cleaned up
-	Done chan struct{}
-
-	// Controls when to shutdown pcp logging
-	PCPLog chan struct{}
-
-	schedTrace *log.Logger
 }
 
 // New electron scheduler
@@ -93,16 +70,18 @@ func NewBottomHeavy(tasks []def.Task, wattsAsAResource bool, schedTracePrefix st
 	// Classification done based on MMPU watts requirements.
 	mid := int(math.Floor((float64(len(tasks)) / 2.0) + 0.5))
 	s := &BottomHeavy{
-		smallTasks:       tasks[:mid],
-		largeTasks:       tasks[mid+1:],
-		wattsAsAResource: wattsAsAResource,
-		classMapWatts:    classMapWatts,
-		Shutdown:         make(chan struct{}),
-		Done:             make(chan struct{}),
-		PCPLog:           make(chan struct{}),
-		running:          make(map[string]map[string]bool),
-		RecordPCP:        false,
-		schedTrace:       log.New(logFile, "", log.LstdFlags),
+		base: base{
+			wattsAsAResource: wattsAsAResource,
+			classMapWatts:    classMapWatts,
+			Shutdown:         make(chan struct{}),
+			Done:             make(chan struct{}),
+			PCPLog:           make(chan struct{}),
+			running:          make(map[string]map[string]bool),
+			RecordPCP:        false,
+			schedTrace:       log.New(logFile, "", log.LstdFlags),
+		},
+		smallTasks: tasks[:mid],
+		largeTasks: tasks[mid+1:],
 	}
 	return s
 }

schedulers/bpswMaxMin.go

@@ -34,34 +34,11 @@ func (s *BPSWMaxMinWatts) takeOffer(offer *mesos.Offer, task def.Task) bool {
 }
 
 type BPSWMaxMinWatts struct {
-	base             //Type embedding to inherit common functions
-	tasksCreated     int
-	tasksRunning     int
-	tasks            []def.Task
-	metrics          map[string]def.Metric
-	running          map[string]map[string]bool
-	wattsAsAResource bool
-	classMapWatts    bool
-
-	// First set of PCP values are garbage values, signal to logger to start recording when we're
-	// about to schedule a new task
-	RecordPCP bool
-
-	// This channel is closed when the program receives an interrupt,
-	// signalling that the program should shut down.
-	Shutdown chan struct{}
-	// This channel is closed after shutdown is closed, and only when all
-	// outstanding tasks have been cleaned up
-	Done chan struct{}
-
-	// Controls when to shutdown pcp logging
-	PCPLog chan struct{}
-
-	schedTrace *log.Logger
+	base //Type embedding to inherit common functions
 }
 
 // New electron scheduler
-func NewBPMaxMinWatts(tasks []def.Task, wattsAsAResource bool, schedTracePrefix string, classMapWatts bool) *BPSWMaxMinWatts {
+func NewBPSWMaxMinWatts(tasks []def.Task, wattsAsAResource bool, schedTracePrefix string, classMapWatts bool) *BPSWMaxMinWatts {
 	sort.Sort(def.WattsSorter(tasks))
 
 	logFile, err := os.Create("./" + schedTracePrefix + "_schedTrace.log")
@@ -70,15 +47,17 @@ func NewBPMaxMinWatts(tasks []def.Task, wattsAsAResource bool, schedTracePrefix
 	}
 
 	s := &BPSWMaxMinWatts{
-		tasks:            tasks,
-		wattsAsAResource: wattsAsAResource,
-		classMapWatts:    classMapWatts,
-		Shutdown:         make(chan struct{}),
-		Done:             make(chan struct{}),
-		PCPLog:           make(chan struct{}),
-		running:          make(map[string]map[string]bool),
-		RecordPCP:        false,
-		schedTrace:       log.New(logFile, "", log.LstdFlags),
+		base: base{
+			tasks:            tasks,
+			wattsAsAResource: wattsAsAResource,
+			classMapWatts:    classMapWatts,
+			Shutdown:         make(chan struct{}),
+			Done:             make(chan struct{}),
+			PCPLog:           make(chan struct{}),
+			running:          make(map[string]map[string]bool),
+			RecordPCP:        false,
+			schedTrace:       log.New(logFile, "", log.LstdFlags),
+		},
 	}
 	return s
 }

schedulers/bpswMaxMinPistonCapping.go

@@ -39,34 +39,11 @@ func (s *BPSWMaxMinPistonCapping) takeOffer(offer *mesos.Offer, task def.Task) b
 }
 
 type BPSWMaxMinPistonCapping struct {
-	base             //Type embedding to inherit common functions
-	tasksCreated     int
-	tasksRunning     int
-	tasks            []def.Task
-	metrics          map[string]def.Metric
-	running          map[string]map[string]bool
-	taskMonitor      map[string][]def.Task
-	totalPower       map[string]float64
-	wattsAsAResource bool
-	classMapWatts    bool
-	ticker           *time.Ticker
-	isCapping        bool
-
-	// First set of PCP values are garbage values, signal to logger to start recording when we're
-	// about to schedule a new task
-	RecordPCP bool
-
-	// This channel is closed when the program receives an interrupt,
-	// signalling that the program should shut down.
-	Shutdown chan struct{}
-	// This channel is closed after shutdown is closed, and only when all
-	// outstanding tasks have been cleaned up
-	Done chan struct{}
-
-	// Controls when to shutdown pcp logging
-	PCPLog chan struct{}
-
-	schedTrace *log.Logger
+	base        //Type embedding to inherit common functions
+	taskMonitor map[string][]def.Task
+	totalPower  map[string]float64
+	ticker      *time.Ticker
+	isCapping   bool
 }
 
 // New electron scheduler
@@ -80,19 +57,21 @@ func NewBPSWMaxMinPistonCapping(tasks []def.Task, wattsAsAResource bool, schedTr
 	}
 
 	s := &BPSWMaxMinPistonCapping{
-		tasks:            tasks,
-		wattsAsAResource: wattsAsAResource,
-		classMapWatts:    classMapWatts,
-		Shutdown:         make(chan struct{}),
-		Done:             make(chan struct{}),
-		PCPLog:           make(chan struct{}),
-		running:          make(map[string]map[string]bool),
-		taskMonitor:      make(map[string][]def.Task),
-		totalPower:       make(map[string]float64),
-		RecordPCP:        false,
-		ticker:           time.NewTicker(5 * time.Second),
-		isCapping:        false,
-		schedTrace:       log.New(logFile, "", log.LstdFlags),
+		base: base{
+			tasks:            tasks,
+			wattsAsAResource: wattsAsAResource,
+			classMapWatts:    classMapWatts,
+			Shutdown:         make(chan struct{}),
+			Done:             make(chan struct{}),
+			PCPLog:           make(chan struct{}),
+			running:          make(map[string]map[string]bool),
+			RecordPCP:        false,
+			schedTrace:       log.New(logFile, "", log.LstdFlags),
+		},
+		taskMonitor: make(map[string][]def.Task),
+		totalPower:  make(map[string]float64),
+		ticker:      time.NewTicker(5 * time.Second),
+		isCapping:   false,
 	}
 	return s
 

schedulers/bpswMaxMinProacCC.go

@@ -38,38 +38,15 @@ func (s *BPSWMaxMinProacCC) takeOffer(offer *mesos.Offer, task def.Task) bool {
 }
 
 type BPSWMaxMinProacCC struct {
-	base             // Type embedding to inherit common functions
-	tasksCreated     int
-	tasksRunning     int
-	tasks            []def.Task
-	metrics          map[string]def.Metric
-	running          map[string]map[string]bool
-	taskMonitor      map[string][]def.Task
-	availablePower   map[string]float64
-	totalPower       map[string]float64
-	wattsAsAResource bool
-	classMapWatts    bool
-	capper           *powCap.ClusterwideCapper
-	ticker           *time.Ticker
-	recapTicker      *time.Ticker
-	isCapping        bool // indicate whether we are currently performing cluster-wide capping.
-	isRecapping      bool // indicate whether we are currently performing cluster-wide recapping.
-
-	// First set of PCP values are garbage values, signal to logger to start recording when we're
-	// about to schedule a new task
-	RecordPCP bool
-
-	// This channel is closed when the program receives an interrupt,
-	// signalling that the program should shut down
-	Shutdown chan struct{}
-	// This channel is closed after shutdown is closed, and only when all
-	// outstanding tasks have been cleaned up
-	Done chan struct{}
-
-	// Controls when to shutdown pcp logging
-	PCPLog chan struct{}
-
-	schedTrace *log.Logger
+	base           // Type embedding to inherit common functions
+	taskMonitor    map[string][]def.Task
+	availablePower map[string]float64
+	totalPower     map[string]float64
+	capper         *powCap.ClusterwideCapper
+	ticker         *time.Ticker
+	recapTicker    *time.Ticker
+	isCapping      bool // indicate whether we are currently performing cluster-wide capping.
+	isRecapping    bool // indicate whether we are currently performing cluster-wide recapping.
 }
 
 // New electron scheduler
@@ -82,23 +59,25 @@ func NewBPSWMaxMinProacCC(tasks []def.Task, wattsAsAResource bool, schedTracePre
 	}
 
 	s := &BPSWMaxMinProacCC{
-		tasks:            tasks,
-		wattsAsAResource: wattsAsAResource,
-		classMapWatts:    classMapWatts,
-		Shutdown:         make(chan struct{}),
-		Done:             make(chan struct{}),
-		PCPLog:           make(chan struct{}),
-		running:          make(map[string]map[string]bool),
-		taskMonitor:      make(map[string][]def.Task),
-		availablePower:   make(map[string]float64),
-		totalPower:       make(map[string]float64),
-		RecordPCP:        false,
-		capper:           powCap.GetClusterwideCapperInstance(),
-		ticker:           time.NewTicker(10 * time.Second),
-		recapTicker:      time.NewTicker(20 * time.Second),
-		isCapping:        false,
-		isRecapping:      false,
-		schedTrace:       log.New(logFile, "", log.LstdFlags),
+		base: base{
+			tasks:            tasks,
+			wattsAsAResource: wattsAsAResource,
+			classMapWatts:    classMapWatts,
+			Shutdown:         make(chan struct{}),
+			Done:             make(chan struct{}),
+			PCPLog:           make(chan struct{}),
+			running:          make(map[string]map[string]bool),
+			RecordPCP:        false,
+			schedTrace:       log.New(logFile, "", log.LstdFlags),
+		},
+		taskMonitor:    make(map[string][]def.Task),
+		availablePower: make(map[string]float64),
+		totalPower:     make(map[string]float64),
+		capper:         powCap.GetClusterwideCapperInstance(),
+		ticker:         time.NewTicker(10 * time.Second),
+		recapTicker:    time.NewTicker(20 * time.Second),
+		isCapping:      false,
+		isRecapping:    false,
 	}
 	return s
 }

schedulers/firstfit.go

@@ -35,30 +35,7 @@ func (s *FirstFit) takeOffer(offer *mesos.Offer, task def.Task) bool {
 
 // electronScheduler implements the Scheduler interface
 type FirstFit struct {
-	base             // Type embedded to inherit common functions
-	tasksCreated     int
-	tasksRunning     int
-	tasks            []def.Task
-	metrics          map[string]def.Metric
-	running          map[string]map[string]bool
-	wattsAsAResource bool
-	classMapWatts    bool
-
-	// First set of PCP values are garbage values, signal to logger to start recording when we're
-	// about to schedule a new task
-	RecordPCP bool
-
-	// This channel is closed when the program receives an interrupt,
-	// signalling that the program should shut down.
-	Shutdown chan struct{}
-	// This channel is closed after shutdown is closed, and only when all
-	// outstanding tasks have been cleaned up
-	Done chan struct{}
-
-	// Controls when to shutdown pcp logging
-	PCPLog chan struct{}
-
-	schedTrace *log.Logger
+	base // Type embedded to inherit common functions
 }
 
 // New electron scheduler
@@ -70,15 +47,17 @@ func NewFirstFit(tasks []def.Task, wattsAsAResource bool, schedTracePrefix strin
 	}
 
 	s := &FirstFit{
-		tasks:            tasks,
-		wattsAsAResource: wattsAsAResource,
-		classMapWatts:    classMapWatts,
-		Shutdown:         make(chan struct{}),
-		Done:             make(chan struct{}),
-		PCPLog:           make(chan struct{}),
-		running:          make(map[string]map[string]bool),
-		RecordPCP:        false,
-		schedTrace:       log.New(logFile, "", log.LstdFlags),
+		base: base{
+			tasks:            tasks,
+			wattsAsAResource: wattsAsAResource,
+			classMapWatts:    classMapWatts,
+			Shutdown:         make(chan struct{}),
+			Done:             make(chan struct{}),
+			PCPLog:           make(chan struct{}),
+			running:          make(map[string]map[string]bool),
+			RecordPCP:        false,
+			schedTrace:       log.New(logFile, "", log.LstdFlags),
+		},
 	}
 	return s
 }

schedulers/firstfitProacCC.go

@@ -36,39 +36,15 @@ func (s *FirstFitProacCC) takeOffer(offer *mesos.Offer, task def.Task) bool {
 
 // electronScheduler implements the Scheduler interface.
 type FirstFitProacCC struct {
-	base             // Type embedded to inherit common functions
-	tasksCreated     int
-	tasksRunning     int
-	tasks            []def.Task
-	metrics          map[string]def.Metric
-	running          map[string]map[string]bool
-	taskMonitor      map[string][]def.Task // store tasks that are currently running.
-	availablePower   map[string]float64    // available power for each node in the cluster.
-	totalPower       map[string]float64    // total power for each node in the cluster.
-	wattsAsAResource bool
-	classMapWatts    bool
-	capper           *powCap.ClusterwideCapper
-	ticker           *time.Ticker
-	recapTicker      *time.Ticker
-	isCapping        bool // indicate whether we are currently performing cluster wide capping.
-	isRecapping      bool // indicate whether we are currently performing cluster wide re-capping.
-
-	// First set of PCP values are garbage values, signal to logger to start recording when we're
-	// about to schedule the new task.
-	RecordPCP bool
-
-	// This channel is closed when the program receives an interrupt,
-	// signalling that the program should shut down.
-	Shutdown chan struct{}
-
-	// This channel is closed after shutdown is closed, and only when all
-	// outstanding tasks have been cleaned up.
-	Done chan struct{}
-
-	// Controls when to shutdown pcp logging.
-	PCPLog chan struct{}
-
-	schedTrace *log.Logger
+	base                                 // Type embedded to inherit common functions
+	taskMonitor    map[string][]def.Task // store tasks that are currently running.
+	availablePower map[string]float64    // available power for each node in the cluster.
+	totalPower     map[string]float64    // total power for each node in the cluster.
+	capper         *powCap.ClusterwideCapper
+	ticker         *time.Ticker
+	recapTicker    *time.Ticker
+	isCapping      bool // indicate whether we are currently performing cluster wide capping.
+	isRecapping    bool // indicate whether we are currently performing cluster wide re-capping.
 }
 
 // New electron scheduler.
@@ -81,23 +57,25 @@ func NewFirstFitProacCC(tasks []def.Task, wattsAsAResource bool, schedTracePrefi
 	}
 
 	s := &FirstFitProacCC{
-		tasks:            tasks,
-		wattsAsAResource: wattsAsAResource,
-		classMapWatts:    classMapWatts,
-		Shutdown:         make(chan struct{}),
-		Done:             make(chan struct{}),
-		PCPLog:           make(chan struct{}),
-		running:          make(map[string]map[string]bool),
-		taskMonitor:      make(map[string][]def.Task),
-		availablePower:   make(map[string]float64),
-		totalPower:       make(map[string]float64),
-		RecordPCP:        false,
-		capper:           powCap.GetClusterwideCapperInstance(),
-		ticker:           time.NewTicker(10 * time.Second),
-		recapTicker:      time.NewTicker(20 * time.Second),
-		isCapping:        false,
-		isRecapping:      false,
-		schedTrace:       log.New(logFile, "", log.LstdFlags),
+		base: base{
+			tasks:            tasks,
+			wattsAsAResource: wattsAsAResource,
+			classMapWatts:    classMapWatts,
+			Shutdown:         make(chan struct{}),
+			Done:             make(chan struct{}),
+			PCPLog:           make(chan struct{}),
+			running:          make(map[string]map[string]bool),
+			RecordPCP:        false,
+			schedTrace:       log.New(logFile, "", log.LstdFlags),
+		},
+		taskMonitor:    make(map[string][]def.Task),
+		availablePower: make(map[string]float64),
+		totalPower:     make(map[string]float64),
+		capper:         powCap.GetClusterwideCapperInstance(),
+		ticker:         time.NewTicker(10 * time.Second),
+		recapTicker:    time.NewTicker(20 * time.Second),
+		isCapping:      false,
+		isRecapping:    false,
 	}
 	return s
 }

schedulers/firstfitSortedOffers.go

@@ -36,30 +36,7 @@ func (s *FirstFitSortedOffers) takeOffer(offer *mesos.Offer, task def.Task) bool
 
 // electronScheduler implements the Scheduler interface
 type FirstFitSortedOffers struct {
-	base             // Type embedded to inherit common functions
-	tasksCreated     int
-	tasksRunning     int
-	tasks            []def.Task
-	metrics          map[string]def.Metric
-	running          map[string]map[string]bool
-	wattsAsAResource bool
-	classMapWatts    bool
-
-	// First set of PCP values are garbage values, signal to logger to start recording when we're
-	// about to schedule a new task
-	RecordPCP bool
-
-	// This channel is closed when the program receives an interrupt,
-	// signalling that the program should shut down.
-	Shutdown chan struct{}
-	// This channel is closed after shutdown is closed, and only when all
-	// outstanding tasks have been cleaned up
-	Done chan struct{}
-
-	// Controls when to shutdown pcp logging
-	PCPLog chan struct{}
-
-	schedTrace *log.Logger
+	base // Type embedded to inherit common functions
 }
 
 // New electron scheduler
@@ -71,15 +48,17 @@ func NewFirstFitSortedOffers(tasks []def.Task, wattsAsAResource bool, schedTrace
 	}
 
 	s := &FirstFitSortedOffers{
-		tasks:            tasks,
-		wattsAsAResource: wattsAsAResource,
-		classMapWatts:    classMapWatts,
-		Shutdown:         make(chan struct{}),
-		Done:             make(chan struct{}),
-		PCPLog:           make(chan struct{}),
-		running:          make(map[string]map[string]bool),
-		RecordPCP:        false,
-		schedTrace:       log.New(logFile, "", log.LstdFlags),
+		base: base{
+			tasks:            tasks,
+			wattsAsAResource: wattsAsAResource,
+			classMapWatts:    classMapWatts,
+			Shutdown:         make(chan struct{}),
+			Done:             make(chan struct{}),
+			PCPLog:           make(chan struct{}),
+			running:          make(map[string]map[string]bool),
+			RecordPCP:        false,
+			schedTrace:       log.New(logFile, "", log.LstdFlags),
+		},
 	}
 	return s
 }

schedulers/firstfitSortedWattsProacCC.go

@@ -47,39 +47,15 @@ func (s *FirstFitSortedWattsProacCC) takeOffer(offer *mesos.Offer, task def.Task
 
 // electronScheduler implements the Scheduler interface
 type FirstFitSortedWattsProacCC struct {
-	base             // Type embedded to inherit common functions
-	tasksCreated     int
-	tasksRunning     int
-	tasks            []def.Task
-	metrics          map[string]def.Metric
-	running          map[string]map[string]bool
-	taskMonitor      map[string][]def.Task // store tasks that are currently running.
-	availablePower   map[string]float64    // available power for each node in the cluster.
-	totalPower       map[string]float64    // total power for each node in the cluster.
-	wattsAsAResource bool
-	classMapWatts    bool
-	capper           *powCap.ClusterwideCapper
-	ticker           *time.Ticker
-	recapTicker      *time.Ticker
-	isCapping        bool // indicate whether we are currently performing cluster wide capping.
-	isRecapping      bool // indicate whether we are currently performing cluster wide re-capping.
-
-	// First set of PCP values are garbage values, signal to logger to start recording when we're
-	// about to schedule the new task.
-	RecordPCP bool
-
-	// This channel is closed when the program receives an interrupt,
-	// signalling that the program should shut down.
-	Shutdown chan struct{}
-
-	// This channel is closed after shutdown is closed, and only when all
-	// outstanding tasks have been cleaned up.
-	Done chan struct{}
-
-	// Controls when to shutdown pcp logging.
-	PCPLog chan struct{}
-
-	schedTrace *log.Logger
+	base                                 // Type embedded to inherit common functions
+	taskMonitor    map[string][]def.Task // store tasks that are currently running.
+	availablePower map[string]float64    // available power for each node in the cluster.
+	totalPower     map[string]float64    // total power for each node in the cluster.
+	capper         *powCap.ClusterwideCapper
+	ticker         *time.Ticker
+	recapTicker    *time.Ticker
+	isCapping      bool // indicate whether we are currently performing cluster wide capping.
+	isRecapping    bool // indicate whether we are currently performing cluster wide re-capping.
 }
 
 // New electron scheduler.
@@ -95,23 +71,25 @@ func NewFirstFitSortedWattsProacCC(tasks []def.Task, wattsAsAResource bool, sche
 	}
 
 	s := &FirstFitSortedWattsProacCC{
-		tasks:            tasks,
-		wattsAsAResource: wattsAsAResource,
-		classMapWatts:    classMapWatts,
-		Shutdown:         make(chan struct{}),
-		Done:             make(chan struct{}),
-		PCPLog:           make(chan struct{}),
-		running:          make(map[string]map[string]bool),
-		taskMonitor:      make(map[string][]def.Task),
-		availablePower:   make(map[string]float64),
-		totalPower:       make(map[string]float64),
-		RecordPCP:        false,
-		capper:           powCap.GetClusterwideCapperInstance(),
-		ticker:           time.NewTicker(10 * time.Second),
-		recapTicker:      time.NewTicker(20 * time.Second),
-		isCapping:        false,
-		isRecapping:      false,
-		schedTrace:       log.New(logFile, "", log.LstdFlags),
+		base: base{
+			tasks:            tasks,
+			wattsAsAResource: wattsAsAResource,
+			classMapWatts:    classMapWatts,
+			Shutdown:         make(chan struct{}),
+			Done:             make(chan struct{}),
+			PCPLog:           make(chan struct{}),
+			running:          make(map[string]map[string]bool),
+			RecordPCP:        false,
+			schedTrace:       log.New(logFile, "", log.LstdFlags),
+		},
+		taskMonitor:    make(map[string][]def.Task),
+		availablePower: make(map[string]float64),
+		totalPower:     make(map[string]float64),
+		capper:         powCap.GetClusterwideCapperInstance(),
+		ticker:         time.NewTicker(10 * time.Second),
+		recapTicker:    time.NewTicker(20 * time.Second),
+		isCapping:      false,
+		isRecapping:    false,
 	}
 	return s
 }

schedulers/firstfitSortedWattsSortedOffers.go

@@ -36,30 +36,7 @@ func (s *FirstFitSortedWattsSortedOffers) takeOffer(offer *mesos.Offer, task def
 
 // electronScheduler implements the Scheduler interface
 type FirstFitSortedWattsSortedOffers struct {
-	base             // Type embedded to inherit common functions
-	tasksCreated     int
-	tasksRunning     int
-	tasks            []def.Task
-	metrics          map[string]def.Metric
-	running          map[string]map[string]bool
-	wattsAsAResource bool
-	classMapWatts    bool
-
-	// First set of PCP values are garbage values, signal to logger to start recording when we're
-	// about to schedule a new task
-	RecordPCP bool
-
-	// This channel is closed when the program receives an interrupt,
-	// signalling that the program should shut down.
-	Shutdown chan struct{}
-	// This channel is closed after shutdown is closed, and only when all
-	// outstanding tasks have been cleaned up
-	Done chan struct{}
-
-	// Controls when to shutdown pcp logging
-	PCPLog chan struct{}
-
-	schedTrace *log.Logger
+	base // Type embedded to inherit common functions
 }
 
 // New electron scheduler
@@ -75,15 +52,17 @@ func NewFirstFitSortedWattsSortedOffers(tasks []def.Task, wattsAsAResource bool,
 	}
 
 	s := &FirstFitSortedWattsSortedOffers{
-		tasks:            tasks,
-		wattsAsAResource: wattsAsAResource,
-		classMapWatts:    classMapWatts,
-		Shutdown:         make(chan struct{}),
-		Done:             make(chan struct{}),
-		PCPLog:           make(chan struct{}),
-		running:          make(map[string]map[string]bool),
-		RecordPCP:        false,
-		schedTrace:       log.New(logFile, "", log.LstdFlags),
+		base: base{
+			tasks:            tasks,
+			wattsAsAResource: wattsAsAResource,
+			classMapWatts:    classMapWatts,
+			Shutdown:         make(chan struct{}),
+			Done:             make(chan struct{}),
+			PCPLog:           make(chan struct{}),
+			running:          make(map[string]map[string]bool),
+			RecordPCP:        false,
+			schedTrace:       log.New(logFile, "", log.LstdFlags),
+		},
 	}
 	return s
 }

schedulers/firstfitsortedwatts.go

@@ -36,30 +36,7 @@ func (s *FirstFitSortedWatts) takeOffer(offer *mesos.Offer, task def.Task) bool
 
 // electronScheduler implements the Scheduler interface
 type FirstFitSortedWatts struct {
-	base             // Type embedded to inherit common functions
-	tasksCreated     int
-	tasksRunning     int
-	tasks            []def.Task
-	metrics          map[string]def.Metric
-	running          map[string]map[string]bool
-	wattsAsAResource bool
-	classMapWatts    bool
-
-	// First set of PCP values are garbage values, signal to logger to start recording when we're
-	// about to schedule a new task
-	RecordPCP bool
-
-	// This channel is closed when the program receives an interrupt,
-	// signalling that the program should shut down.
-	Shutdown chan struct{}
-	// This channel is closed after shutdown is closed, and only when all
-	// outstanding tasks have been cleaned up
-	Done chan struct{}
-
-	// Controls when to shutdown pcp logging
-	PCPLog chan struct{}
-
-	schedTrace *log.Logger
+	base // Type embedded to inherit common functions
 }
 
 // New electron scheduler
@@ -73,15 +50,17 @@ func NewFirstFitSortedWatts(tasks []def.Task, wattsAsAResource bool, schedTraceP
 	}
 
 	s := &FirstFitSortedWatts{
-		tasks:            tasks,
-		wattsAsAResource: wattsAsAResource,
-		classMapWatts:    classMapWatts,
-		Shutdown:         make(chan struct{}),
-		Done:             make(chan struct{}),
-		PCPLog:           make(chan struct{}),
-		running:          make(map[string]map[string]bool),
-		RecordPCP:        false,
-		schedTrace:       log.New(logFile, "", log.LstdFlags),
+		base: base{
+			tasks:            tasks,
+			wattsAsAResource: wattsAsAResource,
+			classMapWatts:    classMapWatts,
+			Shutdown:         make(chan struct{}),
+			Done:             make(chan struct{}),
+			PCPLog:           make(chan struct{}),
+			running:          make(map[string]map[string]bool),
+			RecordPCP:        false,
+			schedTrace:       log.New(logFile, "", log.LstdFlags),
+		},
 	}
 	return s
 }

schedulers/firstfitwattsonly.go

@@ -34,30 +34,7 @@ func (s *FirstFitWattsOnly) takeOffer(offer *mesos.Offer, task def.Task) bool {
 }
 
 type FirstFitWattsOnly struct {
-	base             // Type embedded to inherit common functions
-	tasksCreated     int
-	tasksRunning     int
-	tasks            []def.Task
-	metrics          map[string]def.Metric
-	running          map[string]map[string]bool
-	wattsAsAResource bool
-	classMapWatts    bool
-
-	// First set of PCP values are garbage values, signal to logger to start recording when we're
-	// about to schedule a new task
-	RecordPCP bool
-
-	// This channel is closed when the program receives an interrupt,
-	// signalling that the program should shut down.
-	Shutdown chan struct{}
-	// This channel is closed after shutdown is closed, and only when all
-	// outstanding tasks have been cleaned up
-	Done chan struct{}
-
-	// Controls when to shutdown pcp logging
-	PCPLog chan struct{}
-
-	schedTrace *log.Logger
+	base // Type embedded to inherit common functions
 }
 
 // New electron scheduler
@@ -69,15 +46,17 @@ func NewFirstFitWattsOnly(tasks []def.Task, wattsAsAResource bool, schedTracePre
 	}
 
 	s := &FirstFitWattsOnly{
-		tasks:            tasks,
-		wattsAsAResource: wattsAsAResource,
-		classMapWatts:    classMapWatts,
-		Shutdown:         make(chan struct{}),
-		Done:             make(chan struct{}),
-		PCPLog:           make(chan struct{}),
-		running:          make(map[string]map[string]bool),
-		RecordPCP:        false,
-		schedTrace:       log.New(logFile, "", log.LstdFlags),
+		base: base{
+			tasks:            tasks,
+			wattsAsAResource: wattsAsAResource,
+			classMapWatts:    classMapWatts,
+			Shutdown:         make(chan struct{}),
+			Done:             make(chan struct{}),
+			PCPLog:           make(chan struct{}),
+			running:          make(map[string]map[string]bool),
+			RecordPCP:        false,
+			schedTrace:       log.New(logFile, "", log.LstdFlags),
+		},
 	}
 	return s
 }

schedulers/topHeavy.go

@@ -53,30 +53,7 @@ func (s *TopHeavy) takeOfferFirstFit(offer *mesos.Offer, wattsConsideration floa
 // electronScheduler implements the Scheduler interface
 type TopHeavy struct {
 	base                   // Type embedded to inherit common functions
-	tasksCreated           int
-	tasksRunning           int
-	tasks                  []def.Task
-	metrics                map[string]def.Metric
-	running                map[string]map[string]bool
-	wattsAsAResource       bool
-	classMapWatts          bool
 	smallTasks, largeTasks []def.Task
-
-	// First set of PCP values are garbage values, signal to logger to start recording when we're
-	// about to schedule a new task
-	RecordPCP bool
-
-	// This channel is closed when the program receives an interrupt,
-	// signalling that the program should shut down.
-	Shutdown chan struct{}
-	// This channel is closed after shutdown is closed, and only when all
-	// outstanding tasks have been cleaned up
-	Done chan struct{}
-
-	// Controls when to shutdown pcp logging
-	PCPLog chan struct{}
-
-	schedTrace *log.Logger
 }
 
 // New electron scheduler
@@ -92,16 +69,18 @@ func NewTopHeavy(tasks []def.Task, wattsAsAResource bool, schedTracePrefix strin
 	// Classification done based on MMPU watts requirements.
 	mid := int(math.Floor((float64(len(tasks)) / 2.0) + 0.5))
 	s := &TopHeavy{
-		smallTasks:       tasks[:mid],
-		largeTasks:       tasks[mid+1:],
-		wattsAsAResource: wattsAsAResource,
-		classMapWatts:    classMapWatts,
-		Shutdown:         make(chan struct{}),
-		Done:             make(chan struct{}),
-		PCPLog:           make(chan struct{}),
-		running:          make(map[string]map[string]bool),
-		RecordPCP:        false,
-		schedTrace:       log.New(logFile, "", log.LstdFlags),
+		base: base{
+			wattsAsAResource: wattsAsAResource,
+			classMapWatts:    classMapWatts,
+			Shutdown:         make(chan struct{}),
+			Done:             make(chan struct{}),
+			PCPLog:           make(chan struct{}),
+			running:          make(map[string]map[string]bool),
+			RecordPCP:        false,
+			schedTrace:       log.New(logFile, "", log.LstdFlags),
+		},
+		smallTasks: tasks[:mid],
+		largeTasks: tasks[mid+1:],
 	}
 	return s
 }