| Addressing your points: 1. In my comment I acknowledge that there are space savings with types that include padding. I don't understand why you imply in your answer that I didn't understand this point. Regarding my comment about not copying data: it was based on the benchmark[1] as linked in the blog post. The parts you measure do not copy any of the user data! It only converts your internal vectors of user types to a list of vectors of u8 type. So what you are doing is essentially moving the data. But when using move semantics the size of the user data does not matter any more, so there won't be a difference between your column layout and using the more complex types directly inside the vectors if measured the same way as in this benchmark. In my opinion your benchmark is flawed and does not support the argument you make in your blog post. 2. Ok yes that was bad wording on my side. If you provide adaptors for complex types with pointers like Vec than you can of course also serialize those. 3. I guess this is just about the same argument as point 2) and thus redundant. I made the effort for you to write a serialization framework which does not do "columnarization" but which simulates row layout and also added an adaptor for vec and ran it with the same benchmark, and also reran the original columnar benchmark on my machine. Both benchmarks were compiled exactly the same way. You can find my code here[2]. Here are the results: ============================== columnarization <uint> 12.1 GB/s, 742k values/s columnarization <(uint, (uint, uint))> 5.3 GB/s, 107k values/s columnarization <vec<uint>> 2.1 GB/s, 54k values/s columnarization <Option<uint>> 1.58 GB/s, 163k values/s ============================== row (simple_serialize) <uint> 12.1 GB/s, 730k values/s row (simple_serialize) <(uint, (uint, uint))> 8.83 GB/s, 164 values/s row (simple_serialize) <vec<uint>> 2.13 GB/s, 56 values/s row (simple_serialize) <Option<uint>> 8.82 GB/s, 263k values/s ============================== You see that columnization does not have a performance benefit in your benchmark and it even is significantly slower for Option<uint> type and pairs. In your blog post you never mentioned that columnization will only has the potential to bring performance benefits to de-/serialization when using types with large padding overheads. I think this discussion would probably helped the blog post. It would be much better if it would either omit the currently wrong performance argument and just focus on the nicely typed API or if it would use a proper benchmark which would support your argument, which from my understanding would be only possible in a very limited set of use case scenarios. Here is a list of other valid arguments you could have made instead: * Format saves space at the cost of performance. * Better than repr(packed) as it will also work on platforms that don't support unaligned access [1] https://github.com/frankmcsherry/columnar/blob/master/exampl...
[2] https://github.com/mkaufmann/simple_serialize |
The reason the new numbers look better for Option with the Copy implementation is that you are now writing 16 bytes for each Option. They are a 50-50 mix of Some(0u) and None, which I wrote out in 5 bytes on average (always a 1 byte "present/not", and then 4 bytes of data on average). The Copy implementation is just writing 3x as much data and padding the throughput numbers, rather than reporting something more like goodput.
I sense that this isn't the right place to shake this out, so I'll stop posting. If there is a better way to follow up, let me know.
[edit: I've got you through github, thanks! I'll buy beers when I swing by TU next]