Configure number of stack threads for memory

Christopher Frost · Christopher Frost · commit 485c4552f946 · 2015-08-13T13:13:39.000+01:00
This commit adds the ability to configure the number of threads the memory calculator should use when calculating the stack to allocate per thread. The default behaviour of the Java Buildpack is unchanged.

[#91088912]
diff --git a/config/open_jdk_jre.yml b/config/open_jdk_jre.yml
@@ -22,6 +22,7 @@ jre:
 memory_calculator:
   version: 2.+
   repository_root: ! '{default.repository.root}/memory-calculator/{platform}/{architecture}'
+  stack_threads: 
   memory_sizes:
     heap: 
     metaspace: 64m..
diff --git a/config/oracle_jre.yml b/config/oracle_jre.yml
@@ -25,6 +25,7 @@ jre:
 memory_calculator:
   version: 2.+
   repository_root: ! '{default.repository.root}/memory-calculator/{platform}/{architecture}'
+  stack_threads:
   memory_sizes:
     heap:
     metaspace: 64m..
diff --git a/docs/jre-open_jdk_jre.md b/docs/jre-open_jdk_jre.md
@@ -30,9 +30,9 @@ The JRE can be configured by modifying the [`config/open_jdk_jre.yml`][] file in
 The JRE can also be configured by overlaying a set of resources on the default distribution. To do this, add files to the `resources/open_jdk_jre` directory in the buildpack fork. For example, to add the JCE Unlimited Strength `local_policy.jar` add your file to `resources/open_jdk_jre/lib/security/local_policy.jar`.
 
 ### Memory
-The total available memory is specified when an application is pushed as part of it's configuration. The Java buildpack uses this value to control the JRE's use of various regions of memory. The JRE memory settings can be influenced by configuring the `memory_sizes` and/or `memory_heuristics` mappings.
+The total available memory is specified when an application is pushed as part of it's configuration. The Java buildpack uses this value to control the JRE's use of various regions of memory. The JRE memory settings can be influenced by configuring the `memory_sizes`, `memory_heuristics`, `memory_initials` and/or `stack_threads` mappings.
 
-Note: if the total available memory is scaled up or down, the Java buildpack will re-calculate the JRE memory settings the next time the appication is started.
+Note: if the total available memory is scaled up or down, the Java buildpack will re-calculate the JRE memory settings the next time the application is started.
 
 #### Memory Sizes
 The following optional properties may be specified in the `memory_sizes` mapping.
@@ -83,6 +83,14 @@ If no initial value is specified for a memory type the JVM default will be used.
 
 A value of 100% for each memory types is generally recommended for best performance.  Smaller values will potentially preserve unused system memory for other tenants on the same host.  Using the G1 garbage collector along with aggressive `MinHeapFreeRatio` and `MaxHeapFreeRatio` values the JVM will actually release unused heap back to the system up to the initial value.
 
+#### Stack Threads
+
+The amount of memory that should be allocated to the stack is given as an amount of memory per thread with the command line option `-Xss`. The default behaviour is to use an estimate of the number of threads based on the total memory for the application. If an explicit number of threads should be used for the calculation of stack memory then it should be specified like the following example: 
+
+```yaml
+stack_threads: 500
+```
+
 #### Memory Calculation
 Memory calculation happens before every `start` of an application and is performed by an external program, the [Java Buildpack Memory Calculator]. There is no need to `restage` an application after scaling the memory as restarting will cause the memory settings to be recalculated. 
 
diff --git a/docs/jre-oracle_jre.md b/docs/jre-oracle_jre.md
@@ -39,9 +39,9 @@ The JRE can be configured by modifying the [`config/oracle_jre.yml`][] file in t
 The JRE can also be configured by overlaying a set of resources on the default distribution. To do this, add files to the `resources/oracle_jre` directory in the buildpack fork. For example, to add the JCE Unlimited Strength `local_policy.jar` add your file to `resources/oracle_jre/lib/security/local_policy.jar`.
 
 ### Memory
-The total available memory is specified when an application is pushed as part of it's configuration. The Java buildpack uses this value to control the JRE's use of various regions of memory. The JRE memory settings can be influenced by configuring the `memory_sizes` and/or `memory_heuristics` mappings.
+The total available memory is specified when an application is pushed as part of it's configuration. The Java buildpack uses this value to control the JRE's use of various regions of memory. The JRE memory settings can be influenced by configuring the `memory_sizes`, `memory_heuristics`, `memory_initials` and/or `stack_threads` mappings.
 
-Note: if the total available memory is scaled up or down, the Java buildpack will re-calculate the JRE memory settings the next time the appication is started.
+Note: if the total available memory is scaled up or down, the Java buildpack will re-calculate the JRE memory settings the next time the application is started.
 
 #### Memory Sizes
 The following optional properties may be specified in the `memory_sizes` mapping.
@@ -92,6 +92,14 @@ If no initial value is specified for a memory type the JVM default will be used.
 
 A value of 100% for each memory types is generally recommended for best performance.  Smaller values will potentially preserve unused system memory for other tenants on the same host.  Using the G1 garbage collector along with aggressive `MinHeapFreeRatio` and `MaxHeapFreeRatio` values the JVM will actually release unused heap back to the system up to the initial value.
 
+#### Stack Threads
+
+The amount of memory that should be allocated to the stack is given as an amount of memory per thread with the command line option `-Xss`. The default behaviour is to use an estimate of the number of threads based on the total memory for the application. If an explicit number of threads should be used for the calculation of stack memory then it should be specified like the following example: 
+
+```yaml
+stack_threads: 500
+```
+
 #### Memory Calculation
 Memory calculation happens before every `start` of an application and is performed by an external program, the [Java Buildpack Memory Calculator]. There is no need to `restage` an application after scaling the memory as restarting will cause the memory settings to be recalculated. 
 
diff --git a/lib/java_buildpack/jre/open_jdk_like_memory_calculator.rb b/lib/java_buildpack/jre/open_jdk_like_memory_calculator.rb
@@ -75,8 +75,8 @@ def memory_calculator_tar
 
       def memory_calculation_string(relative_path)
         "#{qualify_path memory_calculator, relative_path} -memorySizes=#{memory_sizes @configuration} " \
-              "-memoryWeights=#{memory_weights @configuration} -memoryInitials=#{memory_initials @configuration} " \
-              '-totMemory=$MEMORY_LIMIT'
+              "-memoryWeights=#{memory_weights @configuration} -memoryInitials=#{memory_initials @configuration}" \
+              "#{stack_threads @configuration} -totMemory=$MEMORY_LIMIT"
       end
 
       def memory_sizes(configuration)
@@ -85,13 +85,13 @@ def memory_sizes(configuration)
       end
 
       def memory_weights(configuration)
-        memory_sizes = version_specific configuration['memory_heuristics']
-        memory_sizes.map { |k, v| "#{k}:#{v}" }.join(',')
+        memory_heuristics = version_specific configuration['memory_heuristics']
+        memory_heuristics.map { |k, v| "#{k}:#{v}" }.join(',')
       end
 
       def memory_initials(configuration)
-        memory_sizes = version_specific configuration['memory_initials']
-        memory_sizes.map { |k, v| "#{k}:#{v}" }.join(',')
+        memory_initials = version_specific configuration['memory_initials']
+        memory_initials.map { |k, v| "#{k}:#{v}" }.join(',')
       end
 
       def unpack_calculator(file)
@@ -103,6 +103,10 @@ def unpack_compressed_calculator(file)
         FileUtils.mv(memory_calculator_tar, memory_calculator)
       end
 
+      def stack_threads(configuration)
+        configuration['stack_threads'] ? " -stackThreads=#{configuration['stack_threads']}" : ''
+      end
+
       def version_specific(configuration)
         if @droplet.java_home.java_8_or_later?
           configuration.delete 'permgen'
diff --git a/spec/java_buildpack/jre/open_jdk_like_memory_calculator_spec.rb b/spec/java_buildpack/jre/open_jdk_like_memory_calculator_spec.rb
@@ -135,4 +135,21 @@
     expect(java_opts).to include('$CALCULATED_MEMORY')
   end
 
+  context do
+
+    let(:configuration) { super().merge 'stack_threads' => '200' }
+
+    it 'create memory calculation command with stack threads specified' do
+      java_home.version = version_7
+      command           = component.memory_calculation_command
+
+      expect(command).to eq('CALCULATED_MEMORY=$($PWD/.java-buildpack/open_jdk_like_memory_calculator/bin/' \
+                            'java-buildpack-memory-calculator-0.0.0 -memorySizes=permgen:64m.. ' \
+                            '-memoryWeights=heap:75,permgen:10,stack:5,native:10 ' \
+                            '-memoryInitials=heap:100%,permgen:100% ' \
+                            '-stackThreads=200 -totMemory=$MEMORY_LIMIT)')
+    end
+
+  end
+
 end
