Benchmarks

MainActivity.java

import android.app.Activity;
import android.os.Bundle;
import android.os.Parcel;
import android.os.Parcelable;
import android.util.Log;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonSerializationContext;
import com.google.gson.JsonSerializer;
import com.google.gson.TypeAdapter;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonWriter;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;
import org.parceler.Parcels;

public class MainActivity extends Activity {

  private static final String LOG_TAG = MainActivity.class.getSimpleName();
  private static final String LOG_FORMAT = "%s\t%f";

  private static final String DUMMY_STRING = "string";
  private static final float DUMMY_FLOAT = 1234567f;
  private static final int DUMMY_INT = 1234567;
  private static final boolean DUMMY_BOOLEAN = false;

  private static final int N = 1000;
  private static final int LIST_SIZE = 25;

  @Override protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    new Thread(new Runnable() {
      @Override public void run() {
        // Serializable
        runBenchmark(new ParcelableBenchmark(), "Parcelable");
        //
        //// Parceler
        //runBenchmark(new ParcelerBenchmark(), "Parceler");
        //
        //// Serializable
        //runBenchmark(new SerializableBenchmark(), "Serializable");
        //
        //// Gson
        //runBenchmark(new GsonBenchmark(), "Gson");
        //
        //// Gson with type adapter
        //runBenchmark(new GsonWithSerializerBenchmark(), "Gson+JsonSerializer");
        //
        //// Gson with type adapter
        //runBenchmark(new GsonWithTypeAdapter(), "Gson+TypeAdapter");
      }
    }).start();
  }

  static void runBenchmark(Benchmark b, String name) {
    Log.i(LOG_TAG, String.format(LOG_FORMAT, name, b.run(N) / 1000000));
  }

  public static interface Benchmark {
    double run(int N);
  }

  public static class GsonBenchmark implements Benchmark {
    @Override public double run(int N) {
      GsonModel p = GsonModel.dummyData();
      Gson gson = new GsonBuilder()
          .create();

      double average = 0;
      double start;
      double end;

      int x = 0;
      while (x < N) {
        start = System.nanoTime();
        gson.toJson(p);
        end = System.nanoTime();

        average += (end - start);
        x++;
      }

      return (average / N);
    }
  }

  public static class GsonWithTypeAdapter implements Benchmark {
    @Override public double run(int N) {
      GsonModel p = GsonModel.dummyData();
      Gson gson = new GsonBuilder()
          .registerTypeAdapter(GsonModel.class, new GsonModelTypeAdapter())
          .create();

      double average = 0;
      double start;
      double end;

      int x = 0;
      while (x < N) {
        start = System.nanoTime();
        gson.toJson(p, GsonModel.class);
        end = System.nanoTime();

        average += (end - start);
        x++;
      }

      return (average / N);
    }

    static class GsonModelTypeAdapter extends TypeAdapter<GsonModel> {
      @Override public void write(JsonWriter out, GsonModel value) throws IOException {
        out.beginObject();
        out.name("name").value(value.name);
        out.name("yearsOfExperience").value(value.yearsOfExperience);
        out.name("favoriteFloat").value(value.favoriteFloat);
        out.name("skillSet");
        out.beginArray();
        for (GsonModel.Skill skill : value.skillSet) {
          out.beginObject()
              .name("name").value(skill.name)
              .name("programmingRelated").value(skill.programmingRelated)
              .endObject();
        }
        out.endArray();
        out.endObject();
      }

      @Override public GsonModel read(JsonReader in) throws IOException {
        GsonModel model = new GsonModel();
        model.name = in.nextString();
        model.yearsOfExperience = in.nextInt();
        model.favoriteFloat = in.nextInt();

        in.beginArray();
        while (in.hasNext()) {
          in.beginObject();
          GsonModel.Skill skill = new GsonModel.Skill();
          skill.name = in.nextString();
          skill.programmingRelated = in.nextBoolean();
          in.endObject();
        }
        in.endArray();

        return model;
      }
    }
  }

  public static class GsonWithSerializerBenchmark implements Benchmark {
    @Override public double run(int N) {
      GsonModel p = GsonModel.dummyData();
      Gson gson = new GsonBuilder()
          .registerTypeAdapter(GsonModel.class, new GsonModelSerializer())
          .create();

      double average = 0;
      double start;
      double end;

      int x = 0;
      while (x < N) {
        start = System.nanoTime();
        gson.toJson(p, GsonModel.class);
        end = System.nanoTime();

        average += (end - start);
        x++;
      }

      return (average / N);
    }

    static class GsonModelSerializer implements JsonSerializer<GsonModel> {
      @Override public JsonElement serialize(GsonModel src, Type typeOfSrc,
          JsonSerializationContext context) {
        JsonObject element = new JsonObject();
        element.addProperty("name", src.name);
        element.addProperty("yearsOfExperience", src.yearsOfExperience);
        JsonArray array = new JsonArray();
        for (GsonModel.Skill skill : src.skillSet) {
          JsonObject o = new JsonObject();
          o.addProperty("name", skill.name);
          o.addProperty("programmingRelated", skill.programmingRelated);
          array.add(o);
        }
        element.add("skillSet", array);
        element.addProperty("favoriteFloat", src.favoriteFloat);
        return element;
      }
    }
  }

  public static class ParcelableBenchmark implements Benchmark {
    @Override public double run(int N) {
      ParcelableModel p = ParcelableModel.dummyData();

      double average = 0;
      double start;
      double end;

      int x = 0;
      while (x < N) {
        start = System.nanoTime();
        p.writeToParcel(Parcel.obtain(), 0);
        end = System.nanoTime();
        average += (end - start);
        x++;
      }

      return (average / N);
    }
  }

  public static class ParcelerBenchmark implements Benchmark {
    @Override public double run(int N) {
      ParcelModel p = ParcelModel.dummyData();

      double average = 0;
      double start;
      double end;

      int x = 0;
      while (x < N) {
        start = System.nanoTime();
        Parcels.wrap(p).writeToParcel(Parcel.obtain(), 0);
        end = System.nanoTime();
        average += (end - start);
        x++;
      }

      return (average / N);
    }
  }

  public static class SerializableBenchmark implements Benchmark {
    @Override public double run(int N) {
      SerializableModel p = SerializableModel.dummyData();

      double average = 0;
      double start;
      double end;

      ByteArrayOutputStream bos = null;
      ObjectOutput out = null;

      int x = 0;
      while (x < N) {
        start = System.nanoTime();
        try {
          bos = new ByteArrayOutputStream();
          out = new ObjectOutputStream(bos);
          out.writeObject(p);
          bos.toByteArray();
        } catch (IOException ignored) {
        } finally {
          try { if (out != null) { out.close(); } } catch (IOException ignored) {}
          try { if (bos != null) { bos.close(); } } catch (IOException ignored) {}
        }
        end = System.nanoTime();

        average += (end - start);
        x++;
      }

      return (average / N);
    }
  }


  /*
      MODELS
   */

  public static class GsonModel {

    public String name;
    public int yearsOfExperience;
    public List<Skill> skillSet;
    public float favoriteFloat;

    public static class Skill {
      public String name;
      public boolean programmingRelated;
    }

    public static GsonModel dummyData() {
      GsonModel p = new GsonModel();
      p.name = DUMMY_STRING;
      p.yearsOfExperience = DUMMY_INT;
      p.skillSet = new ArrayList<Skill>(LIST_SIZE);
      p.favoriteFloat = DUMMY_FLOAT;
      for (int x = 0; x < LIST_SIZE; x++) {
        Skill s = new Skill();
        s.programmingRelated = DUMMY_BOOLEAN;
        s.name = DUMMY_STRING;
        p.skillSet.add(s);
      }

      return p;
    }
  }

  @org.parceler.Parcel
  public static class ParcelModel {

    public String name;
    public int yearsOfExperience;
    public List<Skill> skillSet;
    public float favoriteFloat;

    @org.parceler.Parcel
    public static class Skill implements Serializable {
      public String name;
      public boolean programmingRelated;
    }

    public static ParcelModel dummyData() {
      ParcelModel p = new ParcelModel();
      p.name = DUMMY_STRING;
      p.yearsOfExperience = DUMMY_INT;
      p.skillSet = new ArrayList<Skill>(LIST_SIZE);
      p.favoriteFloat = DUMMY_FLOAT;
      for (int x = 0; x < LIST_SIZE; x++) {
        Skill s = new Skill();
        s.programmingRelated = DUMMY_BOOLEAN;
        s.name = DUMMY_STRING;
        p.skillSet.add(s);
      }

      return p;
    }
  }

  public static class ParcelableModel implements Parcelable {

    public String name;
    public int yearsOfExperience;
    public List<Skill> skillSet;
    public float favoriteFloat;

    public ParcelableModel() {}

    public ParcelableModel(Parcel in) {
      name = in.readString();
      yearsOfExperience = in.readInt();
      skillSet = new ArrayList<Skill>();
      in.readTypedList(skillSet, Skill.CREATOR);
      favoriteFloat = in.readFloat();
    }

    @Override public void writeToParcel(Parcel dest, int flags) {
      dest.writeString(name);
      dest.writeInt(yearsOfExperience);
      dest.writeTypedList(skillSet);
      dest.writeFloat(favoriteFloat);
    }

    @Override public int describeContents() {
      return 0;
    }

    static final Creator<ParcelableModel> CREATOR =
        new Creator<ParcelableModel>() {
          @Override public ParcelableModel createFromParcel(Parcel in) {
            return new ParcelableModel(in);
          }

          @Override public ParcelableModel[] newArray(int size) {
            return new ParcelableModel[size];
          }
        };

    static class Skill implements Parcelable {

      public String name;
      public boolean programmingRelated;

      public Skill() {}

      public Skill(Parcel in) {
        name = in.readString();
        programmingRelated = (in.readInt() == 1);
      }

      @Override public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(name);
        dest.writeInt(programmingRelated ? 1 : 0);
      }

      @Override public int describeContents() {
        return 0;
      }

      static final Creator<Skill> CREATOR = new Creator<Skill>() {
        @Override public Skill createFromParcel(Parcel in) {
          return new Skill(in);
        }

        @Override public Skill[] newArray(int size) {
          return new Skill[size];
        }
      };
    }

    public static ParcelableModel dummyData() {
      ParcelableModel p = new ParcelableModel();
      p.name = DUMMY_STRING;
      p.yearsOfExperience = DUMMY_INT;
      p.skillSet = new ArrayList<Skill>(LIST_SIZE);
      p.favoriteFloat = DUMMY_FLOAT;
      for (int x = 0; x < LIST_SIZE; x++) {
        Skill s = new Skill();
        s.programmingRelated = DUMMY_BOOLEAN;
        s.name = DUMMY_STRING;
        p.skillSet.add(s);
      }

      return p;
    }
  }

  public static class SerializableModel implements Serializable {

    public String name;
    public int yearsOfExperience;
    public List<Skill> skillSet;
    public float favoriteFloat;

    public static class Skill implements Serializable {
      public String name;
      public boolean programmingRelated;
    }

    public static SerializableModel dummyData() {
      SerializableModel p = new SerializableModel();
      p.name = DUMMY_STRING;
      p.yearsOfExperience = DUMMY_INT;
      p.skillSet = new ArrayList<Skill>(LIST_SIZE);
      p.favoriteFloat = DUMMY_FLOAT;
      for (int x = 0; x < LIST_SIZE; x++) {
        Skill s = new Skill();
        s.programmingRelated = DUMMY_BOOLEAN;
        s.name = DUMMY_STRING;
        p.skillSet.add(s);
      }

      return p;
    }
  }
}