Initial Commit.

Co-authored-by: Gang Xiong <[email protected]>
Co-authored-by: Ning Yu <[email protected]>

Author: 3 people

Makefile

@@ -0,0 +1,19 @@
+MODULE_big = vectorize_engine
+
+EXTENSION = vectorize_engine
+DATA = vectorize_engine--1.0.sql
+
+PGFILEDESC = "vectorize engine for PostgreSQL"
+
+REGRESS = vectorize_engine
+
+OBJS += vectorEngine.o nodeSeqscan.o nodeAgg.o nodeUnbatch.o execScan.o plan.o utils.o execTuples.o execQual.o vectorTupleSlot.o
+OBJS += vtype/vtype.o vtype/vtimestamp.o vtype/vint.o vtype/vfloat.o vtype/vpseudotypes.o vtype/vvarchar.o vtype/vdate.o
+
+# print vectorize info when compile
+# PG_CFLAGS = -fopt-info-vec
+
+PG_CFLAGS = -Wno-int-in-bool-context
+PG_CONFIG = pg_config
+PGXS := $(shell $(PG_CONFIG) --pgxs)
+include $(PGXS)

README.md

@@ -0,0 +1,79 @@
+## About
+Vectorize Execution is an extension for Postgres which utilize vectorized technique to accelerate query execution.
+
+Vectorize Execution is based on Postgres 9.6 now, and will support newer Postgres version soon.
+
+## Design
+Below are features in our design.
+1.  Pure extension. We didn't hack any code into postgres kernel.
+2.  CustomScan node. We use CustomScan framework to replace original executor node such as SeqScan, Agg etc.
+    Based on CustomScan, we could extend the CustomScanState, BeginCustomScan(), ExecCustomScan(), EndCustomScan()
+    interface and implement vectorize executor node.
+3.  Post planner hook. After plan is generated, we use plan_tree_walker to traverse the plan tree and check whether
+    it could be vectorized. If yes, we will replace non-vectorized node(seqscan, agg etc.) with vectorized node(in
+    form of customscan node) and use vectorized executor. If no, we will revert to the original plan and use non-vectorized executor.
+4.  Inherit original executor code. Instead of rewriting the whole executor, we choose a more smooth method to modify
+    current Postgres executor node and make it vectorized. We copy the current executor node into our extension, and
+    add vectorize logic based on it. When Postgres enchance its executor, we could relatively easily merge them back.
+5.  Pluggable storage. Postgres has supported pluggable storage now. TupleTableSlot is refactored as abstract struct
+    TupleTableSlotOps. We will implement VectorTupleTableSlot in our extension when we upgrade the extension to latest PG.
+
+## Usage
+1.  Add GCC SIMD support option in configure when building Postgres. `-march=native`
+2.  Build & Install.  `cd vectorize_engine; make install`
+3.  Config postgres.conf & Restart database.  `shared_preload_libraries = 'vectorize_engine'`
+4.  Run test.  `make installcheck`
+5.  Initialize at database level. `create extension vectorize_engine;`
+6.  Enable by GUC(default off). `set enable_vectorize_engine to on;`
+
+## Performance
+We run TPC-H 10G Q1 on machine at GCP(24G memory, 8 Core Intel(R) Xeon(R) CPU @ 2.20GHz).
+
+standard PG run 50s and PG with vectorize engine version run 28s.
+
+lineitem is stored as heap table with schema is as follows
+```
+              Table "public.lineitem"
+     Column      |         Type          | Modifiers
+-----------------+-----------------------+-----------
+ l_orderkey      | bigint                | not null
+ l_partkey       | integer               | not null
+ l_suppkey       | integer               | not null
+ l_linenumber    | integer               | not null
+ l_quantity      | double precision      | not null
+ l_extendedprice | double precision      | not null
+ l_discount      | double precision      | not null
+ l_tax           | double precision      | not null
+ l_returnflag    | character(1)          | not null
+ l_linestatus    | character(1)          | not null
+ l_shipdate      | date                  | not null
+ l_commitdate    | date                  | not null
+ l_receiptdate   | date                  | not null
+ l_shipinstruct  | character(25)         | not null
+ l_shipmode      | character(10)         | not null
+ l_comment       | character varying(44) | not null
+```
+
+
+TPC-H Q1 is
+```
+select
+    l_returnflag,
+    l_linestatus,
+    sum(l_quantity) as sum_qty,
+    sum(l_extendedprice) as sum_base_price,
+    sum(l_extendedprice * (1 - l_discount)) as sum_disc_price,
+    sum(l_extendedprice * (1 - l_discount) * (1 + l_tax)) as sum_charge,
+    avg(l_quantity) as avg_qty,
+    avg(l_extendedprice) as avg_price,
+    avg(l_discount) as avg_disc,
+    count(l_discount) as count_order
+from
+    lineitem1
+where
+    l_shipdate <= date '1998-12-01' - interval '106 day'
+group by
+    l_returnflag,
+    l_linestatus;
+```
+

execQual.c

@@ -0,0 +1,123 @@
+#include "postgres.h"
+
+#include "access/htup_details.h"
+#include "access/nbtree.h"
+#include "access/tupconvert.h"
+#include "catalog/objectaccess.h"
+#include "catalog/pg_type.h"
+#include "executor/execdebug.h"
+#include "executor/nodeSubplan.h"
+#include "funcapi.h"
+#include "miscadmin.h"
+#include "nodes/makefuncs.h"
+#include "nodes/nodeFuncs.h"
+#include "optimizer/planner.h"
+#include "parser/parse_coerce.h"
+#include "parser/parsetree.h"
+#include "pgstat.h"
+#include "utils/acl.h"
+#include "utils/builtins.h"
+#include "utils/lsyscache.h"
+#include "utils/memutils.h"
+#include "utils/typcache.h"
+#include "utils/xml.h"
+
+#include "executor.h"
+#include "execTuples.h"
+#include "vectorTupleSlot.h"
+
+/* ----------------------------------------------------------------
+ *		ExecQual
+ *
+ *		Evaluates a conjunctive boolean expression (qual list) and
+ *		returns true iff none of the subexpressions are false.
+ *		(We also return true if the list is empty.)
+ *
+ *	If some of the subexpressions yield NULL but none yield FALSE,
+ *	then the result of the conjunction is NULL (ie, unknown)
+ *	according to three-valued boolean logic.  In this case,
+ *	we return the value specified by the "resultForNull" parameter.
+ *
+ *	Callers evaluating WHERE clauses should pass resultForNull=FALSE,
+ *	since SQL specifies that tuples with null WHERE results do not
+ *	get selected.  On the other hand, callers evaluating constraint
+ *	conditions should pass resultForNull=TRUE, since SQL also specifies
+ *	that NULL constraint conditions are not failures.
+ *
+ *	NOTE: it would not be correct to use this routine to evaluate an
+ *	AND subclause of a boolean expression; for that purpose, a NULL
+ *	result must be returned as NULL so that it can be properly treated
+ *	in the next higher operator (cf. ExecEvalAnd and ExecEvalOr).
+ *	This routine is only used in contexts where a complete expression
+ *	is being evaluated and we know that NULL can be treated the same
+ *	as one boolean result or the other.
+ *
+ * ----------------------------------------------------------------
+ */
+bool
+VExecScanQual(List *qual, ExprContext *econtext, bool resultForNull)
+{
+	MemoryContext	oldContext;
+	TupleTableSlot	*slot;
+	VectorTupleSlot	*vslot;
+	ListCell		*l;
+	int				row;
+
+	/*
+	 * debugging stuff
+	 */
+	EV_printf("ExecQual: qual is ");
+	EV_nodeDisplay(qual);
+	EV_printf("\n");
+
+	/*
+	 * Run in short-lived per-tuple context while computing expressions.
+	 */
+	oldContext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
+
+	/*
+	 * Evaluate the qual conditions one at a time.  If we find a FALSE result,
+	 * we can stop evaluating and return FALSE --- the AND result must be
+	 * FALSE.  Also, if we find a NULL result when resultForNull is FALSE, we
+	 * can stop and return FALSE --- the AND result must be FALSE or NULL in
+	 * that case, and the caller doesn't care which.
+	 *
+	 * If we get to the end of the list, we can return TRUE.  This will happen
+	 * when the AND result is indeed TRUE, or when the AND result is NULL (one
+	 * or more NULL subresult, with all the rest TRUE) and the caller has
+	 * specified resultForNull = TRUE.
+	 */
+
+	slot = econtext->ecxt_scantuple;
+	vslot = (VectorTupleSlot *)slot;
+	foreach(l, qual)
+	{
+		ExprState  *clause = (ExprState *) lfirst(l);
+		Datum		expr_value;
+		bool		isNull;
+		vbool		*expr_val_bools;
+
+		/* take a batch as input to evaluate quals */
+		expr_value = ExecEvalExpr(clause, econtext, &isNull, NULL);
+		
+		expr_val_bools = (vbool *)DatumGetPointer(expr_value);
+		
+		/* using skip array to indicated row which didn't pass the qual */
+		for(row = 0; row < BATCHSIZE; row++)
+			if((!expr_val_bools->isnull[row] || !resultForNull) && 
+				!DatumGetBool(expr_val_bools->values[row]) &&
+				!vslot->skip[row])
+				vslot->skip[row] = true;
+		/* TODO: opt: add skipped count for vslot to support skipping the whole batch?*/
+	}
+
+	MemoryContextSwitchTo(oldContext);
+
+	/* return true if any tuple in batch pass the qual. */
+	for(row = 0; row < BATCHSIZE; row++)
+		if (!vslot->skip[row])
+			return true;
+
+	return false;
+}
+