commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From pste...@apache.org
Subject svn commit: r611706 - in /commons/sandbox/performance/trunk: ./ src/java/org/apache/commons/performance/pool/ src/test/org/apache/commons/performance/pool/
Date Mon, 14 Jan 2008 04:11:29 GMT
Author: psteitz
Date: Sun Jan 13 20:11:28 2008
New Revision: 611706

URL: http://svn.apache.org/viewvc?rev=611706&view=rev
Log:
Added support for keyed, stack, softReference pools.

Modified:
    commons/sandbox/performance/trunk/config-pool.xml
    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/WaiterFactory.java
    commons/sandbox/performance/trunk/src/test/org/apache/commons/performance/pool/PoolSoakTest.java

Modified: commons/sandbox/performance/trunk/config-pool.xml
URL: http://svn.apache.org/viewvc/commons/sandbox/performance/trunk/config-pool.xml?rev=611706&r1=611705&r2=611706&view=diff
==============================================================================
--- commons/sandbox/performance/trunk/config-pool.xml (original)
+++ commons/sandbox/performance/trunk/config-pool.xml Sun Jan 13 20:11:28 2008
@@ -31,7 +31,8 @@
   </factory>
   
   <pool>
-    <!-- GenericObjectPool or AbandonedObjectPool -->
+    <!-- GenericObjectPool, AbandonedObjectPool, GenericKeyedObjectPool
+         StackObjectPool, StackKeyedObjectPool, SoftReferenceObjectPool -->
     <type>GenericObjectPool</type>
     <max-active>15</max-active>
     <max-idle>15</max-idle>
@@ -45,6 +46,9 @@
     <tests-per-eviction>3</tests-per-eviction>
     <idle-timeout>-1</idle-timeout>
     <test-while-idle>false</test-while-idle>
+    <lifo>false</lifo>
+    <!-- Ignored unless pool type a KeyedObjectPool -->
+    <max-active-per-key>10</max-active-per-key>
   </pool>
   
   <!-- Ignored unless pool type is AbandonedObjectPool -->

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=611706&r1=611705&r2=611706&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 Jan 13 20:11:28 2008
@@ -17,11 +17,15 @@
 
 package org.apache.commons.performance.pool;
 
+import java.util.ArrayList;
 import java.util.List;
 import java.util.logging.Logger;
 
 import org.apache.commons.pool.ObjectPool;
+import org.apache.commons.pool.KeyedObjectPool;
 import org.apache.commons.math.stat.descriptive.SummaryStatistics;
+import org.apache.commons.math.random.RandomData;
+import org.apache.commons.math.random.RandomDataImpl;
 import org.apache.commons.performance.ClientThread;
 
 /**
@@ -33,9 +37,13 @@
 public class PoolClientThread extends ClientThread {
     
     private ObjectPool pool;
+    private KeyedObjectPool keyedPool;
+    private boolean keyed;
+    private List<Integer> keys;
+    private RandomData randomData;
      
     /**
-     * Create a pool client thread.
+     * Create a pool client thread for an ObjectPool.
      * 
      * @param iterations number of iterations
      * @param minDelay minimum mean time between client requests
@@ -48,6 +56,7 @@
      * @param rampType type of ramp (linear or random jumps)
      * @param logger common logger shared by all clients
      * @param statsList List of SummaryStatistics to add results to
+     * @param pool ObjectPool
      */
     public PoolClientThread(long iterations, long minDelay, long maxDelay,
             double sigma, String delayType, long rampPeriod, long peakPeriod,
@@ -58,13 +67,53 @@
                 peakPeriod, troughPeriod, cycleType,rampType, logger, 
                 statsList); 
         this.pool = pool;
+        this.keyed = false;
+    }
+    
+    /**
+     * Create a pool client thread for a KeyedObjectPool.
+     * 
+     * @param iterations number of iterations
+     * @param minDelay minimum mean time between client requests
+     * @param maxDelay maximum mean time between client requests
+     * @param delayType distribution of time between client requests
+     * @param rampPeriod ramp period of cycle for cyclic load
+     * @param peakPeriod peak period of cycle for cyclic load
+     * @param troughPeriod trough period of cycle for cyclic load
+     * @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 statsList List of SummaryStatistics to add results to
+     * @param keyedPool KeyedObjectPool
+     */
+    public PoolClientThread(long iterations, long minDelay, long maxDelay,
+            double sigma, String delayType, long rampPeriod, long peakPeriod,
+            long troughPeriod, String cycleType, String rampType, Logger logger, 
+            List <SummaryStatistics> statsList, KeyedObjectPool keyedPool) {
+        
+        super(iterations, minDelay, maxDelay, sigma, delayType, rampPeriod,
+                peakPeriod, troughPeriod, cycleType,rampType, logger, 
+                statsList); 
+        this.keyedPool = keyedPool;
+        this.keyed = true;
+        keys = new ArrayList<Integer>();
+        for (int i = 0; i < 20; i++) { //TODO: make number of keys configurable
+            keys.add(new Integer(i));
+        }
+        randomData = new RandomDataImpl();
     }
     
     /** Borrow and return */
     public void execute() throws Exception {
-       Waiter waiter = (Waiter) pool.borrowObject(); 
-       waiter.doWait();
-       pool.returnObject(waiter);
+       if (keyed) {
+           Integer key = keys.get(randomData.nextInt(0, 19));
+           Waiter waiter = (Waiter) keyedPool.borrowObject(key);
+           waiter.doWait();
+           keyedPool.returnObject(key, waiter);
+       } else {
+           Waiter waiter = (Waiter) pool.borrowObject(); 
+           waiter.doWait();
+           pool.returnObject(waiter);
+       }
     }
-
 }

Modified: commons/sandbox/performance/trunk/src/java/org/apache/commons/performance/pool/PoolSoak.java
URL: http://svn.apache.org/viewvc/commons/sandbox/performance/trunk/src/java/org/apache/commons/performance/pool/PoolSoak.java?rev=611706&r1=611705&r2=611706&view=diff
==============================================================================
--- commons/sandbox/performance/trunk/src/java/org/apache/commons/performance/pool/PoolSoak.java
(original)
+++ commons/sandbox/performance/trunk/src/java/org/apache/commons/performance/pool/PoolSoak.java
Sun Jan 13 20:11:28 2008
@@ -22,7 +22,13 @@
 import org.apache.commons.dbcp.AbandonedConfig;
 import org.apache.commons.dbcp.AbandonedObjectPool;
 import org.apache.commons.math.stat.descriptive.SummaryStatistics;
+import org.apache.commons.pool.ObjectPool;
+import org.apache.commons.pool.KeyedObjectPool;
 import org.apache.commons.pool.impl.GenericObjectPool;
+import org.apache.commons.pool.impl.StackObjectPool;
+import org.apache.commons.pool.impl.SoftReferenceObjectPool;
+import org.apache.commons.pool.impl.GenericKeyedObjectPool;
+import org.apache.commons.pool.impl.StackKeyedObjectPool;
 import org.apache.commons.performance.ConfigurationException;
 import org.apache.commons.performance.ClientThread;
 import org.apache.commons.performance.LoadGenerator;
@@ -35,10 +41,17 @@
  */
 public class PoolSoak extends LoadGenerator {
     
+    // Pool instances
+    private GenericObjectPool genericObjectPool;
+    private GenericKeyedObjectPool genericKeyedObjectPool;
+    private StackObjectPool stackObjectPool;
+    private SoftReferenceObjectPool softReferenceObjectPool;
+    private StackKeyedObjectPool stackKeyedObjectPool;
+    
     // Pool properties
     private String poolType;
-    private GenericObjectPool pool;
-    private int maxActive;
+    private int maxActive;       // maxActive for GOP, maxTotal for GKOP
+    private int maxActivePerKey; // maxActive for GKOP
     private int maxIdle;
     private int minIdle;
     private long maxWait;
@@ -50,6 +63,7 @@
     private long idleTimeout;
     private boolean testWhileIdle;
     private AbandonedConfig abandonedConfig = new AbandonedConfig();
+    private boolean lifo;
     
     // WaiterFactory properties
     private long activateLatency;
@@ -80,31 +94,35 @@
         digester.addCallParam(
                 "configuration/factory/waiter-latency", 5);   
         digester.addCallMethod("configuration/pool", 
-                "configurePool", 12);
+                "configurePool", 14);
         digester.addCallParam(
                 "configuration/pool/max-active", 0);
         digester.addCallParam(
-                "configuration/pool/max-idle", 1);
+                "configuration/pool/max-active-per-key", 1);
+        digester.addCallParam(
+                "configuration/pool/max-idle", 2);
         digester.addCallParam(
-                "configuration/pool/min-idle", 2);
+                "configuration/pool/min-idle", 3);
         digester.addCallParam(
-                "configuration/pool/max-wait", 3);
+                "configuration/pool/max-wait", 4);
         digester.addCallParam(
-                "configuration/pool/exhausted-action", 4);
+                "configuration/pool/exhausted-action", 5);
         digester.addCallParam(
-                "configuration/pool/test-on-borrow", 5);
+                "configuration/pool/test-on-borrow", 6);
         digester.addCallParam(
-                "configuration/pool/test-on-return", 6);
+                "configuration/pool/test-on-return", 7);
         digester.addCallParam(
-                "configuration/pool/time-between-evictions", 7);
+                "configuration/pool/time-between-evictions", 8);
         digester.addCallParam(
-                "configuration/pool/tests-per-eviction", 8);
+                "configuration/pool/tests-per-eviction", 9);
         digester.addCallParam(
-                "configuration/pool/idle-timeout", 9);
+                "configuration/pool/idle-timeout", 10);
         digester.addCallParam(
-                "configuration/pool/test-while-idle", 10);
+                "configuration/pool/test-while-idle", 11);
         digester.addCallParam(
-                "configuration/pool/type", 11);
+                "configuration/pool/lifo", 12);
+        digester.addCallParam(
+                "configuration/pool/type", 13);
         digester.addCallMethod("configuration/abandoned-config",
                 "configureAbandonedConfig", 3);
         digester.addCallParam(
@@ -122,46 +140,96 @@
      * Create object pool and factory
      */
     protected void init() throws Exception {
+        // Create factory
+        WaiterFactory factory = new WaiterFactory(activateLatency, destroyLatency,
+                makeLatency, passivateLatency, validateLatency, waiterLatency,
+                maxActive, maxActivePerKey); 
+        
         // Create object pool
         if (poolType.equals("GenericObjectPool")) {
-            pool = new GenericObjectPool(
-                    null, maxActive, exhaustedAction,
-                    maxWait, maxIdle, minIdle, testOnBorrow, testOnReturn,
-                    timeBetweenEvictions, testsPerEviction, idleTimeout,
-                    testWhileIdle);
+            genericObjectPool = new GenericObjectPool();
+            genericObjectPool = new AbandonedObjectPool(null,abandonedConfig);
+            genericObjectPool.setMaxActive(maxActive);
+            genericObjectPool.setWhenExhaustedAction(exhaustedAction);
+            genericObjectPool.setMaxWait(maxWait);
+            genericObjectPool.setMaxIdle(maxIdle);
+            genericObjectPool.setMinIdle(minIdle);
+            genericObjectPool.setTestOnBorrow(testOnBorrow);
+            genericObjectPool.setTestOnReturn(testOnReturn);
+            genericObjectPool.setTimeBetweenEvictionRunsMillis(
+                    timeBetweenEvictions);
+            genericObjectPool.setNumTestsPerEvictionRun(testsPerEviction);
+            genericObjectPool.setMinEvictableIdleTimeMillis(idleTimeout);
+            genericObjectPool.setTestWhileIdle(testWhileIdle);
+            genericObjectPool.setLifo(lifo);
+            genericObjectPool.setFactory(factory);
         } else if (poolType.equals("AbandonedObjectPool")) {
-            pool = new AbandonedObjectPool(null,abandonedConfig);
-            pool.setMaxActive(maxActive);
-            pool.setWhenExhaustedAction(exhaustedAction);
-            pool.setMaxWait(maxWait);
-            pool.setMaxIdle(maxIdle);
-            pool.setMinIdle(minIdle);
-            pool.setTestOnBorrow(testOnBorrow);
-            pool.setTestOnReturn(testOnReturn);
-            pool.setTimeBetweenEvictionRunsMillis(timeBetweenEvictions);
-            pool.setNumTestsPerEvictionRun(testsPerEviction);
-            pool.setMinEvictableIdleTimeMillis(idleTimeout);
-            pool.setTestWhileIdle(testWhileIdle);
+            genericObjectPool = new AbandonedObjectPool(null,abandonedConfig);
+            genericObjectPool.setMaxActive(maxActive);
+            genericObjectPool.setWhenExhaustedAction(exhaustedAction);
+            genericObjectPool.setMaxWait(maxWait);
+            genericObjectPool.setMaxIdle(maxIdle);
+            genericObjectPool.setMinIdle(minIdle);
+            genericObjectPool.setTestOnBorrow(testOnBorrow);
+            genericObjectPool.setTestOnReturn(testOnReturn);
+            genericObjectPool.setTimeBetweenEvictionRunsMillis(
+                    timeBetweenEvictions);
+            genericObjectPool.setNumTestsPerEvictionRun(testsPerEviction);
+            genericObjectPool.setMinEvictableIdleTimeMillis(idleTimeout);
+            genericObjectPool.setTestWhileIdle(testWhileIdle);
+            genericObjectPool.setLifo(lifo);
+            genericObjectPool.setFactory(factory);
+        } else if (poolType.equals("GenericKeyedObjectPool")) {
+            genericKeyedObjectPool = new GenericKeyedObjectPool();
+            genericKeyedObjectPool.setMaxActive(maxActivePerKey);
+            genericKeyedObjectPool.setMaxTotal(maxActive);
+            genericKeyedObjectPool.setWhenExhaustedAction(exhaustedAction);
+            genericKeyedObjectPool.setMaxWait(maxWait);
+            genericKeyedObjectPool.setMaxIdle(maxIdle);
+            genericKeyedObjectPool.setMinIdle(minIdle);
+            genericKeyedObjectPool.setTestOnBorrow(testOnBorrow);
+            genericKeyedObjectPool.setTestOnReturn(testOnReturn);
+            genericKeyedObjectPool.setTimeBetweenEvictionRunsMillis(
+                    timeBetweenEvictions);
+            genericKeyedObjectPool.setNumTestsPerEvictionRun(testsPerEviction);
+            genericKeyedObjectPool.setMinEvictableIdleTimeMillis(idleTimeout);
+            genericKeyedObjectPool.setTestWhileIdle(testWhileIdle);
+            genericKeyedObjectPool.setLifo(lifo);
+            genericKeyedObjectPool.setFactory(factory);
+        } else if (poolType.equals("StackObjectPool")) {
+            stackObjectPool = new StackObjectPool();
+            stackObjectPool.setFactory(factory);
+        } else if (poolType.equals("SoftReferenceObjectPool")) {
+            softReferenceObjectPool = new SoftReferenceObjectPool();
+            softReferenceObjectPool.setFactory(factory);
+        } else if (poolType.equals("StackKeyedObjectPool")) {
+            stackKeyedObjectPool = new StackKeyedObjectPool();
+            stackKeyedObjectPool.setFactory(factory);
         } else {
             throw new ConfigurationException(
                     "invalid pool type configuration: " + poolType);
         }
         
-        // Create factory
-        pool.setFactory(new WaiterFactory(activateLatency, destroyLatency,
-                makeLatency, passivateLatency, validateLatency, waiterLatency,
-                maxActive)); 
         logger.info("Initialized pool with properties: ");
-        logger.info(" exhaustedAction: " + pool.getWhenExhaustedAction());
-        logger.info(" maxActive: " + pool.getMaxActive());
-        logger.info(" maxIdle: " + pool.getMaxIdle());
-        logger.info(" minIdle: " + pool.getMinIdle());
-        logger.info(" testOnBorrow: " + pool.getTestOnBorrow());
-        logger.info(" testWhileIdle: " + pool.getTestWhileIdle());
-        logger.info(" timeBetweenEvictions: " + pool.getTimeBetweenEvictionRunsMillis());
-        logger.info(" testsPerEviction: " + pool.getNumTestsPerEvictionRun());
-        logger.info(" idleTimeout: " + pool.getMinEvictableIdleTimeMillis());
-        
+        logger.info(" poolTypeT: " + poolType);
+        logger.info(" exhaustedAction: " + exhaustedAction);
+        logger.info(" maxActive: " + maxActive);
+        logger.info(" maxActivePerKey: " + maxActivePerKey);
+        logger.info(" maxIdle: " + maxIdle);
+        logger.info(" minIdle: " + minIdle);
+        logger.info(" testOnBorrow: " + testOnBorrow);
+        logger.info(" testWhileIdle: " + testWhileIdle);
+        logger.info(" timeBetweenEvictions: " + timeBetweenEvictions);
+        logger.info(" testsPerEviction: " + testsPerEviction);
+        logger.info(" idleTimeout: " + idleTimeout);
+        logger.info(" lifo: " + lifo);
+        logger.info(" abandonedConfig: ");
+        logger.info("  logAbandoned: " +
+                abandonedConfig.getLogAbandoned());
+        logger.info("  removeAbandoned: " +
+                abandonedConfig.getRemoveAbandoned());
+        logger.info("  abandonedTimeout: " + 
+                abandonedConfig.getRemoveAbandonedTimeout()); 
     }
     
     /**
@@ -172,9 +240,36 @@
             long peakPeriod, long troughPeriod, String cycleType, 
             String rampType, Logger logger, 
             List <SummaryStatistics> statsList) {
-        return new PoolClientThread(iterations, minDelay, maxDelay,
-                sigma, delayType, rampPeriod, peakPeriod, troughPeriod,
-                cycleType, rampType, logger, statsList, pool);
+        if (poolType.equals("GenercObjectPool")) {
+            return new PoolClientThread(iterations, minDelay, maxDelay,
+                    sigma, delayType, rampPeriod, peakPeriod, troughPeriod,
+                    cycleType, rampType, logger, statsList, genericObjectPool);
+        }
+        if (poolType.equals("GenericKeyedObjectPool")) {
+            return new PoolClientThread(iterations, minDelay, maxDelay,
+                    sigma, delayType, rampPeriod, peakPeriod, troughPeriod,
+                    cycleType, rampType, logger, statsList,
+                    genericKeyedObjectPool);
+        }
+        if (poolType.equals("StackKeyedObjectPool")) {
+            return new PoolClientThread(iterations, minDelay, maxDelay,
+                    sigma, delayType, rampPeriod, peakPeriod, troughPeriod,
+                    cycleType, rampType, logger, statsList,
+                    stackKeyedObjectPool);
+        }
+        if (poolType.equals("StackObjectPool")) {
+            return new PoolClientThread(iterations, minDelay, maxDelay,
+                    sigma, delayType, rampPeriod, peakPeriod, troughPeriod,
+                    cycleType, rampType, logger, statsList,
+                    stackObjectPool);
+        }
+        if (poolType.equals("SoftReferenceObjectPool")) {
+            return new PoolClientThread(iterations, minDelay, maxDelay,
+                    sigma, delayType, rampPeriod, peakPeriod, troughPeriod,
+                    cycleType, rampType, logger, statsList,
+                    softReferenceObjectPool);
+        }
+        return null;
     }
     
     // ------------------------------------------------------------------------
@@ -193,12 +288,15 @@
         this.waiterLatency = Long.parseLong(waiterLatency);
     }
     
-    public void configurePool(String maxActive, String maxIdle, String minIdle,
-            String maxWait, String exhaustedAction, String testOnBorrow,
+    public void configurePool(String maxActive, String maxActivePerKey,
+            String maxIdle, String minIdle, String maxWait,
+            String exhaustedAction, String testOnBorrow,
             String testOnReturn, String timeBetweenEvictions,
             String testsPerEviction, String idleTimeout, 
-            String testWhileIdle, String type) throws ConfigurationException { 
+            String testWhileIdle, String lifo, String type)
+        throws ConfigurationException { 
         this.maxActive = Integer.parseInt(maxActive);
+        this.maxActivePerKey = Integer.parseInt(maxActivePerKey);
         this.maxIdle = Integer.parseInt(maxIdle);
         this.minIdle = Integer.parseInt(minIdle);
         this.maxWait = Long.parseLong(maxWait);
@@ -208,6 +306,7 @@
         this.testsPerEviction = Integer.parseInt(testsPerEviction);
         this.idleTimeout = Long.parseLong(idleTimeout);
         this.testWhileIdle = Boolean.parseBoolean(testWhileIdle);
+        this.lifo = Boolean.parseBoolean(lifo);
         this.poolType = type;
         if (exhaustedAction.equals("block")) {
             this.exhaustedAction = GenericObjectPool.WHEN_EXHAUSTED_BLOCK;
@@ -231,8 +330,13 @@
                 Integer.parseInt(abandonedTimeout));
     }
     
-    public GenericObjectPool getPool() {
-        return pool;
+    // Pool getters for unit tests
+    protected GenericObjectPool getGenericObjectPool() {
+        return genericObjectPool;
+    }
+    
+    protected GenericKeyedObjectPool getGenericKeyedObjectPool() {
+        return genericKeyedObjectPool;
     }
     
 }

Modified: commons/sandbox/performance/trunk/src/java/org/apache/commons/performance/pool/WaiterFactory.java
URL: http://svn.apache.org/viewvc/commons/sandbox/performance/trunk/src/java/org/apache/commons/performance/pool/WaiterFactory.java?rev=611706&r1=611705&r2=611706&view=diff
==============================================================================
--- commons/sandbox/performance/trunk/src/java/org/apache/commons/performance/pool/WaiterFactory.java
(original)
+++ commons/sandbox/performance/trunk/src/java/org/apache/commons/performance/pool/WaiterFactory.java
Sun Jan 13 20:11:28 2008
@@ -17,16 +17,22 @@
 
 package org.apache.commons.performance.pool;
 
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Iterator;
 import java.util.logging.Logger;
 import java.util.logging.Level;
+import java.util.concurrent.atomic.AtomicInteger;
 
 import org.apache.commons.pool.PoolableObjectFactory;
+import org.apache.commons.pool.KeyedPoolableObjectFactory;
 
 /**
  * Object factory with configurable latencies for object lifecycle methods.
  *
  */
-public class WaiterFactory implements PoolableObjectFactory {
+public class WaiterFactory implements PoolableObjectFactory,
+KeyedPoolableObjectFactory {
     
     // TODO: implement protected getters so these can be stochastic
     private long activateLatency = 0;
@@ -39,15 +45,22 @@
     /** Count of (makes - destroys) since last reset */
     private long activeCount = 0;
     
+    /** Count of (makes - destroys) per key since last reset */
+    private Map<Object, AtomicInteger> activeCounts = 
+        new HashMap<Object, AtomicInteger>();
+    
     /** Maximum of (makes - destroys) - if exceeded IllegalStateException */
     private long maxActive = Long.MAX_VALUE;
     
+    /** Maximum of (makes - destroys) per key */
+    private long maxActivePerKey = Long.MAX_VALUE;
+    
     protected static final Logger logger = 
         Logger.getLogger(WaiterFactory.class.getName());
 
     public WaiterFactory(long activateLatency, long destroyLatency,
             long makeLatency, long passivateLatency, long validateLatency,
-            long waiterLatency,long maxActive) {
+            long waiterLatency,long maxActive, long maxActivePerKey) {
         this.activateLatency = activateLatency;
         this.destroyLatency = destroyLatency;
         this.makeLatency = makeLatency;
@@ -55,13 +68,21 @@
         this.validateLatency = validateLatency;
         this.waiterLatency = waiterLatency;
         this.maxActive = maxActive;
+        this.maxActivePerKey = maxActivePerKey;
     }
     
     public WaiterFactory(long activateLatency, long destroyLatency,
             long makeLatency, long passivateLatency, long validateLatency,
             long waiterLatency) {
         this(activateLatency, destroyLatency, makeLatency, passivateLatency,
-                validateLatency, waiterLatency, Long.MAX_VALUE);
+                validateLatency, waiterLatency, Long.MAX_VALUE, Long.MAX_VALUE);
+    }
+    
+    public WaiterFactory(long activateLatency, long destroyLatency,
+            long makeLatency, long passivateLatency, long validateLatency,
+            long waiterLatency,long maxActive) {
+        this(activateLatency, destroyLatency, makeLatency, passivateLatency,
+                validateLatency, waiterLatency, maxActive, Long.MAX_VALUE);
     }
 
     public void activateObject(Object arg0) throws Exception {
@@ -126,6 +147,13 @@
     
     public synchronized void reset() {
         activeCount = 0;
+        if (activeCounts.isEmpty()) {
+            return;
+        }
+        Iterator it = activeCounts.keySet().iterator();
+        while (it.hasNext()) {
+            ((AtomicInteger) activeCounts.get(it.next())).getAndSet(0);
+        }
     }
 
     /**
@@ -140,6 +168,45 @@
      */
     public synchronized void setMaxActive(long maxActive) {
         this.maxActive = maxActive;
+    }
+
+    // KeyedPoolableObjectFactory methods
+    
+    public void activateObject(Object key, Object obj) throws Exception {
+        activateObject(obj);
+    }
+
+    public void destroyObject(Object key, Object obj) throws Exception {
+        destroyObject(obj);
+        ((AtomicInteger) activeCounts.get(key)).getAndDecrement(); 
+    }
+
+    public Object makeObject(Object key) throws Exception {
+        synchronized (this) {
+            AtomicInteger count = (AtomicInteger) activeCounts.get(key);
+            if (count == null) {
+                count = new AtomicInteger(1);
+                activeCounts.put(key, count);
+            } else {
+                if (count.get() >= maxActivePerKey) {
+                    throw new IllegalStateException("Too many active " +
+                    "instances for key = " + key + ": " + count.get() + 
+                    " in circulation " + "with maxActivePerKey = " + 
+                    maxActivePerKey);
+                } else {
+                    count.incrementAndGet();
+                }
+            }
+        }
+        return makeObject();
+    }
+
+    public void passivateObject(Object key, Object obj) throws Exception {
+        passivateObject(obj);
+    }
+
+    public boolean validateObject(Object key, Object obj) {
+        return validateObject(obj);
     }
 
 }

Modified: commons/sandbox/performance/trunk/src/test/org/apache/commons/performance/pool/PoolSoakTest.java
URL: http://svn.apache.org/viewvc/commons/sandbox/performance/trunk/src/test/org/apache/commons/performance/pool/PoolSoakTest.java?rev=611706&r1=611705&r2=611706&view=diff
==============================================================================
--- commons/sandbox/performance/trunk/src/test/org/apache/commons/performance/pool/PoolSoakTest.java
(original)
+++ commons/sandbox/performance/trunk/src/test/org/apache/commons/performance/pool/PoolSoakTest.java
Sun Jan 13 20:11:28 2008
@@ -65,7 +65,7 @@
     **/
      poolSoak.getDigester().parse(getInputStream("config-pool.xml"));
      poolSoak.init();
-     GenericObjectPool pool = poolSoak.getPool();
+     GenericObjectPool pool = poolSoak.getGenericObjectPool();
      assertEquals(15, pool.getMaxActive());
      assertEquals(15, pool.getMaxIdle());
      assertEquals(10, pool.getMinIdle());
@@ -108,7 +108,7 @@
   */
       poolSoak.getDigester().parse(getInputStream("config-abandoned.xml"));
       poolSoak.init();
-      AbandonedObjectPool pool = (AbandonedObjectPool) poolSoak.getPool();
+      AbandonedObjectPool pool = (AbandonedObjectPool) poolSoak.getGenericObjectPool();
       assertEquals(15, pool.getMaxActive());
       assertEquals(-1, pool.getMaxIdle());
       assertEquals(0, pool.getMinIdle());



Mime
View raw message