Refactor pull request 1

Merge switches functions; eliminate initial switches step; remove
GetSizes() method.

[#99686520]

Author: Steve Powell

README.md

@@ -6,21 +6,22 @@
 [Install Go][] and then `get` the memory calculator (in the Go source tree).
 
 We run our tests with [Ginkgo/Gomega][] and manage dependencies with [Godep][].
-Ginkgo is one of the dependencies we manage, so get Godep before starting work.
+Ginkgo is one of the dependencies we manage, so get Godep before starting work:
 
 ```shell
 go get -v github.com/cloudfoundry/java-buildpack-memory-calculator
 cd src/github.com/cloudfoundry/java-buildpack-memory-calculator
 
 go get -v github.com/tools/godep
 ```
+
 (The `-v` options on `go get` are there so you can see what packages are compiled under the covers.)
 
 The (bash) script `scripts/runTests` uses (the correct version of) Ginkgo to
 run the tests (using the correct versions of the dependencies). `runTests`
 will recompile Ginkgo if necessary.
 
-The parameters to runTests are passed directly to Ginkgo.  For example:
+The parameters to `runTests` are passed directly to Ginkgo.  For example:
 
 ```shell
 scripts/runTests -r=false memory
@@ -38,7 +39,7 @@ To develop against the code, you should issue:
 ```shell
 godep restore
 ```
-in the project directory before running tests or building from the command line.
+in the project directory before building or running tests directly from the command line.
 
 If you wish to develop against a particular tagged *version* then, in the
 project directory, you need to checkout this version (using 
@@ -49,6 +50,15 @@ obtained, or else it cannot be (re)set to the version this project depends on.
 Normally `go get -u <project>` for the dependency in error will then allow
 `godep restore` to complete normally.
 
+### Release binaries
+
+The executables are built for more than one platform, so the Go compiler must exist 
+for the target platforms we need (currently linux and darwin). The shell script (`buildReleases`)
+will use the Go compiler with the `GOOS` environment variable to generate the executables.
+
+This will not work if the Go installation doesn't support all these platforms, so you may have to 
+ensure Go is installed with cross-compiler support.
+
 [Install Go]: http://golang.org/doc/install
 [Godep]: http://github.com/tools/godep
 [Ginkgo/Gomega]: http://github.com/onsi/ginkgo

integration/main_test.go

@@ -322,7 +322,7 @@ var _ = Describe("java-buildpack-memory-calculator executable", func() {
 
 			It("issues a warning", func() {
 				Ω(cmdErr).ShouldNot(HaveOccurred(), "exit status")
-				Ω(string(sErr)).Should(Equal("The configured initial memory size 0 for heap is less than the jvm minimum 2M.  Setting initial value to 2M.\n"), "stderr")
+				Ω(string(sErr)).Should(Equal("The configured initial memory size 0 for heap is less than the minimum 2M.  Setting initial value to 2M.\n"), "stderr")
 				Ω(strings.Split(string(sOut), " ")).Should(ConsistOf(
 					"-Xss1M",
 					"-XX:MaxPermSize=1258291K",

main.go

@@ -45,20 +45,15 @@ func main() {
 		fmt.Fprintf(os.Stderr, "Cannot balance memory: %s", err)
 		os.Exit(1)
 	}
-	if warnings := allocator.GetWarnings(); len(warnings) != 0 {
-		fmt.Fprintln(os.Stderr, strings.Join(warnings, "\n"))
-	}
-	
-	allocatorSwitches := allocator.Switches(switches.AllocatorJreSwitchFuns)
 
-	initialSwitches, warnings := memory.InitialsSwitches(initials, allocator.GetSizes(), switches.InitialJreSwitchFuns)
+	allocator.GenerateInitialAllocations(initials)
 
-	if len(warnings) != 0 {
+	allocatorSwitches := allocator.Switches(switches.AllocatorJreSwitchFuns)
+
+	if warnings := allocator.GetWarnings(); len(warnings) != 0 {
 		fmt.Fprintln(os.Stderr, strings.Join(warnings, "\n"))
 	}
 
-	switches := append(allocatorSwitches, initialSwitches...)
-
-	fmt.Fprint(os.Stdout, strings.Join(switches, " "))
+	fmt.Fprint(os.Stdout, strings.Join(allocatorSwitches, " "))
 
 }

memory/allocator.go

@@ -24,16 +24,17 @@ import (
 )
 
 type Allocator interface {
-	Balance(memLimit MemSize) error  // Balance allocations to buckets within memory limit
-	Switches(switches.Funs) []string // Get selected memory switches from current allocations
-	GetWarnings() []string           // Get warnings (if balancing succeeded)
-	GetSizes() map[string]MemSize    // Get a map of all the sizes after balancing
+	Balance(memLimit MemSize) error                // Balance allocations to buckets within memory limit
+	Switches(switches.Funs) []string               // Get selected memory switches from current allocations
+	GetWarnings() []string                         // Get warnings (if balancing succeeded)
+	GenerateInitialAllocations(map[string]float64) // Generate initial buckets
 }
 
 type allocator struct {
-	originalSizes map[string]Range  // unmodified after creation
-	buckets       map[string]Bucket // named buckets for allocation
-	warnings      []string          // warnings if allocation found issues
+	originalSizes map[string]Range   // unmodified after creation
+	buckets       map[string]Bucket  // named buckets for allocation
+	warnings      []string           // warnings if allocation found issues
+	allocations   map[string]MemSize // calculated sizes
 }
 
 func NewAllocator(sizes map[string]Range, heuristics map[string]float64) (*allocator, error) {
@@ -53,6 +54,13 @@ const (
 	CLOSE_TO_DEFAULT_FACTOR      float64 = 0.1
 )
 
+//Set of initial minimums
+var initialMinimums = map[string]MemSize{
+	"heap":      MemSize(2097152),    //2MB minimum works for Java 7 and Java 8
+	"metaspace": NewMemSize(262144),  //256KB
+	"permgen":   NewMemSize(1048576), // 1MB
+}
+
 // Balance memory between buckets, adjusting stack units, observing
 // constraints, and detecting memory wastage and default proximity.
 func (a *allocator) Balance(memLimit MemSize) error {
@@ -74,13 +82,23 @@ func (a *allocator) Balance(memLimit MemSize) error {
 	// reset stack bucket, if it exists
 	a.unnormaliseStack(stackBucket, estNumThreads)
 
+	// generate allocations
+	a.generateAllocations()
+
 	return nil
 }
 
+func (a *allocator) generateAllocations() {
+	a.allocations = map[string]MemSize{}
+	for name, bucket := range a.buckets {
+		a.allocations[name] = *bucket.GetSize()
+	}
+}
+
 func (a *allocator) Switches(sfs switches.Funs) []string {
 	var strs = make([]string, 0, 10)
-	for s, b := range a.buckets {
-		strs = append(strs, sfs.Apply(s, b.GetSize().String())...)
+	for s, b := range a.allocations {
+		strs = append(strs, sfs.Apply(s, b.String())...)
 	}
 	return strs
 }
@@ -89,12 +107,24 @@ func (a *allocator) GetWarnings() []string {
 	return a.warnings
 }
 
-func (a *allocator) GetSizes() map[string]MemSize {
-	sizes := map[string]MemSize{}
-	for name, bucket := range a.buckets {
-		sizes[name] = *bucket.GetSize()
+func (a *allocator) GenerateInitialAllocations(initials map[string]float64) {
+	for name, ratio := range initials {
+		initial_name := "initial_" + name
+
+		maxSize := a.buckets[name].GetSize()
+		initSize, initMin := maxSize.Scale(ratio), initialMinimums[name]
+
+		if !initSize.LessThan(initMin) {
+			a.allocations[initial_name] = initSize
+		} else if maxSize.LessThan(initMin) {
+			a.allocations[initial_name] = *maxSize
+		} else {
+			a.allocations[initial_name] = initMin
+			a.warnings = append(a.warnings, fmt.Sprintf(
+				"The configured initial memory size %[1]s for %[2]s is less than the minimum %[3]s.  Setting initial value to %[3]s.",
+				initSize, name, initMin))
+		}
 	}
-	return sizes
 }
 
 // getSizes returns a slice of memory type range strings

memory/initials.go

@@ -36,16 +36,13 @@ func apply(ss ...string) func(string) []string {
 
 var (
 	AllocatorJreSwitchFuns = Funs{
-		"heap":      apply("-Xmx%s"),
-		"metaspace": apply("-XX:MaxMetaspaceSize=%s"),
-		"permgen":   apply("-XX:MaxPermSize=%s"),
-		"stack":     apply("-Xss%s"),
-	}
-
-	InitialJreSwitchFuns = Funs{
-		"heap":      apply("-Xms%s"),
-		"metaspace": apply("-XX:MetaspaceSize=%s"),
-		"permgen":   apply("-XX:PermSize=%s"),
+		"heap":              apply("-Xmx%s"),
+		"metaspace":         apply("-XX:MaxMetaspaceSize=%s"),
+		"permgen":           apply("-XX:MaxPermSize=%s"),
+		"stack":             apply("-Xss%s"),
+		"initial_heap":      apply("-Xms%s"),
+		"initial_metaspace": apply("-XX:MetaspaceSize=%s"),
+		"initial_permgen":   apply("-XX:PermSize=%s"),
 	}
 )