svn commit: r929838 - in /ofbiz/trunk/framework: base/src/org/ofbiz/base/util/c
Locked
 
|
Author: doogie
Date: Thu Apr 1 04:46:53 2010 New Revision: 929838 URL: http://svn.apache.org/viewvc?rev=929838&view=rev Log: Inline CacheLineTable into UtilCache. This removes the CacheLineTable class completely. The getCacheLine() method now throws UnsupportedOperationException. Removed: ofbiz/trunk/framework/base/src/org/ofbiz/base/util/cache/CacheLineTable.java Modified: ofbiz/trunk/framework/base/src/org/ofbiz/base/util/cache/UtilCache.java ofbiz/trunk/framework/webtools/src/org/ofbiz/webtools/UtilCacheEvents.java Modified: ofbiz/trunk/framework/base/src/org/ofbiz/base/util/cache/UtilCache.java URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/base/src/org/ofbiz/base/util/cache/UtilCache.java?rev=929838&r1=929837&r2=929838&view=diff ============================================================================== --- ofbiz/trunk/framework/base/src/org/ofbiz/base/util/cache/UtilCache.java (original) +++ ofbiz/trunk/framework/base/src/org/ofbiz/base/util/cache/UtilCache.java Thu Apr 1 04:46:53 2010 @@ -18,25 +18,36 @@ *******************************************************************************/ package org.ofbiz.base.util.cache; +import java.io.IOException; import java.io.Serializable; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; +import java.util.Date; import java.util.HashSet; +import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.MissingResourceException; import java.util.ResourceBundle; import java.util.Set; import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ConcurrentMap; import java.util.concurrent.CopyOnWriteArraySet; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicLong; +import com.reardencommerce.kernel.collections.shared.evictable.ConcurrentLinkedHashMap; + import javolution.util.FastList; +import javolution.util.FastMap; import javolution.util.FastSet; +import jdbm.helper.FastIterator; +import jdbm.htree.HTree; + import org.ofbiz.base.util.Debug; +import org.ofbiz.base.util.ObjectType; import org.ofbiz.base.util.UtilValidate; /** @@ -64,9 +75,6 @@ public class UtilCache<K, V> implements /** The name of the UtilCache instance, is also the key for the instance in utilCacheTable. */ private final String name; - /** A hashtable containing a CacheLine object with a value and a loadTime for each element. */ - private final CacheLineTable<K, V> cacheLineTable; - /** A count of the number of cache hits */ protected AtomicLong hitCount = new AtomicLong(0); @@ -103,6 +111,14 @@ public class UtilCache<K, V> implements /** The set of listeners to receive notifcations when items are modidfied(either delibrately or because they were expired). */ protected Set<CacheListener<K, V>> listeners = new CopyOnWriteArraySet<CacheListener<K, V>>(); + protected transient HTree<Object, CacheLine<V>> fileTable = null; + protected Map<Object, CacheLine<V>> memoryTable = null; + + protected JdbmRecordManager jdbmMgr; + + // weak ref on this + private static final ConcurrentMap<String, JdbmRecordManager> fileManagers = new ConcurrentHashMap<String, JdbmRecordManager>(); + /** Constructor which specifies the cacheName as well as the sizeLimit, expireTime and useSoftReference. * The passed sizeLimit, expireTime and useSoftReference will be overridden by values from cache.properties if found. * @param sizeLimit The sizeLimit member is set to this value @@ -121,7 +137,39 @@ public class UtilCache<K, V> implements setPropertiesParams(propNames); int maxMemSize = this.maxInMemory; if (maxMemSize == 0) maxMemSize = sizeLimit; - this.cacheLineTable = new CacheLineTable<K, V>(this.fileStore, this.name, this.useFileSystemStore, maxMemSize); + if (maxMemSize == 0) { + memoryTable = FastMap.newInstance(); + } else { + memoryTable = ConcurrentLinkedHashMap.create(ConcurrentLinkedHashMap.EvictionPolicy.LRU, maxMemSize); + } + if (this.useFileSystemStore) { + // create the manager the first time it is needed + jdbmMgr = fileManagers.get(fileStore); + if (jdbmMgr == null) { + Debug.logImportant("Creating file system cache store for cache with name: " + cacheName, module); + try { + String ofbizHome = System.getProperty("ofbiz.home"); + if (ofbizHome == null) { + Debug.logError("No ofbiz.home property set in environment", module); + } else { + jdbmMgr = new JdbmRecordManager(ofbizHome + "/" + fileStore); + } + } catch (IOException e) { + Debug.logError(e, "Error creating file system cache store for cache with name: " + cacheName, module); + } + fileManagers.putIfAbsent(fileStore, jdbmMgr); + } + jdbmMgr = fileManagers.get(fileStore); + if (jdbmMgr != null) { + try { + this.fileTable = HTree.createInstance(jdbmMgr); + jdbmMgr.setNamedObject(cacheName, this.fileTable.getRecid()); + jdbmMgr.commit(); + } catch (IOException e) { + Debug.logError(e, module); + } + } + } } private static String getNextDefaultIndex(String cacheName) { @@ -186,12 +234,48 @@ public class UtilCache<K, V> implements } } - public CacheLineTable<K, V> getCacheLineTable() { - return cacheLineTable; + private Object fromKey(Object key) { + return key == null ? ObjectType.NULL : key; + } + + @SuppressWarnings("unchecked") + private K toKey(Object key) { + return key == ObjectType.NULL ? null : (K) key; + } + + @SuppressWarnings("unchecked") + private void addAllFileTableValues(List<CacheLine<V>> values) throws IOException { + FastIterator<CacheLine<V>> iter = fileTable.values(); + CacheLine<V> value = iter.next(); + while (value != null) { + values.add(value); + value = iter.next(); + } + } + + private void addAllFileTableKeys(Set<Object> keys) throws IOException { + FastIterator<Object> iter = fileTable.keys(); + Object key = null; + while ((key = iter.next()) != null) { + keys.add(key); + } + } + + public Object getCacheLineTable() { + throw new UnsupportedOperationException(); } public boolean isEmpty() { - return cacheLineTable.isEmpty(); + if (fileTable != null) { + try { + return fileTable.keys().next() == null; + } catch (IOException e) { + Debug.logError(e, module); + return false; + } + } else { + return memoryTable.isEmpty(); + } } /** Puts or loads the passed element into the cache @@ -217,16 +301,29 @@ public class UtilCache<K, V> implements * @param expireTime how long to keep this key in the cache */ public V put(K key, V value, long expireTime) { - CacheLine<V> oldCacheLine = cacheLineTable.put(key, createCacheLine(value, expireTime)); - - if (oldCacheLine == null) { + CacheLine<V> oldCacheLine = putInternal(fromKey(key), createCacheLine(value, expireTime)); + V oldValue = oldCacheLine == null ? null : oldCacheLine.getValue(); + if (oldValue == null) { noteAddition(key, value); return null; } else { - noteUpdate(key, value, oldCacheLine.getValue()); - return oldCacheLine.getValue(); + noteUpdate(key, value, oldValue); + return oldValue; } + } + CacheLine<V> putInternal(Object key, CacheLine<V> newCacheLine) { + CacheLine<V> oldCacheLine = memoryTable.put(key, newCacheLine); + if (fileTable != null) { + try { + if (oldCacheLine == null) oldCacheLine = fileTable.get(key); + fileTable.put(key, newCacheLine); + jdbmMgr.commit(); + } catch (IOException e) { + Debug.logError(e, module); + } + } + return oldCacheLine; } /** Gets an element from the cache according to the specified key. @@ -244,12 +341,19 @@ public class UtilCache<K, V> implements } protected CacheLine<V> getInternalNoCheck(Object key) { - CacheLine<V> line = cacheLineTable.get(key); - return line; + CacheLine<V> value = memoryTable.get(key); + if (value == null && fileTable != null) { + try { + value = fileTable.get(key); + } catch (IOException e) { + Debug.logError(e, module); + } + } + return value; } protected CacheLine<V> getInternal(Object key, boolean countGet) { - CacheLine<V> line = getInternalNoCheck(key); + CacheLine<V> line = getInternalNoCheck(fromKey(key)); if (line == null) { if (countGet) missCountNotFound.incrementAndGet(); } else if (line.isInvalid()) { @@ -269,27 +373,46 @@ public class UtilCache<K, V> implements } public Collection<V> values() { - if (cacheLineTable.isEmpty()) { - return Collections.emptyList(); - } - - List<V> valuesList = FastList.newInstance(); - for (K key: cacheLineTable.keySet()) { - CacheLine<V> line = this.getInternal(key, false); - if (line == null) { - continue; - } else { + if (fileTable != null) { + List<V> values = FastList.newInstance(); + try { + FastIterator<CacheLine<V>> iter = fileTable.values(); + CacheLine<V> value = iter.next(); + while (value != null) { + values.add(value.getValue()); + value = iter.next(); + } + } catch (IOException e) { + Debug.logError(e, module); + } + return values; + } else { + List<V> valuesList = FastList.newInstance(); + for (CacheLine<V> line: memoryTable.values()) { valuesList.add(line.getValue()); } + return valuesList; } - - return valuesList; } public long getSizeInBytes() { long totalSize = 0; - for (CacheLine<V> line: cacheLineTable.values()) { - totalSize += line.getSizeInBytes(); + if (fileTable != null) { + try { + FastIterator<CacheLine<V>> iter = fileTable.values(); + CacheLine<V> value = iter.next(); + while (value != null) { + totalSize += value.getSizeInBytes(); + value = iter.next(); + } + } catch (IOException e) { + Debug.logError(e, module); + return 0; + } + } else { + for (CacheLine<V> line: memoryTable.values()) { + totalSize += line.getSizeInBytes(); + } } return totalSize; } @@ -305,11 +428,25 @@ public class UtilCache<K, V> implements /** This is used for internal remove calls because we only want to count external calls */ @SuppressWarnings("unchecked") protected synchronized V removeInternal(Object key, boolean countRemove) { - CacheLine<V> line = cacheLineTable.remove(key); - if (line != null) { - noteRemoval((K) key, line.getValue()); + if (key == null) { + if (Debug.verboseOn()) Debug.logVerbose("In UtilCache tried to remove with null key, using NullObject" + this.name, module); + } + Object nulledKey = fromKey(key); + CacheLine<V> oldCacheLine = getInternalNoCheck(nulledKey); + if (fileTable != null) { + try { + fileTable.remove(nulledKey); + jdbmMgr.commit(); + } catch (IOException e) { + Debug.logError(e, module); + } + } + memoryTable.remove(nulledKey); + if (oldCacheLine != null) { + V oldValue = oldCacheLine.getValue(); + noteRemoval((K) key, oldValue); if (countRemove) removeHitCount.incrementAndGet(); - return line.getValue(); + return oldValue; } else { if (countRemove) removeMissCount.incrementAndGet(); return null; @@ -318,11 +455,35 @@ public class UtilCache<K, V> implements /** Removes all elements from this cache */ public synchronized void clear() { - for (K key: cacheLineTable.keySet()) { - CacheLine<V> line = getInternalNoCheck(key); - noteRemoval(key, line == null ? null : line.getValue()); + if (fileTable != null) { + // FIXME: erase from memory too + Set<Object> keys = new HashSet<Object>(); + try { + addAllFileTableKeys(keys); + } catch (IOException e) { + Debug.logError(e, module); + } + for (Object key: keys) { + try { + CacheLine<V> value = fileTable.get(key); + noteRemoval(toKey(key), value.getValue()); + removeHitCount.incrementAndGet(); + fileTable.remove(key); + jdbmMgr.commit(); + } catch (IOException e) { + Debug.logError(e, module); + } + } + memoryTable.clear(); + } else { + Iterator<Map.Entry<Object, CacheLine<V>>> it = memoryTable.entrySet().iterator(); + while (it.hasNext()) { + Map.Entry<Object, CacheLine<V>> entry = it.next(); + noteRemoval(toKey(entry.getKey()), entry.getValue().getValue()); + removeHitCount.incrementAndGet(); + it.remove(); + } } - cacheLineTable.clear(); clearCounters(); } @@ -418,9 +579,22 @@ public class UtilCache<K, V> implements return getMaxInMemory(); } - public void setMaxInMemory(int newMaxInMemory) { - cacheLineTable.setLru(newMaxInMemory); - this.maxInMemory = newMaxInMemory; + public void setMaxInMemory(int newInMemory) { + this.maxInMemory = newInMemory; + Map<Object, CacheLine<V>> oldmap = this.memoryTable; + + if (newInMemory > 0) { + if (this.memoryTable instanceof ConcurrentLinkedHashMap) { + ((ConcurrentLinkedHashMap) this.memoryTable).setCapacity(newInMemory); + return; + } else { + this.memoryTable = ConcurrentLinkedHashMap.create(ConcurrentLinkedHashMap.EvictionPolicy.LRU, newInMemory); + } + } else { + this.memoryTable = FastMap.newInstance(); + } + + this.memoryTable.putAll(oldmap); } public int getMaxInMemory() { @@ -443,8 +617,9 @@ public class UtilCache<K, V> implements // if expire time was <= 0 and is now greater, fill expire table now if (this.expireTime <= 0 && expireTime > 0) { for (K key: getCacheLineKeys()) { - CacheLine<V> line = getInternalNoCheck(key); - cacheLineTable.put(key, line.changeLine(useSoftReference, expireTime)); + Object nulledKey = fromKey(key); + CacheLine<V> line = getInternalNoCheck(nulledKey); + putInternal(nulledKey, line.changeLine(useSoftReference, expireTime)); } } else if (this.expireTime <= 0 && expireTime > 0) { // if expire time was > 0 and is now <=, do nothing, just leave the load times in place, won't hurt anything... @@ -464,9 +639,10 @@ public class UtilCache<K, V> implements public void setUseSoftReference(boolean useSoftReference) { if (this.useSoftReference != useSoftReference) { this.useSoftReference = useSoftReference; - for (K key: cacheLineTable.keySet()) { - CacheLine<V> line = cacheLineTable.get(key); - cacheLineTable.put(key, line.changeLine(useSoftReference, line.expireTime)); + for (K key: getCacheLineKeys()) { + Object nulledKey = fromKey(key); + CacheLine<V> line = getInternalNoCheck(nulledKey); + putInternal(nulledKey, line.changeLine(useSoftReference, expireTime)); } } } @@ -484,7 +660,20 @@ public class UtilCache<K, V> implements * @return The number of elements currently in the cache */ public int size() { - return cacheLineTable.size(); + if (fileTable != null) { + int size = 0; + try { + FastIterator<Object> iter = fileTable.keys(); + while (iter.next() != null) { + size++; + } + } catch (IOException e) { + Debug.logError(e, module); + } + return size; + } else { + return memoryTable.size(); + } } /** Returns a boolean specifying whether or not an element with the specified key is in the cache. @@ -507,15 +696,84 @@ public class UtilCache<K, V> implements * This behavior is necessary for now for the persisted cache feature. */ public Set<? extends K> getCacheLineKeys() { - return cacheLineTable.keySet(); + // note that this must be a HashSet and not a FastSet in order to have a null value + Set<Object> keys; + + if (fileTable != null) { + keys = new HashSet<Object>(); + try { + addAllFileTableKeys(keys); + } catch (IOException e) { + Debug.logError(e, module); + } + if (keys.remove(ObjectType.NULL)) { + keys.add(null); + } + } else { + if (memoryTable.containsKey(ObjectType.NULL)) { + keys = new HashSet<Object>(memoryTable.keySet()); + keys.remove(ObjectType.NULL); + keys.add(null); + } else { + keys = memoryTable.keySet(); + } + } + return Collections.unmodifiableSet((Set<? extends K>) keys); } public Collection<? extends CacheLine<V>> getCacheLineValues() { - return cacheLineTable.values(); + Collection<CacheLine<V>> values; + if (fileTable != null) { + values = FastList.newInstance(); + try { + FastIterator<CacheLine<V>> iter = fileTable.values(); + CacheLine<V> value = iter.next(); + while (value != null) { + values.add(value); + value = iter.next(); + } + } catch (IOException e) { + Debug.logError(e, module); + } + } else { + values = memoryTable.values(); + } + return values; + } + + private Map<String, Object> createLineInfo(int keyNum, K key, CacheLine<V> line) { + Map<String, Object> lineInfo = FastMap.newInstance(); + lineInfo.put("elementKey", key); + if (line.loadTime > 0) { + lineInfo.put("expireTime", new Date(line.loadTime + line.expireTime)); + } + lineInfo.put("lineSize", line.getSizeInBytes()); + lineInfo.put("keyNum", keyNum); + return lineInfo; } public Collection<? extends Map<String, Object>> getLineInfos() { - return cacheLineTable.getLineInfos(); + List<Map<String, Object>> lineInfos = FastList.newInstance(); + int keyIndex = 0; + for (K key: getCacheLineKeys()) { + Object nulledKey = fromKey(key); + CacheLine<V> line; + if (fileTable != null) { + try { + line = fileTable.get(nulledKey); + } catch (IOException e) { + Debug.logError(e, module); + line = null; + } + } else { + line = memoryTable.get(nulledKey); + } + if (line != null) { + lineInfos.add(createLineInfo(keyIndex, key, line)); + } + keyIndex++; + } + return lineInfos; } /** Returns a boolean specifying whether or not the element corresponding to the key has expired. @@ -527,15 +785,16 @@ public class UtilCache<K, V> implements * @return True is the element corresponding to the specified key has expired, otherwise false */ public boolean hasExpired(Object key) { - CacheLine<V> line = getInternalNoCheck(key); + CacheLine<V> line = getInternalNoCheck(fromKey(key)); if (line == null) return false; return line.hasExpired(); } /** Clears all expired cache entries; also clear any cache entries where the SoftReference in the CacheLine object has been cleared by the gc */ public void clearExpired() { - for (K key: cacheLineTable.keySet()) { - if (hasExpired(key)) { + for (K key: getCacheLineKeys()) { + CacheLine<V> line = getInternalNoCheck(key); + if (line.isInvalid()) { removeInternal(key, false); } } Modified: ofbiz/trunk/framework/webtools/src/org/ofbiz/webtools/UtilCacheEvents.java URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/webtools/src/org/ofbiz/webtools/UtilCacheEvents.java?rev=929838&r1=929837&r2=929838&view=diff ============================================================================== --- ofbiz/trunk/framework/webtools/src/org/ofbiz/webtools/UtilCacheEvents.java (original) +++ ofbiz/trunk/framework/webtools/src/org/ofbiz/webtools/UtilCacheEvents.java Thu Apr 1 04:46:53 2010 @@ -79,8 +79,7 @@ public class UtilCacheEvents { if (utilCache != null) { Object key = null; - // no LRU, try looping through the keySet to see if we find the specified index... - Iterator<?> ksIter = utilCache.getCacheLineTable().keySet().iterator(); + Iterator<?> ksIter = utilCache.getCacheLineKeys().iterator(); int curNum = 0; while (ksIter.hasNext()) { |
«
Return to OFBiz - Commits
|
1 view|%1 views
| Free forum by Nabble | Edit this page |