Re: Reducing relcache memory usage: deduping index shapes

>>> I've considered allocating Relations in a slab context to avoid aset's
>>> alignment overhead, but never got far enough with a prototype to get
>>> it to pass all tests.
>>
>> With the other optimizations from [1] we should be able to get below 256
>> bytes. If you want I can give this a try.
>
> Back-of-the-envelope calculation: Currently, RelationData is 488
> bytes, of which 50 wasted on alignment (so, 48 bytes recoverable). If
> we somehow get the index and table fields to not be used at the same
> time, we'd gain another 128 bytes (because the larger of the two must
> remain). This leaves us with 312 bytes, which is still 56 bytes over
> the target, and I don't think we can trivially find 7 pointers' worth
> of fields to remove.
>
> But, feel free to try.

I've managed to crunch sizeof(RelationData) down to 256 bytes and
there's some more room for improvement, see below. Attached is the patch
set. It passes tests.

I had to move RelationData into a new header because the script that
extracts node metadata doesn't like the anonymous unions.

With the patch, GetMemoryChunkSpace(rel) == 264 because the allocation
falls into the 256 bytes size class and additionally has an 8 byte
header. Previously it was 520 bytes.

We could additionally:

1) Change all the arrays of length nkeys to a single array of structs.
That would save a bunch of pointers in the index union elg. It's not
clear though if that might regress performance somewhere because of
cache locality but would be worth a try.

2) Put rules and trigger related members into separately allocated
structured referenced by a single pointer. These members are rarely used
and shouldn't be performance critical.

3) Pack booleans into bitfield.

That might save another 24 or more bytes (depends on the biggest union
leg and padding at the end of the struct). But for the PoC I didn't do that.

--
David Geier