Merge pull request #1124 from piosz/nanny

[Addon resizer] Added ExponentialEstimator to pod nanny

Author: piosz

addon-resizer/Godeps/Godeps.json

@@ -20,8 +20,10 @@ import (
 	api "k8s.io/kubernetes/pkg/api/v1"
 
 	"k8s.io/kubernetes/pkg/api/resource"
+)
 
-	inf "speter.net/go/exp/math/dec/inf"
+const (
+	eps = float64(0.01)
 )
 
 // Resource defines the name of a resource, the quantity, and the marginal value.
@@ -36,20 +38,33 @@ type LinearEstimator struct {
 }
 
 func (e LinearEstimator) scaleWithNodes(numNodes uint64) *api.ResourceRequirements {
+	return calculateResources(numNodes, e.Resources)
+}
+
+// ExponentialEstimator estimates the amount of resources in the way that
+// prevents from frequent updates but may end up with larger resource usage
+// than actually needed (though no more than ScaleFactor).
+type ExponentialEstimator struct {
+	Resources   []Resource
+	ScaleFactor float64
+}
+
+func (e ExponentialEstimator) scaleWithNodes(numNodes uint64) *api.ResourceRequirements {
+	n := uint64(16)
+	for n < numNodes {
+		n = uint64(float64(n)*e.ScaleFactor + eps)
+	}
+	return calculateResources(n, e.Resources)
+}
+
+func calculateResources(numNodes uint64, resources []Resource) *api.ResourceRequirements {
 	limits := make(api.ResourceList)
 	requests := make(api.ResourceList)
-	for _, r := range e.Resources {
-		num := inf.NewDec(int64(numNodes), 0)
-		num.Mul(num, r.ExtraPerNode.Amount)
-		num.Add(num, r.Base.Amount)
-		limits[r.Name] = resource.Quantity{
-			Amount: num,
-			Format: r.Base.Format,
-		}
-		requests[r.Name] = resource.Quantity{
-			Amount: num,
-			Format: r.Base.Format,
-		}
+	for _, r := range resources {
+		val := r.Base.MilliValue() + r.ExtraPerNode.MilliValue()*int64(numNodes)
+		newRes := resource.NewMilliQuantity(val, r.Base.Format)
+		limits[r.Name] = *newRes
+		requests[r.Name] = *newRes
 	}
 	return &api.ResourceRequirements{
 		Limits:   limits,

addon-resizer/Godeps/Readme

@@ -17,7 +17,6 @@ limitations under the License.
 package nanny
 
 import (
-	"reflect"
 	"testing"
 
 	resource "k8s.io/kubernetes/pkg/api/resource"
@@ -90,6 +89,27 @@ var (
 		Resources: []Resource{},
 	}
 
+	exponentialEstimator = ExponentialEstimator{
+		Resources: []Resource{
+			{
+				Base:         resource.MustParse("0.3"),
+				ExtraPerNode: resource.MustParse("1"),
+				Name:         "cpu",
+			},
+			{
+				Base:         resource.MustParse("30Mi"),
+				ExtraPerNode: resource.MustParse("1Mi"),
+				Name:         "memory",
+			},
+			{
+				Base:         resource.MustParse("30Gi"),
+				ExtraPerNode: resource.MustParse("1Gi"),
+				Name:         "storage",
+			},
+		},
+		ScaleFactor: 1.5,
+	}
+
 	baseResources = api.ResourceList{
 		"cpu":     resource.MustParse("0.3"),
 		"memory":  resource.MustParse("30Mi"),
@@ -126,8 +146,34 @@ var (
 		"memory": resource.MustParse("33Mi"),
 	}
 	noResources = api.ResourceList{}
+
+	sixteenNodeResources = api.ResourceList{
+		"cpu":     resource.MustParse("16.3"),
+		"memory":  resource.MustParse("46Mi"),
+		"storage": resource.MustParse("46Gi"),
+	}
+	twentyFourNodeResources = api.ResourceList{
+		"cpu":     resource.MustParse("24.3"),
+		"memory":  resource.MustParse("54Mi"),
+		"storage": resource.MustParse("54Gi"),
+	}
 )
 
+func verifyResources(t *testing.T, kind string, got, want api.ResourceList) {
+	if len(got) != len(want) {
+		t.Errorf("%s not equal got: %+v want: %+v", kind, got, want)
+	}
+	for res, val := range want {
+		actVal, ok := got[res]
+		if !ok {
+			t.Errorf("missing resource %s in %s", res, kind)
+		}
+		if val.Cmp(actVal) != 0 {
+			t.Errorf("not equal resource %s in %s, got: %+v, want: %+v", res, kind, actVal, val)
+		}
+	}
+}
+
 func TestEstimateResources(t *testing.T) {
 	testCases := []struct {
 		e        ResourceEstimator
@@ -137,6 +183,8 @@ func TestEstimateResources(t *testing.T) {
 	}{
 		{fullEstimator, 0, baseResources, baseResources},
 		{fullEstimator, 3, threeNodeResources, threeNodeResources},
+		{fullEstimator, 16, sixteenNodeResources, sixteenNodeResources},
+		{fullEstimator, 24, twentyFourNodeResources, twentyFourNodeResources},
 		{noCPUEstimator, 0, noCPUBaseResources, noCPUBaseResources},
 		{noCPUEstimator, 3, threeNodeNoCPUResources, threeNodeNoCPUResources},
 		{noMemoryEstimator, 0, noMemoryBaseResources, noMemoryBaseResources},
@@ -145,16 +193,22 @@ func TestEstimateResources(t *testing.T) {
 		{noStorageEstimator, 3, threeNodeNoStorageResources, threeNodeNoStorageResources},
 		{emptyEstimator, 0, noResources, noResources},
 		{emptyEstimator, 3, noResources, noResources},
+		{exponentialEstimator, 0, sixteenNodeResources, sixteenNodeResources},
+		{exponentialEstimator, 3, sixteenNodeResources, sixteenNodeResources},
+		{exponentialEstimator, 10, sixteenNodeResources, sixteenNodeResources},
+		{exponentialEstimator, 16, sixteenNodeResources, sixteenNodeResources},
+		{exponentialEstimator, 17, twentyFourNodeResources, twentyFourNodeResources},
+		{exponentialEstimator, 20, twentyFourNodeResources, twentyFourNodeResources},
+		{exponentialEstimator, 24, twentyFourNodeResources, twentyFourNodeResources},
 	}
 
-	for i, tc := range testCases {
+	for _, tc := range testCases {
 		got := tc.e.scaleWithNodes(tc.numNodes)
 		want := &api.ResourceRequirements{
 			Limits:   tc.limits,
 			Requests: tc.requests,
 		}
-		if !reflect.DeepEqual(got, want) {
-			t.Errorf("scaleWithNodes got %v, want %v in test case %d", got, want, i)
-		}
+		verifyResources(t, "limits", got.Limits, want.Limits)
+		verifyResources(t, "requests", got.Requests, want.Limits)
 	}
 }

addon-resizer/nanny/estimator.go

@@ -48,6 +48,7 @@ var (
 	containerName = flag.String("container", "pod-nanny", "The name of the container to watch. This defaults to the nanny itself.")
 	// Flags to control runtime behavior.
 	pollPeriod = time.Millisecond * time.Duration(*flag.Int("poll-period", 10000, "The time, in milliseconds, to poll the dependent container."))
+	estimator  = flag.String("estimator", "linear", "The estimator to use. Currently supported: linear, exponential")
 )
 
 func main() {
@@ -107,8 +108,19 @@ func main() {
 	}
 
 	log.Infof("Resources: %v", resources)
-	est := nanny.LinearEstimator{
-		Resources: resources,
+
+	var est nanny.ResourceEstimator
+	if *estimator == "linear" {
+		est = nanny.LinearEstimator{
+			Resources: resources,
+		}
+	} else if *estimator == "exponential" {
+		est = nanny.ExponentialEstimator{
+			Resources:   resources,
+			ScaleFactor: 1.5,
+		}
+	} else {
+		log.Fatalf("Estimator %s not supported", *estimator)
 	}
 
 	// Begin nannying.

addon-resizer/nanny/estimator_test.go

@@ -24,8 +24,8 @@ import (
 	"time"
 
 	log "github.com/golang/glog"
+	inf "gopkg.in/inf.v0"
 	api "k8s.io/kubernetes/pkg/api/v1"
-	inf "speter.net/go/exp/math/dec/inf"
 )
 
 // checkResource determines whether a specific resource needs to be over-written.
@@ -38,7 +38,7 @@ func checkResource(threshold int64, actual, expected api.ResourceList, res api.R
 	if !ok && !expOk {
 		return false
 	}
-	q := new(inf.Dec).QuoRound(val.Amount, expVal.Amount, 2, inf.RoundDown)
+	q := new(inf.Dec).QuoRound(val.AsDec(), expVal.AsDec(), 2, inf.RoundDown)
 	lower := inf.NewDec(100-threshold, 2)
 	upper := inf.NewDec(100+threshold, 2)
 	if q.Cmp(lower) == -1 || q.Cmp(upper) == 1 {