Performance tuneup for a special DB (disable locking, check-pointing,...)

Question

Hi,
I have simple database contains key/value records. The program is a multi-thread application that iterate over records. Each worker thread read a record and after some calculations, replace it. The records are completely independent from each other. The following is my DBController class that share between all threads. Is there any considerations to achieve best performance?, For example I don't want any locking, check-pointing, caching,...overheads. I just want to achieve THE BEST PERFORMANCE to store and retrieve each record independently.
import gnu.trove.*;
import java.io.*;
import com.sleepycat.bind.tuple.*;
import com.sleepycat.je.*;
public class DBController {
     private class WikiSimTupleBinding extends TupleBinding<TIntObjectHashMap<TIntDoubleHashMap>> {
          // Write an appropriate object to a TupleOutput (a DatabaseEntry)
          public void objectToEntry(TIntObjectHashMap<TIntDoubleHashMap> object, TupleOutput to) {
               try {
                    ByteArrayOutputStream bout = new ByteArrayOutputStream();
                    ObjectOutputStream oout = new ObjectOutputStream(bout);
                    oout.writeObject(object);
                    oout.flush();
                    oout.close();
                    bout.close();
                    byte[] data = bout.toByteArray();
                    to.write(data);
               } catch (IOException e) {
                    e.printStackTrace();
          // Convert a TupleInput(a DatabaseEntry) to an appropriate object
          public TIntObjectHashMap<TIntDoubleHashMap> entryToObject(TupleInput ti) {
               TIntObjectHashMap<TIntDoubleHashMap> object = null;
               try {
                    byte[] data = ti.getBufferBytes();
                    object = (TIntObjectHashMap<TIntDoubleHashMap>) new java.io.ObjectInputStream(
                              new java.io.ByteArrayInputStream(data)).readObject();
               } catch (Exception e) {
                    e.printStackTrace();
               return object;
     private Environment myDbEnvironment = null;
     private Database db_R = null;
     private WikiSimTupleBinding myBinding;
     public DBController(File dbEnv) {
          try {
               // Open the environment. Create it if it does not already exist.
               EnvironmentConfig envConfig = new EnvironmentConfig();
               envConfig.setAllowCreate(true);
               myDbEnvironment = new Environment(dbEnv, envConfig);
               // Open the databases. Create them if they don't already exist.
               DatabaseConfig dbConfig = new DatabaseConfig();
               dbConfig.setAllowCreate(true);
               db_R = myDbEnvironment.openDatabase(null, "R", dbConfig);
               // initialize Binding API
               myBinding = new WikiSimTupleBinding();
          } catch (DatabaseException dbe) {
               // Exception handling goes here
               dbe.printStackTrace();
     private final byte[] intToByteArray(int value) {
          return new byte[] { (byte) (value >>> 24), (byte) (value >>> 16), (byte) (value >>> 8), (byte) value };
     public void put(int id, TIntObjectHashMap<TIntDoubleHashMap> repository) {
          try {
               DatabaseEntry theKey = new DatabaseEntry(intToByteArray(id));
               DatabaseEntry theData = new DatabaseEntry();
               myBinding.objectToEntry(repository, theData);
               db_R.put(null, theKey, theData);
          } catch (Exception dbe) {
               // Exception handling goes here
               dbe.printStackTrace();
     public TIntObjectHashMap<TIntDoubleHashMap> get(int id) {
          TIntObjectHashMap<TIntDoubleHashMap> repository = null;
          try {
               // Create a pair of DatabaseEntry objects. theKey is used to perform the search. theData is used to store the
               // data returned by the get() operation.
               DatabaseEntry theKey = new DatabaseEntry(intToByteArray(id));
               DatabaseEntry theData = new DatabaseEntry();
               // Perform the get.
               if (db_R.get(null, theKey, theData, LockMode.DEFAULT) == OperationStatus.SUCCESS) {
                    // Recreate the data repository
                    repository = myBinding.entryToObject(theData);
               } else {
                    System.out.println("No record found for key '" + id + "'.");
          } catch (Exception e) {
               // Exception handling goes here
               e.printStackTrace();
          return repository;
     public void close() {
          // closing the DB
          try {
               if (db_R != null)
                    db_R.close();
               if (myDbEnvironment != null)
                    myDbEnvironment.close();
          } catch (DatabaseException dbe) {
               // Exception handling goes here
               dbe.printStackTrace();
}

Answer 1

If you are writing and you need to recover in a reasonable amount of time after a crash, you need checkpointing.
If multiple threads may access a record concurrently, you need locking.
If you need good read performance, you need as large a JE cache as possible.
If you want to tune performance, the first step is to print the EnvironmentStats (Environment.getStats) periodically, and read the FAQ performance section. Try to find out if your app's performance is limited by CPU or I/O.
If you are reading records in key order, then you'll get better performance if you also write them in key order.
I'm not sure why you're using a TupleBinding to do Java object serialization If you want Java serialization, try using a SerialBinding.
--mark