<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 AtomicLongs
  private 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 pool
    Set<String> set = managerFlag.keySet();
    Iterator<String> it = set.iterator();
    while(it.hasNext()) {
        String cacheName = it.next();
        if( managerFlag.get(cacheName) == 0 ) {  // not used
            manager = managerPool.get(cacheName);
    
            System.out.println("EhCacheWrapper Cache Name(Pool): " + cacheName);
            
            managerFlag.put(cacheName, 1);
            cache_name = cacheName;
            return manager.getCache(cacheName);
        }
    }

    // add zhenjing
    String cacheName = name + cache_index;
    System.out.println("EhCacheWrapper Cache Name: " + cacheName);
     
    // create Cache from template
    Cache 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 pool
    managerFlag.put(cacheName, 1);
    managerPool.put(cacheName, manager);

    // get cache
    cache_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 cache
    map = 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 created
      persistence = 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 down
    if (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>