Make number of threads explicit

Specify number of threads to be used when calculating stack memory allocation.

[#91088912]

Author: Steve Powell

flags/validate_flags.go

@@ -29,6 +29,7 @@ import (
 const (
 	executableName = "java-buildpack-memory-calculator"
 	totalFlag      = "totMemory"
+	threadsFlag    = "stackThreads"
 	weightsFlag    = "memoryWeights"
 	sizesFlag      = "memorySizes"
 	initialsFlag   = "memoryInitials"
@@ -47,6 +48,9 @@ var (
 	totMemory = flag.String(totalFlag, "",
 		"total memory available to allocate, expressed as an integral "+
 			"number of bytes, kilobytes, megabytes or gigabytes")
+	stackThreads = flag.Int(threadsFlag, 0,
+		"number of threads to use in stack allocation calculations, e.g. '50'; "+
+			"the default value of 0 causes an estimate to be used")
 	memoryWeights = flag.String(weightsFlag, "",
 		"the weights given to each memory type, e.g. 'heap:15,permgen:5,stack:1,native:2'")
 	memorySizes = flag.String(sizesFlag, "",
@@ -58,7 +62,7 @@ var (
 )
 
 // 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, initials map[string]float64) {
+func ValidateFlags() (memSize memory.MemSize, numThreads int, weights map[string]float64, sizes map[string]memory.Range, initials map[string]float64) {
 
 	flag.Parse() // exit on error
 
@@ -69,11 +73,12 @@ func ValidateFlags() (memSize memory.MemSize, weights map[string]float64, sizes
 
 	// validation routines will not return on error
 	memSize = validateTotMemory(*totMemory)
+	numThreads = validateNumThreads(*stackThreads)
 	weights = validateWeights(*memoryWeights)
 	sizes = validateSizes(*memorySizes)
 	initials = validateInitials(*memoryInitials)
 
-	return memSize, weights, sizes, initials
+	return memSize, numThreads, weights, sizes, initials
 }
 
 func validateTotMemory(mem string) memory.MemSize {
@@ -178,6 +183,14 @@ func validateInitials(initials string) map[string]float64 {
 	return is
 }
 
+func validateNumThreads(stackThreads int) int {
+	if stackThreads < 0 {
+		fmt.Fprintf(os.Stderr, "Error in -%s flag; value must be positive", threadsFlag)
+		os.Exit(1)
+	}
+	return stackThreads
+}
+
 func noArgs(args []string) bool {
 	return len(args) == 0
 }

integration/main_test.go

@@ -133,6 +133,21 @@ var _ = Describe("java-buildpack-memory-calculator executable", func() {
 		Ω(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])
 	})
 
+	It("executes with error when stackThreads 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",
+				"-stackThreads=-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("Error in -stackThreads flag; value must be positive"), "stderr incorrect for "+badFlags[0])
+	})
+
 	Context("with valid parameters", func() {
 		var (
 			totMemFlag, weightsFlag, sizesFlag, initialsFlag string

main.go

@@ -33,15 +33,15 @@ const (
 func main() {
 
 	// validateFlags() will exit on error
-	memSize, weights, sizes, initials := flags.ValidateFlags()
+	memSize, numThreads, weights, sizes, initials := flags.ValidateFlags()
 
 	allocator, err := memory.NewAllocator(sizes, weights)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "Cannot allocate memory: %s", err)
 		os.Exit(1)
 	}
 
-	if err = allocator.Balance(memSize); err != nil {
+	if err = allocator.Balance(memSize, numThreads); err != nil {
 		fmt.Fprintf(os.Stderr, "Cannot balance memory: %s", err)
 		os.Exit(1)
 	}

memory/allocator.go

@@ -24,10 +24,10 @@ 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)
-	GenerateInitialAllocations(map[string]float64) // Generate initial buckets
+	Balance(memLimit MemSize, numThreads int) 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 {
@@ -63,13 +63,13 @@ var initialMinimums = map[string]MemSize{
 
 // Balance memory between buckets, adjusting stack units, observing
 // constraints, and detecting memory wastage and default proximity.
-func (a *allocator) Balance(memLimit MemSize) error {
+func (a *allocator) Balance(memLimit MemSize, numThreads int) error {
 	if memLimit.LessThan(MemSize(kILO)) {
 		return fmt.Errorf("Too little memory to allocate: %s", memLimit)
 	}
 
 	// adjust stack bucket, if it exists
-	stackBucket, estNumThreads := a.normaliseStack(memLimit)
+	stackBucket, estNumThreads := a.normaliseStack(memLimit, numThreads)
 
 	// distribute memory among the buckets
 	if berr := a.balance(memLimit); berr != nil {
@@ -160,10 +160,14 @@ func totalWeight(bs map[string]Bucket) float64 {
 }
 
 // Replace stack bucket to make it represent total memory for stacks temporarily
-func (a *allocator) normaliseStack(memLimit MemSize) (originalStackBucket Bucket, estNumThreads float64) {
+func (a *allocator) normaliseStack(memLimit MemSize, numThreads int) (originalStackBucket Bucket, estNumThreads float64) {
 	if sb, ok := a.buckets["stack"]; ok {
 		stackMem := weightedSize(totalWeight(a.buckets), memLimit, sb)
-		estNumThreads = math.Max(1.0, stackMem/float64(sb.DefaultSize()))
+		if numThreads == 0 {
+			estNumThreads = math.Max(1.0, stackMem/float64(sb.DefaultSize()))
+		} else {
+			estNumThreads = float64(numThreads)
+		}
 		nsb, _ := NewBucket("normalised stack", sb.Weight(), sb.Range().Scale(estNumThreads))
 
 		a.buckets["stack"] = nsb

memory/allocator_test.go

@@ -90,13 +90,18 @@ var _ = Describe("Allocator", func() {
 
 	Context("balancing", func() {
 		var (
-			memLimit = memory.MEMSIZE_ZERO
-			aerr     error
+			memLimit   = memory.MEMSIZE_ZERO
+			aerr       error
+			numThreads = 0
 		)
 
+		BeforeEach(func() {
+			numThreads = 0
+		})
+
 		JustBeforeEach(func() {
 			a = shouldWork(memory.NewAllocator(convertToRanges(sizes), weights))
-			aerr = a.Balance(memLimit)
+			aerr = a.Balance(memLimit, numThreads)
 		})
 
 		Context("badly", func() {
@@ -348,6 +353,40 @@ var _ = Describe("Allocator", func() {
 				})
 			})
 
+			Context("when number of threads is specified", func() {
+
+				BeforeEach(func() {
+					sizes = strmap{}
+					weights = floatmap{"heap": 5.0, "permgen": 3.0, "stack": 1.0, "native": 1.0}
+					memLimit = memory.NewMemSize(4 * gIGA)
+					numThreads = 100
+				})
+
+				It("balances the stack according to number of threads", func() {
+					bucks := memory.GetBuckets(a)
+					Ω(bucks).Should(ContainElement(
+						"Bucket{name: stack, size: 4194K, range: 0.., weight: 1}",
+					))
+				})
+			})
+
+			Context("when number of threads is specified and stack size is fixed", func() {
+
+				BeforeEach(func() {
+					sizes = strmap{"stack": "2M"}
+					weights = floatmap{"heap": 5.0, "permgen": 3.0, "stack": 1.0, "native": 1.0}
+					memLimit = memory.NewMemSize(4 * gIGA)
+					numThreads = 100
+				})
+
+				It("balances the stack ignoring the number of threads", func() {
+					bucks := memory.GetBuckets(a)
+					Ω(bucks).Should(ContainElement(
+						"Bucket{name: stack, size: 2M, range: 2M..2M, weight: 1}",
+					))
+				})
+			})
+
 			Context("when thread stack size is specified", func() {
 
 				BeforeEach(func() {