ProfileKvpStores.java - gbif-ecat - GBIF work on the Global Names Architecture

Source path: svn/ trunk/ lookup-benchmarks/ src/ main/ java/ org/ gbif/ ecat/ benchmark/ ProfileKvpStores.java

‹r334

r5044

package org.gbif.ecat.benchmark;

import org.gbif.utils.file.FileUtils;

import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;

import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.Term;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.RAMDirectory;
import org.h2.jdbcx.JdbcDataSource;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;

/**
 * Testing the data layout
 */
public class ProfileKvpStores {
  private static File data = FileUtils.getClasspathFile("scinames.txt");

  private static Connection createDB(boolean inMemory) throws SQLException, IOException {
    JdbcDataSource h2 = new JdbcDataSource();
    // use data temp dir if disk h2 is required
    if (inMemory) {
      h2.setURL("jdbc:h2:mem:");
    } else {
      String dir = "/Users/markus/Desktop/test";
      h2.setURL("jdbc:h2:" + dir + "/benchmark");
      File df = new File(dir);
      if (df.exists()) {
        org.apache.commons.io.FileUtils.forceDelete(df);
      }
    }
    h2.setUser("sa");
    h2.setPassword("sa");

    Connection cn = h2.getConnection();
    Statement st = cn.createStatement();
    st.execute("CREATE TABLE terms (key VARCHAR(255) PRIMARY KEY, value VARCHAR(64) )");
    cn.commit();
    return cn;
  }

  public static void main(String[] args) throws IOException, SQLException {
    System.out.println("Reading data file...");
    List<String> lookups = new ArrayList<String>(Arrays.asList(new String[]{
        "Craspedacusta", "Amphisbaena borelli", "Trypanea mundella", "Aaptolasma triderma", "Ypzia", "Gampsocera hedini", "Heterorachis",
        "Leptactina latifolia", "Nitella gracilis var. confervacea f. conformis", "Rhyncolus culinaris", "Coelotes italicus", "Rhyncolus gibts nicht"}));
    Map<String, String> dataMap = FileUtils.streamToMap(new FileInputStream(data));
//		Map<String,String> dataMap = new HashMap<String,String>();
//		for (String l:lookups){
//			dataMap.put(l, l);
//		}
    DataContainer obj = null;
    System.gc();
    System.out.println("done\n");

    obj = testHashSet(dataMap);
    testLookupPerformance(obj, lookups, 10000);
    waitForSpace();

//		obj=null;
//		System.gc();
//		obj = testTreeSet(dataMap);
//		testLookupPerformance(obj, lookups, 10000);
//		waitForSpace();
//		
//		obj=null;
//		System.gc();
//		obj = testHashMap(dataMap);
//		testLookupPerformance(obj, lookups, 10000);
//		waitForSpace();
//		
//		obj=null;
//		System.gc();
//		obj = testTreeMap(dataMap);
//		testLookupPerformance(obj, lookups, 10000);
//		waitForSpace();
//		
//		obj=null;
//		System.gc();
//		obj = testArrayList(dataMap);
//		testLookupPerformance(obj, lookups, 100);
//		waitForSpace();
//
//		obj=null;
//		System.gc();
//		obj = testLinkedList(dataMap);
//		testLookupPerformance(obj, lookups, 100);
//		waitForSpace();
//
//		obj=null;
//		System.gc();
//		obj = testPrimitiveArray(dataMap);
//		waitForSpace();
//		
//		obj=null;
//		System.gc();
//		obj = testCommonsHashMap(dataMap);
//		testLookupPerformance(obj, lookups, 10000);
//		waitForSpace();

//		obj=null;
//		System.gc();
//		obj = testFastList(dataMap);
//		testLookupPerformance(obj, lookups, 100);
//		waitForSpace();
//
//		obj=null;
//		System.gc();
//		obj = testFastMap(dataMap);
//		testLookupPerformance(obj, lookups, 10000);
//		waitForSpace();
//
//		obj=null;
//		System.gc();
//		obj = testFastTable(dataMap);
//		testLookupPerformance(obj, lookups, 100);
//		waitForSpace();
//
//		obj=null;
//		System.gc();
//		obj = testFastSet(dataMap);
//		testLookupPerformance(obj, lookups, 10000);
//		waitForSpace();
//		
//		obj=null;
//		System.gc();
//		obj = testTroveSet(dataMap);
//		testLookupPerformance(obj, lookups, 10000);
//		waitForSpace();
//		
//		obj=null;
//		System.gc();
//		obj = testTroveMap(dataMap);
//		testLookupPerformance(obj, lookups, 10000);
//		waitForSpace();

    obj = null;
    System.gc();
    obj = testGoogleSet(dataMap);
    testLookupPerformance(obj, lookups, 10000);
    waitForSpace();

    obj = null;
    System.gc();
    obj = testGoogleMap(dataMap);
    testLookupPerformance(obj, lookups, 10000);
    waitForSpace();

    obj = null;
    System.gc();
    obj = testLuceneKVP(dataMap);
    testLuceneLookupPerformance(obj, lookups, 10000);
    waitForSpace();

    obj = null;
    System.gc();
    obj = testLuceneMinimal(dataMap);
    testLuceneLookupPerformance(obj, lookups, 10000);
    waitForSpace();

    obj = null;
    System.gc();
    obj = testH2(dataMap, true);
    testH2LookupPerformance(obj, lookups, 10000);
    waitForSpace();

    obj = null;
    System.gc();
    obj = testH2(dataMap, false);
    testH2LookupPerformance(obj, lookups, 10000);
    waitForSpace();

    System.out.println("Done.");
  }

  private static DataContainer testArrayList(Map<String, String> dataMap) throws IOException {
    List<String> hs = new ArrayList<String>(dataMap.keySet());
    System.out.println("  " + hs.size() + " records loaded into ArrayList");
    return new DataContainer(hs);
  }

  private static DataContainer testCommonsHashMap(Map<String, String> dataMap) throws IOException {
    // no generics
    org.apache.commons.collections.map.HashedMap hs = new org.apache.commons.collections.map.HashedMap(dataMap);
    System.out.println("  " + hs.size() + " records loaded into commons HashedMap");
    return new DataContainer(hs);
  }

  private static DataContainer testFastList(Map<String, String> dataMap) throws IOException {
    List<String> hs = new javolution.util.FastList<String>(dataMap.keySet());
    System.out.println("  " + hs.size() + " records loaded into javolution FastList");
    return new DataContainer(hs);
  }

  private static DataContainer testFastMap(Map<String, String> dataMap) throws IOException {
    Map<String, String> hs = new javolution.util.FastMap<String, String>(dataMap);
    System.out.println("  " + hs.size() + " records loaded into javolution FastMap");
    return new DataContainer(hs);
  }

  private static DataContainer testFastSet(Map<String, String> dataMap) throws IOException {
    Set<String> hs = new javolution.util.FastSet<String>(dataMap.keySet());
    System.out.println("  " + hs.size() + " records loaded into javolution FastSet");
    return new DataContainer(hs);
  }

  private static DataContainer testFastTable(Map<String, String> dataMap) throws IOException {
    List<String> hs = new javolution.util.FastTable<String>(dataMap.keySet());
    System.out.println("  " + hs.size() + " records loaded into javolution FastTable");
    return new DataContainer(hs);
  }

  private static DataContainer testGoogleArray(Map<String, String> dataMap) throws IOException {
//		com.google.common.collect.
//		List<String> hs = new ArrayList<String>(FileUtils.fileToList(genera));
//		System.out.println("  "+hs.size()+" records loaded into String[] array");
    return new DataContainer(null);
  }

  private static DataContainer testGoogleMap(Map<String, String> dataMap) {
    ImmutableMap<String, String> hs = ImmutableMap.copyOf(dataMap);
    System.out.println("  " + hs.size() + " records loaded into com.google.common.collect.ImmutableMap");
    return new DataContainer(hs);
  }

  private static DataContainer testGoogleSet(Map<String, String> dataMap) {
    ImmutableSet<Set<String>> hs = ImmutableSet.of(dataMap.keySet());
    System.out.println("  " + hs.size() + " records loaded into com.google.common.collect.ImmutableSet");
    return new DataContainer(hs);
  }

  private static DataContainer testH2() throws IOException {
    int i = 0;
    for (String g : FileUtils.streamToSet(new FileInputStream(data))) {
      i++;
    }
    System.out.println("  " + i + " records loaded into H2");
    return new DataContainer(null);
  }

  private static DataContainer testH2(Map<String, String> generaMap, boolean inMemory) throws SQLException, IOException {
    long time = System.currentTimeMillis();

    Connection cn = createDB(inMemory);
    cn.setAutoCommit(false);
    PreparedStatement pst = cn.prepareStatement("INSERT INTO terms (key, value) VALUES (?, ?)");
    for (String key : generaMap.keySet()) {
      pst.setString(1, key);
      pst.setString(2, generaMap.get(key));
      pst.execute();
    }
    cn.commit();
    String dbType = "file";
    if (inMemory) {
      dbType = "in memory";
    }
    System.out.println("  " + generaMap.size() + " records loaded into H2 " + dbType + " database in " + (System.currentTimeMillis() - time) + " msecs");
    return new DataContainer(cn);
  }

  private static void testH2LookupPerformance(DataContainer data, List<String> lookups, int loops) {
    Connection cn = (Connection) data.getData();
    int cnt = 0;
    boolean contains;
    long time = 0;

    try {
      ResultSet result;

//			String sql2 = "select count(*) from terms";
//			Statement st2 = cn.createStatement();
//			result = st2.executeQuery(sql2);
//			result.first();
//			System.out.println("Term sql count: "+ result.getInt(1));

      String sql = "select value from terms where key=?";
      PreparedStatement st = cn.prepareStatement(sql, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, ResultSet.CLOSE_CURSORS_AT_COMMIT);
      st.setFetchSize(1);
      st.setMaxRows(1);
      time = System.currentTimeMillis();

      while (cnt < loops) {
        for (String l : lookups) {
          st.setString(1, l);
          result = st.executeQuery();
          contains = result.first();
        }
        cnt++;
      }
    } catch (SQLException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    System.out.println("  sql equals test of " + loops + " x " + lookups.size() + " terms took " + (System.currentTimeMillis() - time) + " msecs");
  }

  private static DataContainer testHashMap(Map<String, String> dataMap) throws IOException {
    HashMap hs = new HashMap<String, Integer>();
    for (String g : dataMap.keySet()) {
      hs.put(g, Integer.valueOf(dataMap.get(g)));
    }
    System.out.println("  " + hs.size() + " records loaded into HashMap");
    return new DataContainer(hs);
  }

  private static DataContainer testHashSet(Map<String, String> dataMap) throws IOException {
    Set<String> hs = new HashSet<String>(dataMap.keySet());
    System.out.println("  " + hs.size() + " records loaded into HashSet");
    return new DataContainer(hs);
  }

  private static DataContainer testLinkedList(Map<String, String> dataMap) throws IOException {
    List<String> hs = new LinkedList<String>(dataMap.keySet());
    System.out.println("  " + hs.size() + " records loaded into LinkedList");
    return new DataContainer(hs);
  }

  // 276MB set
  // 172MB table
  private static void testLookupPerformance(DataContainer data, List<String> lookups, int loops) {
    int cnt = 0;
    boolean contains;
    long time;
    String keyAddon = "";
    try {
      Collection c = (Collection) data.getData();
      time = System.currentTimeMillis();
      while (cnt < loops) {
        for (String l : lookups) {
          contains = c.contains(l);
        }
        cnt++;
      }
    } catch (ClassCastException e) {
      Map m = (Map) data.getData();
      keyAddon = "(key) ";
      time = System.currentTimeMillis();
      while (cnt < loops) {
        for (String l : lookups) {
          contains = m.containsKey(l);
        }
        cnt++;
      }
    }
    System.out.println("  contains " + keyAddon + "test of " + loops + " x " + lookups.size() + " terms took " + (System.currentTimeMillis() - time) + " msecs");
  }

  private static DataContainer testLuceneKVP(Map<String, String> dataMap) throws IOException {
    long time = System.currentTimeMillis();
    Directory memDir = new RAMDirectory();
    LuceneUtils.buildKeyValueIndex(dataMap, memDir, true);
    System.out.println("  " + dataMap.size() + " records loaded into Lucene KVP index in " + (System.currentTimeMillis() - time) + " msecs");
    IndexReader reader = IndexReader.open(memDir, true);
    IndexSearcher searcher = new IndexSearcher(reader);
    return new DataContainer(searcher);
  }

  private static void testLuceneLookupPerformance(DataContainer data, List<String> lookups, int loops) {
    IndexSearcher searcher = (IndexSearcher) data.getData();
    int cnt = 0;
    boolean contains;
    TopDocs docs;
    long time;
    Term term = new Term(LuceneUtils.FIELD_KEY);
    TermQuery query;
    time = System.currentTimeMillis();
    try {
      while (cnt < loops) {
        for (String l : lookups) {
          docs = searcher.search(new TermQuery(term.createTerm(l)), 1);
          contains = docs.totalHits > 0;
        }
        cnt++;
      }
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    System.out.println("  lucene " + loops + " x " + lookups.size() + " TermQueries took " + (System.currentTimeMillis() - time) + " msecs");
  }

  private static DataContainer testLuceneMinimal(Map<String, String> generaMap) throws IOException {
    long time = System.currentTimeMillis();
    Directory memDir = new RAMDirectory();
    LuceneUtils.buildSimpleIndex(generaMap.keySet(), memDir, true);
    System.out.println("  " + generaMap.size() + " records loaded into simple Lucene term index in " + (System.currentTimeMillis() - time) + " msecs");
    IndexReader reader = IndexReader.open(memDir, true);
    IndexSearcher searcher = new IndexSearcher(reader);
    return new DataContainer(searcher);
  }

  private static DataContainer testPrimitiveArray(Map<String, String> dataMap) throws IOException {
    DataContainer dc = new DataContainer(dataMap.keySet().toArray());
    System.out.println("  " + dataMap.size() + " records loaded into String[] array");
    return dc;
  }

  private static DataContainer testTreeMap(Map<String, String> dataMap) throws IOException {
    TreeMap<String, Integer> hs = new TreeMap<String, Integer>();
    for (String g : dataMap.keySet()) {
      hs.put(g, Integer.valueOf(dataMap.get(g)));
    }
    System.out.println("  " + hs.size() + " records loaded into TreeMap");
    return new DataContainer(hs);
  }

  private static DataContainer testTreeSet(Map<String, String> dataMap) throws IOException {
    Set<String> hs = new TreeSet<String>(dataMap.keySet());
    System.out.println("  " + hs.size() + " records loaded into TreeSet");
    return new DataContainer(hs);
  }

  private static DataContainer testTroveMap(Map<String, String> dataMap) throws IOException {
    Map<String, String> hs = new gnu.trove.THashMap<String, String>(dataMap);
    System.out.println("  " + hs.size() + " records loaded into gnu.trove.THashMap");
    return new DataContainer(hs);
  }

  private static DataContainer testTroveSet(Map<String, String> dataMap) throws IOException {
    Set<String> hs = new gnu.trove.THashSet<String>(dataMap.keySet());
    System.out.println("  " + hs.size() + " records loaded into gnu.trove.THashSet");
    return new DataContainer(hs);
  }

  private static void waitForSpace() {
    String str = null;// " ";
    System.out.println("Please press ENTER to continue \n");
    while (str == null) {
      try {
        str = new BufferedReader(new InputStreamReader(System.in)).readLine();
      } catch (IOException e) {
        // TODO do exception handling
      }
    }
    System.out.println("  running next task...");
  }
}

Show details Hide details

Change log

r3157 by wixner on Jan 12, 2011 Diff

lucene benchmarking

Go to:

Project members, sign in to write a code review

Older revisions

r334 by mdoer...@gbif.org on Jul 2, 2009 Diff

added google immutable collections

r331 by wixner on Jul 2, 2009 Diff

[No log message]

All revisions of this file

File info

Size: 16003 bytes, 463 lines

View raw file

File properties

svn:mime-type: text/plain