Performance comparisons between POF & open source serialization mechanism?

Question

I'm curious whether anyone has done any comparisons of performance and serialized object sizes between POF and open source mechanisms such as Google Protocol Buffers and Thrift, both of which seem to be becoming quite popular. Personally, I dislike having to write a separate schema and then generate classes from it, which Protocol Buffers and Thrift require you to do, and I vastly prefer POF's mechanism of keeping everything in the code (although I wish the POF annotation framework was officially supported). But aside from that, I'd prefer to use Coherence for many of the purposes that some of my co-workers are currently using other solutions for, and this would be useful information to have in making the case.
FWIW, I hope someone at Oracle is seriously considering open-sourcing POF. I don't think that anyone who would've bought a Coherence license would decide not to because they could get POF for free. They'd just go and use something else, like the aforementioned Protocol Buffers and Thrift. Not only are many companies adopting these as standards, but as has been mentioned in other threads on this forum, that's exactly what even some Coherence users are doing:
Re: POF compatibility across Coherence versions
I really wish I could to encourage developers that I work with to give POF a look as an alternative to those two (both of which we're currently using), regardless of whether or not they plan on using Coherence in the immediate future. As things stand right now, I can't use Coherence for code that needs to be shared with people in other groups who haven't adopted Coherence yet. But if I could use POF outside of Coherence, it would probably be acceptable to those folks as a generic serialization mechanism, and it would make migrating such code to Coherence at some point down the road that much easier. If, on the other hand, I have to write that code around, say, Protocol Buffers, then it becomes much harder to later justify creating and maintaining POF as a second serialization mechanism for the same set of objects, which means it's much harder to justify using Coherence for those objects.
In short, making POF usable outside of Coherence, and who knows, maybe even getting it supported in popular open source projects such as Cassandra (which, as I understand it, uses Thrift) would make it easier to adopt Coherence in environments where objects are already persisted in other systems.
That's my two cents.

Answer 1

Hi,
Thank you for links. It is very interesting.
I have implemented POF serialization plugin for this benchmark http://wiki.github.com/eishay/jvm-serializers/
You can get code, run benchmark for yourself and compare result.
Handmade POF serialization http://gridkit.googlecode.com/svn/wiki/snippets/CoherencePofSerializer.java
Reflection POF serialization http://gridkit.googlecode.com/svn/wiki/snippets/CoherencePofReflection.java
Also you should put a two line in BenchmarkRunner.java, all other instructions are on jvm-serializers project page.
          Protobuf.register(groups);
          Thrift.register(groups);
          ActiveMQProtobuf.register(groups);
          Protostuff.register(groups);
          Kryo.register(groups);
          AvroSpecific.register(groups);
          AvroGeneric.register(groups);
// register POF tests here
          CoherencePofSerializer.register(groups);
          CoherencePofReflection.register(groups);
          CksBinary.register(groups);
          Hessian.register(groups);
          JavaBuiltIn.register(groups);
          JavaManual.register(groups);
          Scala.register(groups);A few comments on result.
* Micro benchmark is a micro benchmark, I saw quite differnt results then comparis java vs POF vs POF reflection on own domain objects.
* POF score very good compared to protocols like Protobuf or Thrift, especially on deserialization.
* Kryo project is quite interesting, I'm going to give it a try in next project for sure.
Again, thanks a lot for a link.