Merge branch 'youngm-initial_memory'

* youngm-initial_memory:
  Refactor pull request 1
  Support for initial memory sizes

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

flags/validate_flags.go

@@ -31,6 +31,7 @@ const (
 	totalFlag      = "totMemory"
 	weightsFlag    = "memoryWeights"
 	sizesFlag      = "memorySizes"
+	initialsFlag   = "memoryInitials"
 )
 
 func printHelp() {
@@ -51,10 +52,13 @@ var (
 	memorySizes = flag.String(sizesFlag, "",
 		"the size ranges allowed for each memory type, "+
 			"e.g. 'heap:128m..1G,permgen:64m,stack:2m..4m,native:100m..'")
+	memoryInitials = flag.String(initialsFlag, "",
+		"the initial values for each memory type, "+
+			"e.g. 'heap:128m,permgen:64m'")
 )
 
 // Validate flags passed on command line; exit(1) if invalid; exit(2) if help printed
-func ValidateFlags() (memSize memory.MemSize, weights map[string]float64, sizes map[string]memory.Range) {
+func ValidateFlags() (memSize memory.MemSize, weights map[string]float64, sizes map[string]memory.Range, initials map[string]float64) {
 
 	flag.Parse() // exit on error
 
@@ -67,8 +71,9 @@ func ValidateFlags() (memSize memory.MemSize, weights map[string]float64, sizes
 	memSize = validateTotMemory(*totMemory)
 	weights = validateWeights(*memoryWeights)
 	sizes = validateSizes(*memorySizes)
+	initials = validateInitials(*memoryInitials)
 
-	return memSize, weights, sizes
+	return memSize, weights, sizes, initials
 }
 
 func validateTotMemory(mem string) memory.MemSize {
@@ -140,6 +145,39 @@ func validateSizes(sizes string) map[string]memory.Range {
 	return rs
 }
 
+func validateInitials(initials string) map[string]float64 {
+	is := map[string]float64{}
+
+	if initials == "" {
+		return is
+	}
+
+	initialClauses := strings.Split(initials, ",")
+	for _, clause := range initialClauses {
+		if parts := strings.Split(clause, ":"); len(parts) == 2 {
+			if !strings.HasSuffix(parts[1], "%") {
+				fmt.Fprintf(os.Stderr, "Bad initial value in -%s flag; clause '%s' : value must be a percentage (e.g. 10%%)", initialsFlag, clause)
+				os.Exit(1)
+			}
+			if floatVal, err := strconv.ParseFloat(strings.Replace(parts[1], "%", "", 1), 32); err != nil {
+				fmt.Fprintf(os.Stderr, "Bad initial value in -%s flag; clause '%s' : %s", initialsFlag, clause, err)
+				os.Exit(1)
+			} else if floatVal < 0.0 || floatVal > 100.0 {
+				fmt.Fprintf(os.Stderr, "Initial value must be zero or more but no more than 100%% in -%s flag; clause '%s'", initialsFlag, clause)
+				os.Exit(1)
+			} else {
+				//Convert value to valid scale factor
+				is[parts[0]] = floatVal * .01
+			}
+		} else {
+			fmt.Fprintf(os.Stderr, "Bad clause '%s' in -%s flag", clause, initialsFlag)
+			os.Exit(1)
+		}
+	}
+
+	return is
+}
+
 func noArgs(args []string) bool {
 	return len(args) == 0
 }

integration/main_test.go

@@ -88,21 +88,67 @@ var _ = Describe("java-buildpack-memory-calculator executable", func() {
 		Ω(string(se)).Should(ContainSubstring("Total memory (-totMemory flag) is less than 1K"), "stderr incorrect for "+badFlags[0])
 	})
 
+	It("executes with error when initial is not a percentage", func() {
+		badFlags :=
+			[]string{
+				"-totMemory=2G",
+				"-memoryWeights=heap:5,stack:1,permgen:3,native:1",
+				"-memorySizes=stack:2m..,heap:30m..400m,permgen:10m..12m",
+				"-memoryInitials=heap:50",
+			}
+		so, se, err := runOutAndErr(badFlags...)
+		Ω(err).Should(HaveOccurred(), badFlags[0])
+
+		Ω(string(so)).Should(BeEmpty(), "stdout not empty for "+badFlags[0])
+		Ω(string(se)).Should(ContainSubstring("Bad initial value in -memoryInitials flag; clause 'heap:50' : value must be a percentage (e.g. 10%)"), "stderr incorrect for "+badFlags[0])
+	})
+
+	It("executes with error when initial too big", func() {
+		badFlags :=
+			[]string{
+				"-totMemory=2G",
+				"-memoryWeights=heap:5,stack:1,permgen:3,native:1",
+				"-memorySizes=stack:2m..,heap:30m..400m,permgen:10m..12m",
+				"-memoryInitials=heap:101%",
+			}
+		so, se, err := runOutAndErr(badFlags...)
+		Ω(err).Should(HaveOccurred(), badFlags[0])
+
+		Ω(string(so)).Should(BeEmpty(), "stdout not empty for "+badFlags[0])
+		Ω(string(se)).Should(ContainSubstring("Initial value must be zero or more but no more than 100% in -memoryInitials flag; clause 'heap:101%'"), "stderr incorrect for "+badFlags[0])
+	})
+
+	It("executes with error when initial is negative", func() {
+		badFlags :=
+			[]string{
+				"-totMemory=2G",
+				"-memoryWeights=heap:5,stack:1,permgen:3,native:1",
+				"-memorySizes=stack:2m..,heap:30m..400m,permgen:10m..12m",
+				"-memoryInitials=heap:-1%",
+			}
+		so, se, err := runOutAndErr(badFlags...)
+		Ω(err).Should(HaveOccurred(), badFlags[0])
+
+		Ω(string(so)).Should(BeEmpty(), "stdout not empty for "+badFlags[0])
+		Ω(string(se)).Should(ContainSubstring("Initial value must be zero or more but no more than 100% in -memoryInitials flag; clause 'heap:-1%'"), "stderr incorrect for "+badFlags[0])
+	})
+
 	Context("with valid parameters", func() {
 		var (
-			totMemFlag, weightsFlag, sizesFlag string
-			sOut, sErr                         []byte
-			cmdErr                             error
+			totMemFlag, weightsFlag, sizesFlag, initialsFlag string
+			sOut, sErr                                       []byte
+			cmdErr                                           error
 		)
 
 		BeforeEach(func() {
 			totMemFlag = "-totMemory=4g"
 			weightsFlag = "-memoryWeights=heap:5,stack:1,permgen:3,native:1"
 			sizesFlag = "-memorySizes=stack:1m"
+			initialsFlag = "-memoryInitials=heap:50%,permgen:50%"
 		})
 
 		JustBeforeEach(func() {
-			goodFlags := []string{totMemFlag, weightsFlag, sizesFlag}
+			goodFlags := []string{totMemFlag, weightsFlag, sizesFlag, initialsFlag}
 			sOut, sErr, cmdErr = runOutAndErr(goodFlags...)
 		})
 
@@ -111,6 +157,7 @@ var _ = Describe("java-buildpack-memory-calculator executable", func() {
 				totMemFlag = "-totMemory=4g"
 				weightsFlag = ""
 				sizesFlag = ""
+				initialsFlag = ""
 			})
 
 			It("succeeds", func() {
@@ -120,6 +167,22 @@ var _ = Describe("java-buildpack-memory-calculator executable", func() {
 			})
 		})
 
+		Context("using no memoryInitials parameter", func() {
+			BeforeEach(func() {
+				initialsFlag = ""
+			})
+
+			It("succeeds", func() {
+				Ω(cmdErr).ShouldNot(HaveOccurred(), "exit status")
+				Ω(string(sErr)).Should(Equal(""), "stderr")
+				Ω(strings.Split(string(sOut), " ")).Should(ConsistOf(
+					"-Xmx2G",
+					"-Xss1M",
+					"-XX:MaxPermSize=1258291K",
+				), "stdout")
+			})
+		})
+
 		Context("using permgen", func() {
 			BeforeEach(func() {
 				totMemFlag = "-totMemory=4g"
@@ -131,10 +194,10 @@ var _ = Describe("java-buildpack-memory-calculator executable", func() {
 				Ω(string(sErr)).Should(Equal(""), "stderr")
 				Ω(strings.Split(string(sOut), " ")).Should(ConsistOf(
 					"-Xmx2G",
-					"-Xms2G",
+					"-Xms1G",
 					"-Xss1M",
 					"-XX:MaxPermSize=1258291K",
-					"-XX:PermSize=1258291K",
+					"-XX:PermSize=629145K",
 				), "stdout")
 			})
 		})
@@ -143,17 +206,18 @@ var _ = Describe("java-buildpack-memory-calculator executable", func() {
 			BeforeEach(func() {
 				totMemFlag = "-totMemory=4g"
 				weightsFlag = "-memoryWeights=heap:5,stack:1,metaspace:3,native:1"
+				initialsFlag = "-memoryInitials=heap:50%,metaspace:50%"
 			})
 
 			It("succeeds", func() {
 				Ω(cmdErr).ShouldNot(HaveOccurred(), "exit status")
 				Ω(string(sErr)).Should(Equal(""), "stderr")
 				Ω(strings.Split(string(sOut), " ")).Should(ConsistOf(
 					"-Xmx2G",
-					"-Xms2G",
+					"-Xms1G",
 					"-Xss1M",
 					"-XX:MaxMetaspaceSize=1258291K",
-					"-XX:MetaspaceSize=1258291K",
+					"-XX:MetaspaceSize=629145K",
 				), "stdout")
 			})
 		})
@@ -184,10 +248,10 @@ var _ = Describe("java-buildpack-memory-calculator executable", func() {
 				Ω(string(sErr)).Should(Equal("There is more than 3 times more spare native memory than the default so configured Java memory may be too small or available memory may be too large\n"), "stderr")
 				Ω(strings.Split(string(sOut), " ")).Should(ConsistOf(
 					"-Xmx800M",
-					"-Xms800M",
+					"-Xms400M",
 					"-Xss3120K",
 					"-XX:MaxPermSize=800M",
-					"-XX:PermSize=800M",
+					"-XX:PermSize=400M",
 				), "stdout")
 			})
 		})
@@ -201,7 +265,7 @@ var _ = Describe("java-buildpack-memory-calculator executable", func() {
 
 			It("issues a warning", func() {
 				Ω(cmdErr).ShouldNot(HaveOccurred(), "exit status")
-				Ω(string(sErr)).Should(Equal("The allocated Java memory sizes total 2469478K which is less than 0.8 of the available memory, so configured Java memory sizes may be too small or available memory may be too large\n"), "stderr")
+				Ω(string(sErr)).Should(ContainSubstring("The allocated Java memory sizes total 2469478K which is less than 0.8 of the available memory, so configured Java memory sizes may be too small or available memory may be too large\n"), "stderr")
 				Ω(strings.Split(string(sOut), " ")).Should(ConsistOf(
 					"-XX:MaxPermSize=1M",
 					"-XX:PermSize=1M",
@@ -224,9 +288,9 @@ var _ = Describe("java-buildpack-memory-calculator executable", func() {
 				Ω(string(sErr)).Should(Equal("The specified value 2049M for memory type heap is close to the computed value 2G. Consider taking the default.\n"), "stderr")
 				Ω(strings.Split(string(sOut), " ")).Should(ConsistOf(
 					"-XX:MaxPermSize=1257676K",
-					"-XX:PermSize=1257676K",
+					"-XX:PermSize=628838K",
 					"-Xmx2049M",
-					"-Xms2049M",
+					"-Xms1049088K",
 					"-Xss1023K",
 				), "stdout")
 			})
@@ -245,9 +309,25 @@ var _ = Describe("java-buildpack-memory-calculator executable", func() {
 				Ω(strings.Split(string(sOut), " ")).Should(ConsistOf(
 					"-Xss984K",
 					"-XX:MaxPermSize=1339M",
-					"-XX:PermSize=1339M",
+					"-XX:PermSize=685568K",
 					"-Xmx2016548K",
-					"-Xms2016548K",
+					"-Xms1008274K",
+				), "stdout")
+			})
+		})
+		Context("when the specified initial memory is less than static minimum", func() {
+			BeforeEach(func() {
+				initialsFlag = "-memoryInitials=heap:0%"
+			})
+
+			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 minimum 2M.  Setting initial value to 2M.\n"), "stderr")
+				Ω(strings.Split(string(sOut), " ")).Should(ConsistOf(
+					"-Xss1M",
+					"-XX:MaxPermSize=1258291K",
+					"-Xmx2G",
+					"-Xms2M",
 				), "stdout")
 			})
 		})

main.go

@@ -33,9 +33,7 @@ const (
 func main() {
 
 	// validateFlags() will exit on error
-	memSize, weights, sizes := flags.ValidateFlags()
-
-	switchFuns := switches.AllJreSwitchFuns
+	memSize, weights, sizes, initials := flags.ValidateFlags()
 
 	allocator, err := memory.NewAllocator(sizes, weights)
 	if err != nil {
@@ -47,11 +45,15 @@ func main() {
 		fmt.Fprintf(os.Stderr, "Cannot balance memory: %s", err)
 		os.Exit(1)
 	}
+
+	allocator.GenerateInitialAllocations(initials)
+
+	allocatorSwitches := allocator.Switches(switches.AllocatorJreSwitchFuns)
+
 	if warnings := allocator.GetWarnings(); len(warnings) != 0 {
 		fmt.Fprintln(os.Stderr, strings.Join(warnings, "\n"))
 	}
 
-	switches := allocator.Switches(switchFuns)
-	fmt.Fprint(os.Stdout, strings.Join(switches, " "))
+	fmt.Fprint(os.Stdout, strings.Join(allocatorSwitches, " "))
 
 }