Make the optimiser aware of the parallel temp scan

Consider the extra cost of flushing temporary tables in partial path
comparisons. With this commit, the optimiser gains a rationale for cost-based
decision on enabling the parallel scan of subtrees that include temporary
tables. It is achieved by adding to the path comparison routine an extra
'flush buffers' weighting factor.

It is trivial to calculate the cost by tracking the number of dirtied temporary
buffers and multiplying it by the write_page_cost parameter.
The functions compare_path_costs and compare_fractional_path_costs
were modified to account for this additional factor.

Author: danolivo

src/backend/optimizer/path/costsize.c

@@ -104,6 +104,7 @@
 #include "optimizer/plancat.h"
 #include "optimizer/restrictinfo.h"
 #include "parser/parsetree.h"
+#include "storage/bufmgr.h"
 #include "utils/lsyscache.h"
 #include "utils/selfuncs.h"
 #include "utils/spccache.h"
@@ -129,6 +130,7 @@
 
 double		seq_page_cost = DEFAULT_SEQ_PAGE_COST;
 double		random_page_cost = DEFAULT_RANDOM_PAGE_COST;
+double		write_page_cost = DEFAULT_WRITE_PAGE_COST;
 double		cpu_tuple_cost = DEFAULT_CPU_TUPLE_COST;
 double		cpu_index_tuple_cost = DEFAULT_CPU_INDEX_TUPLE_COST;
 double		cpu_operator_cost = DEFAULT_CPU_OPERATOR_COST;
@@ -6655,3 +6657,25 @@ compute_gather_rows(Path *path)
 
 	return clamp_row_est(path->rows * get_parallel_divisor(path));
 }
+
+/*
+ * Before the launch parallel workers in a SELECT query, the leader process must
+ * flush all dirty pages in temp buffers to guarantee equal access to the data
+ * in each parallel worker.
+ * It seems difficult to calculate specific set of tables, indexes and toasts
+ * that may be touched inside the subtree. Moreover, stored procedures may also
+ * scan temporary tables. So, it makes sense to flush all temporary buffers.
+ * Here we calculate the cost of such operation to allow small queries do not
+ * activate expensive parallel scan over temp resources.
+ */
+Cost
+tempbuf_flush_extra_cost()
+{
+	if (!extended_parallel_processing)
+		/* Fast exit if feature is disabled */
+		return 0.0;
+
+	/* Hopefully, we have an statistics on the number of dirtied buffers */
+	Assert(dirtied_localbufs >= 0);
+	return write_page_cost * dirtied_localbufs;
+}

src/backend/optimizer/util/pathnode.c

@@ -69,6 +69,12 @@ static bool pathlist_is_reparameterizable_by_child(List *pathlist,
 int
 compare_path_costs(Path *path1, Path *path2, CostSelector criterion)
 {
+	Cost startup_cost1 = path1->startup_cost;
+	Cost startup_cost2 = path2->startup_cost;
+	Cost total_cost1 = path1->total_cost;
+	Cost total_cost2 = path2->total_cost;
+	Cost extra_cost = tempbuf_flush_extra_cost();
+
 	/* Number of disabled nodes, if different, trumps all else. */
 	if (unlikely(path1->disabled_nodes != path2->disabled_nodes))
 	{
@@ -78,35 +84,50 @@ compare_path_costs(Path *path1, Path *path2, CostSelector criterion)
 			return +1;
 	}
 
+	/*
+	 * Add an extra cost of temporary buffers flushing fofr the time
+	 * of comparison only.
+	 */
+	if (path1->parallel_safe == NEEDS_TEMP_FLUSH)
+	{
+		startup_cost1 += extra_cost;
+		total_cost1 += extra_cost;
+	}
+	if (path2->parallel_safe == NEEDS_TEMP_FLUSH)
+	{
+		startup_cost2 += extra_cost;
+		total_cost2 += extra_cost;
+	}
+
 	if (criterion == STARTUP_COST)
 	{
-		if (path1->startup_cost < path2->startup_cost)
+		if (startup_cost1 < startup_cost2)
 			return -1;
-		if (path1->startup_cost > path2->startup_cost)
+		if (startup_cost1 > startup_cost2)
 			return +1;
 
 		/*
 		 * If paths have the same startup cost (not at all unlikely), order
 		 * them by total cost.
 		 */
-		if (path1->total_cost < path2->total_cost)
+		if (total_cost1 < total_cost2)
 			return -1;
-		if (path1->total_cost > path2->total_cost)
+		if (total_cost1 > total_cost2)
 			return +1;
 	}
 	else
 	{
-		if (path1->total_cost < path2->total_cost)
+		if (total_cost1 < total_cost2)
 			return -1;
-		if (path1->total_cost > path2->total_cost)
+		if (total_cost1 > total_cost2)
 			return +1;
 
 		/*
 		 * If paths have the same total cost, order them by startup cost.
 		 */
-		if (path1->startup_cost < path2->startup_cost)
+		if (startup_cost1 < startup_cost2)
 			return -1;
-		if (path1->startup_cost > path2->startup_cost)
+		if (startup_cost1 > startup_cost2)
 			return +1;
 	}
 	return 0;

src/backend/utils/misc/guc_parameters.dat

@@ -3502,6 +3502,15 @@
   max => 'MAX_KILOBYTES',
 },
 
+
+{ name => 'write_page_cost', type => 'real', context => 'PGC_USERSET', group => 'QUERY_TUNING_COST',
+  short_desc => 'Sets the planner\'s estimate of the cost of a disk page flushing.',
+  flags => 'GUC_EXPLAIN',
+  variable => 'write_page_cost',
+  boot_val => 'DEFAULT_WRITE_PAGE_COST',
+  min => '0',
+  max => 'DBL_MAX',
+},
 { name => 'xmlbinary', type => 'enum', context => 'PGC_USERSET', group => 'CLIENT_CONN_STATEMENT',
   short_desc => 'Sets how binary values are to be encoded in XML.',
   variable => 'xmlbinary',

src/backend/utils/misc/postgresql.conf.sample

@@ -435,6 +435,7 @@
 
 #seq_page_cost = 1.0                    # measured on an arbitrary scale
 #random_page_cost = 4.0                 # same scale as above
+#write_page_cost = 5.0                  # same scale as above
 #cpu_tuple_cost = 0.01                  # same scale as above
 #cpu_index_tuple_cost = 0.005           # same scale as above
 #cpu_operator_cost = 0.0025             # same scale as above

src/include/optimizer/cost.h

@@ -23,6 +23,7 @@
 /* If you change these, update backend/utils/misc/postgresql.conf.sample */
 #define DEFAULT_SEQ_PAGE_COST  1.0
 #define DEFAULT_RANDOM_PAGE_COST  4.0
+#define DEFAULT_WRITE_PAGE_COST	5.0 /* Make it a little more than random read. */
 #define DEFAULT_CPU_TUPLE_COST	0.01
 #define DEFAULT_CPU_INDEX_TUPLE_COST 0.005
 #define DEFAULT_CPU_OPERATOR_COST  0.0025
@@ -222,5 +223,6 @@ extern double compute_bitmap_pages(PlannerInfo *root, RelOptInfo *baserel,
 								   Path *bitmapqual, double loop_count,
 								   Cost *cost_p, double *tuples_p);
 extern double compute_gather_rows(Path *path);
+extern Cost tempbuf_flush_extra_cost(void);
 
 #endif							/* COST_H */

src/include/optimizer/optimizer.h

@@ -72,6 +72,7 @@ extern Selectivity clauselist_selectivity_ext(PlannerInfo *root,
 /* widely used cost parameters */
 extern PGDLLIMPORT double seq_page_cost;
 extern PGDLLIMPORT double random_page_cost;
+extern PGDLLIMPORT double write_page_cost;
 extern PGDLLIMPORT double cpu_tuple_cost;
 extern PGDLLIMPORT double cpu_index_tuple_cost;
 extern PGDLLIMPORT double cpu_operator_cost;