Author: stliu Date: 2010-11-08 03:39:22 -0500 (Mon, 08 Nov 2010) New Revision: 20856 Added: core/branches/Branch_3_2_4_SP1_CP/src/org/hibernate/util/LRUMap.java Modified: core/branches/Branch_3_2_4_SP1_CP/src/org/hibernate/cfg/Environment.java core/branches/Branch_3_2_4_SP1_CP/src/org/hibernate/engine/SessionFactoryImplementor.java core/branches/Branch_3_2_4_SP1_CP/src/org/hibernate/engine/query/QueryPlanCache.java core/branches/Branch_3_2_4_SP1_CP/src/org/hibernate/impl/SessionFactoryImpl.java core/branches/Branch_3_2_4_SP1_CP/src/org/hibernate/util/SoftLimitMRUCache.java Log: JBPAPP-5392 Backport HHH-5300 to EAP to fix memory leak in QueryPlanCache Modified: core/branches/Branch_3_2_4_SP1_CP/src/org/hibernate/cfg/Environment.java =================================================================== --- core/branches/Branch_3_2_4_SP1_CP/src/org/hibernate/cfg/Environment.java 2010-11-03 09:15:19 UTC (rev 20855) +++ core/branches/Branch_3_2_4_SP1_CP/src/org/hibernate/cfg/Environment.java 2010-11-08 08:39:22 UTC (rev 20856) @@ -466,6 +466,14 @@ * The jacc context id of the deployment */ public static final String JACC_CONTEXTID = "hibernate.jacc_context_id"; + /** + * The maximum number of strong references maintained by {@link org.hibernate.util.SoftLimitMRUCache}. Default is 128. + */ + public static final String QUERY_PLAN_CACHE_MAX_STRONG_REFERENCES = "hibernate.query.plan_cache_max_strong_references"; + /** + * The maximum number of soft references maintained by {@link org.hibernate.util.SoftLimitMRUCache}. Default is 2048. + */ + public static final String QUERY_PLAN_CACHE_MAX_SOFT_REFERENCES = "hibernate.query.plan_cache_max_soft_references"; public static final String BYTECODE_PROVIDER = "hibernate.bytecode.provider"; Modified: core/branches/Branch_3_2_4_SP1_CP/src/org/hibernate/engine/SessionFactoryImplementor.java =================================================================== --- core/branches/Branch_3_2_4_SP1_CP/src/org/hibernate/engine/SessionFactoryImplementor.java 2010-11-03 09:15:19 UTC (rev 20855) +++ core/branches/Branch_3_2_4_SP1_CP/src/org/hibernate/engine/SessionFactoryImplementor.java 2010-11-08 08:39:22 UTC (rev 20856) @@ -2,6 +2,7 @@ package org.hibernate.engine; import java.util.Map; +import java.util.Properties; import java.util.Set; import java.sql.Connection; @@ -37,8 +38,13 @@ * @author Gavin King */ public interface SessionFactoryImplementor extends Mapping, SessionFactory { - /** + * Get a copy of the Properties used to configure this session factory. + * + * @return The properties. + */ + public Properties getProperties(); + /** * Get the persister for the named entity */ public EntityPersister getEntityPersister(String entityName) throws MappingException; Modified: core/branches/Branch_3_2_4_SP1_CP/src/org/hibernate/engine/query/QueryPlanCache.java =================================================================== --- core/branches/Branch_3_2_4_SP1_CP/src/org/hibernate/engine/query/QueryPlanCache.java 2010-11-03 09:15:19 UTC (rev 20855) +++ core/branches/Branch_3_2_4_SP1_CP/src/org/hibernate/engine/query/QueryPlanCache.java 2010-11-08 08:39:22 UTC (rev 20856) @@ -1,9 +1,33 @@ +/* + * Hibernate, Relational Persistence for Idiomatic Java + * + * Copyright (c) 2010, Red Hat Inc. or third-party contributors as + * indicated by the @author tags or express copyright attribution + * statements applied by the authors. All third-party contributions are + * distributed under license by Red Hat Inc. + * + * This copyrighted material is made available to anyone wishing to use, modify, + * copy, or redistribute it subject to the terms and conditions of the GNU + * Lesser General Public License, as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License + * for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this distribution; if not, write to: + * Free Software Foundation, Inc. + * 51 Franklin Street, Fifth Floor + * Boston, MA 02110-1301 USA + */ package org.hibernate.engine.query; -import org.hibernate.util.ArrayHelper; import org.hibernate.util.CollectionHelper; +import org.hibernate.util.PropertiesHelper; import org.hibernate.util.SimpleMRUCache; import org.hibernate.util.SoftLimitMRUCache; +import org.hibernate.cfg.Environment; import org.hibernate.engine.SessionFactoryImplementor; import org.hibernate.engine.query.sql.NativeSQLQuerySpecification; import org.hibernate.impl.FilterImpl; @@ -16,7 +40,6 @@ import java.util.Collection; import java.util.Map; import java.util.HashMap; -import java.util.List; import java.util.Iterator; import java.util.Set; import java.util.HashSet; @@ -25,6 +48,9 @@ /** * Acts as a cache for compiled query plans, as well as query-parameter metadata. * + * @see Environment#QUERY_PLAN_CACHE_MAX_STRONG_REFERENCES + * @see Environment#QUERY_PLAN_CACHE_MAX_SOFT_REFERENCES + * * @author <a href="mailto:steve@hibernate.org">Steve Ebersole </a> */ public class QueryPlanCache implements Serializable { @@ -34,29 +60,49 @@ private SessionFactoryImplementor factory; public QueryPlanCache(SessionFactoryImplementor factory) { + int maxStrongReferenceCount = PropertiesHelper.getInt( + Environment.QUERY_PLAN_CACHE_MAX_STRONG_REFERENCES, + factory.getProperties(), + SoftLimitMRUCache.DEFAULT_STRONG_REF_COUNT + ); + int maxSoftReferenceCount = PropertiesHelper.getInt( + Environment.QUERY_PLAN_CACHE_MAX_SOFT_REFERENCES, + factory.getProperties(), + SoftLimitMRUCache.DEFAULT_SOFT_REF_COUNT + ); this.factory = factory; + this.sqlParamMetadataCache = new SimpleMRUCache( maxStrongReferenceCount ); + this.planCache = new SoftLimitMRUCache( maxStrongReferenceCount, maxSoftReferenceCount ); + } + /** + * simple cache of param metadata based on query string. Ideally, the original "user-supplied query" + * string should be used to obtain this metadata (i.e., not the para-list-expanded query string) to avoid + * unnecessary cache entries. + * <p> + * Used solely for caching param metadata for native-sql queries, see {@link #getSQLParameterMetadata} for a + * discussion as to why... + */ + private final SimpleMRUCache sqlParamMetadataCache; - // simple cache of param metadata based on query string. Ideally, the - // original "user-supplied query" string should be used to retreive this - // metadata (i.e., not the para-list-expanded query string) to avoid - // unnecessary cache entries. - // Used solely for caching param metadata for native-sql queries, see - // getSQLParameterMetadata() for a discussion as to why... - private final SimpleMRUCache sqlParamMetadataCache = new SimpleMRUCache(); + /** + * the cache of the actual plans... + */ + private final SoftLimitMRUCache planCache; - // the cache of the actual plans... - private final SoftLimitMRUCache planCache = new SoftLimitMRUCache( 128 ); - - + /** + * Obtain the parameter metadata for given native-sql query. + * <p/> + * for native-sql queries, the param metadata is determined outside any relation to a query plan, because + * query plan creation and/or retrieval for a native-sql query depends on all of the return types having been + * set, which might not be the case up-front when param metadata would be most useful + * + * @param query The query + * @return The parameter metadata + */ public ParameterMetadata getSQLParameterMetadata(String query) { ParameterMetadata metadata = ( ParameterMetadata ) sqlParamMetadataCache.get( query ); if ( metadata == null ) { - // for native-sql queries, the param metadata is determined outside - // any relation to a query plan, because query plan creation and/or - // retreival for a native-sql query depends on all of the return - // types having been set, which might not be the case up-front when - // param metadata would be most useful metadata = buildNativeSQLParameterMetadata( query ); sqlParamMetadataCache.put( query, metadata ); } @@ -137,7 +183,7 @@ } Iterator itr = recognizer.getNamedParameterDescriptionMap().entrySet().iterator(); - Map namedParamDescriptorMap = new HashMap(); + Map<String,NamedParameterDescriptor> namedParamDescriptorMap = new HashMap<String,NamedParameterDescriptor>(); while( itr.hasNext() ) { final Map.Entry entry = ( Map.Entry ) itr.next(); final String name = ( String ) entry.getKey(); @@ -155,7 +201,7 @@ private static class HQLQueryPlanKey implements Serializable { private final String query; private final boolean shallow; - private final Set filterKeys; + private final Set<DynamicFilterKey> filterKeys; private final int hashCode; public HQLQueryPlanKey(String query, boolean shallow, Map enabledFilters) { @@ -163,16 +209,15 @@ this.shallow = shallow; if ( enabledFilters == null || enabledFilters.isEmpty() ) { - filterKeys = Collections.EMPTY_SET; + filterKeys = Collections.emptySet(); } else { - Set tmp = new HashSet( + Set<DynamicFilterKey> tmp = new HashSet<DynamicFilterKey>( CollectionHelper.determineProperSizing( enabledFilters ), CollectionHelper.LOAD_FACTOR ); - Iterator itr = enabledFilters.values().iterator(); - while ( itr.hasNext() ) { - tmp.add( new DynamicFilterKey( ( FilterImpl ) itr.next() ) ); + for ( Object o : enabledFilters.values() ) { + tmp.add( new DynamicFilterKey( (FilterImpl) o ) ); } this.filterKeys = Collections.unmodifiableSet( tmp ); } @@ -205,30 +250,31 @@ } private static class DynamicFilterKey implements Serializable { private final String filterName; - private final Map parameterMetadata; + private final Map<String,Integer> parameterMetadata; private final int hashCode; private DynamicFilterKey(FilterImpl filter) { this.filterName = filter.getName(); if ( filter.getParameters().isEmpty() ) { - parameterMetadata = Collections.EMPTY_MAP; + parameterMetadata = Collections.emptyMap(); } else { - parameterMetadata = new HashMap( + parameterMetadata = new HashMap<String,Integer>( CollectionHelper.determineProperSizing( filter.getParameters() ), CollectionHelper.LOAD_FACTOR ); - Iterator itr = filter.getParameters().entrySet().iterator(); - while ( itr.hasNext() ) { - final Integer valueCount; - final Map.Entry entry = ( Map.Entry ) itr.next(); + for ( Object o : filter.getParameters().entrySet() ) { + final Map.Entry entry = (Map.Entry) o; + final String key = (String) entry.getKey(); + + final Integer valueCount; if ( Collection.class.isInstance( entry.getValue() ) ) { valueCount = new Integer( ( (Collection) entry.getValue() ).size() ); } else { valueCount = new Integer(1); } - parameterMetadata.put( entry.getKey(), valueCount ); + parameterMetadata.put( key, valueCount ); } } @@ -260,7 +306,7 @@ private final String query; private final String collectionRole; private final boolean shallow; - private final Set filterNames; + private final Set<String> filterNames; private final int hashCode; public FilterQueryPlanKey(String query, String collectionRole, boolean shallow, Map enabledFilters) { @@ -269,10 +315,10 @@ this.shallow = shallow; if ( enabledFilters == null || enabledFilters.isEmpty() ) { - filterNames = Collections.EMPTY_SET; + filterNames = Collections.emptySet(); } else { - Set tmp = new HashSet(); + Set<String> tmp = new HashSet<String>(); tmp.addAll( enabledFilters.keySet() ); this.filterNames = Collections.unmodifiableSet( tmp ); } Modified: core/branches/Branch_3_2_4_SP1_CP/src/org/hibernate/impl/SessionFactoryImpl.java =================================================================== --- core/branches/Branch_3_2_4_SP1_CP/src/org/hibernate/impl/SessionFactoryImpl.java 2010-11-03 09:15:19 UTC (rev 20855) +++ core/branches/Branch_3_2_4_SP1_CP/src/org/hibernate/impl/SessionFactoryImpl.java 2010-11-08 08:39:22 UTC (rev 20856) @@ -142,7 +142,7 @@ private final transient EntityNotFoundDelegate entityNotFoundDelegate; private final transient SQLFunctionRegistry sqlFunctionRegistry; - private final QueryPlanCache queryPlanCache = new QueryPlanCache( this ); + private final QueryPlanCache queryPlanCache; private transient boolean isClosed = false; @@ -181,7 +181,7 @@ // Caches settings.getCacheProvider().start( properties ); - + this.queryPlanCache = new QueryPlanCache( this ); //Generators: identifierGenerators = new HashMap(); @@ -974,7 +974,9 @@ public BatcherFactory getBatcherFactory() { return settings.getBatcherFactory(); } - + public Properties getProperties() { + return properties; + } public IdentifierGenerator getIdentifierGenerator(String rootEntityName) { return (IdentifierGenerator) identifierGenerators.get(rootEntityName); } Added: core/branches/Branch_3_2_4_SP1_CP/src/org/hibernate/util/LRUMap.java =================================================================== --- core/branches/Branch_3_2_4_SP1_CP/src/org/hibernate/util/LRUMap.java (rev 0) +++ core/branches/Branch_3_2_4_SP1_CP/src/org/hibernate/util/LRUMap.java 2010-11-08 08:39:22 UTC (rev 20856) @@ -0,0 +1,50 @@ +/* + * Hibernate, Relational Persistence for Idiomatic Java + * + * Copyright (c) 2010, Red Hat Inc. or third-party contributors as + * indicated by the @author tags or express copyright attribution + * statements applied by the authors. All third-party contributions are + * distributed under license by Red Hat Inc. + * + * This copyrighted material is made available to anyone wishing to use, modify, + * copy, or redistribute it subject to the terms and conditions of the GNU + * Lesser General Public License, as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License + * for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this distribution; if not, write to: + * Free Software Foundation, Inc. + * 51 Franklin Street, Fifth Floor + * Boston, MA 02110-1301 USA + */ +package org.hibernate.util; + +import java.io.Serializable; +import java.util.LinkedHashMap; +import java.util.Map; + +/** + * A simple LRU cache that implements the <code>Map</code> interface. Instances + * are not thread-safe and should be synchronized externally, for instance by + * using {@link java.util.Collections#synchronizedMap}. + * + * @author Manuel Dominguez Sarmiento + */ +public class LRUMap extends LinkedHashMap implements Serializable { + private static final long serialVersionUID = -5522608033020688048L; + + private final int maxEntries; + + public LRUMap(int maxEntries) { + super( maxEntries, .75f, true ); + this.maxEntries = maxEntries; + } + + protected boolean removeEldestEntry(Map.Entry eldest) { + return ( size() > maxEntries ); + } +} \ No newline at end of file Modified: core/branches/Branch_3_2_4_SP1_CP/src/org/hibernate/util/SoftLimitMRUCache.java =================================================================== --- core/branches/Branch_3_2_4_SP1_CP/src/org/hibernate/util/SoftLimitMRUCache.java 2010-11-03 09:15:19 UTC (rev 20855) +++ core/branches/Branch_3_2_4_SP1_CP/src/org/hibernate/util/SoftLimitMRUCache.java 2010-11-08 08:39:22 UTC (rev 20856) @@ -1,13 +1,35 @@ +/* + * Hibernate, Relational Persistence for Idiomatic Java + * + * Copyright (c) 2010, Red Hat Inc. or third-party contributors as + * indicated by the @author tags or express copyright attribution + * statements applied by the authors. All third-party contributions are + * distributed under license by Red Hat Inc. + * + * This copyrighted material is made available to anyone wishing to use, modify, + * copy, or redistribute it subject to the terms and conditions of the GNU + * Lesser General Public License, as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License + * for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this distribution; if not, write to: + * Free Software Foundation, Inc. + * 51 Franklin Street, Fifth Floor + * Boston, MA 02110-1301 USA + */ package org.hibernate.util; -import org.apache.commons.collections.ReferenceMap; -import org.apache.commons.collections.LRUMap; - import java.io.Serializable; import java.io.IOException; +import java.lang.ref.ReferenceQueue; +import java.lang.ref.SoftReference; /** - * Cache following a "Most Recently Used" (MRY) algorithm for maintaining a + * Cache following a "Most Recently Used" (MRU) algorithm for maintaining a * bounded in-memory size; the "Least Recently Used" (LRU) entry is the first * available for removal from the cache. * <p/> @@ -15,60 +37,168 @@ * meaning that all cache entries are kept within a completely * {@link java.lang.ref.SoftReference}-based map with the most recently utilized * entries additionally kept in a hard-reference manner to prevent those cache - * entries soft references from becoming enqueued by the garbage collector. - * Thus the actual size of this cache impl can actually grow beyond the stated - * max size bound as long as GC is not actively seeking soft references for + * entries soft references from becoming enqueued by the garbage collector. Thus + * the actual size of this cache impl can actually grow beyond the stated max + * size bound as long as GC is not actively seeking soft references for * enqueuement. + * <p/> + * The soft-size is bounded and configurable. This allows controlling memory + * usage which can grow out of control under some circumstances, especially when + * very large heaps are in use. Although memory usage per se should not be a + * problem with soft references, which are cleared when necessary, this can + * trigger extremely slow stop-the-world GC pauses when nearing full heap usage, + * even with CMS concurrent GC (i.e. concurrent mode failure). This is most + * evident when ad-hoc HQL queries are produced by the application, leading to + * poor soft-cache hit ratios. This can also occur with heavy use of SQL IN + * clauses, which will generate multiples SQL queries (even if parameterized), + * one for each collection/array size passed to the IN clause. Many slightly + * different queries will eventually fill the heap and trigger a full GC to + * reclaim space, leading to unacceptable pauses in some cases. + * <p/> + * <strong>Note:</strong> This class is serializable, however all entries are + * discarded on serialization. * + * @see org.hibernate.cfg.Environment#QUERY_PLAN_CACHE_MAX_STRONG_REFERENCES + * @see org.hibernate.cfg.Environment#QUERY_PLAN_CACHE_MAX_SOFT_REFERENCES + * * @author Steve Ebersole + * @author Manuel Dominguez Sarmiento */ public class SoftLimitMRUCache implements Serializable { - + /** + * The default strong reference count. + */ public static final int DEFAULT_STRONG_REF_COUNT = 128; - private final int strongReferenceCount; + /** + * The default soft reference count. + */ + public static final int DEFAULT_SOFT_REF_COUNT = 2048; - // actual cache of the entries. soft references are used for both the keys and the - // values here since the values pertaining to the MRU entries are kept in a - // seperate hard reference cache (to avoid their enqueuement/garbage-collection). - private transient ReferenceMap softReferenceCache = new ReferenceMap( ReferenceMap.SOFT, ReferenceMap.SOFT ); - // the MRU cache used to keep hard references to the most recently used query plans; - // note : LRU here is a bit of a misnomer, it indicates that LRU entries are removed, the - // actual kept entries are the MRU entries - private transient LRUMap strongReferenceCache; + private final int strongRefCount; + private final int softRefCount; + private transient LRUMap strongRefCache; + private transient LRUMap softRefCache; + private transient ReferenceQueue referenceQueue; + + /** + * Constructs a cache with the default settings. + * + * @see #DEFAULT_STRONG_REF_COUNT + * @see #DEFAULT_SOFT_REF_COUNT + */ public SoftLimitMRUCache() { - this( DEFAULT_STRONG_REF_COUNT ); + this( DEFAULT_STRONG_REF_COUNT, DEFAULT_SOFT_REF_COUNT ); } - public SoftLimitMRUCache(int strongRefCount) { - this.strongReferenceCount = strongRefCount; + /** + * Constructs a cache with the specified settings. + * + * @param strongRefCount the strong reference count. + * @param softRefCount the soft reference count. + * + * @throws IllegalArgumentException if either of the arguments is less than one, or if the strong + * reference count is higher than the soft reference count. + */ + public SoftLimitMRUCache(int strongRefCount, int softRefCount) { + if ( strongRefCount < 1 || softRefCount < 1 ) { + throw new IllegalArgumentException( "Reference counts must be greater than zero" ); + } + if ( strongRefCount > softRefCount ) { + throw new IllegalArgumentException( "Strong reference count cannot exceed soft reference count" ); + } + + this.strongRefCount = strongRefCount; + this.softRefCount = softRefCount; init(); } + /** + * Gets an object from the cache. + * + * @param key the cache key. + * + * @return the stored value, or <code>null</code> if no entry exists. + */ public synchronized Object get(Object key) { - Object result = softReferenceCache.get( key ); - if ( result != null ) { - strongReferenceCache.put( key, result ); + if ( key == null ) { + throw new NullPointerException( "Key to get cannot be null" ); } - return result; + + clearObsoleteReferences(); + + SoftReference ref = (SoftReference) softRefCache.get( key ); + if ( ref != null ) { + Object refValue = ref.get(); + if ( refValue != null ) { + // This ensures recently used entries are strongly-reachable + strongRefCache.put( key, refValue ); + return refValue; + } + } + + return null; } + /** + * Puts a value in the cache. + * + * @param key the key. + * @param value the value. + * + * @return the previous value stored in the cache, if any. + */ public synchronized Object put(Object key, Object value) { - softReferenceCache.put( key, value ); - return strongReferenceCache.put( key, value ); + if ( key == null || value == null ) { + throw new NullPointerException( + getClass().getName() + "does not support null key [" + key + "] or value [" + value + "]" + ); + } + + clearObsoleteReferences(); + + strongRefCache.put( key, value ); + SoftReference ref = (SoftReference) softRefCache.put( + key, + new KeyedSoftReference( key, value, referenceQueue ) + ); + + return ( ref != null ) ? ref.get() : null; } + /** + * Gets the strong reference cache size. + * + * @return the strong reference cache size. + */ public synchronized int size() { - return strongReferenceCache.size(); + clearObsoleteReferences(); + return strongRefCache.size(); } + /** + * Gets the soft reference cache size. + * + * @return the soft reference cache size. + */ public synchronized int softSize() { - return softReferenceCache.size(); + clearObsoleteReferences(); + return softRefCache.size(); } + /** + * Clears the cache. + */ + public synchronized void clear() { + strongRefCache.clear(); + softRefCache.clear(); + } + private void init() { - strongReferenceCache = new LRUMap( strongReferenceCount ); + this.strongRefCache = new LRUMap( strongRefCount ); + this.softRefCache = new LRUMap( softRefCount ); + this.referenceQueue = new ReferenceQueue(); } private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException { @@ -76,8 +206,26 @@ init(); } - public synchronized void clear() { - strongReferenceCache.clear(); - softReferenceCache.clear(); + private void clearObsoleteReferences() { + // Clear entries for soft references removed by garbage collector + KeyedSoftReference obsoleteRef; + while ( ( obsoleteRef = (KeyedSoftReference) referenceQueue.poll() ) != null ) { + Object key = obsoleteRef.getKey(); + softRefCache.remove( key ); + } } + + private static class KeyedSoftReference extends SoftReference { + private final Object key; + + @SuppressWarnings({ "unchecked" }) + private KeyedSoftReference(Object key, Object value, ReferenceQueue q) { + super( value, q ); + this.key = key; + } + + private Object getKey() { + return key; + } + } }