binaryheap.c File Reference

#include "postgres.h"
#include <math.h>
#include "lib/binaryheap.h"

Include dependency graph for binaryheap.c:

Go to the source code of this file.

Functions
static void	sift_down (binaryheap *heap, int node_off)
static void	sift_up (binaryheap *heap, int node_off)
binaryheap *	binaryheap_allocate (int capacity, binaryheap_comparator compare, void *arg)
void	binaryheap_reset (binaryheap *heap)
void	binaryheap_free (binaryheap *heap)
static int	left_offset (int i)
static int	right_offset (int i)
static int	parent_offset (int i)
void	binaryheap_add_unordered (binaryheap *heap, bh_node_type d)
void	binaryheap_build (binaryheap *heap)
void	binaryheap_add (binaryheap *heap, bh_node_type d)
bh_node_type	binaryheap_first (binaryheap *heap)
bh_node_type	binaryheap_remove_first (binaryheap *heap)
void	binaryheap_remove_node (binaryheap *heap, int n)
void	binaryheap_replace_first (binaryheap *heap, bh_node_type d)

Function Documentation

binaryheap_add()

void binaryheap_add	(	binaryheap *	heap,
		bh_node_type	d
	)

Definition at line 154 of file binaryheap.c.

{
    if (heap->bh_size >= heap->bh_space)
    {
#ifdef FRONTEND
        pg_fatal("out of binary heap slots");
#else
        elog(ERROR, "out of binary heap slots");
#endif
    }
    heap->bh_nodes[heap->bh_size] = d;
    heap->bh_size++;
    sift_up(heap, heap->bh_size - 1);
}

References binaryheap::bh_nodes, binaryheap::bh_size, binaryheap::bh_space, elog, ERROR, pg_fatal, and sift_up().

Referenced by move_to_ready_heap(), pgarch_readyXlog(), reduce_dependencies(), and TopoSort().

binaryheap_add_unordered()

void binaryheap_add_unordered	(	binaryheap *	heap,
		bh_node_type	d
	)

Definition at line 116 of file binaryheap.c.

{
    if (heap->bh_size >= heap->bh_space)
    {
#ifdef FRONTEND
        pg_fatal("out of binary heap slots");
#else
        elog(ERROR, "out of binary heap slots");
#endif
    }
    heap->bh_has_heap_property = false;
    heap->bh_nodes[heap->bh_size] = d;
    heap->bh_size++;
}

References binaryheap::bh_has_heap_property, binaryheap::bh_nodes, binaryheap::bh_size, binaryheap::bh_space, elog, ERROR, and pg_fatal.

Referenced by BufferSync(), ExecMergeAppend(), gather_merge_init(), pgarch_readyXlog(), ReorderBufferIterTXNInit(), and TopoSort().

binaryheap_allocate()

binaryheap * binaryheap_allocate	(	int	capacity,
		binaryheap_comparator	compare,
		void *	arg
	)

Definition at line 39 of file binaryheap.c.

{
    int         sz;
    binaryheap *heap;
 
    sz = offsetof(binaryheap, bh_nodes) + sizeof(bh_node_type) * capacity;
    heap = (binaryheap *) palloc(sz);
    heap->bh_space = capacity;
    heap->bh_compare = compare;
    heap->bh_arg = arg;
 
    heap->bh_size = 0;
    heap->bh_has_heap_property = true;
 
    return heap;
}

References arg, binaryheap::bh_arg, binaryheap::bh_compare, binaryheap::bh_has_heap_property, binaryheap::bh_size, binaryheap::bh_space, compare(), and palloc().

Referenced by BufferSync(), ExecInitMergeAppend(), gather_merge_setup(), PgArchiverMain(), ReorderBufferIterTXNInit(), restore_toc_entries_parallel(), and TopoSort().

binaryheap_build()

void binaryheap_build

(

binaryheap *

heap

)

Definition at line 138 of file binaryheap.c.

{
    int         i;
 
    for (i = parent_offset(heap->bh_size - 1); i >= 0; i--)
        sift_down(heap, i);
    heap->bh_has_heap_property = true;
}

References binaryheap::bh_has_heap_property, binaryheap::bh_size, i, parent_offset(), and sift_down().

Referenced by BufferSync(), ExecMergeAppend(), gather_merge_init(), pgarch_readyXlog(), ReorderBufferIterTXNInit(), and TopoSort().

binaryheap_first()

bh_node_type binaryheap_first

(

binaryheap *

heap

)

Definition at line 177 of file binaryheap.c.

{
    Assert(!binaryheap_empty(heap) && heap->bh_has_heap_property);
    return heap->bh_nodes[0];
}

References Assert(), binaryheap::bh_has_heap_property, binaryheap::bh_nodes, and binaryheap_empty.

Referenced by BufferSync(), ExecMergeAppend(), gather_merge_getnext(), pgarch_readyXlog(), and ReorderBufferIterTXNNext().

binaryheap_free()

void binaryheap_free

(

binaryheap *

heap

)

Definition at line 75 of file binaryheap.c.

{
    pfree(heap);
}

References pfree().

Referenced by BufferSync(), ReorderBufferIterTXNFinish(), restore_toc_entries_parallel(), and TopoSort().

binaryheap_remove_first()

bh_node_type binaryheap_remove_first

(

binaryheap *

heap

)

Definition at line 192 of file binaryheap.c.

{
    bh_node_type result;
 
    Assert(!binaryheap_empty(heap) && heap->bh_has_heap_property);
 
    /* extract the root node, which will be the result */
    result = heap->bh_nodes[0];
 
    /* easy if heap contains one element */
    if (heap->bh_size == 1)
    {
        heap->bh_size--;
        return result;
    }
 
    /*
     * Remove the last node, placing it in the vacated root entry, and sift
     * the new root node down to its correct position.
     */
    heap->bh_nodes[0] = heap->bh_nodes[--heap->bh_size];
    sift_down(heap, 0);
 
    return result;
}

References Assert(), binaryheap::bh_has_heap_property, binaryheap::bh_nodes, binaryheap::bh_size, binaryheap_empty, and sift_down().

Referenced by BufferSync(), ExecMergeAppend(), gather_merge_getnext(), pgarch_readyXlog(), ReorderBufferIterTXNNext(), and TopoSort().

binaryheap_remove_node()

void binaryheap_remove_node	(	binaryheap *	heap,
		int	n
	)

Definition at line 225 of file binaryheap.c.

{
    int         cmp;
 
    Assert(!binaryheap_empty(heap) && heap->bh_has_heap_property);
    Assert(n >= 0 && n < heap->bh_size);
 
    /* compare last node to the one that is being removed */
    cmp = heap->bh_compare(heap->bh_nodes[--heap->bh_size],
                           heap->bh_nodes[n],
                           heap->bh_arg);
 
    /* remove the last node, placing it in the vacated entry */
    heap->bh_nodes[n] = heap->bh_nodes[heap->bh_size];
 
    /* sift as needed to preserve the heap property */
    if (cmp > 0)
        sift_up(heap, n);
    else if (cmp < 0)
        sift_down(heap, n);
}

References Assert(), binaryheap::bh_arg, binaryheap::bh_compare, binaryheap::bh_has_heap_property, binaryheap::bh_nodes, binaryheap::bh_size, binaryheap_empty, cmp(), sift_down(), and sift_up().

Referenced by pop_next_work_item().

binaryheap_replace_first()

void binaryheap_replace_first	(	binaryheap *	heap,
		bh_node_type	d
	)

Definition at line 255 of file binaryheap.c.

{
    Assert(!binaryheap_empty(heap) && heap->bh_has_heap_property);
 
    heap->bh_nodes[0] = d;
 
    if (heap->bh_size > 1)
        sift_down(heap, 0);
}

References Assert(), binaryheap::bh_has_heap_property, binaryheap::bh_nodes, binaryheap::bh_size, binaryheap_empty, and sift_down().

Referenced by BufferSync(), ExecMergeAppend(), gather_merge_getnext(), and ReorderBufferIterTXNNext().

binaryheap_reset()

void binaryheap_reset

(

binaryheap *

heap

)

Definition at line 63 of file binaryheap.c.

{
    heap->bh_size = 0;
    heap->bh_has_heap_property = true;
}

References binaryheap::bh_has_heap_property, and binaryheap::bh_size.

Referenced by ExecReScanMergeAppend(), gather_merge_init(), and pgarch_readyXlog().

left_offset()

static int left_offset ( int  i )

inlinestatic

Definition at line 90 of file binaryheap.c.

{
    return 2 * i + 1;
}

References i.

Referenced by sift_down().

parent_offset()

static int parent_offset ( int  i )

inlinestatic

Definition at line 102 of file binaryheap.c.

{
    return (i - 1) / 2;
}

References i.

Referenced by binaryheap_build(), and sift_up().

right_offset()

static int right_offset ( int  i )

inlinestatic

Definition at line 96 of file binaryheap.c.

{
    return 2 * i + 2;
}

References i.

Referenced by sift_down().

sift_down()

static void sift_down ( binaryheap *  heap, int  node_off  )

static

Definition at line 313 of file binaryheap.c.

{
    bh_node_type node_val = heap->bh_nodes[node_off];
 
    /*
     * Within the loop, the node_off'th array entry is a "hole" that
     * notionally holds node_val, but we don't actually store node_val there
     * till the end, saving some unnecessary data copying steps.
     */
    while (true)
    {
        int         left_off = left_offset(node_off);
        int         right_off = right_offset(node_off);
        int         swap_off = left_off;
 
        /* Is the right child larger than the left child? */
        if (right_off < heap->bh_size &&
            heap->bh_compare(heap->bh_nodes[left_off],
                             heap->bh_nodes[right_off],
                             heap->bh_arg) < 0)
            swap_off = right_off;
 
        /*
         * If no children or parent is >= the larger child, heap condition is
         * satisfied, and we're done.
         */
        if (left_off >= heap->bh_size ||
            heap->bh_compare(node_val,
                             heap->bh_nodes[swap_off],
                             heap->bh_arg) >= 0)
            break;
 
        /*
         * Otherwise, swap the hole with the child that violates the heap
         * property; then go on to check its children.
         */
        heap->bh_nodes[node_off] = heap->bh_nodes[swap_off];
        node_off = swap_off;
    }
    /* Re-fill the hole */
    heap->bh_nodes[node_off] = node_val;
}

References binaryheap::bh_arg, binaryheap::bh_compare, binaryheap::bh_nodes, binaryheap::bh_size, left_offset(), and right_offset().

Referenced by binaryheap_build(), binaryheap_remove_first(), binaryheap_remove_node(), and binaryheap_replace_first().

sift_up()

static void sift_up ( binaryheap *  heap, int  node_off  )

static

Definition at line 270 of file binaryheap.c.

{
    bh_node_type node_val = heap->bh_nodes[node_off];
 
    /*
     * Within the loop, the node_off'th array entry is a "hole" that
     * notionally holds node_val, but we don't actually store node_val there
     * till the end, saving some unnecessary data copying steps.
     */
    while (node_off != 0)
    {
        int         cmp;
        int         parent_off;
        bh_node_type parent_val;
 
        /*
         * If this node is smaller than its parent, the heap condition is
         * satisfied, and we're done.
         */
        parent_off = parent_offset(node_off);
        parent_val = heap->bh_nodes[parent_off];
        cmp = heap->bh_compare(node_val,
                               parent_val,
                               heap->bh_arg);
        if (cmp <= 0)
            break;
 
        /*
         * Otherwise, swap the parent value with the hole, and go on to check
         * the node's new parent.
         */
        heap->bh_nodes[node_off] = parent_val;
        node_off = parent_off;
    }
    /* Re-fill the hole */
    heap->bh_nodes[node_off] = node_val;
}

References binaryheap::bh_arg, binaryheap::bh_compare, binaryheap::bh_nodes, cmp(), and parent_offset().

Referenced by binaryheap_add(), and binaryheap_remove_node().