* Copyright (c) 2020 Huawei Technologies Co.,Ltd.
*
* openGauss is licensed under Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
*
* http://license.coscl.org.cn/MulanPSL2
*
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
* ---------------------------------------------------------------------------------------
*
* vechashaggcodegen.h
* Declarations of code generation for vechashagg funtions.
*
* For each vechashagg function, they have the same functionality as the ones
* defined in vechashagg.h. Code generation will not change the logical of the
* the whole function.
*
* IDENTIFICATION
* src/include/codegen/vechashaggcodegen.h
*
* ---------------------------------------------------------------------------------------
*/
#ifndef LLVM_VECHASHAGG_H
#define LLVM_VECHASHAGG_H
#include "codegen/gscodegen.h"
#include "executor/node/nodeAgg.h"
#include "nodes/execnodes.h"
#include "vecexecutor/vecnodes.h"
namespace dorado {
* VecHashAggCodeGen class implements specific optimization by using LLVM
*/
#ifdef ENABLE_LLVM_COMPILE
class VecHashAggCodeGen : public BaseObject {
public:
* @Brief : Calculate scale of expression.
* @Description : Give expression node, calculate the scale of current,
* this function only be used when we can use fast codegen.
* @in node : The expression that we need to evaluate scale.
* @return : return the scale of current node expr.
*/
static int GetAlignedScale(Expr* node);
* @Brief : Check the expressions we supported
* @Description : Since we only support simple expression in agg
* operator, we should restrict the ones we support.
* @in state : Input expression state node.
* @return : If the current node is allowed to do codegen or not.
*/
static bool AggRefJittable(ExprState* state);
* @Brief : Check if current expression can use special codegen path.
* @Description : For simple var expression and simple algorithm expression
* with numeric data type, if we could represent it by
* big integer, use fast path at the beginning.
* @in state : Input expression state node.
* @return : Return true if the expression can use fast codegen path.
*/
static bool AggRefFastJittable(ExprState* state);
* @Brief : Check the validation of VecAggState for agghashing.
* @Description : Check if the current agg node could be codegened
* or not. We only support sum and avg operation. The
* data type could only be int8 and numeric with
* precision less than or equal to 18.
* @in node : vecaggstate, the node to be checked.
* @return : Return true if current agg node could be codegened.
*/
static bool AgghashingJittable(VecAggState* node);
* @Brief : Main function process to build LLVM ir function used to generate
* : machine code.
* @Description : Build LLVM ir function with respect to special query according to
* : current agg state, including build function and agg function.
* @in node : vector aggregate state information.
*/
static void HashAggCodeGen(VecAggState* node);
* @Brief : Main function process to build LLVM IR function used to generate
* : machine code.
* @Description : Build LLVM ir function with respect to special query according to
* : current sonic agg state, including agg function.
* @in node : vector aggregate state information, special for sonic case.
*/
static void SonicHashAggCodeGen(VecAggState* node);
* @Brief : Code generation for Hashing process
* @Description : The whole HashAggRunner::BuildAggTbl functions
* can be divieded into three part. AgghashingCodeGen
* contains (a)computing hash value & compare hash value
* & match key and (b)allocate new hash cell.
* @in node : vecaggstate, the node to be codegened
* @return : The codegeneration of part of HashAggRunner::BuildAggTbl
* function.
*/
template <bool isSglTbl>
static llvm::Function* AgghashingCodeGenorSglTbl(VecAggState* node);
* @Description : Same as above function except the prefetching hashCell.
*/
template <bool isSglTbl>
static llvm::Function* AgghashingWithPrefetchCodeGenorSglTbl(VecAggState* node);
* @Brief : Code generation for vechashtable::hashBatch function.
* @Description : Code generation for hashBatch function with the fixed
* row number 'idx'. The original function calculate the
* whole hash values of that batch with respect to the
* group by clauses. hashBatchCodeGen only calculate the
* hash value of one row.
* @in node : node which contains aggstate information.
* @in idx : the row number of the batch.
* @in rehash : check if we need to rehash the row.
* @return : LLVM function pointer.
*
*/
static llvm::Function* HashBatchCodeGen(VecAggState* node, int idx, bool rehash);
* @Brief : Code generation for match_key function with respect to
* one key.
* @Description : Code generation for match_key function with the fixed
* row number 'idx' and fixed key. We only consider the
* idx-th cell and the idx-th tuple in batch.
* @in node : Node which contains aggstate information.
* @in idx : The row number of the batch.
* @return : LLVM function pointer.
*/
static llvm::Function* MatchOneKeyCodeGen(VecAggState* node, int idx);
* @Brief : Check the validation of VecAggState for batch aggregation.
* @Description : Check if the current node can be codegened for aggregation
* or not. Since we only support sum and avg operation with
* data type int8 and numeric with allowed precision(<=18).
* @in node : vecaggstate, the node to be codegened
* @return : return true if current node is allowed to do codegen of
* batch aggregation.
*/
static bool BatchAggJittable(VecAggState* node, bool isSonic);
* @Brief : Code generation for BatchAggregation.
* @Description : Do codegen for function BaseAggRunner::BatchAggregation.
* The main process contains projection of expressions and
* aggregation of the agg operator.
* @in node : vecaggstate, the node to be codegened
* @in use_prefetch : Flag used to decide if we need to prefetch data.
* @return : LLVM function pointer that point to the codegeneration of
* BatchAggregation.
*/
static llvm::Function* BatchAggregationCodeGen(VecAggState* node, bool use_prefetch);
* @Brief : LLVM function used to evaluation numeric expression in
* fast path.
* @Description : Evaluate numeric expression in fast path if the mid-result
* can be represented in BI64 by avoiding make numeric
* result all the time.
* @in state : ExprState node
* @in builder : LLVM Builder associated with the current module.
* @in jitted_func : the current llvm function that we need to generate.
* @in bb_null : null basicblock used for deal with null value.
* @in bb_last : maks parent basic block dynamically to get value from
* last basicblock.
* @bb_outofbound : basicblock used to deal with the case where the result
* can not be represented in BI64.
* @econtext : ExprContext of the current operator.
* @argVector : the input scalevector.
* @phi_idx : the idxth row that we need to evaluation.
* @return : the result of this value if no outofbound or null is meet.
*/
static llvm::Value* EvalFastExprInBatchAgg(ExprState* state, GsCodeGen::LlvmBuilder& builder,
llvm::Function* jitted_func, llvm::BasicBlock** bb_null, llvm::BasicBlock** bb_last,
llvm::BasicBlock** bb_outofbound, llvm::Value* econtext, llvm::Value* argVector, llvm::Value* phi_idx);
* @Brief : Code generation for expressions in agg function.
* @Description : Do codegen for ExecVecProject function in BatchAggregation.
* Since we only deal with simple expressions, we could list
* these simple cases one by one.
* @in node : ExprState node.
* @in builder : LLVM Builder associated with the current module.
* @in econtext : Expr Context with respect to current aggref Expr.
* @in phi_idx : the index of the current tuple.
* @in isNull : flag used to mask the return value is null or not.
* @return : return the result of this expression.
*/
static llvm::Value* EvalSimpleExprInBatchAgg(ExprState* node, GsCodeGen::LlvmBuilder& builder,
llvm::Value* econtext, llvm::Value* phi_idx, llvm::Value* isNull);
static llvm::Function* SonicBatchAggregationCodeGen(VecAggState* node, bool use_prefetch);
* @Brief : Code generation for allocating a new hash cell and initialization.
* @Description : Code generation for allocating hash cell and initilize the
* hash cell. It has the same functionality as the orginal one.
* @in ptrbuilder : LLVM Builder associated with the current module.
* @in hAggRunner : HashAggRunner information.
* @in batch : vectorbatch which needed to creat hash cell.
* @in idx : the index of the current tuple.
* @in keysimple : mark whether the key is simple or not.
*/
static void WarpAllocHashSlotCodeGen(GsCodeGen::LlvmBuilder* ptrbuilder, llvm::Value* hAggRunner,
llvm::Value* batch, llvm::Value* idx, llvm::Value* keysimple);
static void WarpSglTblAllocHashSlotCodeGen(GsCodeGen::LlvmBuilder* ptrbuilder, llvm::Value* hAggRunner,
llvm::Value* batch, llvm::Value* idx, llvm::Value* keysimple);
* @Brief : Reset current expr context.
* @Description : Codeg generation for reset expr context in LLVM assemble.
* @in econtext : Current expr context.
*/
static void WrapResetEContextCodeGen(GsCodeGen::LlvmBuilder* ptrbuilder, llvm::Value* econtext);
};
#endif
}
#endif