This benchmark say nothing

[zutherb]

i did the benchmark in native java and hazelcast is not so bad. i think jruby distort the benchmark.

import com.hazelcast.config.Config;
import com.hazelcast.core.Hazelcast;
import com.hazelcast.core.HazelcastInstance;
import org.apache.commons.lang.time.StopWatch;
import org.infinispan.manager.DefaultCacheManager;

import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

/**

• @author zutherb
  */
  public class PerformanceTest {

  private static final int SIZE = 100000;

  private static final Map<Integer, Integer> JAVA_MAP = new HashMap<Integer, Integer>();
  private static final HazelcastInstance HAZELCAST_INSTANCE;
  private static final DefaultCacheManager INFINISPAN_INSTANCE = new DefaultCacheManager();

  static {
  Config config = new Config();
  Properties properties = new Properties();
  config.setProperties(properties);
  HAZELCAST_INSTANCE = Hazelcast.newHazelcastInstance(config);
  }

  public static void main(String [] args){
  System.out.println("Performance of Java-Map");
  StopWatch stopWatch = new StopWatch();
  stopWatch.start();
  new Runnable() {
  @OverRide
  protected void doSomething(int i) {
  JAVA_MAP.put(i, i);
  }
  }.run();
  stopWatch.stop();
  System.out.println("write:\t" + stopWatch.toString());

  stopWatch = new StopWatch();
  stopWatch.start();
  new Runnable() {
      @Override
      protected void doSomething(int i) {
          JAVA_MAP.get(i);
      }
  }.run();
  stopWatch.stop();
  System.out.println("read:\t" + stopWatch.toString());
  
  System.out.println("Performance of Hazelcast-Map");
  stopWatch = new StopWatch();
  stopWatch.start();
  new Runnable() {
      @Override
      protected void doSomething(int i) {
          HAZELCAST_INSTANCE.getMap("performance").put(i, i);
      }
  }.run();
  stopWatch.stop();
  System.out.println("write:\t" + stopWatch.toString());
  
  stopWatch = new StopWatch();
  stopWatch.start();
  new Runnable() {
      @Override
      protected void doSomething(int i) {
          HAZELCAST_INSTANCE.getMap("performance").get(i);
      }
  }.run();
  stopWatch.stop();
  System.out.println("read:\t" + stopWatch.toString());
  
  System.out.println("Performance of Hazelcast-Map");
  stopWatch = new StopWatch();
  stopWatch.start();
  new Runnable() {
      @Override
      protected void doSomething(int i) {
          INFINISPAN_INSTANCE.getCache().put(i, i);
      }
  }.run();
  stopWatch.stop();
  System.out.println("write:\t" + stopWatch.toString());
  
  stopWatch = new StopWatch();
  stopWatch.start();
  new Runnable() {
      @Override
      protected void doSomething(int i) {
          INFINISPAN_INSTANCE.getCache().get(i);
      }
  }.run();
  stopWatch.stop();
  System.out.println("read:\t" + stopWatch.toString());
  
  HAZELCAST_INSTANCE.getLifecycleService().kill();
  

  }

  private static abstract class Runnable {

  public void run (){
      for (int i = 0; i < 10000; i++){
          doSomething(i);
      }
  }
  
  protected abstract void doSomething(int i);
  

  }

}

[mikaelhg]

I wasn't able to reproduce the original result without JRuby, either.

https://gist.github.com/mikaelhg/5446346

[andrewfinnell]

It should also be noted that you should never use Hazelcast if you are on one node. Their team even says this. It is not meant to be a single node cache.

[sam]

The benchmark says what it says about running on JRuby. It is what it is.

Also, I've tried multi-node Hazelcast. Write performance scales. That's why it's recommended (aside from HA obviously). Read performance doesn't do any better than you'd expect from pretty much anything else (and often worse).

Personally I've picked Hazelcast for a new project (in Scala) because it's a lot simpler than configuring JGroups, it's more than fast-enough without being handicapped by JRuby. I don't use it for permament storage, but if that was your use case it's even more reason to choose Hazelcast.

That said, if raw performance is your primary goal, you don't mind some additional complexity and you don't need anything more than a Cache then Hazelcast is probably the wrong tool.

[changgengli]

For a single node scenario, Infinispan would be faster than hazelcast. This is determined by their design difference. Hazelcast performs serialization and serialization even for single node deployment, while infinispan would not do this.

Agree with afinnell's comment.