<project name="bigmemory" basedir="."><property name="build.dir" value="${basedir}/build" /><property name="src.class.dir" value="${build.dir}" /><property name="src.dir" value="${basedir}/src" /><property name="lib.dir" value="${basedir}/../lib" /><property name="config.dir" value="${basedir}/config" /><path id="base.classpath"><pathelement location="${src.class.dir}" /><pathelement location="${config.dir}" /><fileset dir="${lib.dir}"><include name="**/*.jar" /></fileset></path><path id="classpath"><path refid="base.classpath" /><fileset dir="${lib.dir}"><include name="**/*.jar" /></fileset></path><path id="build.src.path"><pathelement location="${src.class.dir}" /></path><target name="clean" description="clean"><delete dir="${build.dir}" /></target><target name="compile" depends="clean" description="compile"><mkdir dir="${src.class.dir}" /><javac srcdir="${src.dir}" destdir="${src.class.dir}" source="1.6" debug="on" encoding="utf-8" includeantruntime="false"><classpath refid="base.classpath" /></javac></target><target name="jar" depends="compile" description="jar"><jar destfile="${build.dir}/bigmemory.jar"><fileset dir="${src.class.dir}"><exclude name="**/timer/**" /></fileset></jar></target>
</project>

package org.apache.solr.search;import org.apache.solr.common.SolrException;
import org.apache.solr.common.util.NamedList;
import org.apache.solr.common.util.SimpleOrderedMap;
import org.apache.solr.core.SolrCore;import java.util.*;
import java.util.concurrent.atomic.AtomicLong;
import java.io.IOException;
import java.net.URL;import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;
import net.sf.ehcache.config.CacheConfiguration;
import net.sf.ehcache.config.Configuration;
import net.sf.ehcache.config.MemoryUnit;/*** @version $Id: EhCacheWrapper.java 2013-03-27  zhenjing chen $*/
public class EhCacheWrapper implements SolrCache {/* An instance of this class will be shared across multiple instances* of an LRUCache at the same time.  Make sure everything is thread safe.*/private static class CumulativeStats {AtomicLong lookups = new AtomicLong();AtomicLong hits = new AtomicLong();AtomicLong inserts = new AtomicLong();AtomicLong evictions = new AtomicLong();}private CumulativeStats stats;// per instance stats.  The synchronization used for the map will also be// used for updating these statistics (and hence they are not AtomicLongsprivate long lookups;private long hits;private long inserts;private long evictions;private long warmupTime = 0;private CacheManager manager = null;private Cache map;private String name;private String cache_name;private int autowarmCount;private State state;private CacheRegenerator regenerator;private String description="Eh LRU Cache";private static int cache_index = 0;private static Map<String, CacheManager> managerPool = null;private static Map<String, Integer> managerFlag = null;private static CacheManager managerTemplate = null;static{managerPool = new HashMap<String, CacheManager>();managerFlag = new HashMap<String, Integer>();managerTemplate = new CacheManager("/data/conf/ehcache.xml");}private Cache GetCache() {// use cache poolSet<String> set = managerFlag.keySet();Iterator<String> it = set.iterator();while(it.hasNext()) {String cacheName = it.next();if( managerFlag.get(cacheName) == 0 ) {  // not usedmanager = managerPool.get(cacheName);System.out.println("EhCacheWrapper Cache Name(Pool): " + cacheName);managerFlag.put(cacheName, 1);cache_name = cacheName;return manager.getCache(cacheName);}}// add zhenjingString cacheName = name + cache_index;System.out.println("EhCacheWrapper Cache Name: " + cacheName);// create Cache from templateCache orig = managerTemplate.getCache(name);CacheConfiguration configTmp = orig.getCacheConfiguration();configTmp.setName(cacheName);Configuration managerConfiguration = new Configuration();managerConfiguration.setName(cacheName);manager = new CacheManager(managerConfiguration.cache(configTmp));// put to cache poolmanagerFlag.put(cacheName, 1);managerPool.put(cacheName, manager);// get cachecache_index++;cache_name = cacheName;return manager.getCache(cacheName);}public Object init(Map args, Object persistence, CacheRegenerator regenerator) {state=State.CREATED;this.regenerator = regenerator;name = (String)args.get("name");String str = (String)args.get("size");final int limit = str==null ? 1024 : Integer.parseInt(str);str = (String)args.get("initialSize");final int initialSize = Math.min(str==null ? 1024 : Integer.parseInt(str), limit);str = (String)args.get("autowarmCount");autowarmCount = str==null ? 0 : Integer.parseInt(str);// get cachemap = GetCache();CacheConfiguration config = map.getCacheConfiguration();description = "Eh LRU Cache(MaxBytesLocalOffHeap=" + config.getMaxBytesLocalOffHeap() + ", MaxBytesLocalHeap=" + config.getMaxBytesLocalHeap() + ", MaxEntriesLocalHeap=" + config.getMaxEntriesLocalHeap() + ")";if (persistence==null) {// must be the first time a cache of this type is being createdpersistence = new CumulativeStats();}stats = (CumulativeStats)persistence;return persistence;}public String name() {return name;}public int size() {synchronized(map) {return map.getSize();}}public Object put(Object key, Object value) {synchronized (map) {if (state == State.LIVE) {stats.inserts.incrementAndGet();}// increment local inserts regardless of state???// it does make it more consistent with the current size...inserts++;map.put(new Element(key,value));return null;  // fake the previous value associated with key.}}public Object get(Object key) {synchronized (map) {Element val = map.get(key);if (state == State.LIVE) {// only increment lookups and hits if we are live.lookups++;stats.lookups.incrementAndGet();if (val!=null) {hits++;stats.hits.incrementAndGet();//System.out.println(name + " EH Cache HIT. key=" + key.toString());}}if( val == null)  return null;return val.getObjectValue();}}public void clear() {synchronized(map) {map.removeAll();}}public void setState(State state) {this.state = state;}public State getState() {return state;}public void warm(SolrIndexSearcher searcher, SolrCache old) throws IOException {return;}public void close() {clear();// flag un-used managerFlag.put(cache_name, 0);System.out.println("EhCacheWrapper Cache Name(Reuse): " + cache_name);}SolrInfoMBeans methods //public String getName() {return EhCacheWrapper.class.getName();}public String getVersion() {return SolrCore.version;}public String getDescription() {return description;}public Category getCategory() {return Category.CACHE;}public String getSourceId() {return " NULL ";}public String getSource() {return " NULL ";}public URL[] getDocs() {return null;}// returns a ratio, not a percent.private static String calcHitRatio(long lookups, long hits) {if (lookups==0) return "0.00";if (lookups==hits) return "1.00";int hundredths = (int)(hits*100/lookups);   // rounded downif (hundredths < 10) return "0.0" + hundredths;return "0." + hundredths;/*** code to produce a percent, if we want it...int ones = (int)(hits*100 / lookups);int tenths = (int)(hits*1000 / lookups) - ones*10;return Integer.toString(ones) + '.' + tenths;***/}public NamedList getStatistics() {NamedList lst = new SimpleOrderedMap();synchronized (map) {lst.add("lookups", lookups);lst.add("hits", hits);lst.add("hitratio", calcHitRatio(lookups,hits));lst.add("inserts", inserts);lst.add("evictions", evictions);lst.add("size", map.getSize());}lst.add("warmupTime", warmupTime);long clookups = stats.lookups.get();long chits = stats.hits.get();lst.add("cumulative_lookups", clookups);lst.add("cumulative_hits", chits);lst.add("cumulative_hitratio", calcHitRatio(clookups,chits));lst.add("cumulative_inserts", stats.inserts.get());lst.add("cumulative_evictions", stats.evictions.get());return lst;}public String toString() {return name + getStatistics().toString();}
}

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"updateCheck="false" monitoring="autodetect"dynamicConfig="true" name="config"><!--<cache name="filterCache"maxEntriesLocalHeap="1024"eternal="true"overflowToOffHeap="true"maxBytesLocalOffHeap="1g"></cache><cache name="fieldValueCache"maxEntriesLocalHeap="1024"eternal="true"overflowToOffHeap="true"maxBytesLocalOffHeap="1g"></cache>--><cache name="queryResultCache"maxEntriesLocalHeap="1"eternal="true"overflowToOffHeap="true"maxBytesLocalOffHeap="800m"></cache><!-- ehcache not support documentCache, encoding format error.<cache name="documentCache"maxEntriesLocalHeap="1024"eternal="true"overflowToOffHeap="true"maxBytesLocalOffHeap="1g"></cache>--></ehcache>