Exemple #1
0
/*
 * Prepare heap (expand lv) at postion cur.
 */
static void
mkheap_prep_siftdown_lv(MKHeap *mkheap, int lv, int cur, MKContext *mkctxt)
{
	bool		expchild = false;

	int			c;

	Assert(cur < mkheap->maxentry);
	Assert(cur >= 0);

	/* If necessary, expand right */
	if (RIGHT(cur) < mkheap->maxentry)
	{
		c = mkheap_compare(mkheap, mkheap->p + cur, mkheap->p + RIGHT(cur));
		if (c == 0)
		{
			mkheap_prep_siftdown_lv(mkheap, lv, RIGHT(cur), mkctxt);
			expchild = true;
		}
	}

	/* If necessary, expand left */
	if (LEFT(cur) < mkheap->maxentry)
	{
		c = mkheap_compare(mkheap, mkheap->p + cur, mkheap->p + LEFT(cur));
		if (c == 0)
		{
			mkheap_prep_siftdown_lv(mkheap, lv, LEFT(cur), mkctxt);
			expchild = true;
		}
	}

	Assert(mke_get_lv(mkheap->p + cur) == lv - 1);
	if (mkheap->mkctxt->fetchForPrep)
		tupsort_prepare(mkheap->p + cur, mkctxt, lv);

	mke_set_lv(mkheap->p + cur, lv);

	if (expchild)
	{
		MKEntry		tmp = mkheap->p[cur];

		mkheap_siftdown(mkheap, cur, &tmp);
	}
}
/*
 * Update all lvtops entries. The lvtops entries whose array index is not greater
 * than the level value stored in the current top element in the heap, update them
 * with the value from the top element in the heap. This function also cleans up
 * the remaining lvtops entries.
 *
 * This is needed after the current top entry in the heap is removed from the heap, since
 * some lvtops' ptr may point to the tuple that could be freed when its associated entry
 * is removed from the heap.
 */
static void mkheap_update_lvtops(MKHeap *mkheap)
{
	int top_lv = mke_get_lv(mkheap->p);

	for (int lv = 0; lv < mkheap->mkctxt->total_lv; lv++)
	{
		MKEntry *lvEntry = mkheap->lvtops + lv;
		MKEntry *srcEntry = NULL;
		
		if (lv <= top_lv)
		{
			srcEntry = mkheap->p;

			if ( mkheap->mkctxt->fetchForPrep)
				tupsort_prepare(mkheap->p, mkheap->mkctxt, lv);
		}

		(*mkheap->mkctxt->cpfr)(lvEntry, srcEntry, mkheap->mkctxt->lvctxt + lv);

		/* Set the correct level */
		mke_set_lv(lvEntry, lv);
	}
}
void mkheap_verify_heap(MKHeap *heap, int top)
{
    int empty_cnt = 0;
    int i;
    MKEntry e;

    if(heap->count == 0)
        return;

    Assert(heap->count > 0);
    Assert(heap->maxentry > 0);
    Assert(heap->count <= heap->maxentry);
    Assert(heap->maxentry <= heap->alloc_size);

    e = heap->p[0];
    mke_set_lv(&e, 0);
    mke_clear_refc_copied(&e);

    /* Checking for lvtops */
    for(i=0; i<mke_get_lv(heap->p); ++i)
    {
        int c;

        /* Too much trouble dealing with ref counters.  Just don't */
        /*
           if(!mke_test_flag(heap->lvtops+i, MKE_RefCnt | MKE_Copied))
           {
         */
        mke_set_lv(&e, i);
        if ( heap->mkctxt->fetchForPrep)
        	tupsort_prepare(&e, heap->mkctxt, i);

        c = mkheap_compare(heap, &e, heap->lvtops+i);
        Assert(c==0);
        /*
           }
         */
    }

    /* Verify Heap property */
    for(i=top; i<heap->maxentry; ++i)
    {
        int left = LEFT(i);
        int right = RIGHT(i);
        int cl, cr;

        if(mke_is_empty(heap->p+i))
            ++empty_cnt;

        if(left >= heap->maxentry)
            continue;

        cl = mkheap_compare(heap, heap->p+i, heap->p+left);
        Assert(cl<=0);
        if(i==0 && cl==0)
            Assert(mke_get_lv(heap->p) == heap->mkctxt->total_lv-1);

        if(right >= heap->maxentry)
            continue;

        cr = mkheap_compare(heap, heap->p+i, heap->p+right);
        Assert(cr<=0);
        if(i==0 && cr==0)
            Assert(mke_get_lv(heap->p) == heap->mkctxt->total_lv-1);
    }
}
/*
 * Insert an entry and perhaps return the top element of the heap in *e
 *
 * Comparison happens from the specified level to the end of levels, as needed:
 *   Return < 0 if smaller than heap top; *e is unchanged
 *   Return = 0 if eq to heap top ; *e is unchanged (but will have value equal to the heap top)
 *   Return > 0 if successfully inserted; *e is populated with the removed heap top
 *
 * If 0 would be returned but the heap is marked as needing uniqueness enforcement, error is generated instead
 */
static int mkheap_putAndGet_impl(MKHeap *mkheap, MKEntry *e)
{
    int c = 0;
    int toplv;
    MKEntry tmp;

    /* can't put+get from an empty heap */
    Assert(mkheap->count > 0);

    if ( mkheap->mkctxt->enforceUnique &&
         mke_has_duplicates_with_root(mkheap))
    {
        /**
         * See NOTE ON UNIQUENESS CHECKING in the comment at the top of the file
         * for information about why we check for duplicates here
         */
        ERROR_UNIQUENESS_VIOLATED();
    }

    if(mke_is_empty(e))
    {
    	/* adding an empty (sentinel): just remove from count and fallthrough to where top is removed */
    	--mkheap->count;
    }
    else if (mke_get_run(e) != mke_get_run(mkheap->p))
    {
    	/* this code assumes that the new one, with lower run, is LARGER than the top -- so it must be larger run */
    	Assert(mke_get_run(e) > mke_get_run(mkheap->p));

    	/* when the runs differ it is because we attempted once with the runs equal.
    	 *   So if level is zero then:  the level was zero AND validly prepared for the previous run -- and there is no need to prep again
    	 */
    	if ( mke_get_lv(e) != 0 )
    	{
			/* Not same run, at least prepare lv 0 */
			if ( mkheap->mkctxt->fetchForPrep)
				tupsort_prepare(e, mkheap->mkctxt, 0);
			mke_set_lv(e, 0);
    	}

        /* now fall through and let top be returned, new one is also inserted so no change to count */
    }
    else
    {
    	/* same run so figure out where it fits in relation to the heap top */
        int lv = 0;

        toplv = mke_get_lv(mkheap->p);
        mke_set_lv(e, lv);

        /* populate level until we differ from the top element of the heap */
        while (lv < toplv)
        {
        	if ( mkheap->mkctxt->fetchForPrep)
				tupsort_prepare(e, mkheap->mkctxt, lv);
            c = mkheap_compare(mkheap, e, mkheap->lvtops+lv);
            if(c!=0)
                break;

            mke_set_lv(e, ++lv);
        }

        /* smaller than top */
        if(c<0)
            return -1;

        /* we have not done e->lv == toplv yet since we increment at the end of the previous loop.  Do it now. */
        Assert(mke_get_lv(e) == lv);
        if(lv == toplv)
        {
        	if ( mkheap->mkctxt->fetchForPrep)
				tupsort_prepare(e, mkheap->mkctxt, lv);
            c = mkheap_compare(mkheap, e, mkheap->p);
            if(c < 0)
                return -1;
        }

        if(c==0)
        {
            /*
             * Equal and at top level.
             *
             * This means that e is less-than/equal to all entries except the heap top.
             */
            Assert(mke_get_lv(e) == lv);
            Assert(lv == mke_get_lv(mkheap->p));

            /*
             * Expand more levels of lvtop in the current top and the new one until we detect a difference.
             */
			while(lv < mkheap->mkctxt->total_lv - 1)
            {
                mkheap_save_lvtop(mkheap);

                ++lv;

                /* expand top */
                if ( mkheap->mkctxt->fetchForPrep)
					tupsort_prepare(mkheap->p, mkheap->mkctxt, lv);

            	/* expand new element */
                if ( mkheap->mkctxt->fetchForPrep)
					tupsort_prepare(e, mkheap->mkctxt, lv);

                mke_set_lv(mkheap->p, lv);
				mke_set_lv(e, lv);

                c = mkheap_compare(mkheap, e, mkheap->p);
                if(c != 0)
                    break;
            }

            if(c<=0)
            {
            	/* if new one is less than current top then we just return that negative comparison */
            	/* if new one equals the current top then we could do an insert and immediate removal -- but it
            	 *    won't matter so we simply return right away, leaving *e untouched */

                /* enforce uniqueness first */
                if(c == 0 && mkheap->mkctxt->enforceUnique)
                {
                    ERROR_UNIQUENESS_VIOLATED();
                }

            	return c;
            }
        }
    }

    /* Now, I am bigger than top but not definitely smaller/equal to all other entries
     *
     * So we will:
     *    return top as *e
     *    do heap shuffling to restore heap ordering
     */
    tmp = *e;
    *e = mkheap->p[0];

    /* Sift down a hole to bottom of (current or next) run, depends on tmp.run */
    mkheap_siftdown(mkheap, 0, &tmp);

    if(mkheap_need_heapify(mkheap))
        mkheap_heapify(mkheap, false);

	if (mkheap->count > 0)
	{
		mkheap_update_lvtops(mkheap);
	}

#ifdef USE_ASSERT_CHECKING
    if(gp_mk_sort_check)
        mkheap_verify_heap(mkheap, 0);
#endif

    return 1;
}