doris-vectorized · zuochunwei · Mar 19, 2021 · Mar 22, 2021 · Mar 22, 2021 · Mar 22, 2021
diff --git a/be/CMakeLists.txt b/be/CMakeLists.txt
@@ -329,7 +329,7 @@ check_function_exists(sched_getcpu HAVE_SCHED_GETCPU)
 #  -DBOOST_DATE_TIME_POSIX_TIME_STD_CONFIG: enable nanosecond precision for boost
 #  -fno-omit-frame-pointers: Keep frame pointer for functions in register
 set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wall -Wno-sign-compare -Wno-unknown-pragmas -pthread -Werror=strict-aliasing")
-set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -fno-omit-frame-pointer")
+set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -fstrict-aliasing -fno-omit-frame-pointer -Werror=return-type")
 set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -std=gnu++17 -D__STDC_FORMAT_MACROS")
 set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-deprecated -Wno-vla")
 set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -DBOOST_DATE_TIME_POSIX_TIME_STD_CONFIG")
@@ -461,6 +461,7 @@ set(DORIS_LINK_LIBS
     Webserver
     TestUtil
     Geo
+    Vec
     Plugin
     ${WL_END_GROUP}
 )
@@ -631,6 +632,7 @@ add_subdirectory(${SRC_DIR}/udf)
 add_subdirectory(${SRC_DIR}/tools)
 add_subdirectory(${SRC_DIR}/util)
 add_subdirectory(${SRC_DIR}/plugin)
+add_subdirectory(${SRC_DIR}/vec)
 
 # Utility CMake function to make specifying tests and benchmarks less verbose
 FUNCTION(ADD_BE_TEST TEST_NAME)
@@ -682,6 +684,12 @@ if (${MAKE_TEST} STREQUAL "ON")
     add_subdirectory(${TEST_DIR}/runtime)
     add_subdirectory(${TEST_DIR}/udf)
     add_subdirectory(${TEST_DIR}/util)
+    add_subdirectory(${TEST_DIR}/vec/core)
+    add_subdirectory(${TEST_DIR}/vec/exec)
+    add_subdirectory(${TEST_DIR}/vec/exprs)
+    add_subdirectory(${TEST_DIR}/vec/function)
+    add_subdirectory(${TEST_DIR}/vec/runtime)
+    add_subdirectory(${TEST_DIR}/vec/aggregate_functions)
     add_subdirectory(${TEST_DIR}/plugin)
     add_subdirectory(${TEST_DIR}/plugin/example)
 endif ()
@@ -704,3 +712,8 @@ install(FILES
     ${BASE_DIR}/../conf/odbcinst.ini
     DESTINATION ${OUTPUT_DIR}/conf)
 
+
+get_property(dirs DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY INCLUDE_DIRECTORIES)
+foreach(dir ${dirs})
+  message(STATUS "dir='${dir}'")
+  endforeach()
diff --git a/be/src/common/compiler_util.h b/be/src/common/compiler_util.h
@@ -42,7 +42,12 @@
 /// not a command. This should be used sparingly for cases when either the function
 /// needs to be inlined for a specific reason or the compiler's heuristics make a bad
 /// decision, e.g. not inlining a small function on a hot path.
+#ifdef ALWAYS_INLINE
+#undef ALWAYS_INLINE
+#endif
 #define ALWAYS_INLINE __attribute__((always_inline))
+#define NO_INLINE __attribute__((__noinline__))
+#define MAY_ALIAS __attribute__((__may_alias__))
 
 #define ALIGN_CACHE_LINE __attribute__((aligned(CACHE_LINE_SIZE)))
 

diff --git a/be/src/common/logging.h b/be/src/common/logging.h
@@ -85,4 +85,5 @@
     DCHECK(a == b) << "[ " #a " = " << static_cast<int>(a) << " , " #b " = " \
                    << static_cast<int>(b) << " ]"
 
+#include "fmt/format.h"
 #endif
diff --git a/be/src/common/status.h b/be/src/common/status.h
@@ -235,6 +235,8 @@ class Status {
     ///   trailing message.
     Status clone_and_append(const Slice& msg) const;
 
+    operator bool() { return this->ok(); }
+
 private:
     const char* copy_state(const char* state);
 

diff --git a/be/src/exec/aggregation_node.cpp b/be/src/exec/aggregation_node.cpp
@@ -19,7 +19,6 @@
 
 #include <gperftools/profiler.h>
 #include <math.h>
-#include <thrift/protocol/TDebugProtocol.h>
 
 #include <sstream>
 
@@ -223,6 +222,15 @@ Status AggregationNode::open(RuntimeState* state) {
 }
 
 Status AggregationNode::get_next(RuntimeState* state, RowBatch* row_batch, bool* eos) {
+    // 1. `!need_finalize` means this aggregation node not the level two aggregation node
+    // 2. `_singleton_output_tuple != nullptr` means is not group by
+    // 3. `child(0)->rows_returned() == 0` mean not data from child
+    // in level two aggregation node should return NULL result
+    //    level one aggregation node set `eos = true` return directly
+    if (UNLIKELY(!_needs_finalize && _singleton_output_tuple != nullptr && child(0)->rows_returned() == 0)) {
+        *eos = true;
+        return Status::OK();
+    }
     SCOPED_TIMER(_runtime_profile->total_time_counter());
     RETURN_IF_ERROR(exec_debug_action(TExecNodePhase::GETNEXT));
     RETURN_IF_CANCELLED(state);
@@ -403,7 +411,8 @@ Tuple* AggregationNode::finalize_tuple(Tuple* tuple, MemPool* pool) {
         dst = Tuple::create(_output_tuple_desc->byte_size(), pool);
     }
     if (_needs_finalize) {
-        AggFnEvaluator::finalize(_aggregate_evaluators, _agg_fn_ctxs, tuple, dst);
+        AggFnEvaluator::finalize(_aggregate_evaluators, _agg_fn_ctxs, tuple, dst,
+                _singleton_output_tuple != nullptr && child(0)->rows_returned() == 0);
     } else {
         AggFnEvaluator::serialize(_aggregate_evaluators, _agg_fn_ctxs, tuple);
     }

diff --git a/be/src/exec/broker_scan_node.cpp b/be/src/exec/broker_scan_node.cpp
@@ -47,7 +47,7 @@ BrokerScanNode::BrokerScanNode(ObjectPool* pool, const TPlanNode& tnode, const D
 BrokerScanNode::~BrokerScanNode() {}
 
 Status BrokerScanNode::init(const TPlanNode& tnode, RuntimeState* state) {
-    RETURN_IF_ERROR(ScanNode::init(tnode));
+    RETURN_IF_ERROR(ScanNode::init(tnode, state));
     auto& broker_scan_node = tnode.broker_scan_node;
 
     if (broker_scan_node.__isset.pre_filter_exprs) {

diff --git a/be/src/exec/cross_join_node.cpp b/be/src/exec/cross_join_node.cpp
@@ -60,7 +60,7 @@ Status CrossJoinNode::construct_build_side(RuntimeState* state) {
         RETURN_IF_CANCELLED(state);
         // TODO(zhaochun):
         // RETURN_IF_ERROR(state->CheckQueryState());
-        bool eos = true;
+        bool eos = false;
         RETURN_IF_ERROR(child(1)->get_next(state, batch, &eos));
 
         // to prevent use too many memory

diff --git a/be/src/exec/data_sink.cpp b/be/src/exec/data_sink.cpp
@@ -35,13 +35,16 @@
 #include "runtime/result_sink.h"
 #include "runtime/runtime_state.h"
 #include "util/logging.h"
+#include "vec/sink/result_sink.h"
+#include "vec/sink/vdata_stream_sender.h"
 
 namespace doris {
 
 Status DataSink::create_data_sink(ObjectPool* pool, const TDataSink& thrift_sink,
                                   const std::vector<TExpr>& output_exprs,
                                   const TPlanFragmentExecParams& params,
                                   const RowDescriptor& row_desc,
+                                  bool is_vec,
                                   boost::scoped_ptr<DataSink>* sink) {
     DataSink* tmp_sink = NULL;
 
@@ -55,9 +58,15 @@ Status DataSink::create_data_sink(ObjectPool* pool, const TDataSink& thrift_sink
                         ? params.send_query_statistics_with_every_batch
                         : false;
         // TODO: figure out good buffer size based on size of output row
-        tmp_sink = new DataStreamSender(pool, params.sender_id, row_desc, thrift_sink.stream_sink,
-                                        params.destinations, 16 * 1024,
-                                        send_query_statistics_with_every_batch);
+        if (is_vec) {
+            tmp_sink = new doris::vectorized::VDataStreamSender(
+                    pool, params.sender_id, row_desc, thrift_sink.stream_sink, params.destinations,
+                    16 * 1024, send_query_statistics_with_every_batch);
+        } else {
+            tmp_sink = new DataStreamSender(pool, params.sender_id, row_desc, thrift_sink.stream_sink,
+                                 params.destinations, 16 * 1024,
+                                 send_query_statistics_with_every_batch);
+        }
         // RETURN_IF_ERROR(sender->prepare(state->obj_pool(), thrift_sink.stream_sink));
         sink->reset(tmp_sink);
         break;
@@ -68,7 +77,11 @@ Status DataSink::create_data_sink(ObjectPool* pool, const TDataSink& thrift_sink
         }
 
         // TODO: figure out good buffer size based on size of output row
-        tmp_sink = new ResultSink(row_desc, output_exprs, thrift_sink.result_sink, 1024);
+        if (is_vec) {
+            tmp_sink = new doris::vectorized::ResultSink(row_desc, output_exprs, thrift_sink.result_sink, 1024);
+        } else {
+            tmp_sink = new ResultSink(row_desc, output_exprs, thrift_sink.result_sink, 1024);
+        }
         sink->reset(tmp_sink);
         break;
     case TDataSinkType::MEMORY_SCRATCH_SINK:
@@ -98,8 +111,7 @@ Status DataSink::create_data_sink(ObjectPool* pool, const TDataSink& thrift_sink
         if (!thrift_sink.__isset.odbc_table_sink) {
             return Status::InternalError("Missing data odbc sink.");
         }
-        OdbcTableSink* odbc_tbl_sink = new OdbcTableSink(pool,
-                                                         row_desc, output_exprs);
+        OdbcTableSink* odbc_tbl_sink = new OdbcTableSink(pool, row_desc, output_exprs);
         sink->reset(odbc_tbl_sink);
         break;
     }
@@ -158,9 +170,9 @@ Status DataSink::init(const TDataSink& thrift_sink) {
 }
 
 Status DataSink::prepare(RuntimeState* state) {
-    _expr_mem_tracker = MemTracker::CreateTracker(
-            -1, _name + ":Expr:" + std::to_string(state->load_job_id()),
-            state->instance_mem_tracker());
+    _expr_mem_tracker =
+            MemTracker::CreateTracker(-1, _name + ":Expr:" + std::to_string(state->load_job_id()),
+                                      state->instance_mem_tracker());
     return Status::OK();
 }
 

diff --git a/be/src/exec/data_sink.h b/be/src/exec/data_sink.h
@@ -74,6 +74,7 @@ class DataSink {
                                    const std::vector<TExpr>& output_exprs,
                                    const TPlanFragmentExecParams& params,
                                    const RowDescriptor& row_desc,
+                                   bool is_vec,
                                    boost::scoped_ptr<DataSink>* sink);
 
     // Returns the runtime profile for the sink.

diff --git a/be/src/exec/exec_node.cpp b/be/src/exec/exec_node.cpp
@@ -61,6 +61,15 @@
 #include "runtime/runtime_state.h"
 #include "util/debug_util.h"
 #include "util/runtime_profile.h"
+#include "vec/core/block.h"
+#include "vec/exec/join/vhash_join_node.h"
+#include "vec/exec/vaggregation_node.h"
+#include "vec/exec/vcross_join_node.h"
+#include "vec/exec/vexchange_node.h"
+#include "vec/exec/volap_scan_node.h"
+#include "vec/exec/vsort_node.h"
+#include "vec/exec/vunion_node.h"
+#include "vec/exprs/vexpr.h"
 
 namespace doris {
 
@@ -127,9 +136,7 @@ ExecNode::ExecNode(ObjectPool* pool, const TPlanNode& tnode, const DescriptorTbl
           _rows_returned_counter(NULL),
           _rows_returned_rate(NULL),
           _memory_used_counter(NULL),
-          _is_closed(false) {
-    init_runtime_profile(print_plan_node_type(tnode.node_type));
-}
+          _is_closed(false) {}
 
 ExecNode::~ExecNode() {}
 
@@ -159,7 +166,21 @@ void ExecNode::push_down_predicate(RuntimeState* state, std::list<ExprContext*>*
 }
 
 Status ExecNode::init(const TPlanNode& tnode, RuntimeState* state) {
+    std::string profile;
+    if (state && state->enable_vectorized_exec()) {
+        profile = "V" + print_plan_node_type(tnode.node_type);
+    } else {
+        profile = print_plan_node_type(tnode.node_type);
+    }
+    init_runtime_profile(profile);
+
+    if (tnode.__isset.vconjunct) {
+        _vconjunct_ctx_ptr.reset(new doris::vectorized::VExprContext*);
+        RETURN_IF_ERROR(doris::vectorized::VExpr::create_expr_tree(_pool, tnode.vconjunct,
+                                                                   _vconjunct_ctx_ptr.get()));
+    }
     RETURN_IF_ERROR(Expr::create_expr_trees(_pool, tnode.conjuncts, &_conjunct_ctxs));
+
     return Status::OK();
 }
 
@@ -178,11 +199,14 @@ Status ExecNode::prepare(RuntimeState* state) {
     _expr_mem_tracker = MemTracker::CreateTracker(-1, "ExecNode:Exprs:" + _runtime_profile->name(),
                                                   _mem_tracker);
     _expr_mem_pool.reset(new MemPool(_expr_mem_tracker.get()));
-    // TODO chenhao
+
+    if (_vconjunct_ctx_ptr) {
+        RETURN_IF_ERROR((*_vconjunct_ctx_ptr)->prepare(state, row_desc(), expr_mem_tracker()));
+    }
     RETURN_IF_ERROR(Expr::prepare(_conjunct_ctxs, state, row_desc(), expr_mem_tracker()));
+
     // TODO(zc):
     // AddExprCtxsToFree(_conjunct_ctxs);
-
     for (int i = 0; i < _children.size(); ++i) {
         RETURN_IF_ERROR(_children[i]->prepare(state));
     }
@@ -192,6 +216,9 @@ Status ExecNode::prepare(RuntimeState* state) {
 
 Status ExecNode::open(RuntimeState* state) {
     RETURN_IF_ERROR(exec_debug_action(TExecNodePhase::OPEN));
+    if (_vconjunct_ctx_ptr) {
+        RETURN_IF_ERROR((*_vconjunct_ctx_ptr)->open(state));
+    }
     return Expr::open(_conjunct_ctxs, state);
 }
 
@@ -230,6 +257,7 @@ Status ExecNode::close(RuntimeState* state) {
         }
     }
 
+    if (_vconjunct_ctx_ptr) (*_vconjunct_ctx_ptr)->close(state);
     Expr::close(_conjunct_ctxs, state);
 
     if (expr_mem_pool() != nullptr) {
@@ -362,22 +390,39 @@ Status ExecNode::create_node(RuntimeState* state, ObjectPool* pool, const TPlanN
         return Status::OK();
 
     case TPlanNodeType::OLAP_SCAN_NODE:
-        *node = pool->add(new OlapScanNode(pool, tnode, descs));
+        if (state->enable_vectorized_exec()) {
+            *node = pool->add(new vectorized::VOlapScanNode(pool, tnode, descs));
+        } else {
+            *node = pool->add(new OlapScanNode(pool, tnode, descs));
+        }
         return Status::OK();
 
     case TPlanNodeType::AGGREGATION_NODE:
-        if (config::enable_partitioned_aggregation) {
-            *node = pool->add(new PartitionedAggregationNode(pool, tnode, descs));
+        if (state->enable_vectorized_exec()) {
+            *node = pool->add(new vectorized::AggregationNode(pool, tnode, descs));
         } else {
-            *node = pool->add(new AggregationNode(pool, tnode, descs));
+            if (config::enable_partitioned_aggregation) {
+                *node = pool->add(new PartitionedAggregationNode(pool, tnode, descs));
+            } else {
+                *node = pool->add(new AggregationNode(pool, tnode, descs));
+            }
         }
         return Status::OK();
+
     case TPlanNodeType::HASH_JOIN_NODE:
-        *node = pool->add(new HashJoinNode(pool, tnode, descs));
+        if (state->enable_vectorized_exec()) {
+            *node = pool->add(new vectorized::HashJoinNode(pool, tnode, descs));
+        } else {
+            *node = pool->add(new HashJoinNode(pool, tnode, descs));
+        }
         return Status::OK();
 
     case TPlanNodeType::CROSS_JOIN_NODE:
-        *node = pool->add(new CrossJoinNode(pool, tnode, descs));
+        if (state->enable_vectorized_exec()) {
+            *node = pool->add(new vectorized::VCrossJoinNode(pool, tnode, descs));
+        } else {
+            *node = pool->add(new CrossJoinNode(pool, tnode, descs));
+        }
         return Status::OK();
 
     case TPlanNodeType::MERGE_JOIN_NODE:
@@ -389,7 +434,11 @@ Status ExecNode::create_node(RuntimeState* state, ObjectPool* pool, const TPlanN
         return Status::OK();
 
     case TPlanNodeType::EXCHANGE_NODE:
-        *node = pool->add(new ExchangeNode(pool, tnode, descs));
+        if (state->enable_vectorized_exec()) {
+            *node = pool->add(new doris::vectorized::VExchangeNode(pool, tnode, descs));
+        } else {
+            *node = pool->add(new ExchangeNode(pool, tnode, descs));
+        }
         return Status::OK();
 
     case TPlanNodeType::SELECT_NODE:
@@ -401,10 +450,14 @@ Status ExecNode::create_node(RuntimeState* state, ObjectPool* pool, const TPlanN
         return Status::OK();
 
     case TPlanNodeType::SORT_NODE:
-        if (tnode.sort_node.use_top_n) {
-            *node = pool->add(new TopNNode(pool, tnode, descs));
+        if (state->enable_vectorized_exec()) {
+            *node = pool->add(new vectorized::VSortNode(pool, tnode, descs));
         } else {
-            *node = pool->add(new SpillSortNode(pool, tnode, descs));
+            if (tnode.sort_node.use_top_n) {
+                *node = pool->add(new TopNNode(pool, tnode, descs));
+            } else {
+                *node = pool->add(new SpillSortNode(pool, tnode, descs));
+            }
         }
 
         return Status::OK();
@@ -417,7 +470,11 @@ Status ExecNode::create_node(RuntimeState* state, ObjectPool* pool, const TPlanN
         return Status::OK();
 
     case TPlanNodeType::UNION_NODE:
-        *node = pool->add(new UnionNode(pool, tnode, descs));
+        if (state->enable_vectorized_exec()) {
+            *node = pool->add(new vectorized::VUnionNode(pool, tnode, descs));
+        } else {
+            *node = pool->add(new UnionNode(pool, tnode, descs));
+        }
         return Status::OK();
 
     case TPlanNodeType::INTERSECT_NODE:
@@ -624,4 +681,8 @@ Status ExecNode::QueryMaintenance(RuntimeState* state, const std::string& msg) {
     return state->check_query_state(msg);
 }
 
+Status ExecNode::get_next(RuntimeState* state, vectorized::Block* block, bool* eos) {
+    return Status::NotSupported("Not Implemented get block");
+}
+
 } // namespace doris