Add some CHECK_FOR_INTERRUPTS() calls to the heap-sort call path.

robertmhaas · robertmhaas · commit aefa6d163e21 · 2012-03-20T21:26:39.000-04:00
I broke this in commit 337b6f5, which among other things arranged for quicksorts to CHECK_FOR_INTERRUPTS() slightly less frequently. Sadly, it also arranged for heapsorts to CHECK_FOR_INTERRUPTS() much less frequently. Repair.
diff --git a/src/backend/utils/sort/tuplesort.c b/src/backend/utils/sort/tuplesort.c
@@ -1168,6 +1168,7 @@ puttuple_common(Tuplesortstate *state, SortTuple *tuple)
 			{
 				/* new tuple <= top of the heap, so we can discard it */
 				free_sort_tuple(state, tuple);
+				CHECK_FOR_INTERRUPTS();
 			}
 			else
 			{
@@ -2431,6 +2432,7 @@ make_bounded_heap(Tuplesortstate *state)
 		{
 			/* New tuple would just get thrown out, so skip it */
 			free_sort_tuple(state, &state->memtuples[i]);
+			CHECK_FOR_INTERRUPTS();
 		}
 		else
 		{
@@ -2518,6 +2520,8 @@ tuplesort_heap_insert(Tuplesortstate *state, SortTuple *tuple,
 	memtuples = state->memtuples;
 	Assert(state->memtupcount < state->memtupsize);
 
+	CHECK_FOR_INTERRUPTS();
+
 	/*
 	 * Sift-up the new entry, per Knuth 5.2.3 exercise 16. Note that Knuth is
 	 * using 1-based array indexes, not 0-based.
@@ -2549,6 +2553,9 @@ tuplesort_heap_siftup(Tuplesortstate *state, bool checkIndex)
 
 	if (--state->memtupcount <= 0)
 		return;
+
+	CHECK_FOR_INTERRUPTS();
+
 	n = state->memtupcount;
 	tuple = &memtuples[n];		/* tuple that must be reinserted */
 	i = 0;						/* i is where the "hole" is */

Original file line number	Diff line number	Diff line change
`@@ -1168,6 +1168,7 @@ puttuple_common(Tuplesortstate state, SortTuple tuple)`
`1168`	`1168`	`{`
`1169`	`1169`	`/* new tuple <= top of the heap, so we can discard it */`
`1170`	`1170`	`free_sort_tuple(state, tuple);`
	`1171`	`+ CHECK_FOR_INTERRUPTS();`
`1171`	`1172`	`}`
`1172`	`1173`	`else`
`1173`	`1174`	`{`
`@@ -2431,6 +2432,7 @@ make_bounded_heap(Tuplesortstate *state)`
`2431`	`2432`	`{`
`2432`	`2433`	`/* New tuple would just get thrown out, so skip it */`
`2433`	`2434`	`free_sort_tuple(state, &state->memtuples[i]);`
	`2435`	`+ CHECK_FOR_INTERRUPTS();`
`2434`	`2436`	`}`
`2435`	`2437`	`else`
`2436`	`2438`	`{`
`@@ -2518,6 +2520,8 @@ tuplesort_heap_insert(Tuplesortstate state, SortTuple tuple,`
`2518`	`2520`	`memtuples = state->memtuples;`
`2519`	`2521`	`Assert(state->memtupcount < state->memtupsize);`
`2520`	`2522`
	`2523`	`+ CHECK_FOR_INTERRUPTS();`
	`2524`	`+`
`2521`	`2525`	`/*`
`2522`	`2526`	`* Sift-up the new entry, per Knuth 5.2.3 exercise 16. Note that Knuth is`
`2523`	`2527`	`* using 1-based array indexes, not 0-based.`
`@@ -2549,6 +2553,9 @@ tuplesort_heap_siftup(Tuplesortstate *state, bool checkIndex)`
`2549`	`2553`
`2550`	`2554`	`if (--state->memtupcount <= 0)`
`2551`	`2555`	`return;`
	`2556`	`+`
	`2557`	`+ CHECK_FOR_INTERRUPTS();`
	`2558`	`+`
`2552`	`2559`	`n = state->memtupcount;`
`2553`	`2560`	`tuple = &memtuples[n]; /* tuple that must be reinserted */`
`2554`	`2561`	`i = 0; /* i is where the "hole" is */`