I went through our so-called "direct serialization" and appears to be not
very efficient to me. We never write message length. As a result we have to
constantly track what was written and what was not, and whether we have a
room for the next write. The same goes for reader. As a result even single
"writeInt" is surrounded with multiple checks and writes.
It looks like we can make our algorithm much more simple, straightforward
and efficient if we add two things to every message:
- Message length
- Flag indicating whether it was written fully or not.
If message was written fully to the buffer, we do no need to perform any
checks during deserialization. To read int it is enough to call
*ByteBuffer.getInt()*. To read byte array it is enough to call
*ByteBuffer.getByte()*, etc. Simple and fast.
And only if message was split into pieces on either send or receive sides,
which should not happen often, we may want to fallback to current
implementation. Or may be we may copy such message to a separate buffer
and still read them without any boundaries checks and "incrementStates".