On 09/14/2016 07:57 PM, Andrew Borodin wrote:
Here is v6 of cube penalty patch.
There was a warning about unused edge function  under systems without
__STDC_IEC_559__ defined, this patch fixes it.


Thanks!

Reading through this thread again, I think we got a bit side-tracked with this float bit-twiddling aspect, and we haven't really discussed the algorithm itself. So:

On 08/29/2016 09:04 AM, Andrew Borodin wrote:
Some time ago I put a patch to commitfest that optimizes slightly GiST
inserts and updates. It's effect in general is quite modest (15% perf
improved), but for sorted data inserts are 3 times quicker. This
effect I attribute to mitigation of deficiencies of old split
algorithm.
Alexander Korotkov advised me to lookup some features of the RR*-tree.
>
The RR*-tree differs from combination of Gist + cube extension in two
algorithms:
1.    Algorithm to choose subtree for insertion
2.    Split algorithm

Got a link for a description of the RR*-tree? Would be good to reference it in the patch comments, too.

This is the message regarding implementation of first one in GiST. I
think that both of this algorithms will improve querying performance.

Long story short, there are two problems in choose subtree algorithm.
1.    GiST chooses subtree via penalty calculation for each entry,
while RR*-tree employs complicated conditional logic: when there are
MBBs (Minimum Bounding Box) which do not require extensions, smallest
of them is chosen; in some cases, entries are chosen not by volume,
but by theirs margin.
2.    RR*-tree algorithm jumps through entry comparation non-linearly,
I think this means that GiST penalty computation function will have to
access other entries on a page.

In this message I address only first problem. I want to construct a
penalty function that will choose:
1.    Entry with a zero volume and smallest margin, that can
accommodate insertion tuple without extension, if one exists;
2.    Entry with smallest volume, that can accommodate insertion tuple
without extension, if one exists;
3.    Entry with zero volume increase after insert and smallest margin
increase, if one exists;
4.    Entry with minimal volume increase after insert.

Current cube behavior inspects only 4th option by returning as a
penalty (float) MBB’s volume increase. To implement all 4 options, I
use a hack: order of positive floats corresponds exactly to order of
integers with same binary representation (I’m not sure this stands for
every single supported platform). So I use two bits of float as if it
were integer, and all others are used as shifted bits of corresponding
float: option 4 – volume increase, 3 - margin increase, 2 – MBB
volume, 1 – MBB margin. You can check the reinterpretation cast
function pack_float() in the patch.

If I understand correctly, cases #1 and #3 arise when one of the dimensions is 0. For example, in a 3D space, if the existing entry is a rectangle on a plane, with zero-length edge on one of the dimensions, and the new entry is on the same plane. Case #1 arises if the new entry falls within that rectangle, and case #3 if it's outside it. Currently, we treat all such cases as 0-penalty, because the degenerate 0-dimension causes all the calculated volumes to become zero. So clearly we can do better, which is what this patch does.

At first blush, I'm surprised that you switch to using the sum of the edges in those cases. I would expect to ignore the degenerate 0-dimension, and calculate the volume using the other dimensions. So in a 3D space, you would calculate the increase of the area of the rectangle (A*B), not the sum of the edges (A+B). And it probably would be best to take into account how many of the dimensions are zero. So in a 3D space, if there is an existing line segment that the new point falls into, and also a rectangle that the new point falls into, you should prefer the 1-dimensional line segment over the 2-dimensional rectangle.

I don't know how big a difference that makes in practice. But it seems odd that if you e.g. have a set of 3D points, but the Z dimension in all of the points is 0, the algorithm behaves differently than if you had the exact same points in a 2D space.

(If this is explained in the RR*-tree paper, feel free to just point me to that and I'll ask again if I have further questions.)

- Heikki


--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers

Reply via email to