YQL-20309: Purge TStatefulWideFlowCodegeneratorNode

commit_hash:a3bbef18870abda431203c08f773634bd3a776f7

1 files changed, 0 insertions, 149 deletions

diff --git a/yql/essentials/minikql/computation/mkql_simple_codegen.cpp b/yql/essentials/minikql/computation/mkql_simple_codegen.cpp
deleted file mode 100644
index 3703465fa7b..00000000000
--- a/yql/essentials/minikql/computation/mkql_simple_codegen.cpp
+++ /dev/null
@@ -1,149 +0,0 @@
-#include <yql/essentials/minikql/computation/mkql_computation_node_codegen.h>  // Y_IGNORE
-#include "mkql_simple_codegen.h"
-
-namespace NKikimr {
-namespace NMiniKQL {
-
-#ifndef MKQL_DISABLE_CODEGEN
-ICodegeneratorInlineWideNode::TGenerateResult TSimpleStatefulWideFlowCodegeneratorNodeLLVMBase::DoGenGetValues(const NKikimr::NMiniKQL::TCodegenContext &ctx, llvm::Value *statePtrVal, llvm::BasicBlock *&genToBlock) const  {
-    // init stuff (mainly in global entry block)
-
-    auto& context = ctx.Codegen.GetContext();
-
-    const auto valueType = Type::getInt128Ty(context);
-    const auto init = BasicBlock::Create(context, "init", ctx.Func);
-    const auto loop = BasicBlock::Create(context, "loop", ctx.Func);
-    const auto loopFetch = BasicBlock::Create(context, "loop_fetch", ctx.Func);
-    const auto loopCalc = BasicBlock::Create(context, "loop_calc", ctx.Func);
-    const auto loopTail = BasicBlock::Create(context, "loop_tail", ctx.Func);
-    const auto done = BasicBlock::Create(context, "done", ctx.Func);
-    const auto entryPos = &ctx.Func->getEntryBlock().back();
-
-    const auto thisType = StructType::get(context)->getPointerTo();
-    const auto thisRawVal = ConstantInt::get(Type::getInt64Ty(context), PtrTable.ThisPtr);
-    const auto thisVal = CastInst::Create(Instruction::IntToPtr, thisRawVal, thisType, "this", entryPos);
-    const auto valuePtrType = PointerType::getUnqual(valueType);
-    const auto valuePtrsPtrType = PointerType::getUnqual(valuePtrType);
-    const auto statePtrType = statePtrVal->getType();
-    const auto ctxType = ctx.Ctx->getType();
-    const auto i32Type = Type::getInt32Ty(context);
-    const auto valueNullptrVal = ConstantPointerNull::get(valuePtrType);
-    const auto valuePtrNullptrVal = ConstantPointerNull::get(valuePtrsPtrType);
-    const auto oneVal = ConstantInt::get(i32Type, static_cast<i32>(EFetchResult::One));
-    const auto maybeResType = TMaybeFetchResult::LLVMType(context);
-    const auto noneVal = TMaybeFetchResult::None().LLVMConst(context);
-
-    const auto outputArrayVal = new AllocaInst(valueType, 0, ConstantInt::get(i32Type, OutWidth), "output_array", entryPos);
-    const auto outputPtrsVal = new AllocaInst(valuePtrType, 0, ConstantInt::get(Type::getInt64Ty(context), OutWidth), "output_ptrs", entryPos);
-    for (ui32 pos = 0; pos < OutWidth; pos++) {
-        const auto posVal = ConstantInt::get(i32Type, pos);
-        const auto arrayPtrVal = GetElementPtrInst::CreateInBounds(valueType, outputArrayVal, {posVal}, "array_ptr", entryPos);
-        const auto ptrsPtrVal = GetElementPtrInst::CreateInBounds(valuePtrType, outputPtrsVal, {posVal}, "ptrs_ptr", entryPos);
-        new StoreInst(arrayPtrVal, ptrsPtrVal, &ctx.Func->getEntryBlock().back());
-    }
-
-    auto block = genToBlock; // >>> start of main code chunk
-
-    const auto stateVal = new LoadInst(valueType, statePtrVal, "state", block);
-    BranchInst::Create(init, loop, IsInvalid(stateVal, block, context), block);
-
-    block = init; // state initialization block:
-
-    const auto initFuncType = FunctionType::get(Type::getVoidTy(context), {thisType, statePtrType, ctxType}, false);
-    const auto initFuncRawVal = ConstantInt::get(Type::getInt64Ty(context), PtrTable.InitStateMethPtr);
-    const auto initFuncVal = CastInst::Create(Instruction::IntToPtr, initFuncRawVal, PointerType::getUnqual(initFuncType), "init_func", block);
-    CallInst::Create(initFuncType, initFuncVal, {thisVal, statePtrVal, ctx.Ctx}, "", block);
-    BranchInst::Create(loop, block);
-
-    block = loop; // loop head block: (prepare inputs and decide whether to calculate row or not)
-
-    const auto generated = GenFetchProcess(statePtrVal, ctx, std::bind_front(GetNodeValues, SourceFlow), block);
-    auto processResVal = generated.first;
-    if (processResVal == nullptr) {
-        const auto prepareFuncType = FunctionType::get(valuePtrsPtrType, {thisType, statePtrType, ctxType, valuePtrsPtrType}, false);
-        const auto prepareFuncRawVal = ConstantInt::get(Type::getInt64Ty(context), PtrTable.PrepareInputMethPtr);
-        const auto prepareFuncVal = CastInst::Create(Instruction::IntToPtr, prepareFuncRawVal, PointerType::getUnqual(prepareFuncType), "prepare_func", block);
-        const auto inputPtrsVal = CallInst::Create(prepareFuncType, prepareFuncVal, {thisVal, statePtrVal, ctx.Ctx, outputPtrsVal}, "input_ptrs", block);
-        const auto skipFetchCond = CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_EQ, inputPtrsVal, valuePtrNullptrVal, "skip_fetch", block);
-        BranchInst::Create(loopTail, loopFetch, skipFetchCond, block);
-
-        block = loopFetch; // loop fetch chunk:
-
-        const auto [fetchResVal, getters] = GetNodeValues(SourceFlow, ctx, block);
-        const auto fetchResExtVal = new ZExtInst(fetchResVal, maybeResType, "res_ext", block);
-        const auto skipCalcCond = CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_NE, fetchResVal, oneVal, "skip_calc", block);
-        const auto fetchSourceBlock = block;
-        BranchInst::Create(loopTail, loopCalc, skipCalcCond, block);
-
-        block = loopCalc; // loop calc chunk: (calculate needed values in the row)
-
-        for (ui32 pos = 0; pos < InWidth; pos++) {
-            const auto stor = BasicBlock::Create(context, "stor", ctx.Func);
-            const auto cont = BasicBlock::Create(context, "cont", ctx.Func);
-
-            auto innerBlock = block; // >>> start of inner chunk (calculates and stores the value if needed)
-
-            const auto posVal = ConstantInt::get(i32Type, pos);
-            const auto inputPtrPtrVal = GetElementPtrInst::CreateInBounds(valuePtrType, inputPtrsVal, {posVal}, "input_ptr_ptr", innerBlock);
-            const auto inputPtrVal = new LoadInst(valuePtrType, inputPtrPtrVal, "input_ptr", innerBlock);
-            const auto isNullCond = CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_EQ, inputPtrVal, valueNullptrVal, "is_null", innerBlock);
-            BranchInst::Create(cont, stor, isNullCond, innerBlock);
-
-            innerBlock = stor; // calculate & store chunk:
-
-            new StoreInst(getters[pos](ctx, innerBlock), inputPtrVal, innerBlock);
-            BranchInst::Create(cont, innerBlock);
-
-            innerBlock = cont; // skip input value block:
-
-            /* nothing here yet */
-
-            block = innerBlock; // <<< end of inner chunk
-        }
-        const auto calcSourceBlock = block;
-        BranchInst::Create(loopTail, block);
-
-        block = loopTail; // loop tail block: (process row)
-
-        const auto maybeFetchResVal = PHINode::Create(maybeResType, 2, "fetch_res", block);
-        maybeFetchResVal->addIncoming(noneVal, loop);
-        maybeFetchResVal->addIncoming(fetchResExtVal, fetchSourceBlock);
-        maybeFetchResVal->addIncoming(fetchResExtVal, calcSourceBlock);
-        const auto processFuncType = FunctionType::get(maybeResType, {thisType, statePtrType, ctxType, maybeResType, valuePtrsPtrType}, false);
-        const auto processFuncRawVal = ConstantInt::get(Type::getInt64Ty(context), PtrTable.DoProcessMethPtr);
-        const auto processFuncVal = CastInst::Create(Instruction::IntToPtr, processFuncRawVal, PointerType::getUnqual(processFuncType), "process_func", block);
-        processResVal = CallInst::Create(processFuncType, processFuncVal, {thisVal, statePtrVal, ctx.Ctx, maybeFetchResVal, outputPtrsVal}, "process_res", block);
-    } else {
-        BranchInst::Create(loopFetch, loopFetch);
-        BranchInst::Create(loopCalc, loopCalc);
-        BranchInst::Create(loopTail, loopTail);
-    }
-    const auto brkCond = CmpInst::Create(Instruction::ICmp, ICmpInst::ICMP_NE, processResVal, noneVal, "brk", block);
-    BranchInst::Create(done, loop, brkCond, block);
-
-    block = done; // finalization block:
-
-    const auto processResTruncVal = new TruncInst(processResVal, i32Type, "res_trunc", block);
-
-    genToBlock = block; // <<< end of main code chunk
-
-    if (generated.first) {
-        return {processResTruncVal, generated.second};
-    }
-
-    ICodegeneratorInlineWideNode::TGettersList new_getters;
-    new_getters.reserve(OutWidth);
-    for (size_t pos = 0; pos < OutWidth; pos++) {
-        new_getters.push_back([pos, outputArrayVal, i32Type, valueType] (const TCodegenContext&, BasicBlock*& block) -> Value* {
-            const auto posVal = ConstantInt::get(i32Type, pos);
-            const auto arrayPtrVal = GetElementPtrInst::CreateInBounds(valueType, outputArrayVal, {posVal}, "array_ptr", block);
-            const auto valueVal = new LoadInst(valueType, arrayPtrVal, "value", block);
-            return valueVal;
-        });
-    }
-    return {processResTruncVal, std::move(new_getters)};
-}
-#endif
-
-}
-}