Introduced auto-deactivation into intelligent mode and a cache of queries for which aqo is deactivated to improve performance.

Author: tigvarts

README.md

@@ -43,9 +43,6 @@ on it, just add line "aqo.mode = 'intelligent'" into your postgresql.conf.
 Now this mode may work not good for rapidly changing data and query
 distributions, so it is better to reset extension manually when that happens.
 
-Intelligent mode also may decrease performance for workloads with a large frequency
-of fast simple queries. This drawback will be fixed soon.
-
 Please note that intelligent mode is not supposed to work with queries with
 dynamically generated structure. Nevertheless, dynamically generated constants
 are being handled well.

aqo--1.0.sql

@@ -58,3 +58,10 @@ ALTER COLUMN cardinality_error_with_aqo SET STORAGE MAIN;
 INSERT INTO aqo_queries VALUES (0, false, false, 0, false);
 INSERT INTO aqo_query_texts VALUES (0, 'COMMON feature space (do not delete!)');
 -- a virtual query for COMMON feature space
+
+CREATE FUNCTION invalidate_deactivated_queries_cache() RETURNS trigger
+	AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE TRIGGER aqo_queries_invalidate AFTER UPDATE OR DELETE OR TRUNCATE
+	ON aqo_queries FOR EACH STATEMENT
+	EXECUTE PROCEDURE invalidate_deactivated_queries_cache();

aqo.c

@@ -20,6 +20,7 @@ static const struct config_enum_entry format_options[] = {
 int			aqo_stat_size = 10;
 int			auto_tuning_window_size = 5;
 double		auto_tuning_exploration = 0.1;
+int			auto_tuning_max_iterations = 50;
 
 /* Machine learning parameters */
 double		object_selection_prediction_threshold = 0.3;
@@ -97,6 +98,7 @@ _PG_init(void)
 		&aqo_get_parameterized_joinrel_size;
 	prev_copy_generic_path_info_hook = copy_generic_path_info_hook;
 	copy_generic_path_info_hook = &aqo_copy_generic_path_info;
+	init_deactivated_queries_storage();
 }
 
 void
@@ -113,4 +115,15 @@ _PG_fini(void)
 	get_parameterized_joinrel_size_hook =
 		prev_get_parameterized_joinrel_size_hook;
 	copy_generic_path_info_hook = prev_copy_generic_path_info_hook;
+	fini_deactivated_queries_storage();
+}
+
+PG_FUNCTION_INFO_V1(invalidate_deactivated_queries_cache);
+
+Datum
+invalidate_deactivated_queries_cache(PG_FUNCTION_ARGS)
+{
+	fini_deactivated_queries_storage();
+	init_deactivated_queries_storage();
+	PG_RETURN_POINTER(NULL);
 }

aqo.h

@@ -132,6 +132,7 @@
 #include "utils/array.h"
 #include "utils/builtins.h"
 #include "utils/guc.h"
+#include "utils/hsearch.h"
 #include "utils/rel.h"
 #include "utils/tqual.h"
 #include "utils/fmgroids.h"
@@ -172,6 +173,7 @@ typedef struct
 extern int	aqo_stat_size;
 extern int	auto_tuning_window_size;
 extern double auto_tuning_exploration;
+extern int	auto_tuning_max_iterations;
 
 /* Machine learning parameters */
 extern double object_selection_prediction_threshold;
@@ -236,6 +238,10 @@ bool update_fss(int fss_hash, int nrows, int ncols,
 		   int old_nrows, List *changed_rows);
 QueryStat  *get_aqo_stat(int query_hash);
 void		update_aqo_stat(int query_hash, QueryStat * stat);
+void		init_deactivated_queries_storage(void);
+void		fini_deactivated_queries_storage(void);
+bool		query_is_deactivated(int query_hash);
+void		add_deactivated_query(int query_hash);
 
 /* Query preprocessing hooks */
 void		get_query_text(ParseState *pstate, Query *query);

auto_tuning.c

@@ -69,17 +69,22 @@ converged_cq(double *elems, int nelems)
  * If we find out that cardinality quality diverged during the exploration, we
  * return to step 2 and run the query type with both aqo usage and aqo learning
  * enabled until convergence.
+ * If after auto_tuning_max_iterations steps we consider that for this query
+ * it is better not to use aqo, we set auto_tuning, learn_aqo and use_aqo for
+ * this query to false.
  */
 void
-automatical_query_tuning(int query_hash, QueryStat * stat)
+automatical_query_tuning(int query_hash, QueryStat *stat)
 {
 	double		unstability = auto_tuning_exploration;
 	double		t_aqo,
 				t_not_aqo;
-	double		p_use;
+	double		p_use = -1;
+	long long	num_iterations;
 
+	num_iterations = stat->executions_with_aqo + stat->executions_without_aqo;
 	learn_aqo = true;
-	if (stat->executions_without_aqo < auto_tuning_window_size)
+	if (stat->executions_without_aqo < auto_tuning_window_size + 1)
 		use_aqo = false;
 	else if (!converged_cq(stat->cardinality_error_with_aqo,
 						   stat->cardinality_error_with_aqo_size))
@@ -103,5 +108,8 @@ automatical_query_tuning(int query_hash, QueryStat * stat)
 		learn_aqo = use_aqo;
 	}
 
-	update_query(query_hash, learn_aqo, use_aqo, fspace_hash, true);
+	if (num_iterations <= auto_tuning_max_iterations || p_use > 0.5)
+		update_query(query_hash, learn_aqo, use_aqo, fspace_hash, true);
+	else
+		update_query(query_hash, false, false, fspace_hash, false);
 }

preprocessing.c

@@ -81,7 +81,7 @@ call_default_planner(Query *parse,
  * This hook computes query_hash, and sets values of learn_aqo,
  * use_aqo and is_common flags for given query.
  * Creates an entry in aqo_queries for new type of query if it is
- * necessary, i. e. linking strategy is not "disabled".
+ * necessary, i. e. aqo mode is not "manual".
  */
 PlannedStmt *
 aqo_planner(Query *parse,
@@ -104,6 +104,13 @@ aqo_planner(Query *parse,
 	INSTR_TIME_SET_CURRENT(query_starttime);
 
 	query_hash = get_query_hash(parse, query_text);
+
+	if (query_is_deactivated(query_hash))
+	{
+		disable_aqo_for_query();
+		return call_default_planner(parse, cursorOptions, boundParams);
+	}
+
 	query_is_stored = find_query(query_hash, &query_params[0], &query_nulls[0]);
 
 	if (!query_is_stored)
@@ -151,7 +158,9 @@ aqo_planner(Query *parse,
 		use_aqo = DatumGetBool(query_params[2]);
 		fspace_hash = DatumGetInt32(query_params[3]);
 		auto_tuning = DatumGetBool(query_params[4]);
-		collect_stat = true;
+		collect_stat = learn_aqo || use_aqo || auto_tuning;
+		if (!collect_stat)
+			add_deactivated_query(query_hash);
 	}
 
 	return call_default_planner(parse, cursorOptions, boundParams);

storage.c

@@ -9,6 +9,8 @@
  *
  *****************************************************************************/
 
+HTAB  *deactivated_queries = NULL;
+
 static void deform_matrix(Datum datum, double **matrix);
 static void deform_vector(Datum datum, double *vector, int *nelems);
 static ArrayType *form_matrix(double **matrix, int nrows, int ncols);
@@ -832,3 +834,46 @@ my_simple_heap_update(Relation relation, ItemPointer otid, HeapTuple tup)
 			break;
 	}
 }
+
+/* Creates a storage for hashes of deactivated queries */
+void
+init_deactivated_queries_storage(void)
+{
+	HASHCTL	hash_ctl;
+
+	/* Create the hashtable proper */
+	MemSet(&hash_ctl, 0, sizeof(hash_ctl));
+	hash_ctl.keysize = sizeof(int);
+	hash_ctl.entrysize = sizeof(int);
+	deactivated_queries = hash_create("aqo_deactivated_queries",
+									  128,  /* start small and extend */
+									  &hash_ctl,
+									  HASH_ELEM);
+}
+
+/* Destroys the storage for hash of deactivated queries */
+void
+fini_deactivated_queries_storage(void)
+{
+	hash_destroy(deactivated_queries);
+	deactivated_queries = NULL;
+}
+
+/* Checks whether the query with given hash is deactivated */
+bool
+query_is_deactivated(int query_hash)
+{
+	bool	found;
+
+	hash_search(deactivated_queries, &query_hash, HASH_FIND, &found);
+	return found;
+}
+
+/* Adds given query hash into the set of hashes of deactivated queries*/
+void
+add_deactivated_query(int query_hash)
+{
+	bool	found;
+
+	hash_search(deactivated_queries, &query_hash, HASH_ENTER, &found);
+}