commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From pste...@apache.org
Subject svn commit: r1580595 [1/2] - in /commons/sandbox/performance/trunk: ./ src/java/org/apache/commons/performance/ src/java/org/apache/commons/performance/dbcp/ src/java/org/apache/commons/performance/pool/ src/pool/ src/test/org/apache/commons/performanc...
Date Sun, 23 Mar 2014 20:31:37 GMT
Author: psteitz
Date: Sun Mar 23 20:31:36 2014
New Revision: 1580595

URL: http://svn.apache.org/r1580595
Log:
Udpated dependencies; implemented final pool 2.x API; replaced sandbox parent; reformatted some code.

Modified:
    commons/sandbox/performance/trunk/pom.xml
    commons/sandbox/performance/trunk/src/java/org/apache/commons/performance/ClientThread.java
    commons/sandbox/performance/trunk/src/java/org/apache/commons/performance/Statistics.java
    commons/sandbox/performance/trunk/src/java/org/apache/commons/performance/dbcp/DBCPSoak.java
    commons/sandbox/performance/trunk/src/java/org/apache/commons/performance/pool/PoolClientThread.java
    commons/sandbox/performance/trunk/src/java/org/apache/commons/performance/pool/PoolSoak.java
    commons/sandbox/performance/trunk/src/java/org/apache/commons/performance/pool/WaiterFactory2.java
    commons/sandbox/performance/trunk/src/pool/build.properties.sample
    commons/sandbox/performance/trunk/src/pool/build.xml
    commons/sandbox/performance/trunk/src/test/org/apache/commons/performance/LoadGeneratorTest.java
    commons/sandbox/performance/trunk/src/test/org/apache/commons/performance/pool/PoolSoakTest.java
    commons/sandbox/performance/trunk/src/test/org/apache/commons/performance/pool/WaiterTest.java

Modified: commons/sandbox/performance/trunk/pom.xml
URL: http://svn.apache.org/viewvc/commons/sandbox/performance/trunk/pom.xml?rev=1580595&r1=1580594&r2=1580595&view=diff
==============================================================================
--- commons/sandbox/performance/trunk/pom.xml (original)
+++ commons/sandbox/performance/trunk/pom.xml Sun Mar 23 20:31:36 2014
@@ -22,8 +22,8 @@
   <modelVersion>4.0.0</modelVersion>
   <parent>
     <groupId>org.apache.commons</groupId>
-	  <artifactId>commons-sandbox-parent</artifactId>
-    <version>10-SNAPSHOT</version>
+	  <artifactId>commons-parent</artifactId>
+    <version>33</version>
   </parent>
 
   <artifactId>commons-performance</artifactId>
@@ -51,7 +51,7 @@
     <dependency>
       <groupId>commons-digester</groupId>
       <artifactId>commons-digester</artifactId>
-      <version>1.8</version>
+      <version>2.1</version>
     </dependency>
    <dependency>
       <groupId>commons-dbcp</groupId>
@@ -65,8 +65,8 @@
     </dependency>
     <dependency>
        <groupId>org.apache.commons</groupId>
-       <artifactId>commons-math</artifactId>
-       <version>2.2</version>
+       <artifactId>commons-math3</artifactId>
+       <version>3.2</version>
     </dependency>
     <dependency>
        <groupId>commons-httpclient</groupId>
@@ -76,7 +76,7 @@
     <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
-      <version>3.8.1</version>
+      <version>4.11</version>
       <scope>test</scope>
     </dependency>
     
@@ -84,12 +84,12 @@
     <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
-       <version>2.0-SNAPSHOT</version>
+       <version>2.2</version>
     </dependency>
     <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-dbcp2</artifactId>
-       <version>2.0-SNAPSHOT</version>
+       <version>2.0</version>
     </dependency>
     <dependency>
        <groupId>org.apache.tomcat</groupId>
@@ -207,8 +207,8 @@
 
   <!-- Compiler source and target JVM -->
   <properties>
-    <maven.compile.source>1.5</maven.compile.source>
-    <maven.compile.target>1.5</maven.compile.target>
+    <maven.compiler.source>1.6</maven.compiler.source>
+    <maven.compiler.target>1.6</maven.compiler.target>
     <commons.componentid>performance</commons.componentid>
     <commons.jira.componentid>12312203</commons.jira.componentid>
   </properties> 

Modified: commons/sandbox/performance/trunk/src/java/org/apache/commons/performance/ClientThread.java
URL: http://svn.apache.org/viewvc/commons/sandbox/performance/trunk/src/java/org/apache/commons/performance/ClientThread.java?rev=1580595&r1=1580594&r2=1580595&view=diff
==============================================================================
--- commons/sandbox/performance/trunk/src/java/org/apache/commons/performance/ClientThread.java (original)
+++ commons/sandbox/performance/trunk/src/java/org/apache/commons/performance/ClientThread.java Sun Mar 23 20:31:36 2014
@@ -19,36 +19,38 @@ package org.apache.commons.performance;
 
 import java.util.logging.Logger;
 
-import org.apache.commons.math.random.RandomData;
-import org.apache.commons.math.random.RandomDataImpl;
-import org.apache.commons.math.stat.descriptive.SummaryStatistics;
+import org.apache.commons.math3.random.RandomDataGenerator;
+import org.apache.commons.math3.stat.descriptive.SummaryStatistics;
 
 /**
- * <p>Base for performance / load test clients. 
- * The run method executes init, then setup-execute-cleanup in a loop,
- * gathering performance statistics, with time between executions based
- * on configuration parameters. The <code>finish</code> method is executed once
- * at the end of a run. See {@link #nextDelay()} for details on
- * inter-arrival time computation.</p>
+ * <p>
+ * Base for performance / load test clients. The run method executes init, then
+ * setup-execute-cleanup in a loop, gathering performance statistics, with time between executions
+ * based on configuration parameters. The <code>finish</code> method is executed once at the end of
+ * a run. See {@link #nextDelay()} for details on inter-arrival time computation.
+ * </p>
  * 
- * <p>Subclasses <strong>must</strong> implement <code>execute</code>, which
- * is the basic client request action that is executed, and timed, 
- * repeatedly. If per-request setup is required, and you do not want the time
- * associated with this setup to be included in the reported timings, implement 
- * <code>setUp</code> and put the setup code there.  Similarly for 
- * <code>cleanUp</code>. Initialization code that needs to be executed once
- * only, before any requests are initiated, should be put into 
- * <code>init</code> and cleanup code that needs to be executed only once
- * at the end of a simulation should be put into <code>finish.</code></p>
+ * <p>
+ * Subclasses <strong>must</strong> implement <code>execute</code>, which is the basic client
+ * request action that is executed, and timed, repeatedly. If per-request setup is required, and you
+ * do not want the time associated with this setup to be included in the reported timings, implement
+ * <code>setUp</code> and put the setup code there. Similarly for <code>cleanUp</code>.
+ * Initialization code that needs to be executed once only, before any requests are initiated,
+ * should be put into <code>init</code> and cleanup code that needs to be executed only once at the
+ * end of a simulation should be put into <code>finish.</code>
+ * </p>
  * 
- * <p>By default, the only statistics accumulated are for the latency of the 
- * <code>execute</code> method. Additional metrics can be captured and added
- * to the {@link Statistics} for the running thread.</p>
+ * <p>
+ * By default, the only statistics accumulated are for the latency of the <code>execute</code>
+ * method. Additional metrics can be captured and added to the {@link Statistics} for the running
+ * thread.
+ * </p>
  * 
  */
-public abstract class ClientThread implements Runnable {
+public abstract class ClientThread
+    implements Runnable {
 
-    // Inter-arrival time configuration parameters 
+    // Inter-arrival time configuration parameters
     /** Minimum mean time between requests */
     private long minDelay;
     /** Maximum mean time between requests */
@@ -67,10 +69,10 @@ public abstract class ClientThread imple
     private final String cycleType;
     /** Ramp type */
     private String rampType;
-    
+
     /** Number of iterations */
     private final long iterations;
-    
+
     // State data
     /** Start time of run */
     private long startTime;
@@ -89,14 +91,14 @@ public abstract class ClientThread imple
     private long numErrors = 0;
     /** Number of misses */
     private long numMisses = 0;
-    
+
     /** Random data generator */
-    protected RandomData randomData = new RandomDataImpl();
+    protected RandomDataGenerator randomData = new RandomDataGenerator();
     /** Statistics container */
     protected Statistics stats;
     /** Logger shared by client threads */
     protected Logger logger;
-    
+
     /**
      * Create a client thread.
      * 
@@ -113,11 +115,9 @@ public abstract class ClientThread imple
      * @param logger common logger shared by all clients
      * @param stats Statistics instance to add results to
      */
-    public ClientThread(long iterations, long minDelay, long maxDelay,
-            double sigma, String delayType, long rampPeriod, long peakPeriod,
-            long troughPeriod, String cycleType,
-            String rampType, Logger logger,
-            Statistics stats) {
+    public ClientThread(long iterations, long minDelay, long maxDelay, double sigma, String delayType, long rampPeriod,
+                        long peakPeriod, long troughPeriod, String cycleType, String rampType, Logger logger,
+                        Statistics stats) {
         this.iterations = iterations;
         this.minDelay = minDelay;
         this.maxDelay = maxDelay;
@@ -131,7 +131,8 @@ public abstract class ClientThread imple
         this.logger = logger;
         this.stats = stats;
     }
-    
+
+    @Override
     public void run() {
         try {
             init();
@@ -144,7 +145,7 @@ public abstract class ClientThread imple
         startTime = System.currentTimeMillis();
         long lastStart = startTime;
         periodStart = System.currentTimeMillis();
-        lastMean = (double) maxDelay; // Ramp up, if any, starts here
+        lastMean = maxDelay; // Ramp up, if any, starts here
         SummaryStatistics responseStats = new SummaryStatistics();
         SummaryStatistics onTimeStats = new SummaryStatistics();
         SummaryStatistics successStats = new SummaryStatistics();
@@ -166,7 +167,7 @@ public abstract class ClientThread imple
                         logger.info("Sleep interrupted");
                     }
                 }
-                
+
                 // Fire the request and measure response time
                 lastStart = System.currentTimeMillis();
                 start = System.nanoTime();
@@ -176,17 +177,17 @@ public abstract class ClientThread imple
                 success = false;
             } finally {
                 try {
-                    //TODO: Keep times in ns here, convert stats for ms reporting
-                    responseStats.addValue((System.nanoTime() - start)/1000f/1000f); 
+                    // TODO: Keep times in ns here, convert stats for ms reporting
+                    responseStats.addValue((System.nanoTime() - start) / 1000f / 1000f);
                     successStats.addValue(success ? 1 : 0);
                     onTimeStats.addValue(onTime ? 1 : 0);
                     cleanUp();
                 } catch (Exception e) {
-                    e.printStackTrace();                    
+                    e.printStackTrace();
                 }
             }
         }
-        
+
         try {
             finish();
         } catch (Exception ex) {
@@ -194,73 +195,87 @@ public abstract class ClientThread imple
             ex.printStackTrace();
             return;
         }
-        
+
         // Use thread name as process name
         String process = Thread.currentThread().getName();
-        
+
         // Record statistics
         stats.addStatistics(responseStats, process, "latency");
         stats.addStatistics(onTimeStats, process, "on time startup rate");
         stats.addStatistics(successStats, process, "successful completion rate");
-        
+
         // Log accumulated statistics for this thread
-        logger.info(stats.displayProcessStatistics(process)); 
+        logger.info(stats.displayProcessStatistics(process));
     }
-    
+
     /** Executed once at the beginning of the run */
-    protected void init() throws Exception {}
-    
+    protected void init()
+        throws Exception {
+    }
+
     /** Executed at the beginning of each iteration */
-    protected void setUp() throws Exception {}
-    
+    protected void setUp()
+        throws Exception {
+    }
+
     /** Executed in finally block of iteration try-catch */
-    protected void cleanUp() throws Exception {}
-    
+    protected void cleanUp()
+        throws Exception {
+    }
+
     /** Executed once after the run finishes */
-    protected void finish() throws Exception {}
-    
-    /** 
-     * Core iteration code.  Timings are based on this,
-     *  so keep it tight.
+    protected void finish()
+        throws Exception {
+    }
+
+    /**
+     * Core iteration code. Timings are based on this, so keep it tight.
      */
-    public abstract void execute() throws Exception;
-    
+    public abstract void execute()
+        throws Exception;
+
     /**
-     * <p>Computes the next inter-arrival time (time to wait between requests)
-     * based on configured values for min/max delay, delay type, cycle type, 
-     * ramp type and period. Currently supports constant (always returning
-     * <code>minDelay</code> delay time), Poisson and Gaussian distributed
-     * random time delays, linear and random ramps, and oscillating / 
-     * non-oscillating cycle types.</p>
-     * 
-     * <p><strong>loadType</strong> determines whether returned times are
-     * deterministic or random. If <code>loadType</code> is not "constant",
-     * a random value with the specified distribution and mean determined by
-     * the other parameters is returned. For "gaussian" <code>loadType</code>,
-     * <code>sigma</code> is used as used as the standard deviation. </p>
-     * 
-     * <p><strong>cycleType</strong> determines how the returned times vary
-     * over time. "oscillating", means times ramp up and down between 
-     * <code>minDelay</code> and <code>maxDelay.</code> Ramp type is controlled
-     * by <code>rampType.</code>  Linear <code>rampType</code> means the means
-     * increase or decrease linearly over the time of the period.  Random
-     * makes random jumps up or down toward the next peak or trough. "None" for
-     * <code>rampType</code> under oscillating <code>cycleType</code> makes the
-     * means alternate between peak (<code>minDelay</code>) and trough 
-     *(<code>maxDelay</code>) with no ramp between. </p>
-     * 
-     * <p>Oscillating loads cycle through RAMPING_UP, PEAK_LOAD, RAMPING_DOWN
-     * and TROUGH_LOAD states, with the amount of time spent in each state
-     * determined by <code>rampPeriod</code> (time spent increasing on the way
-     * up and decreasing on the way down), <code>peakPeriod</code> (time spent
-     * at peak load, i.e., <code>minDelay</code> mean delay) and 
-     * <code>troughPeriod</code> (time spent at minimum load, i.e., 
-     * <code>maxDelay</code> mean delay). All times are specified in
-     * milliseconds. </p>
+     * <p>
+     * Computes the next inter-arrival time (time to wait between requests) based on configured
+     * values for min/max delay, delay type, cycle type, ramp type and period. Currently supports
+     * constant (always returning <code>minDelay</code> delay time), Poisson and Gaussian
+     * distributed random time delays, linear and random ramps, and oscillating / non-oscillating
+     * cycle types.
+     * </p>
+     * 
+     * <p>
+     * <strong>loadType</strong> determines whether returned times are deterministic or random. If
+     * <code>loadType</code> is not "constant", a random value with the specified distribution and
+     * mean determined by the other parameters is returned. For "gaussian" <code>loadType</code>,
+     * <code>sigma</code> is used as used as the standard deviation.
+     * </p>
+     * 
+     * <p>
+     * <strong>cycleType</strong> determines how the returned times vary over time. "oscillating",
+     * means times ramp up and down between <code>minDelay</code> and <code>maxDelay.</code> Ramp
+     * type is controlled by <code>rampType.</code> Linear <code>rampType</code> means the means
+     * increase or decrease linearly over the time of the period. Random makes random jumps up or
+     * down toward the next peak or trough. "None" for <code>rampType</code> under oscillating
+     * <code>cycleType</code> makes the means alternate between peak (<code>minDelay</code>) and
+     * trough (<code>maxDelay</code>) with no ramp between.
+     * </p>
+     * 
+     * <p>
+     * Oscillating loads cycle through RAMPING_UP, PEAK_LOAD, RAMPING_DOWN and TROUGH_LOAD states,
+     * with the amount of time spent in each state determined by <code>rampPeriod</code> (time spent
+     * increasing on the way up and decreasing on the way down), <code>peakPeriod</code> (time spent
+     * at peak load, i.e., <code>minDelay</code> mean delay) and <code>troughPeriod</code> (time
+     * spent at minimum load, i.e., <code>maxDelay</code> mean delay). All times are specified in
+     * milliseconds.
+     * </p>
+     * 
+     * <p>
+     * <strong>Examples:</strong>
+     * <ol>
      * 
-     * <p><strong>Examples:</strong><ol>
+     * <li>Given
      * 
-     * <li>Given<pre>
+     * <pre>
      * delayType = "constant"
      * minDelay = 250
      * maxDelay = 500
@@ -268,14 +283,18 @@ public abstract class ClientThread imple
      * rampType = "linear" 
      * rampPeriod = 10000
      * peakPeriod = 20000
-     * troughPeriod = 30000</pre> load will start at one request every 500 ms,
-     * which is "trough load." Load then ramps up linearly over the next 10
-     * seconds unil it reaches one request per 250 milliseconds, which is 
-     * "peak load."  Peak load is sustained for 20 seconds and then load ramps
-     * back down, again taking 10 seconds to get down to "trough load," which
-     * is sustained for 30 seconds.  The cycle then repeats.</li>
+     * troughPeriod = 30000
+     * </pre>
      * 
-     * <li><pre>
+     * load will start at one request every 500 ms, which is "trough load." Load then ramps up
+     * linearly over the next 10 seconds unil it reaches one request per 250 milliseconds, which is
+     * "peak load." Peak load is sustained for 20 seconds and then load ramps back down, again
+     * taking 10 seconds to get down to "trough load," which is sustained for 30 seconds. The cycle
+     * then repeats.</li>
+     * 
+     * <li>
+     * 
+     * <pre>
      * delayType = "gaussian"
      * minDelay = 250
      * maxDelay = 500
@@ -284,54 +303,62 @@ public abstract class ClientThread imple
      * rampPeriod = 10000
      * peakPeriod = 20000
      * troughPeriod = 30000
-     * sigma = 100 </pre> produces a load pattern similar to example 1, but in
-     * this case the computed delay value is fed into a gaussian random number
-     * generator as the mean and 100 as the standard deviation - i.e., 
-     * <code>nextDelay</code> returns random, gaussian distributed values with
-     * means moving according to the cyclic pattern in example 1.</li>
+     * sigma = 100
+     * </pre>
+     * 
+     * produces a load pattern similar to example 1, but in this case the computed delay value is
+     * fed into a gaussian random number generator as the mean and 100 as the standard deviation -
+     * i.e., <code>nextDelay</code> returns random, gaussian distributed values with means moving
+     * according to the cyclic pattern in example 1.</li>
      * 
-     * <li><pre>
+     * <li>
+     * 
+     * <pre>
      * delayType = "constant"
      * minDelay = 250
      * maxDelay = 500
      * cycleType = "none"
      * rampType = "linear" 
-     * rampPeriod = 10000</pre> produces a load pattern that increases linearly
-     * from one request every 500ms to one request every 250ms and then stays
-     * constant at that level until the run is over.  Other parameters are
+     * rampPeriod = 10000
+     * </pre>
+     * 
+     * produces a load pattern that increases linearly from one request every 500ms to one request
+     * every 250ms and then stays constant at that level until the run is over. Other parameters are
      * ignored in this case.</li>
      * 
-     * <li><pre>
+     * <li>
+     * 
+     * <pre>
      * delayType = "poisson"
      * minDelay = 250
      * maxDelay = 500
      * cycleType = "none"
-     * rampType = "none" 
-     * </pre> produces inter-arrival times that are poisson distributed with
-     * mean 250ms. Note that when rampType is "none," the value of 
-     * <code>minDelay</code> is used as the (constant) mean delay.</li></ol>
+     * rampType = "none"
+     * </pre>
+     * 
+     * produces inter-arrival times that are poisson distributed with mean 250ms. Note that when
+     * rampType is "none," the value of <code>minDelay</code> is used as the (constant) mean delay.</li>
+     * </ol>
      * 
      * @return next value for delay
      */
-    protected long nextDelay() throws ConfigurationException {
-        double targetDelay = 0; 
-        final double dMinDelay = (double) minDelay;
-        final double dMaxDelay = (double) maxDelay;
+    protected long nextDelay()
+        throws ConfigurationException {
+        double targetDelay = 0;
+        final double dMinDelay = minDelay;
+        final double dMaxDelay = maxDelay;
         final double delayDifference = dMaxDelay - dMinDelay;
         final long currentTime = System.currentTimeMillis();
         if (cycleType.equals("none")) {
-            if (rampType.equals("none") || 
-                    (currentTime - startTime) > rampPeriod) { // ramped up
+            if (rampType.equals("none") || (currentTime - startTime) > rampPeriod) { // ramped up
                 targetDelay = dMinDelay;
             } else if (rampType.equals("linear")) { // single period linear
-                double prop = 
-                    (double) (currentTime - startTime) / (double) rampPeriod;
-                targetDelay =  dMaxDelay - delayDifference * prop;
+                double prop = (double) (currentTime - startTime) / (double) rampPeriod;
+                targetDelay = dMaxDelay - delayDifference * prop;
             } else { // Random jumps down to delay - single period
                 // TODO: govern size of jumps as in oscillating
                 // Where we last were as proportion of way down to minDelay
-                final double lastProp = 
-                    (dMaxDelay - lastMean) / delayDifference;
+                final double lastProp = (dMaxDelay - lastMean) / delayDifference;
                 // Make a random jump toward 1 (1 = all the way down)
                 final double prop = randomData.nextUniform(lastProp, 1);
                 targetDelay = dMaxDelay - delayDifference * prop;
@@ -339,17 +366,15 @@ public abstract class ClientThread imple
         } else if (cycleType.equals("oscillating")) {
             // First change cycle state if we need to
             adjustState(currentTime);
-            targetDelay = computeCyclicDelay(
-                    currentTime, dMinDelay, dMaxDelay);
+            targetDelay = computeCyclicDelay(currentTime, dMinDelay, dMaxDelay);
         } else {
-            throw new ConfigurationException(
-                    "Cycle type not supported: " + cycleType);
+            throw new ConfigurationException("Cycle type not supported: " + cycleType);
         }
 
         // Remember last mean for ramp up / down
         lastMean = targetDelay;
 
-        if (delayType.equals("constant")) { 
+        if (delayType.equals("constant")) {
             return Math.round(targetDelay);
         }
 
@@ -358,82 +383,78 @@ public abstract class ClientThread imple
             return Math.round(randomData.nextGaussian(targetDelay, sigma));
         } else { // must be Poisson
             return randomData.nextPoisson(targetDelay);
-        } 
+        }
     }
-    
+
     /**
-     * Adjusts cycleState, periodStart and lastMean if a cycle state
-     * transition needs to happen.
+     * Adjusts cycleState, periodStart and lastMean if a cycle state transition needs to happen.
      * 
      * @param currentTime current time
      */
     protected void adjustState(long currentTime) {
         long timeInPeriod = currentTime - periodStart;
-        if ( ((cycleState == RAMPING_UP || cycleState == RAMPING_DOWN) && 
-                timeInPeriod < rampPeriod) ||
-             (cycleState == PEAK_LOAD && timeInPeriod < peakPeriod) ||
-             (cycleState == TROUGH_LOAD && timeInPeriod < troughPeriod)) {
+        if (((cycleState == RAMPING_UP || cycleState == RAMPING_DOWN) && timeInPeriod < rampPeriod) ||
+            (cycleState == PEAK_LOAD && timeInPeriod < peakPeriod) ||
+            (cycleState == TROUGH_LOAD && timeInPeriod < troughPeriod)) {
             return; // No state change
         }
         switch (cycleState) {
-            case RAMPING_UP: 
+            case RAMPING_UP:
                 if (peakPeriod > 0) {
                     cycleState = PEAK_LOAD;
                 } else {
                     cycleState = RAMPING_DOWN;
                 }
-                lastMean = (double) minDelay;
+                lastMean = minDelay;
                 periodStart = currentTime;
                 break;
-            
-            case RAMPING_DOWN: 
+
+            case RAMPING_DOWN:
                 if (troughPeriod > 0) {
                     cycleState = TROUGH_LOAD;
                 } else {
                     cycleState = RAMPING_UP;
                 }
-                lastMean = (double) maxDelay;
+                lastMean = maxDelay;
                 periodStart = currentTime;
                 break;
-            
-            case PEAK_LOAD: 
+
+            case PEAK_LOAD:
                 if (rampPeriod > 0) {
                     cycleState = RAMPING_DOWN;
-                    lastMean = (double) minDelay;
+                    lastMean = minDelay;
                 } else {
                     cycleState = TROUGH_LOAD;
-                    lastMean = (double) maxDelay;
+                    lastMean = maxDelay;
                 }
                 periodStart = currentTime;
                 break;
-            
-            case TROUGH_LOAD: 
+
+            case TROUGH_LOAD:
                 if (rampPeriod > 0) {
                     cycleState = RAMPING_UP;
-                    lastMean = (double) maxDelay;
+                    lastMean = maxDelay;
                 } else {
                     cycleState = PEAK_LOAD;
-                    lastMean = (double) minDelay;
+                    lastMean = minDelay;
                 }
                 periodStart = currentTime;
                 break;
-            
-            default: 
-                throw new IllegalStateException(
-                        "Illegal cycle state: " + cycleState);
+
+            default:
+                throw new IllegalStateException("Illegal cycle state: " + cycleState);
         }
     }
-    
-    protected double computeCyclicDelay(
-            long currentTime, double min, double max) {
-        
+
+    protected double computeCyclicDelay(long currentTime, double min, double max) {
+
         // Constant load states
-        if (cycleState == PEAK_LOAD) { 
+        if (cycleState == PEAK_LOAD) {
             return min;
-        } 
+        }
         if (cycleState == TROUGH_LOAD) {
             return max;
-        } 
+        }
 
         // No ramp - stay at min or max load during ramp
         if (rampType.equals("none")) { // min or max, no ramp
@@ -442,32 +463,27 @@ public abstract class ClientThread imple
             } else {
                 return min;
             }
-        } 
+        }
 
         // Linear ramp type and ramping up or down
         double diff = max - min;
         if (rampType.equals("linear")) {
-            double prop = 
-                (double)(currentTime - periodStart) / (double) rampPeriod;
+            double prop = (double) (currentTime - periodStart) / (double) rampPeriod;
             if (cycleState == RAMPING_UP) {
-                return max - diff * prop; 
+                return max - diff * prop;
             } else {
                 return min + diff * prop;
             }
         } else { // random jumps down, then back up
             // Where we last were as proportion of way down to minDelay
-            double lastProp = 
-                (max - lastMean) / diff;
+            double lastProp = (max - lastMean) / diff;
             // Where we would be if this were a linear ramp
-            double linearProp = 
-                (double)(currentTime - periodStart) / (double) rampPeriod;
+            double linearProp = (double) (currentTime - periodStart) / (double) rampPeriod;
             // Need to govern size of jumps, otherwise "convergence"
             // can be too fast - use linear ramp as governor
-            if ((cycleState == RAMPING_UP && (lastProp > linearProp)) || 
-                    (cycleState == RAMPING_DOWN && 
-                            ((1 - lastProp) > linearProp))) 
-                lastProp = (cycleState == RAMPING_UP) ? linearProp : 
-                    (1 - linearProp);
+            if ((cycleState == RAMPING_UP && (lastProp > linearProp)) ||
+                (cycleState == RAMPING_DOWN && ((1 - lastProp) > linearProp)))
+                lastProp = (cycleState == RAMPING_UP) ? linearProp : (1 - linearProp);
             double prop = 0;
             if (cycleState == RAMPING_UP) { // Random jump toward 1
                 prop = randomData.nextUniform(lastProp, 1);
@@ -606,5 +622,5 @@ public abstract class ClientThread imple
     public void setTroughPeriod(long troughPeriod) {
         this.troughPeriod = troughPeriod;
     }
-    
+
 }

Modified: commons/sandbox/performance/trunk/src/java/org/apache/commons/performance/Statistics.java
URL: http://svn.apache.org/viewvc/commons/sandbox/performance/trunk/src/java/org/apache/commons/performance/Statistics.java?rev=1580595&r1=1580594&r2=1580595&view=diff
==============================================================================
--- commons/sandbox/performance/trunk/src/java/org/apache/commons/performance/Statistics.java (original)
+++ commons/sandbox/performance/trunk/src/java/org/apache/commons/performance/Statistics.java Sun Mar 23 20:31:36 2014
@@ -16,73 +16,74 @@
  */
 package org.apache.commons.performance;
 
+import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
-import java.io.Serializable;
-import org.apache.commons.math.stat.descriptive.AggregateSummaryStatistics;
-import org.apache.commons.math.stat.descriptive.SummaryStatistics;
-import org.apache.commons.math.stat.descriptive.StatisticalSummaryValues;
+
+import org.apache.commons.math3.stat.descriptive.AggregateSummaryStatistics;
+import org.apache.commons.math3.stat.descriptive.StatisticalSummaryValues;
+import org.apache.commons.math3.stat.descriptive.SummaryStatistics;
 
 /**
- * <p>Container for {@link SummaryStatistics} accumulated during 
- * {@link ClientThread} executions.</p>
+ * <p>
+ * Container for {@link SummaryStatistics} accumulated during {@link ClientThread} executions.
+ * </p>
+ * 
+ * <p>
+ * Maintains a HashMap of {@link SummaryStatistics} instances with a composite key of the form
+ * (process,type). "Process" typically identifies the client thread and "type" identifies the metric
+ * - e.g., "latency", "numActive."
+ * </p>
  * 
- * <p>Maintains a HashMap of {@link SummaryStatistics} instances with a composite
- * key of the form (process,type).  "Process" typically identifies the client
- * thread and "type" identifies the metric - e.g., "latency", "numActive."</p>
+ * <p>
+ * {@link ClientThread#run()} adds one <code>SummaryStatistics</code> instance, with key = (current
+ * thread id,"latency").
+ * </p>
  * 
- * <p>{@link ClientThread#run()} adds one <code>SummaryStatistics</code>
- * instance, with key = (current thread id,"latency").</p>
- *
  */
-public class Statistics implements Serializable {
-    
+public class Statistics
+    implements Serializable {
+
     /**
-     * Map of SummaryStatistics keyed on <process,type>, where process corresponds
-     * to a thread being monitored and type is a user-supplied characteristic being
-     * measured and tracked.  For example, <thread name, "latency">.
-     */
-    private HashMap<StatisticsKey,SummaryStatistics> data = 
-        new HashMap <StatisticsKey,SummaryStatistics>();
-    
+     * Map of SummaryStatistics keyed on <process,type>, where process corresponds to a thread being
+     * monitored and type is a user-supplied characteristic being measured and tracked. For example,
+     * <thread name, "latency">.
+     */
+    private HashMap<StatisticsKey, SummaryStatistics> data = new HashMap<StatisticsKey, SummaryStatistics>();
+
     /**
-     * Adds the results of the given SummaryStatistics instance under
-     * the key <process,type>
+     * Adds the results of the given SummaryStatistics instance under the key <process,type>
      * 
      * @param stats the SummaryStatistics whose results we are adding
      * @param process name of the associated process
      * @param type description of the associated metric
      */
-    public synchronized void addStatistics(SummaryStatistics stats,
-            String process, String type) {
+    public synchronized void addStatistics(SummaryStatistics stats, String process, String type) {
         StatisticsKey key = new StatisticsKey(process, type);
         data.put(key, stats);
     }
-    
+
     /**
-     * Retrieves the SummaryStatistics corresponding to the given
-     * process and type, if this exists; null otherwise.
+     * Retrieves the SummaryStatistics corresponding to the given process and type, if this exists;
+     * null otherwise.
      * 
      * @param process name of the associated process
      * @param type description of the associated metric
-     * @return SummaryStatistics for the given <process,type>; null if there is
-     * no such element in the container
+     * @return SummaryStatistics for the given <process,type>; null if there is no such element in
+     *         the container
      */
-    public synchronized SummaryStatistics getStatistics(String process,
-            String type) {
+    public synchronized SummaryStatistics getStatistics(String process, String type) {
         StatisticsKey key = new StatisticsKey(process, type);
         return data.get(key);
     }
-    
+
     /**
-     * Returns the full list of SummaryStatistics corresponding to
-     * the given <code>type</code> - i.e, the list of statistics of the 
-     * given type across processes.  For example, 
-     * <code>getStatisticsByType("latency")</code> will return a list of latency
-     * summaries, one for each process, assuming "latency" is the name of 
-     * an accumulated metric.
+     * Returns the full list of SummaryStatistics corresponding to the given <code>type</code> -
+     * i.e, the list of statistics of the given type across processes. For example,
+     * <code>getStatisticsByType("latency")</code> will return a list of latency summaries, one for
+     * each process, assuming "latency" is the name of an accumulated metric.
      * 
      * @param type the type value to get statistics for
      * @return the List of SummaryStatistics stored under the given type
@@ -98,17 +99,15 @@ public class Statistics implements Seria
         }
         return result;
     }
-    
+
     /**
-     * Returns the full list of SummaryStatistics corresponding to
-     * the given <code>process</code> - i.e, the list of statistics of
-     * of different types maintained for the given process. 
+     * Returns the full list of SummaryStatistics corresponding to the given <code>process</code> -
+     * i.e, the list of statistics of of different types maintained for the given process.
      * 
      * @param process the process to get statistics for
      * @return the List of SummaryStatistics for the given process
      */
-    public synchronized List<SummaryStatistics> getStatisticsByProcess(
-            String process) {
+    public synchronized List<SummaryStatistics> getStatisticsByProcess(String process) {
         ArrayList<SummaryStatistics> result = new ArrayList<SummaryStatistics>();
         Iterator<StatisticsKey> it = data.keySet().iterator();
         while (it.hasNext()) {
@@ -119,22 +118,23 @@ public class Statistics implements Seria
         }
         return result;
     }
-    
+
     /**
-     * <p>Returns a SummaryStatistics instance describing the mean of the given
-     * metric across processes - i.e., the "mean of the means", the 
-     * "min of the means" etc. More precisely, the returned SummaryStatistics
-     * describes the distribution of the individual process means for the given
-     * metric.</p>
-     * 
-     * <p>The same results could be obtained by iterating over the result of 
-     * {{@link #getStatisticsByType(String)} for the given <code>type</code>,
-     * extracting the mean and adding its value to a SummaryStatistics
-     * instance.</p>
+     * <p>
+     * Returns a SummaryStatistics instance describing the mean of the given metric across processes
+     * - i.e., the "mean of the means", the "min of the means" etc. More precisely, the returned
+     * SummaryStatistics describes the distribution of the individual process means for the given
+     * metric.
+     * </p>
+     * 
+     * <p>
+     * The same results could be obtained by iterating over the result of {
+     * {@link #getStatisticsByType(String)} for the given <code>type</code>, extracting the mean and
+     * adding its value to a SummaryStatistics instance.
+     * </p>
      * 
      * @param type the metric to get summary mean statistics for
-     * @return a SummaryStatistics instance describing the process means for
-     * the given metric
+     * @return a SummaryStatistics instance describing the process means for the given metric
      */
     public synchronized SummaryStatistics getMeanSummary(String type) {
         SummaryStatistics result = new SummaryStatistics();
@@ -147,14 +147,13 @@ public class Statistics implements Seria
         }
         return result;
     }
-    
+
     /**
-     * Returns SummaryStatistics for the standard deviation of the given metric
-     * across processes.
+     * Returns SummaryStatistics for the standard deviation of the given metric across processes.
      * 
      * @param type the metric to get summary standard deviation statistics for
-     * @return a SummaryStatistics instance describing the process standard
-     * deviations for the given metric
+     * @return a SummaryStatistics instance describing the process standard deviations for the given
+     *         metric
      * @see #getMeanSummary(String)
      */
     public synchronized SummaryStatistics getStdSummary(String type) {
@@ -168,14 +167,12 @@ public class Statistics implements Seria
         }
         return result;
     }
-    
+
     /**
-     * Returns SummaryStatistics for the minimum of the given metric across
-     * processes.
+     * Returns SummaryStatistics for the minimum of the given metric across processes.
      * 
      * @param type the metric to get summary minimum statistics for
-     * @return a SummaryStatistics instance describing the process minima
-     * for the given metric
+     * @return a SummaryStatistics instance describing the process minima for the given metric
      * @see #getMeanSummary(String)
      */
     public synchronized SummaryStatistics getMinSummary(String type) {
@@ -189,14 +186,12 @@ public class Statistics implements Seria
         }
         return result;
     }
-    
+
     /**
-     * Returns SummaryStatistics for the maximum of the given metric across
-     * processes.
+     * Returns SummaryStatistics for the maximum of the given metric across processes.
      * 
      * @param type the metric to get summary maximum statistics for
-     * @return a SummaryStatistics describing the process maxima
-     * for the given metric
+     * @return a SummaryStatistics describing the process maxima for the given metric
      * @see #getMeanSummary(String)
      */
     public synchronized SummaryStatistics getMaxSummary(String type) {
@@ -210,14 +205,13 @@ public class Statistics implements Seria
         }
         return result;
     }
-    
+
     /**
-     * Returns overall SummaryStatistics, aggregating the results for metrics
-     * of the given type across processes.
+     * Returns overall SummaryStatistics, aggregating the results for metrics of the given type
+     * across processes.
      * 
      * @param type the metric to get overall statistics for
-     * @return a SummaryStatistics instance summarizing the combined dataset
-     * for the given metric
+     * @return a SummaryStatistics instance summarizing the combined dataset for the given metric
      */
     public synchronized StatisticalSummaryValues getOverallSummary(String type) {
         ArrayList<SummaryStatistics> contributingStats = new ArrayList<SummaryStatistics>();
@@ -230,7 +224,7 @@ public class Statistics implements Seria
         }
         return AggregateSummaryStatistics.aggregate(contributingStats);
     }
-    
+
     /**
      * Returns the List of processes corresponding to statistics.
      * 
@@ -247,7 +241,7 @@ public class Statistics implements Seria
         }
         return result;
     }
-    
+
     /**
      * Returns the List of types corresponding to statistics.
      * 
@@ -264,13 +258,13 @@ public class Statistics implements Seria
         }
         return result;
     }
-    
+
     /**
-     * Computes and formats display of summary statistics by type, as means of means, etc.
-     * with the process as the unit of observation.  Not currently displayed.
-     * TODO: Make inclusion of this report configurable.
+     * Computes and formats display of summary statistics by type, as means of means, etc. with the
+     * process as the unit of observation. Not currently displayed. TODO: Make inclusion of this
+     * report configurable.
      * 
-     * @return String representing summaries for each metric 
+     * @return String representing summaries for each metric
      */
     public synchronized String displayProcessLevelSummary() {
         Iterator<String> metricsIterator = getTypes().iterator();
@@ -301,8 +295,7 @@ public class Statistics implements Seria
     }
 
     /**
-     * Displays overall statistics for each metric, aggregating data
-     * across threads.
+     * Displays overall statistics for each metric, aggregating data across threads.
      * 
      * @return overall statistics report
      */
@@ -321,13 +314,12 @@ public class Statistics implements Seria
         }
         return buffer.toString();
     }
-    
+
     /**
      * Displays statistics for the given process
      * 
      * @param process the process to retrieve metrics for
-     * @return String representing all currently defined statistics for the
-     * given process
+     * @return String representing all currently defined statistics for the given process
      */
     public synchronized String displayProcessStatistics(String process) {
         Iterator<String> metricsIterator = getTypes().iterator();
@@ -344,33 +336,40 @@ public class Statistics implements Seria
         }
         return buffer.toString();
     }
-    
-    
+
     /**
      * Composite key (<process,type>).
      */
-    private static class StatisticsKey implements Serializable {
+    private static class StatisticsKey
+        implements Serializable {
+
         public StatisticsKey(String process, String type) {
             this.process = process;
             this.type = type;
         }
+
         private String process = null;
         private String type = null;
+
+        @Override
         public boolean equals(Object obj) {
             if (!(obj instanceof StatisticsKey) || obj == null) {
                 return false;
             } else {
                 StatisticsKey other = (StatisticsKey) obj;
-                return (other.process.equals(this.process)) &&
-                    (other.type.equals(this.type));  
+                return (other.process.equals(this.process)) && (other.type.equals(this.type));
             }
         }
+
+        @Override
         public int hashCode() {
             return 7 + 11 * process.hashCode() + 17 * type.hashCode();
-        } 
+        }
+
         public String getType() {
             return type;
         }
+
         public String getProcess() {
             return process;
         }

Modified: commons/sandbox/performance/trunk/src/java/org/apache/commons/performance/dbcp/DBCPSoak.java
URL: http://svn.apache.org/viewvc/commons/sandbox/performance/trunk/src/java/org/apache/commons/performance/dbcp/DBCPSoak.java?rev=1580595&r1=1580594&r2=1580595&view=diff
==============================================================================
--- commons/sandbox/performance/trunk/src/java/org/apache/commons/performance/dbcp/DBCPSoak.java (original)
+++ commons/sandbox/performance/trunk/src/java/org/apache/commons/performance/dbcp/DBCPSoak.java Sun Mar 23 20:31:36 2014
@@ -17,48 +17,48 @@
 
 package org.apache.commons.performance.dbcp;
 
-
 import java.sql.Connection;
 import java.sql.Driver;
 import java.sql.DriverManager;
 import java.sql.Statement;
 import java.util.Properties;
 import java.util.logging.Logger;
+
 import javax.sql.DataSource;
+
 import org.apache.commons.dbcp.AbandonedConfig;
-import org.apache.commons.dbcp.AbandonedObjectPool;
 import org.apache.commons.dbcp.ConnectionFactory;
 import org.apache.commons.dbcp.DriverConnectionFactory;
 import org.apache.commons.dbcp.DriverManagerConnectionFactory;
 import org.apache.commons.dbcp.PoolableConnectionFactory;
 import org.apache.commons.dbcp.PoolingDataSource;
+import org.apache.commons.math3.random.RandomDataGenerator;
+import org.apache.commons.performance.ClientThread;
+import org.apache.commons.performance.ConfigurationException;
+import org.apache.commons.performance.LoadGenerator;
+import org.apache.commons.performance.Statistics;
 import org.apache.commons.pool.KeyedObjectPoolFactory;
 import org.apache.commons.pool.PoolableObjectFactory;
 import org.apache.commons.pool.impl.GenericKeyedObjectPool;
 import org.apache.commons.pool.impl.GenericKeyedObjectPoolFactory;
 import org.apache.commons.pool.impl.GenericObjectPool;
-import org.apache.commons.math.random.RandomData;
-import org.apache.commons.math.random.RandomDataImpl;
-import org.apache.commons.performance.ConfigurationException;
-import org.apache.commons.performance.ClientThread;
-import org.apache.commons.performance.LoadGenerator;
-import org.apache.commons.performance.Statistics;
 import org.apache.tomcat.jdbc.pool.PoolProperties;
- 
+
 /**
- * Configurable load / performance tester for commons dbcp.
- * Uses Commons Digester to parse and load configuration and spawns
- * DBCPClientThread instances to generate load and gather statistics.
- *
+ * Configurable load / performance tester for commons dbcp. Uses Commons Digester to parse and load
+ * configuration and spawns DBCPClientThread instances to generate load and gather statistics.
+ * 
  */
-public class DBCPSoak extends LoadGenerator {
+public class DBCPSoak
+    extends LoadGenerator {
+
     // Connection properties
     private String driverClass;
     private String connectUrl;
     private String connectUser;
     private String connectPassword;
     private String queryType;
-    
+
     // Connection pool properties
     private String poolType;
     private String driverType;
@@ -80,19 +80,21 @@ public class DBCPSoak extends LoadGenera
     private int maxIdle;
     private int minIdle;
     private long maxWait;
-    
+
     // DataSource type
     private String dataSourceType;
-    
+
     // Instance variables
-    private GenericObjectPool connectionPool; 
+    private GenericObjectPool connectionPool;
     private DataSource dataSource;
-    
+
     /**
      * Create connection pool and, if necessary, test table.
      */
-    protected void init() throws Exception {
-        
+    @Override
+    protected void init()
+        throws Exception {
+
         if (dataSourceType.equals("BasicDataSource")) {
             org.apache.commons.dbcp.BasicDataSource bds = new org.apache.commons.dbcp.BasicDataSource();
             bds.setDefaultAutoCommit(autocommit);
@@ -114,13 +116,13 @@ public class DBCPSoak extends LoadGenera
             bds.setTimeBetweenEvictionRunsMillis(timeBetweenEvictions);
             bds.setValidationQuery(validationQuery);
             if (poolType.equals("AbandonedObjectPool")) {
-                    bds.setRemoveAbandoned(true);
+                bds.setRemoveAbandoned(true);
             }
-            dataSource = bds; 
+            dataSource = bds;
             checkDatabase();
             return;
         }
-        
+
         if (dataSourceType.equals("BasicDataSource2")) {
             org.apache.commons.dbcp2.BasicDataSource bds = new org.apache.commons.dbcp2.BasicDataSource();
             bds.setDefaultAutoCommit(autocommit);
@@ -129,9 +131,9 @@ public class DBCPSoak extends LoadGenera
             bds.setUsername(connectUser);
             bds.setDriverClassName(driverClass);
             bds.setMinEvictableIdleTimeMillis(idleTimeout);
-            bds.setMaxActive(maxActive);
+            bds.setMaxTotal(maxActive);
             bds.setMaxIdle(maxIdle);
-            bds.setMaxWait(maxWait);
+            bds.setMaxWaitMillis(maxWait);
             bds.setMinIdle(minIdle);
             bds.setPoolPreparedStatements(poolPreparedStatements);
             bds.setDefaultReadOnly(readOnly);
@@ -142,13 +144,13 @@ public class DBCPSoak extends LoadGenera
             bds.setTimeBetweenEvictionRunsMillis(timeBetweenEvictions);
             bds.setValidationQuery(validationQuery);
             if (poolType.equals("AbandonedObjectPool")) {
-                    bds.setRemoveAbandoned(true);
+                bds.setRemoveAbandonedOnBorrow(true);
             }
-            dataSource = bds; 
+            dataSource = bds;
             checkDatabase();
             return;
         }
-        
+
         if (dataSourceType.equals("tomcat-jdbc-pool")) {
             PoolProperties config = new PoolProperties();
             config.setDefaultAutoCommit(autocommit);
@@ -173,71 +175,66 @@ public class DBCPSoak extends LoadGenera
         }
 
         Class.forName(driverClass);
-        
+
         // Create object pool
         if (poolType.equals("GenericObjectPool")) {
-            connectionPool = new org.apache.commons.pool.impl.GenericObjectPool(
-                    null, maxActive, exhaustedAction,
-                    maxWait, maxIdle, minIdle, testOnBorrow, testOnReturn,
-                    timeBetweenEvictions, testsPerEviction, idleTimeout,
-                    testWhileIdle);
+            connectionPool = new org.apache.commons.pool.impl.GenericObjectPool(null, maxActive, exhaustedAction,
+                                                                                maxWait, maxIdle, minIdle,
+                                                                                testOnBorrow, testOnReturn,
+                                                                                timeBetweenEvictions, testsPerEviction,
+                                                                                idleTimeout, testWhileIdle);
         } else if (poolType.equals("AbandonedObjectPool")) {
-            connectionPool = new org.apache.commons.dbcp.AbandonedObjectPool(null,abandonedConfig);
+            connectionPool = new org.apache.commons.dbcp.AbandonedObjectPool(null, abandonedConfig);
         } else {
-            throw new ConfigurationException(
-                    "invalid pool type configuration: " + poolType);
+            throw new ConfigurationException("invalid pool type configuration: " + poolType);
         }
-        
+
         // Create raw connection factory
         ConnectionFactory connectionFactory = null;
         if (driverType.equals("DriverManager")) {
-            connectionFactory = new DriverManagerConnectionFactory(
-                    connectUrl,connectUser,
-                    connectPassword);
+            connectionFactory = new DriverManagerConnectionFactory(connectUrl, connectUser, connectPassword);
         } else if (driverType.equals("Driver")) {
             Properties props = new Properties();
             props.put("user", connectUser);
             props.put("password", connectPassword);
-            connectionFactory = new DriverConnectionFactory(
-                    (Driver) Class.forName(driverClass).newInstance(),
-                    connectUrl, props);
+            connectionFactory = new DriverConnectionFactory((Driver) Class.forName(driverClass).newInstance(),
+                                                            connectUrl, props);
         } else {
-            throw new ConfigurationException(
-            "Bad config setting for driver type"); 
-        } 
-   
+            throw new ConfigurationException("Bad config setting for driver type");
+        }
+
         // Create object factory
         PoolableObjectFactory poolableConnectionFactory = null;
         KeyedObjectPoolFactory statementPoolFactory = null;
         if (poolPreparedStatements) { // Use same defaults as BasicDataSource
-            statementPoolFactory = new GenericKeyedObjectPoolFactory(null,
-                        -1, // unlimited maxActive (per key)
-                        GenericKeyedObjectPool.WHEN_EXHAUSTED_FAIL,
-                        0, // maxWait
-                        1, // maxIdle (per key)
-                        maxOpenStatements); //TODO: make all configurable
+            statementPoolFactory = new GenericKeyedObjectPoolFactory(null, -1, // unlimited
+                                                                               // maxActive (per
+                                                                               // key)
+                                                                     GenericKeyedObjectPool.WHEN_EXHAUSTED_FAIL, 0, // maxWait
+                                                                     1, // maxIdle (per key)
+                                                                     maxOpenStatements); // TODO:
+                                                                                         // make all
+                                                                                         // configurable
         }
         if (factoryType.equals("PoolableConnectionFactory")) {
-            poolableConnectionFactory = 
-                new PoolableConnectionFactory(
-                        connectionFactory,connectionPool, statementPoolFactory,
-                        validationQuery, readOnly, autocommit);
+            poolableConnectionFactory = new PoolableConnectionFactory(connectionFactory, connectionPool,
+                                                                      statementPoolFactory, validationQuery, readOnly,
+                                                                      autocommit);
         } else if (factoryType.equals("CPDSConnectionFactory")) {
-            throw new ConfigurationException(
-            "CPDSConnectionFactory not implemented yet");
+            throw new ConfigurationException("CPDSConnectionFactory not implemented yet");
         } else {
-            throw new ConfigurationException(
-                    "Invalid factory type: " + factoryType);
+            throw new ConfigurationException("Invalid factory type: " + factoryType);
         }
-        
+
         // Create DataSource
-        dataSource = new PoolingDataSource(connectionPool); 
-        checkDatabase();   
+        dataSource = new PoolingDataSource(connectionPool);
+        checkDatabase();
     }
-    
-    protected void checkDatabase() throws Exception {
-        // Try to connect and query test_table. If "test_table" appears in 
-        // exception message, assume table needs to be created. 
+
+    protected void checkDatabase()
+        throws Exception {
+        // Try to connect and query test_table. If "test_table" appears in
+        // exception message, assume table needs to be created.
         Connection conn = dataSource.getConnection();
         try {
             Statement stmnt = conn.createStatement();
@@ -255,11 +252,13 @@ public class DBCPSoak extends LoadGenera
             conn.close();
         }
     }
-    
+
     /**
      * Close connection pool
      */
-    protected void cleanUp() throws Exception {
+    @Override
+    protected void cleanUp()
+        throws Exception {
         if (dataSourceType.equals("BasicDataSource")) {
             ((org.apache.commons.dbcp.BasicDataSource) dataSource).close();
         } else if (dataSourceType.equals("tomcat-jdbc-pool")) {
@@ -268,57 +267,49 @@ public class DBCPSoak extends LoadGenera
             ((org.apache.commons.dbcp2.BasicDataSource) dataSource).close();
         }
     }
-    
-    protected ClientThread makeClientThread(
-            long iterations, long minDelay, long maxDelay, double sigma,
-            String delayType, long rampPeriod, long peakPeriod,
-            long troughPeriod, String cycleType, String rampType,
-            Logger logger, Statistics stats) {
-        
-        return new DBCPClientThread(iterations, minDelay, maxDelay,
-            sigma, delayType, queryType, rampPeriod, peakPeriod, 
-            troughPeriod, cycleType, rampType, logger, dataSource,
-            stats);
+
+    @Override
+    protected ClientThread makeClientThread(long iterations, long minDelay, long maxDelay, double sigma,
+                                            String delayType, long rampPeriod, long peakPeriod, long troughPeriod,
+                                            String cycleType, String rampType, Logger logger, Statistics stats) {
+
+        return new DBCPClientThread(iterations, minDelay, maxDelay, sigma, delayType, queryType, rampPeriod,
+                                    peakPeriod, troughPeriod, cycleType, rampType, logger, dataSource, stats);
     }
-    
+
     // ------------------------------------------------------------------------
     // Configuration methods specific to this LoadGenerator invoked by Digester
     // when superclass execute calls digester.parse.
     // ------------------------------------------------------------------------
-    public void configureDataBase(String driver, String url,
-            String username, String password, String queryType) {
+    public void configureDataBase(String driver, String url, String username, String password, String queryType) {
         this.driverClass = driver;
         this.connectUrl = url;
         this.connectUser = username;
         this.connectPassword = password;
         this.queryType = queryType;
     }
-    
+
     public void configureDataSource(String type) {
         this.dataSourceType = type;
     }
-    
-    public void configureConnectionFactory(String type,
-            String autoCommit, String readOnly, String validationQuery) {
+
+    public void configureConnectionFactory(String type, String autoCommit, String readOnly, String validationQuery) {
         this.driverType = type;
         this.autocommit = Boolean.parseBoolean(autoCommit);
         this.readOnly = Boolean.parseBoolean(readOnly);
         this.validationQuery = validationQuery;
     }
-    
-    public void configurePoolableConnectionFactory(String type, 
-            String poolPreparedStatements, String maxOpenStatements) {
+
+    public void configurePoolableConnectionFactory(String type, String poolPreparedStatements, String maxOpenStatements) {
         this.factoryType = type;
-        this.poolPreparedStatements = 
-            Boolean.parseBoolean(poolPreparedStatements);
+        this.poolPreparedStatements = Boolean.parseBoolean(poolPreparedStatements);
         this.maxOpenStatements = Integer.parseInt(maxOpenStatements);
     }
-    
-    public void configurePool(String maxActive, String maxIdle, String minIdle,
-            String maxWait, String exhaustedAction, String testOnBorrow,
-            String testOnReturn, String timeBetweenEvictions,
-            String testsPerEviction, String idleTimeout, 
-            String testWhileIdle, String type) throws ConfigurationException { 
+
+    public void configurePool(String maxActive, String maxIdle, String minIdle, String maxWait, String exhaustedAction,
+                              String testOnBorrow, String testOnReturn, String timeBetweenEvictions,
+                              String testsPerEviction, String idleTimeout, String testWhileIdle, String type)
+        throws ConfigurationException {
         this.maxActive = Integer.parseInt(maxActive);
         this.maxIdle = Integer.parseInt(maxIdle);
         this.minIdle = Integer.parseInt(minIdle);
@@ -336,54 +327,45 @@ public class DBCPSoak extends LoadGenera
             this.exhaustedAction = GenericObjectPool.WHEN_EXHAUSTED_FAIL;
         } else if (exhaustedAction.equals("grow")) {
             this.exhaustedAction = GenericObjectPool.WHEN_EXHAUSTED_GROW;
-        } else { 
-            throw new ConfigurationException(
-            "Bad configuration setting for exhausted action: "
-                    + exhaustedAction); 
-        }  
-    }
-    
-    public void configureAbandonedConfig(String logAbandoned,
-            String removeAbandoned, String abandonedTimeout) {
+        } else {
+            throw new ConfigurationException("Bad configuration setting for exhausted action: " + exhaustedAction);
+        }
+    }
+
+    public void configureAbandonedConfig(String logAbandoned, String removeAbandoned, String abandonedTimeout) {
         abandonedConfig.setLogAbandoned(Boolean.parseBoolean(logAbandoned));
-        abandonedConfig.setRemoveAbandoned(
-                Boolean.parseBoolean(removeAbandoned));
-        abandonedConfig.setRemoveAbandonedTimeout(
-                Integer.parseInt(abandonedTimeout));
+        abandonedConfig.setRemoveAbandoned(Boolean.parseBoolean(removeAbandoned));
+        abandonedConfig.setRemoveAbandonedTimeout(Integer.parseInt(abandonedTimeout));
     }
-     
+
     /**
-     * Creates and populates the test table (test_table) used in the 
-     * load tests. The created table will have 10,000 rows and 3 columns,
-     * populated with random data: <ul>
-     * <li> indexed (indexed integer column) </li>
-     * <li> not_indexed (non-indexed integer column) </li>
-     * <li> text (non-indexed varchar column) </li>
+     * Creates and populates the test table (test_table) used in the load tests. The created table
+     * will have 10,000 rows and 3 columns, populated with random data:
+     * <ul>
+     * <li>indexed (indexed integer column)</li>
+     * <li>not_indexed (non-indexed integer column)</li>
+     * <li>text (non-indexed varchar column)</li>
      * </ul>
-     *
+     * 
      * @throws Exception
      */
-    protected void makeTable() throws Exception {
-        Class.forName(driverClass); 
-        Connection db = DriverManager.getConnection(connectUrl,connectUser,
-                connectPassword);
+    protected void makeTable()
+        throws Exception {
+        Class.forName(driverClass);
+        Connection db = DriverManager.getConnection(connectUrl, connectUser, connectPassword);
         try {
             Statement sql = db.createStatement();
-            String sqlText = 
-                "create table test_table (indexed int, text varchar(20)," + 
-                " not_indexed int)";
+            String sqlText = "create table test_table (indexed int, text varchar(20)," + " not_indexed int)";
             sql.executeUpdate(sqlText);
             sqlText = "CREATE INDEX test1_id_index ON test_table (indexed);";
             sql.executeUpdate(sqlText);
-            RandomData randomData = new RandomDataImpl();
+            RandomDataGenerator randomData = new RandomDataGenerator();
             for (int i = 0; i < 10000; i++) {
                 int indexed = randomData.nextInt(0, 100);
                 int not_indexed = randomData.nextInt(0, 1000);
                 String text = randomData.nextHexString(20);
-                sqlText = 
-                    "INSERT INTO test_table (indexed, text, not_indexed)" + 
-                    "VALUES (" + indexed + "," + "'"+ text + "'," + 
-                    not_indexed + ");";
+                sqlText = "INSERT INTO test_table (indexed, text, not_indexed)" + "VALUES (" + indexed + "," + "'" +
+                          text + "'," + not_indexed + ");";
                 sql.executeUpdate(sqlText);
             }
             sql.close();
@@ -391,82 +373,56 @@ public class DBCPSoak extends LoadGenera
             db.close();
         }
     }
-    
+
     /**
-     * Add dbcp configuration to parameters loaded by super.
-     * Also set config file name.
+     * Add dbcp configuration to parameters loaded by super. Also set config file name.
      */
-    protected void configure() throws Exception {
-        
+    @Override
+    protected void configure()
+        throws Exception {
+
         super.configure();
-        
-        digester.addCallMethod("configuration/database",
-                "configureDataBase", 5);
+
+        digester.addCallMethod("configuration/database", "configureDataBase", 5);
         digester.addCallParam("configuration/database/driver", 0);
         digester.addCallParam("configuration/database/url", 1);
         digester.addCallParam("configuration/database/username", 2);
         digester.addCallParam("configuration/database/password", 3);
         digester.addCallParam("configuration/database/query-type", 4);
-        
+
         digester.addCallMethod("configuration", "configureDataSource", 1);
         digester.addCallParam("configuration/datasource-type", 0);
-        
-        digester.addCallMethod("configuration/connection-factory", 
-                "configureConnectionFactory", 4);
-        digester.addCallParam(
-                "configuration/connection-factory/type", 0);
-        digester.addCallParam(
-                "configuration/connection-factory/auto-commit", 1);
-        digester.addCallParam(
-                "configuration/connection-factory/read-only", 2);
-        digester.addCallParam(
-                "configuration/connection-factory/validation-query", 3);
-        
-        digester.addCallMethod("configuration/poolable-connection-factory", 
-                "configurePoolableConnectionFactory", 3);
-        digester.addCallParam(
-                "configuration/poolable-connection-factory/type", 0);
-        digester.addCallParam(
-                "configuration/poolable-connection-factory/pool-prepared-statements", 1);
-        digester.addCallParam(
-                "configuration/poolable-connection-factory/max-open-statements", 2);
-        
-        digester.addCallMethod("configuration/pool", 
-                "configurePool", 12);
-        digester.addCallParam(
-                "configuration/pool/max-active", 0);
-        digester.addCallParam(
-                "configuration/pool/max-idle", 1);
-        digester.addCallParam(
-                "configuration/pool/min-idle", 2);
-        digester.addCallParam(
-                "configuration/pool/max-wait", 3);
-        digester.addCallParam(
-                "configuration/pool/exhausted-action", 4);
-        digester.addCallParam(
-                "configuration/pool/test-on-borrow", 5);
-        digester.addCallParam(
-                "configuration/pool/test-on-return", 6);
-        digester.addCallParam(
-                "configuration/pool/time-between-evictions", 7);
-        digester.addCallParam(
-                "configuration/pool/tests-per-eviction", 8);
-        digester.addCallParam(
-                "configuration/pool/idle-timeout", 9);
-        digester.addCallParam(
-                "configuration/pool/test-while-idle", 10);
-        digester.addCallParam(
-                "configuration/pool/type", 11);
-        
-        digester.addCallMethod("configuration/abandoned-config",
-                "configureAbandonedConfig", 3);
-        digester.addCallParam(
-                "configuration/abandoned-config/log-abandoned", 0);
-        digester.addCallParam(
-                "configuration/abandoned-config/remove-abandoned", 1);
-        digester.addCallParam(
-                "configuration/abandoned-config/abandoned-timeout", 2);
-        
+
+        digester.addCallMethod("configuration/connection-factory", "configureConnectionFactory", 4);
+        digester.addCallParam("configuration/connection-factory/type", 0);
+        digester.addCallParam("configuration/connection-factory/auto-commit", 1);
+        digester.addCallParam("configuration/connection-factory/read-only", 2);
+        digester.addCallParam("configuration/connection-factory/validation-query", 3);
+
+        digester.addCallMethod("configuration/poolable-connection-factory", "configurePoolableConnectionFactory", 3);
+        digester.addCallParam("configuration/poolable-connection-factory/type", 0);
+        digester.addCallParam("configuration/poolable-connection-factory/pool-prepared-statements", 1);
+        digester.addCallParam("configuration/poolable-connection-factory/max-open-statements", 2);
+
+        digester.addCallMethod("configuration/pool", "configurePool", 12);
+        digester.addCallParam("configuration/pool/max-active", 0);
+        digester.addCallParam("configuration/pool/max-idle", 1);
+        digester.addCallParam("configuration/pool/min-idle", 2);
+        digester.addCallParam("configuration/pool/max-wait", 3);
+        digester.addCallParam("configuration/pool/exhausted-action", 4);
+        digester.addCallParam("configuration/pool/test-on-borrow", 5);
+        digester.addCallParam("configuration/pool/test-on-return", 6);
+        digester.addCallParam("configuration/pool/time-between-evictions", 7);
+        digester.addCallParam("configuration/pool/tests-per-eviction", 8);
+        digester.addCallParam("configuration/pool/idle-timeout", 9);
+        digester.addCallParam("configuration/pool/test-while-idle", 10);
+        digester.addCallParam("configuration/pool/type", 11);
+
+        digester.addCallMethod("configuration/abandoned-config", "configureAbandonedConfig", 3);
+        digester.addCallParam("configuration/abandoned-config/log-abandoned", 0);
+        digester.addCallParam("configuration/abandoned-config/remove-abandoned", 1);
+        digester.addCallParam("configuration/abandoned-config/abandoned-timeout", 2);
+
         this.configFile = "config-dbcp.xml";
     }
 }

Modified: commons/sandbox/performance/trunk/src/java/org/apache/commons/performance/pool/PoolClientThread.java
URL: http://svn.apache.org/viewvc/commons/sandbox/performance/trunk/src/java/org/apache/commons/performance/pool/PoolClientThread.java?rev=1580595&r1=1580594&r2=1580595&view=diff
==============================================================================
--- commons/sandbox/performance/trunk/src/java/org/apache/commons/performance/pool/PoolClientThread.java (original)
+++ commons/sandbox/performance/trunk/src/java/org/apache/commons/performance/pool/PoolClientThread.java Sun Mar 23 20:31:36 2014
@@ -25,59 +25,62 @@ import java.util.logging.Logger;
 //import org.apache.commons.pool2.ObjectPool;
 //import org.apache.commons.pool.KeyedObjectPool;
 //import org.apache.commons.pool2.KeyedObjectPool;
-import org.apache.commons.math.random.RandomData;
-import org.apache.commons.math.random.RandomDataImpl;
-import org.apache.commons.math.stat.descriptive.SummaryStatistics;
+import org.apache.commons.math3.random.RandomDataGenerator;
+import org.apache.commons.math3.stat.descriptive.SummaryStatistics;
 import org.apache.commons.performance.ClientThread;
 import org.apache.commons.performance.Statistics;
 
 /**
- * <p>Client thread that borrows and returns objects from a pool in a loop.
- * See {@link ClientThread ClientThread javadoc} for a description
- * of how times between requests are computed.  In addition to request latency,
- * pool numIdle and numActive statistics and stats on instance idle time are tracked.
- * Constructors are provided for both 1.x and version 2 simple and keyed pools.</p>
+ * <p>
+ * Client thread that borrows and returns objects from a pool in a loop. See {@link ClientThread
+ * ClientThread javadoc} for a description of how times between requests are computed. In addition
+ * to request latency, pool numIdle and numActive statistics and stats on instance idle time are
+ * tracked. Constructors are provided for both 1.x and version 2 simple and keyed pools.
+ * </p>
  * 
- * <p>Note that this class is *not* threadsafe.</p>
+ * <p>
+ * Note that this class is *not* threadsafe.
+ * </p>
  */
-public class PoolClientThread extends ClientThread {
-    
+public class PoolClientThread
+    extends ClientThread {
+
     /** Version 1.x object pool (if keyed = false) */
     private final org.apache.commons.pool.ObjectPool pool;
-    
+
     /** Version 1.x keyed pool (if keyed = true) */
     private final org.apache.commons.pool.KeyedObjectPool keyedPool;
-    
+
     /** Version 2 object pool (if keyed = false) */
     private final org.apache.commons.pool2.ObjectPool<Waiter> pool2;
-    
+
     /** Version 2 keyed pool (if keyed = true) */
     private final org.apache.commons.pool2.KeyedObjectPool<Integer, Waiter> keyedPool2;
-    
+
     /** Whether or not pool being tested is keyed */
     private boolean keyed;
-    
+
     /** Randomly generated keys (if keyed = true) */
-    private List<Integer> keys; 
-    
+    private List<Integer> keys;
+
     /** Source of randomness (for keys, if keyed = true) */
-    private final RandomData randomData = new RandomDataImpl(); 
-    
+    private final RandomDataGenerator randomData = new RandomDataGenerator();
+
     /** Statistics on numActive */
     private SummaryStatistics numActiveStats = new SummaryStatistics();
-    
+
     /** Statistics on numIdle */
     private SummaryStatistics numIdleStats = new SummaryStatistics();
-    
+
     /** Sampling rate for numActive, numIdle */
     private double samplingRate;
-    
+
     /** Statistics on instance idle time */
     private SummaryStatistics instanceIdleTimeStats = new SummaryStatistics();
-    
+
     /** Just-borrowed Waiter instance (used to grab idle time stats in cleanUp) */
     private Waiter waiter = null;
-     
+
     /**
      * Create a pool client thread for a version 1.x ObjectPool.
      * 
@@ -93,18 +96,16 @@ public class PoolClientThread extends Cl
      * @param logger common logger shared by all clients
      * @param stats Statistics container
      * @param pool ObjectPool
-     * @param samplingRate proportion of requests for which numIdle and numActive
-     * will be sampled for statistical analysis
+     * @param samplingRate proportion of requests for which numIdle and numActive will be sampled
+     *        for statistical analysis
      */
-    public PoolClientThread(long iterations, long minDelay, long maxDelay,
-            double sigma, String delayType, long rampPeriod, long peakPeriod,
-            long troughPeriod, String cycleType, String rampType, Logger logger, 
-            Statistics stats, org.apache.commons.pool.ObjectPool pool,
-            double samplingRate) {
-        
-        super(iterations, minDelay, maxDelay, sigma, delayType, rampPeriod,
-                peakPeriod, troughPeriod, cycleType,rampType, logger, 
-                stats); 
+    public PoolClientThread(long iterations, long minDelay, long maxDelay, double sigma, String delayType,
+                            long rampPeriod, long peakPeriod, long troughPeriod, String cycleType, String rampType,
+                            Logger logger, Statistics stats, org.apache.commons.pool.ObjectPool pool,
+                            double samplingRate) {
+
+        super(iterations, minDelay, maxDelay, sigma, delayType, rampPeriod, peakPeriod, troughPeriod, cycleType,
+              rampType, logger, stats);
         this.pool = pool;
         this.pool2 = null;
         this.keyedPool2 = null;
@@ -112,7 +113,7 @@ public class PoolClientThread extends Cl
         this.keyed = false;
         this.samplingRate = samplingRate;
     }
-    
+
     /**
      * Create a pool client thread for a version 1.x KeyedObjectPool.
      * 
@@ -126,21 +127,19 @@ public class PoolClientThread extends Cl
      * @param cycleType type of cycle for mean delay
      * @param rampType type of ramp (linear or random jumps)
      * @param logger common logger shared by all clients
-     * @param stats Statistics container 
+     * @param stats Statistics container
      * @param keyedPool KeyedObjectPool
-     * @param samplingRate proportion of requests for which numIdle and numActive
-     * will be sampled for statistical analysis
+     * @param samplingRate proportion of requests for which numIdle and numActive will be sampled
+     *        for statistical analysis
      */
-    public PoolClientThread(long iterations, long minDelay, long maxDelay,
-            double sigma, String delayType, long rampPeriod, long peakPeriod,
-            long troughPeriod, String cycleType, String rampType, Logger logger, 
-            Statistics stats, org.apache.commons.pool.KeyedObjectPool keyedPool,
-            double samplingRate) {
-        
-        super(iterations, minDelay, maxDelay, sigma, delayType, rampPeriod,
-                peakPeriod, troughPeriod, cycleType,rampType, logger, 
-                stats); 
-        
+    public PoolClientThread(long iterations, long minDelay, long maxDelay, double sigma, String delayType,
+                            long rampPeriod, long peakPeriod, long troughPeriod, String cycleType, String rampType,
+                            Logger logger, Statistics stats, org.apache.commons.pool.KeyedObjectPool keyedPool,
+                            double samplingRate) {
+
+        super(iterations, minDelay, maxDelay, sigma, delayType, rampPeriod, peakPeriod, troughPeriod, cycleType,
+              rampType, logger, stats);
+
         this.keyedPool = keyedPool;
         this.pool = null;
         this.pool2 = null;
@@ -148,11 +147,11 @@ public class PoolClientThread extends Cl
         this.keyed = true;
         this.samplingRate = samplingRate;
         keys = new ArrayList<Integer>();
-        for (int i = 0; i < 20; i++) { //TODO: make number of keys configurable
+        for (int i = 0; i < 20; i++) { // TODO: make number of keys configurable
             keys.add(new Integer(i));
         }
     }
-    
+
     /**
      * Create a pool client thread for a version 1.x ObjectPool.
      * 
@@ -168,18 +167,16 @@ public class PoolClientThread extends Cl
      * @param logger common logger shared by all clients
      * @param stats Statistics container
      * @param pool ObjectPool
-     * @param samplingRate proportion of requests for which numIdle and numActive
-     * will be sampled for statistical analysis
+     * @param samplingRate proportion of requests for which numIdle and numActive will be sampled
+     *        for statistical analysis
      */
-    public PoolClientThread(long iterations, long minDelay, long maxDelay,
-            double sigma, String delayType, long rampPeriod, long peakPeriod,
-            long troughPeriod, String cycleType, String rampType, Logger logger, 
-            Statistics stats, org.apache.commons.pool2.ObjectPool<Waiter> pool,
-            double samplingRate) {
-        
-        super(iterations, minDelay, maxDelay, sigma, delayType, rampPeriod,
-                peakPeriod, troughPeriod, cycleType,rampType, logger, 
-                stats); 
+    public PoolClientThread(long iterations, long minDelay, long maxDelay, double sigma, String delayType,
+                            long rampPeriod, long peakPeriod, long troughPeriod, String cycleType, String rampType,
+                            Logger logger, Statistics stats, org.apache.commons.pool2.ObjectPool<Waiter> pool,
+                            double samplingRate) {
+
+        super(iterations, minDelay, maxDelay, sigma, delayType, rampPeriod, peakPeriod, troughPeriod, cycleType,
+              rampType, logger, stats);
         this.pool2 = pool;
         this.pool = null;
         this.keyedPool2 = null;
@@ -187,7 +184,7 @@ public class PoolClientThread extends Cl
         this.keyed = false;
         this.samplingRate = samplingRate;
     }
-    
+
     /**
      * Create a pool client thread for a version 1.x KeyedObjectPool.
      * 
@@ -201,21 +198,19 @@ public class PoolClientThread extends Cl
      * @param cycleType type of cycle for mean delay
      * @param rampType type of ramp (linear or random jumps)
      * @param logger common logger shared by all clients
-     * @param stats Statistics container 
+     * @param stats Statistics container
      * @param keyedPool KeyedObjectPool
-     * @param samplingRate proportion of requests for which numIdle and numActive
-     * will be sampled for statistical analysis
+     * @param samplingRate proportion of requests for which numIdle and numActive will be sampled
+     *        for statistical analysis
      */
-    public PoolClientThread(long iterations, long minDelay, long maxDelay,
-            double sigma, String delayType, long rampPeriod, long peakPeriod,
-            long troughPeriod, String cycleType, String rampType, Logger logger, 
-            Statistics stats, org.apache.commons.pool2.KeyedObjectPool<Integer, Waiter> keyedPool,
-            double samplingRate) {
-        
-        super(iterations, minDelay, maxDelay, sigma, delayType, rampPeriod,
-                peakPeriod, troughPeriod, cycleType,rampType, logger, 
-                stats); 
-        
+    public PoolClientThread(long iterations, long minDelay, long maxDelay, double sigma, String delayType,
+                            long rampPeriod, long peakPeriod, long troughPeriod, String cycleType, String rampType,
+                            Logger logger, Statistics stats,
+                            org.apache.commons.pool2.KeyedObjectPool<Integer, Waiter> keyedPool, double samplingRate) {
+
+        super(iterations, minDelay, maxDelay, sigma, delayType, rampPeriod, peakPeriod, troughPeriod, cycleType,
+              rampType, logger, stats);
+
         this.keyedPool2 = keyedPool;
         this.pool = null;
         this.pool2 = null;
@@ -223,48 +218,46 @@ public class PoolClientThread extends Cl
         this.keyed = true;
         this.samplingRate = samplingRate;
         keys = new ArrayList<Integer>();
-        for (int i = 0; i < 20; i++) { //TODO: make number of keys configurable
+        for (int i = 0; i < 20; i++) { // TODO: make number of keys configurable
             keys.add(new Integer(i));
         }
     }
-    
+
     /** Borrow and return */
-    public void execute() throws Exception {
-       if (keyed) {
-           Integer key = keys.get(randomData.nextInt(0, 19));
-           waiter = keyedPool2 == null ? (Waiter) keyedPool.borrowObject(key) :
-               keyedPool2.borrowObject(key);
-           waiter.doWait();
-           if (keyedPool2 == null) {
-               keyedPool.returnObject(key, waiter);
-           } else {
-               keyedPool2.returnObject(key, waiter);
-           }
-       } else {
-           waiter = pool2 == null ? (Waiter) pool.borrowObject() :
-               pool2.borrowObject(); 
-           waiter.doWait();
-           if (pool2 == null) {
-               pool.returnObject(waiter);
-           } else {
-               pool2.returnObject(waiter);
-           }
-       }
+    @Override
+    public void execute()
+        throws Exception {
+        if (keyed) {
+            Integer key = keys.get(randomData.nextInt(0, 19));
+            waiter = keyedPool2 == null ? (Waiter) keyedPool.borrowObject(key) : keyedPool2.borrowObject(key);
+            waiter.doWait();
+            if (keyedPool2 == null) {
+                keyedPool.returnObject(key, waiter);
+            } else {
+                keyedPool2.returnObject(key, waiter);
+            }
+        } else {
+            waiter = pool2 == null ? (Waiter) pool.borrowObject() : pool2.borrowObject();
+            waiter.doWait();
+            if (pool2 == null) {
+                pool.returnObject(waiter);
+            } else {
+                pool2.returnObject(waiter);
+            }
+        }
     }
-    
-    protected void cleanUp() throws Exception {
-        // Capture pool metrics 
+
+    @Override
+    protected void cleanUp()
+        throws Exception {
+        // Capture pool metrics
         if (randomData.nextUniform(0, 1) < samplingRate) {
             if (keyed) {
-                numIdleStats.addValue(keyedPool2 == null ? keyedPool.getNumIdle() :
-                    keyedPool2.getNumIdle());
-                numActiveStats.addValue(keyedPool2 == null ? keyedPool.getNumActive() :
-                    keyedPool2.getNumActive());
+                numIdleStats.addValue(keyedPool2 == null ? keyedPool.getNumIdle() : keyedPool2.getNumIdle());
+                numActiveStats.addValue(keyedPool2 == null ? keyedPool.getNumActive() : keyedPool2.getNumActive());
             } else {
-                numIdleStats.addValue(pool2 == null ? pool.getNumIdle() :
-                    pool2.getNumIdle());
-                numActiveStats.addValue(pool2 == null ? pool.getNumActive() :
-                    pool2.getNumActive());
+                numIdleStats.addValue(pool2 == null ? pool.getNumIdle() : pool2.getNumIdle());
+                numActiveStats.addValue(pool2 == null ? pool.getNumActive() : pool2.getNumActive());
             }
         }
         if (waiter != null) {
@@ -272,14 +265,13 @@ public class PoolClientThread extends Cl
         }
         waiter = null;
     }
-    
-    protected void finish() throws Exception {
+
+    @Override
+    protected void finish()
+        throws Exception {
         // Add metrics to stats
-        stats.addStatistics(
-                numIdleStats, Thread.currentThread().getName(), "numIdle");
-        stats.addStatistics(
-                numActiveStats, Thread.currentThread().getName(), "numActive");
-        stats.addStatistics(
-                instanceIdleTimeStats, Thread.currentThread().getName(), "instance idle time");
+        stats.addStatistics(numIdleStats, Thread.currentThread().getName(), "numIdle");
+        stats.addStatistics(numActiveStats, Thread.currentThread().getName(), "numActive");
+        stats.addStatistics(instanceIdleTimeStats, Thread.currentThread().getName(), "instance idle time");
     }
 }



Mime
View raw message