[CASSANDRA-21535] Avoid extra copy for cached Mutation serialization

[koo-taejin]

Description
In Mutation.Serializer.serialization(), we first calculate the serialized size.

After that, current code serializes the mutation to a thread local DataOutputBuffer. Then unsafeToByteArray() creates a new byte array and copies all serialized bytes.

The serialized size is already known.
So we can create a fixed size heap buffer first and serialize directly to that buffer.

This change removes one full byte array copy when we create a cached mutation serialization.

I also added a check that the written size is same as the calculated serialized size.

Benchmark
I added a JMH benchmark for this case.

For every benchmark operation:

• clear cached serialization
• serialize the Mutation
• create cached serialization again

JDK 17, arm64, 1 thread:

Value size	Before	After	Result
128 B	3.70 M ops/s	3.87 M ops/s	+4%
16 KiB	608 K ops/s	716 K ops/s	+18%
256 KiB	41.4 K ops/s	53.1 K ops/s	+28%
768 KiB	6.83 K ops/s	18.88 K ops/s	+177%

The result is bigger for large mutations because current code writes the data to a direct buffer first, and then copies all data again to a heap byte array.

With this change, serialization writes directly to the final heap byte array.

This benchmark measures cache creation cost. It does not mean normal write throughput will be 2.77x faster, because normal requests can reuse the cached serialization.

patch by koo.taejin; reviewed by for CASSANDRA-21535

The Cassandra Jira

[netudima]

Could you please also share the JMH benchmark too?

[koo-taejin]

I also include the files used for the test.

Sorry, I should explain the test environment and the test result more clearly. I shared the result without including enough test details.

Please feel free to give me any feedback.

Thank you. :)