Halide is stalling on subset of resnet18

[ivangarcia44]

Halide is stalling on the resnet18 subset code below.

With the Adams autoscheduler, I tried a few AMD machines (Linux Debian 12). My personal AMD machine died twice running it. Others kept running for hours, and for the cases it completed it returned "Killed" without additional clues. This issue happens also in Windows.

Yesterday at around 3pm I started running on an Intel machine the plain Halide reproduction steps below (no Adams autoscheduler), and it is still running. It has been running for almost 20 hours. Hence this issue seems to be related to Halide itself and not the Adams autoscheduler.

The resnet18 subset Halide code below was automatically generated from Simulink deep learning layer blocks (https://www.mathworks.com/help/deeplearning/ug/list-of-deep-learning-layer-blocks.html) and Halide code generation (https://www.mathworks.com/help/ecoder/ug/speed-up-generated-code-execution-with-halide.html). We are trying to leverage automatically generated Halide code with the Adams autoscheduler for convolutional neural networks. This issue is a major blocker for us. What could be going wrong in this case?

Below are the full reproduction steps, you should be able to try in your machine.

commands (resnet18Subset.cpp is defined at the bottom of this message):

First make Halide available and create build folder:

export HALIDE_FOLDER=<Your Halide path goes here, I used Halide version 16.0.0>
mkdir bin1

Run plain Halide

g++ resnet18Subset.cpp -std=c++17 -g -I $HALIDE_FOLDER/include/ -L $HALIDE_FOLDER/bin/ -lHalide -lpthread -ldl -rdynamic -fno-rtti -Wl,-rpath,$HALIDE_FOLDER/bin/ $HALIDE_FOLDER/tools/GenGen.cpp -o bin1/resnet18SubsetLib
./bin1/resnet18SubsetLib -f resnet18SubsetFun -g resnet18SubsetGenerator -e static_library,h,assembly,bitcode,cpp,html,cpp_stub,stmt,o,schedule target=host-enable_llvm_loop_opt -o bin1

Or, alternatively, run Halide with Adams autoscheduler

g++ resnet18Subset.cpp -std=c++17 -g -I $HALIDE_FOLDER/include/ -L $HALIDE_FOLDER/bin/ -lHalide -lpthread -ldl -rdynamic -fno-rtti -Wl,-rpath,$HALIDE_FOLDER/bin/ $HALIDE_FOLDER/tools/GenGen.cpp -o bin1/resnet18SubsetLib
./bin1/resnet18SubsetLib -f resnet18SubsetFun -g resnet18SubsetGenerator -e static_library,h,assembly,bitcode,cpp,html,cpp_stub,stmt,o,schedule target=host-enable_llvm_loop_opt autoscheduler.parallelism=4 autoscheduler=Adams2019 -p $HALIDE_FOLDER/bin/libautoschedule_adams2019.so target=host -o bin1

Halide generator code:

resnet18Subset.cpp file definition:

#include "Halide.h"
#include <stdio.h>
#include <climits>
using namespace Halide;
class resnet18Subset : public Halide::Generator <resnet18Subset> {

    public:
        Input<Buffer<float>> rtb_MatrixConcatenate_in{"rtb_MatrixConcatenate_in", 3};
        Input<Buffer<float>> Weights_Value_in{"Weights_Value_in", 4};
        Input<Buffer<float>> pooled5_in{"pooled5_in", 1};
        Input<float> Selector_in{"Selector_in"};
        Input<float> Selector1_in{"Selector1_in"};
        Input<Buffer<float>> Weights_Value_m_in{"Weights_Value_m_in", 4};
        Input<float> Selector_h0_in{"Selector_h0_in"};
        Input<float> Selector1_jp_in{"Selector1_jp_in"};
        Input<Buffer<float>> Weights_Value_c_in{"Weights_Value_c_in", 4};
        Input<float> Selector_g_in{"Selector_g_in"};
        Input<float> Selector1_nd_in{"Selector1_nd_in"};
        Input<Buffer<float>> Weights_Value_n_in{"Weights_Value_n_in", 4};
        Input<float> Selector_nb_in{"Selector_nb_in"};
        Input<float> Selector1_b4_in{"Selector1_b4_in"};
        Input<Buffer<float>> Weights_Value_f_in{"Weights_Value_f_in", 4};
        Input<float> Selector_ha_in{"Selector_ha_in"};
        Input<float> Selector1_ni_in{"Selector1_ni_in"};
        Input<Buffer<float>> Weights_Value_i_in{"Weights_Value_i_in", 4};
        Input<Buffer<float>> pooled7_in{"pooled7_in", 1};
        Input<float> Selector_by_in{"Selector_by_in"};
        Input<float> Selector1_d_in{"Selector1_d_in"};
        Input<Buffer<float>> Weights_Value_p_in{"Weights_Value_p_in", 4};
        Input<float> Selector_nv_in{"Selector_nv_in"};
        Input<float> Selector1_j_in{"Selector1_j_in"};
        Input<Buffer<float>> Weights_Value_c1_in{"Weights_Value_c1_in", 4};
        Input<float> Selector_d_in{"Selector_d_in"};
        Input<float> Selector1_i_in{"Selector1_i_in"};
        Input<Buffer<float>> Weights_Value_m1_in{"Weights_Value_m1_in", 4};
        Input<float> Selector_n_in{"Selector_n_in"};
        Input<float> Selector1_mp_in{"Selector1_mp_in"};
        Input<Buffer<float>> Weights_Value_ne_in{"Weights_Value_ne_in", 4};
        Input<float> Selector_o4_in{"Selector_o4_in"};
        Input<float> Selector1_cf_in{"Selector1_cf_in"};
        Input<Buffer<float>> Weights_Value_h_in{"Weights_Value_h_in", 4};
        Input<Buffer<float>> pooled8_in{"pooled8_in", 1};
        Input<float> Selector_ih_in{"Selector_ih_in"};
        Input<float> Selector1_m_in{"Selector1_m_in"};
        Input<Buffer<float>> Weights_Value_l_in{"Weights_Value_l_in", 4};
        Input<float> Selector_og_in{"Selector_og_in"};
        Input<float> Selector1_ae_in{"Selector1_ae_in"};
        Input<Buffer<float>> Weights_Value_b_in{"Weights_Value_b_in", 4};
        Input<float> Selector_oa_in{"Selector_oa_in"};
        Input<float> Selector1_f_in{"Selector1_f_in"};
        Input<Buffer<float>> Weights_Value_k_in{"Weights_Value_k_in", 4};
        Input<float> Selector_a_in{"Selector_a_in"};
        Input<float> Selector1_l_in{"Selector1_l_in"};
        Input<Buffer<float>> Weights_Value_e_in{"Weights_Value_e_in", 4};
        Input<float> Selector_i_in{"Selector_i_in"};
        Input<float> Selector1_k_in{"Selector1_k_in"};
        Input<Buffer<float>> Weights_Value_j_in{"Weights_Value_j_in", 4};
        Input<Buffer<float>> pooled9_in{"pooled9_in", 1};
        Input<float> Selector_h_in{"Selector_h_in"};
        Input<float> Selector1_c_in{"Selector1_c_in"};
        Input<Buffer<float>> Weights_Value_kd_in{"Weights_Value_kd_in", 4};
        Input<float> Selector_be_in{"Selector_be_in"};
        Input<float> Selector1_b5_in{"Selector1_b5_in"};
        Input<Buffer<float>> Weights_Value_cp_in{"Weights_Value_cp_in", 4};
        Input<float> Selector_hi_in{"Selector_hi_in"};
        Input<float> Selector1_a_in{"Selector1_a_in"};
        Input<Buffer<float>> Weights_Value_fc_in{"Weights_Value_fc_in", 4};
        Input<float> Selector_o_in{"Selector_o_in"};
        Input<float> Selector1_n_in{"Selector1_n_in"};
        Input<Buffer<float>> Weights_Value_li_in{"Weights_Value_li_in", 4};
        Input<float> Selector_b_in{"Selector_b_in"};
        Input<float> Selector1_b_in{"Selector1_b_in"};
        Output<Buffer<float>> rtb_ImpAsg_InsertedFor_Out1_at_fcn{"rtb_ImpAsg_InsertedFor_Out1_at_fcn", 3};

        void generate() {
            rtb_MatrixConcatenate_clamped(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_MatrixConcatenate_in, 0)(d1, d2, d3);
            RDom r(0, 7, 0, 7, 0, 3);
            rtb_ImpAsg_InsertedFor_Outpu_lq_func(d1, d2, d3) = sum(rtb_MatrixConcatenate_clamped(2*d1+r.x-3, 2*d2+r.y-3, r.z) * Weights_Value_in(r.x, r.y, r.z, d3))+pooled5_in(d3);
            rtb_ImpAsg_InsertedFor_Out_at_i_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Outpu_lq_func(d1, d2, d3) * Selector_in + Selector1_in;
            rtb_ImpAsg_InsertedFor_Out1__ph_func(d1, d2, d3) = max(rtb_ImpAsg_InsertedFor_Out_at_i_func(d1, d2, d3),0.000000000f);
            rtb_ImpAsg_InsertedFor_Out1__ph_clamped(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_InsertedFor_Out1__ph_func, cast<float>(Expr(-340282346638528897590636046441678635008.000000)), {{0, 112}, {0, 112}, {0, 64}})(d1, d2, d3);
            RDom r1(0, 3, 0, 3);
            rtb_ImpAsg_InsertedFor_Out1_a_n_func(d1, d2, d3) = maximum(rtb_ImpAsg_InsertedFor_Out1__ph_clamped(2*d1+r1.x-1, 2*d2+r1.y-1, d3));
            rtb_ImpAsg_InsertedFor_Out1_a_n_clamped(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_InsertedFor_Out1_a_n_func, 0, {{0, 56}, {0, 56}, {0, 64}})(d1, d2, d3);
            RDom r2(0, 3, 0, 3, 0, 64);
            rtb_ImpAsg_InsertedFor_Output_d_func(d1, d2, d3) = sum(rtb_ImpAsg_InsertedFor_Out1_a_n_clamped(d1+r2.x-1, d2+r2.y-1, r2.z) * Weights_Value_m_in(r2.x, r2.y, r2.z, d3))+pooled5_in(d3);
            rtb_ImpAsg_InsertedFor_Out_a_fm_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Output_d_func(d1, d2, d3) * Selector_h0_in + Selector1_jp_in;
            rtb_ImpAsg_InsertedFor_Out1_a_h_func(d1, d2, d3) = max(rtb_ImpAsg_InsertedFor_Out_a_fm_func(d1, d2, d3),0.000000000f);
            rtb_ImpAsg_InsertedFor_Out1_a_h_clamped(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_InsertedFor_Out1_a_h_func, 0, {{0, 56}, {0, 56}, {0, 64}})(d1, d2, d3);
            RDom r3(0, 3, 0, 3, 0, 64);
            rtb_ImpAsg_InsertedFor_Outpu_go_func(d1, d2, d3) = sum(rtb_ImpAsg_InsertedFor_Out1_a_h_clamped(d1+r3.x-1, d2+r3.y-1, r3.z) * Weights_Value_c_in(r3.x, r3.y, r3.z, d3))+pooled5_in(d3);
            rtb_ImpAsg_InsertedFor_Out_at_f_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Outpu_go_func(d1, d2, d3) * Selector_g_in + Selector1_nd_in;
            rtb_ImpAsg_InsertedFor_Out1__kq_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Out_at_f_func(d1, d2, d3) + rtb_ImpAsg_InsertedFor_Out1_a_n_func(d1, d2, d3);
            rtb_ImpAsg_InsertedFor_Out1__dk_func(d1, d2, d3) = max(rtb_ImpAsg_InsertedFor_Out1__kq_func(d1, d2, d3),0.000000000f);
            rtb_ImpAsg_InsertedFor_Out1__dk_clamped(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_InsertedFor_Out1__dk_func, 0, {{0, 56}, {0, 56}, {0, 64}})(d1, d2, d3);
            RDom r4(0, 3, 0, 3, 0, 64);
            rtb_ImpAsg_InsertedFor_Outpu_gz_func(d1, d2, d3) = sum(rtb_ImpAsg_InsertedFor_Out1__dk_clamped(d1+r4.x-1, d2+r4.y-1, r4.z) * Weights_Value_n_in(r4.x, r4.y, r4.z, d3))+pooled5_in(d3);
            rtb_ImpAsg_InsertedFor_Out_at_o_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Outpu_gz_func(d1, d2, d3) * Selector_nb_in + Selector1_b4_in;
            rtb_ImpAsg_InsertedFor_Out1__fn_func(d1, d2, d3) = max(rtb_ImpAsg_InsertedFor_Out_at_o_func(d1, d2, d3),0.000000000f);
            rtb_ImpAsg_InsertedFor_Out1__fn_clamped(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_InsertedFor_Out1__fn_func, 0, {{0, 56}, {0, 56}, {0, 64}})(d1, d2, d3);
            RDom r5(0, 3, 0, 3, 0, 64);
            rtb_ImpAsg_InsertedFor_Output_l_func(d1, d2, d3) = sum(rtb_ImpAsg_InsertedFor_Out1__fn_clamped(d1+r5.x-1, d2+r5.y-1, r5.z) * Weights_Value_f_in(r5.x, r5.y, r5.z, d3))+pooled5_in(d3);
            rtb_ImpAsg_InsertedFor_Out_at_b_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Output_l_func(d1, d2, d3) * Selector_ha_in + Selector1_ni_in;
            rtb_ImpAsg_InsertedFor_Out1_a_a_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Out_at_b_func(d1, d2, d3) + rtb_ImpAsg_InsertedFor_Out1__dk_func(d1, d2, d3);
            rtb_ImpAsg_InsertedFor_Out1_a_d_func(d1, d2, d3) = max(rtb_ImpAsg_InsertedFor_Out1_a_a_func(d1, d2, d3),0.000000000f);
            rtb_ImpAsg_InsertedFor_Out1_a_d_clamped(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_InsertedFor_Out1_a_d_func, 0, {{0, 56}, {0, 56}, {0, 64}})(d1, d2, d3);
            RDom r6(0, 3, 0, 3, 0, 64);
            rtb_ImpAsg_InsertedFor_Output_h_func(d1, d2, d3) = sum(rtb_ImpAsg_InsertedFor_Out1_a_d_clamped(2*d1+r6.x-1, 2*d2+r6.y-1, r6.z) * Weights_Value_i_in(r6.x, r6.y, r6.z, d3))+pooled7_in(d3);
            rtb_ImpAsg_Inser_ge3aidxxc3fepd_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Output_h_func(d1, d2, d3) * Selector_by_in + Selector1_d_in;
            rtb_ImpAsg_InsertedFor_Out1_a_f_func(d1, d2, d3) = max(rtb_ImpAsg_Inser_ge3aidxxc3fepd_func(d1, d2, d3),0.000000000f);
            rtb_ImpAsg_InsertedFor_Out1_a_f_clamped(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_InsertedFor_Out1_a_f_func, 0, {{0, 28}, {0, 28}, {0, 128}})(d1, d2, d3);
            RDom r7(0, 3, 0, 3, 0, 128);
            rtb_ImpAsg_InsertedFor_Outpu_i0_func(d1, d2, d3) = sum(rtb_ImpAsg_InsertedFor_Out1_a_f_clamped(d1+r7.x-1, d2+r7.y-1, r7.z) * Weights_Value_p_in(r7.x, r7.y, r7.z, d3))+pooled7_in(d3);
            rtb_ImpAsg_Insert_ge3aidxxc3fep_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Outpu_i0_func(d1, d2, d3) * Selector_nv_in + Selector1_j_in;
            rtb_ImpAsg_InsertedFor_Out1_a_d_clamped_1(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_InsertedFor_Out1_a_d_func, 0, {{0, 56}, {0, 56}, {0, 64}})(d1, d2, d3);
            RDom r8(0, 64);
            rtb_ImpAsg_InsertedFor_Outpu_im_func(d1, d2, d3) = sum(rtb_ImpAsg_InsertedFor_Out1_a_d_clamped_1(2*d1, 2*d2, r8) * Weights_Value_c1_in(0, 0, r8, d3))+pooled7_in(d3);
            rtb_ImpAsg_Inse_ge3aidxxc3fepdc_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Outpu_im_func(d1, d2, d3) * Selector_d_in + Selector1_i_in;
            rtb_ImpAsg_InsertedFor_Out1_a_p_func(d1, d2, d3) = rtb_ImpAsg_Insert_ge3aidxxc3fep_func(d1, d2, d3) + rtb_ImpAsg_Inse_ge3aidxxc3fepdc_func(d1, d2, d3);
            rtb_ImpAsg_Inse_ke3scgxilhaxevx_func(d1, d2, d3) = max(rtb_ImpAsg_InsertedFor_Out1_a_p_func(d1, d2, d3),0.000000000f);
            rtb_ImpAsg_Inse_ke3scgxilhaxevx_clamped(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_Inse_ke3scgxilhaxevx_func, 0, {{0, 28}, {0, 28}, {0, 128}})(d1, d2, d3);
            RDom r9(0, 3, 0, 3, 0, 128);
            rtb_ImpAsg_InsertedFor_Output_b_func(d1, d2, d3) = sum(rtb_ImpAsg_Inse_ke3scgxilhaxevx_clamped(d1+r9.x-1, d2+r9.y-1, r9.z) * Weights_Value_m1_in(r9.x, r9.y, r9.z, d3))+pooled7_in(d3);
            rtb_ImpAsg_Inserte_ge3aidxxc3fe_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Output_b_func(d1, d2, d3) * Selector_n_in + Selector1_mp_in;
            rtb_ImpAsg_Insert_ke3scgxilhaxe_func(d1, d2, d3) = max(rtb_ImpAsg_Inserte_ge3aidxxc3fe_func(d1, d2, d3),0.000000000f);
            rtb_ImpAsg_Insert_ke3scgxilhaxe_clamped(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_Insert_ke3scgxilhaxe_func, 0, {{0, 28}, {0, 28}, {0, 128}})(d1, d2, d3);
            RDom r10(0, 3, 0, 3, 0, 128);
            rtb_ImpAsg_InsertedFor_Output_g_func(d1, d2, d3) = sum(rtb_ImpAsg_Insert_ke3scgxilhaxe_clamped(d1+r10.x-1, d2+r10.y-1, r10.z) * Weights_Value_ne_in(r10.x, r10.y, r10.z, d3))+pooled7_in(d3);
            rtb_ImpAsg_Inserted_ge3aidxxc3f_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Output_g_func(d1, d2, d3) * Selector_o4_in + Selector1_cf_in;
            rtb_ImpAsg_Inser_ke3scgxilhaxev_func(d1, d2, d3) = rtb_ImpAsg_Inserted_ge3aidxxc3f_func(d1, d2, d3) + rtb_ImpAsg_Inse_ke3scgxilhaxevx_func(d1, d2, d3);
            rtb_ImpAsg_Inserte_ke3scgxilhax_func(d1, d2, d3) = max(rtb_ImpAsg_Inser_ke3scgxilhaxev_func(d1, d2, d3),0.000000000f);
            rtb_ImpAsg_Inserte_ke3scgxilhax_clamped(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_Inserte_ke3scgxilhax_func, 0, {{0, 28}, {0, 28}, {0, 128}})(d1, d2, d3);
            RDom r11(0, 3, 0, 3, 0, 128);
            rtb_ImpAsg_InsertedFor_Output_c_func(d1, d2, d3) = sum(rtb_ImpAsg_Inserte_ke3scgxilhax_clamped(2*d1+r11.x-1, 2*d2+r11.y-1, r11.z) * Weights_Value_h_in(r11.x, r11.y, r11.z, d3))+pooled8_in(d3);
            rtb_ImpAsg_InsertedFo_ge3aidxxc_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Output_c_func(d1, d2, d3) * Selector_ih_in + Selector1_m_in;
            rtb_ImpAsg_InsertedF_ke3scgxilh_func(d1, d2, d3) = max(rtb_ImpAsg_InsertedFo_ge3aidxxc_func(d1, d2, d3),0.000000000f);
            rtb_ImpAsg_InsertedF_ke3scgxilh_clamped(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_InsertedF_ke3scgxilh_func, 0, {{0, 14}, {0, 14}, {0, 256}})(d1, d2, d3);
            RDom r12(0, 3, 0, 3, 0, 256);
            rtb_ImpAsg_InsertedFor_Output_p_func(d1, d2, d3) = sum(rtb_ImpAsg_InsertedF_ke3scgxilh_clamped(d1+r12.x-1, d2+r12.y-1, r12.z) * Weights_Value_l_in(r12.x, r12.y, r12.z, d3))+pooled8_in(d3);
            rtb_ImpAsg_InsertedFor_ge3aidxx_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Output_p_func(d1, d2, d3) * Selector_og_in + Selector1_ae_in;
            rtb_ImpAsg_Inserte_ke3scgxilhax_clamped_1(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_Inserte_ke3scgxilhax_func, 0, {{0, 28}, {0, 28}, {0, 128}})(d1, d2, d3);
            RDom r13(0, 128);
            rtb_ImpAsg_InsertedFor_Output_m_func(d1, d2, d3) = sum(rtb_ImpAsg_Inserte_ke3scgxilhax_clamped_1(2*d1, 2*d2, r13) * Weights_Value_b_in(0, 0, r13, d3))+pooled8_in(d3);
            rtb_ImpAsg_InsertedF_ge3aidxxc3_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Output_m_func(d1, d2, d3) * Selector_oa_in + Selector1_f_in;
            rtb_ImpAsg_Inserted_ke3scgxilha_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_ge3aidxx_func(d1, d2, d3) + rtb_ImpAsg_InsertedF_ge3aidxxc3_func(d1, d2, d3);
            rtb_ImpAsg_InsertedFo_ke3scgxil_func(d1, d2, d3) = max(rtb_ImpAsg_Inserted_ke3scgxilha_func(d1, d2, d3),0.000000000f);
            rtb_ImpAsg_InsertedFo_ke3scgxil_clamped(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_InsertedFo_ke3scgxil_func, 0, {{0, 14}, {0, 14}, {0, 256}})(d1, d2, d3);
            RDom r14(0, 3, 0, 3, 0, 256);
            rtb_ImpAsg_InsertedFor_Outpu_oo_func(d1, d2, d3) = sum(rtb_ImpAsg_InsertedFo_ke3scgxil_clamped(d1+r14.x-1, d2+r14.y-1, r14.z) * Weights_Value_k_in(r14.x, r14.y, r14.z, d3))+pooled8_in(d3);
            rtb_ImpAsg_InsertedFor__ge3aidx_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Outpu_oo_func(d1, d2, d3) * Selector_a_in + Selector1_l_in;
            rtb_ImpAsg_InsertedFor__ke3scgx_func(d1, d2, d3) = max(rtb_ImpAsg_InsertedFor__ge3aidx_func(d1, d2, d3),0.000000000f);
            rtb_ImpAsg_InsertedFor__ke3scgx_clamped(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_InsertedFor__ke3scgx_func, 0, {{0, 14}, {0, 14}, {0, 256}})(d1, d2, d3);
            RDom r15(0, 3, 0, 3, 0, 256);
            rtb_ImpAsg_InsertedFor_Output_f_func(d1, d2, d3) = sum(rtb_ImpAsg_InsertedFor__ke3scgx_clamped(d1+r15.x-1, d2+r15.y-1, r15.z) * Weights_Value_e_in(r15.x, r15.y, r15.z, d3))+pooled8_in(d3);
            rtb_ImpAsg_InsertedFor_O_ge3aid_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Output_f_func(d1, d2, d3) * Selector_i_in + Selector1_k_in;
            rtb_ImpAsg_InsertedFor_ke3scgxi_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_O_ge3aid_func(d1, d2, d3) + rtb_ImpAsg_InsertedFo_ke3scgxil_func(d1, d2, d3);
            rtb_ImpAsg_InsertedFor_O_ke3scg_func(d1, d2, d3) = max(rtb_ImpAsg_InsertedFor_ke3scgxi_func(d1, d2, d3),0.000000000f);
            rtb_ImpAsg_InsertedFor_O_ke3scg_clamped(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_InsertedFor_O_ke3scg_func, 0, {{0, 14}, {0, 14}, {0, 256}})(d1, d2, d3);
            RDom r16(0, 3, 0, 3, 0, 256);
            rtb_ImpAsg_InsertedFor_Outpu_i1_func(d1, d2, d3) = sum(rtb_ImpAsg_InsertedFor_O_ke3scg_clamped(2*d1+r16.x-1, 2*d2+r16.y-1, r16.z) * Weights_Value_j_in(r16.x, r16.y, r16.z, d3))+pooled9_in(d3);
            rtb_ImpAsg_InsertedFor_Out_ge3a_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Outpu_i1_func(d1, d2, d3) * Selector_h_in + Selector1_c_in;
            rtb_ImpAsg_InsertedFor_Out_ke3s_func(d1, d2, d3) = max(rtb_ImpAsg_InsertedFor_Out_ge3a_func(d1, d2, d3),0.000000000f);
            rtb_ImpAsg_InsertedFor_Out_ke3s_clamped(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_InsertedFor_Out_ke3s_func, 0, {{0, 7}, {0, 7}, {0, 512}})(d1, d2, d3);
            RDom r17(0, 3, 0, 3, 0, 512);
            rtb_ImpAsg_InsertedFor_Outpu_ox_func(d1, d2, d3) = sum(rtb_ImpAsg_InsertedFor_Out_ke3s_clamped(d1+r17.x-1, d2+r17.y-1, r17.z) * Weights_Value_kd_in(r17.x, r17.y, r17.z, d3))+pooled9_in(d3);
            rtb_ImpAsg_InsertedFor_Out__ge3_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Outpu_ox_func(d1, d2, d3) * Selector_be_in + Selector1_b5_in;
            rtb_ImpAsg_InsertedFor_O_ke3scg_clamped_1(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_InsertedFor_O_ke3scg_func, 0, {{0, 14}, {0, 14}, {0, 256}})(d1, d2, d3);
            RDom r18(0, 256);
            rtb_ImpAsg_InsertedFor_Output_n_func(d1, d2, d3) = sum(rtb_ImpAsg_InsertedFor_O_ke3scg_clamped_1(2*d1, 2*d2, r18) * Weights_Value_cp_in(0, 0, r18, d3))+pooled9_in(d3);
            rtb_ImpAsg_InsertedFor_Ou_ge3ai_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Output_n_func(d1, d2, d3) * Selector_hi_in + Selector1_a_in;
            rtb_ImpAsg_InsertedFor_Ou_ke3sc_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Out__ge3_func(d1, d2, d3) + rtb_ImpAsg_InsertedFor_Ou_ge3ai_func(d1, d2, d3);
            rtb_ImpAsg_InsertedFor_Out1_ke3_func(d1, d2, d3) = max(rtb_ImpAsg_InsertedFor_Ou_ke3sc_func(d1, d2, d3),0.000000000f);
            rtb_ImpAsg_InsertedFor_Out1_ke3_clamped(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_InsertedFor_Out1_ke3_func, 0, {{0, 7}, {0, 7}, {0, 512}})(d1, d2, d3);
            RDom r19(0, 3, 0, 3, 0, 512);
            rtb_ImpAsg_InsertedFor_Output_o_func(d1, d2, d3) = sum(rtb_ImpAsg_InsertedFor_Out1_ke3_clamped(d1+r19.x-1, d2+r19.y-1, r19.z) * Weights_Value_fc_in(r19.x, r19.y, r19.z, d3))+pooled9_in(d3);
            rtb_ImpAsg_InsertedFor_Out_a_ge_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Output_o_func(d1, d2, d3) * Selector_o_in + Selector1_n_in;
            rtb_ImpAsg_InsertedFor_Out1_a_k_func(d1, d2, d3) = max(rtb_ImpAsg_InsertedFor_Out_a_ge_func(d1, d2, d3),0.000000000f);
            rtb_ImpAsg_InsertedFor_Out1_a_k_clamped(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_InsertedFor_Out1_a_k_func, 0, {{0, 7}, {0, 7}, {0, 512}})(d1, d2, d3);
            RDom r20(0, 3, 0, 3, 0, 512);
            rtb_ImpAsg_InsertedFor_Output_i_func(d1, d2, d3) = sum(rtb_ImpAsg_InsertedFor_Out1_a_k_clamped(d1+r20.x-1, d2+r20.y-1, r20.z) * Weights_Value_li_in(r20.x, r20.y, r20.z, d3))+pooled9_in(d3);
            rtb_ImpAsg_InsertedFor_Out_at_g_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Output_i_func(d1, d2, d3) * Selector_b_in + Selector1_b_in;
            rtb_ImpAsg_InsertedFor_Out1__ke_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Out_at_g_func(d1, d2, d3) + rtb_ImpAsg_InsertedFor_Out1_ke3_func(d1, d2, d3);
            rtb_ImpAsg_InsertedFor_Out1_at_func(d1, d2, d3) = max(rtb_ImpAsg_InsertedFor_Out1__ke_func(d1, d2, d3),0.000000000f);
            rtb_ImpAsg_InsertedFor_Out1_at_fcn(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Out1_at_func(d1, d2, d3);
        }

        void schedule() {
        // Schedule is determined by autoscheduler. Need to set estimate on buffer
            if(using_autoscheduler()) {
                rtb_MatrixConcatenate_in.dim(2).set_estimate(0, 3);
                rtb_MatrixConcatenate_in.dim(1).set_estimate(0, 224);
                rtb_MatrixConcatenate_in.dim(0).set_estimate(0, 224);
                Weights_Value_in.dim(3).set_estimate(0, 64);
                Weights_Value_in.dim(2).set_estimate(0, 3);
                Weights_Value_in.dim(1).set_estimate(0, 7);
                Weights_Value_in.dim(0).set_estimate(0, 7);
                pooled5_in.dim(0).set_estimate(0, 64);
                Selector_in.set_estimate(1.0f);
                Selector1_in.set_estimate(1.0f);
                Weights_Value_m_in.dim(3).set_estimate(0, 64);
                Weights_Value_m_in.dim(2).set_estimate(0, 64);
                Weights_Value_m_in.dim(1).set_estimate(0, 3);
                Weights_Value_m_in.dim(0).set_estimate(0, 3);
                Selector_h0_in.set_estimate(1.0f);
                Selector1_jp_in.set_estimate(1.0f);
                Weights_Value_c_in.dim(3).set_estimate(0, 64);
                Weights_Value_c_in.dim(2).set_estimate(0, 64);
                Weights_Value_c_in.dim(1).set_estimate(0, 3);
                Weights_Value_c_in.dim(0).set_estimate(0, 3);
                Selector_g_in.set_estimate(1.0f);
                Selector1_nd_in.set_estimate(1.0f);
                Weights_Value_n_in.dim(3).set_estimate(0, 64);
                Weights_Value_n_in.dim(2).set_estimate(0, 64);
                Weights_Value_n_in.dim(1).set_estimate(0, 3);
                Weights_Value_n_in.dim(0).set_estimate(0, 3);
                Selector_nb_in.set_estimate(1.0f);
                Selector1_b4_in.set_estimate(1.0f);
                Weights_Value_f_in.dim(3).set_estimate(0, 64);
                Weights_Value_f_in.dim(2).set_estimate(0, 64);
                Weights_Value_f_in.dim(1).set_estimate(0, 3);
                Weights_Value_f_in.dim(0).set_estimate(0, 3);
                Selector_ha_in.set_estimate(1.0f);
                Selector1_ni_in.set_estimate(1.0f);
                Weights_Value_i_in.dim(3).set_estimate(0, 128);
                Weights_Value_i_in.dim(2).set_estimate(0, 64);
                Weights_Value_i_in.dim(1).set_estimate(0, 3);
                Weights_Value_i_in.dim(0).set_estimate(0, 3);
                pooled7_in.dim(0).set_estimate(0, 128);
                Selector_by_in.set_estimate(1.0f);
                Selector1_d_in.set_estimate(1.0f);
                Weights_Value_p_in.dim(3).set_estimate(0, 128);
                Weights_Value_p_in.dim(2).set_estimate(0, 128);
                Weights_Value_p_in.dim(1).set_estimate(0, 3);
                Weights_Value_p_in.dim(0).set_estimate(0, 3);
                Selector_nv_in.set_estimate(1.0f);
                Selector1_j_in.set_estimate(1.0f);
                Weights_Value_c1_in.dim(3).set_estimate(0, 128);
                Weights_Value_c1_in.dim(2).set_estimate(0, 64);
                Weights_Value_c1_in.dim(1).set_estimate(0, 1);
                Weights_Value_c1_in.dim(0).set_estimate(0, 1);
                Selector_d_in.set_estimate(1.0f);
                Selector1_i_in.set_estimate(1.0f);
                Weights_Value_m1_in.dim(3).set_estimate(0, 128);
                Weights_Value_m1_in.dim(2).set_estimate(0, 128);
                Weights_Value_m1_in.dim(1).set_estimate(0, 3);
                Weights_Value_m1_in.dim(0).set_estimate(0, 3);
                Selector_n_in.set_estimate(1.0f);
                Selector1_mp_in.set_estimate(1.0f);
                Weights_Value_ne_in.dim(3).set_estimate(0, 128);
                Weights_Value_ne_in.dim(2).set_estimate(0, 128);
                Weights_Value_ne_in.dim(1).set_estimate(0, 3);
                Weights_Value_ne_in.dim(0).set_estimate(0, 3);
                Selector_o4_in.set_estimate(1.0f);
                Selector1_cf_in.set_estimate(1.0f);
                Weights_Value_h_in.dim(3).set_estimate(0, 256);
                Weights_Value_h_in.dim(2).set_estimate(0, 128);
                Weights_Value_h_in.dim(1).set_estimate(0, 3);
                Weights_Value_h_in.dim(0).set_estimate(0, 3);
                pooled8_in.dim(0).set_estimate(0, 256);
                Selector_ih_in.set_estimate(1.0f);
                Selector1_m_in.set_estimate(1.0f);
                Weights_Value_l_in.dim(3).set_estimate(0, 256);
                Weights_Value_l_in.dim(2).set_estimate(0, 256);
                Weights_Value_l_in.dim(1).set_estimate(0, 3);
                Weights_Value_l_in.dim(0).set_estimate(0, 3);
                Selector_og_in.set_estimate(1.0f);
                Selector1_ae_in.set_estimate(1.0f);
                Weights_Value_b_in.dim(3).set_estimate(0, 256);
                Weights_Value_b_in.dim(2).set_estimate(0, 128);
                Weights_Value_b_in.dim(1).set_estimate(0, 1);
                Weights_Value_b_in.dim(0).set_estimate(0, 1);
                Selector_oa_in.set_estimate(1.0f);
                Selector1_f_in.set_estimate(1.0f);
                Weights_Value_k_in.dim(3).set_estimate(0, 256);
                Weights_Value_k_in.dim(2).set_estimate(0, 256);
                Weights_Value_k_in.dim(1).set_estimate(0, 3);
                Weights_Value_k_in.dim(0).set_estimate(0, 3);
                Selector_a_in.set_estimate(1.0f);
                Selector1_l_in.set_estimate(1.0f);
                Weights_Value_e_in.dim(3).set_estimate(0, 256);
                Weights_Value_e_in.dim(2).set_estimate(0, 256);
                Weights_Value_e_in.dim(1).set_estimate(0, 3);
                Weights_Value_e_in.dim(0).set_estimate(0, 3);
                Selector_i_in.set_estimate(1.0f);
                Selector1_k_in.set_estimate(1.0f);
                Weights_Value_j_in.dim(3).set_estimate(0, 512);
                Weights_Value_j_in.dim(2).set_estimate(0, 256);
                Weights_Value_j_in.dim(1).set_estimate(0, 3);
                Weights_Value_j_in.dim(0).set_estimate(0, 3);
                pooled9_in.dim(0).set_estimate(0, 512);
                Selector_h_in.set_estimate(1.0f);
                Selector1_c_in.set_estimate(1.0f);
                Weights_Value_kd_in.dim(3).set_estimate(0, 512);
                Weights_Value_kd_in.dim(2).set_estimate(0, 512);
                Weights_Value_kd_in.dim(1).set_estimate(0, 3);
                Weights_Value_kd_in.dim(0).set_estimate(0, 3);
                Selector_be_in.set_estimate(1.0f);
                Selector1_b5_in.set_estimate(1.0f);
                Weights_Value_cp_in.dim(3).set_estimate(0, 512);
                Weights_Value_cp_in.dim(2).set_estimate(0, 256);
                Weights_Value_cp_in.dim(1).set_estimate(0, 1);
                Weights_Value_cp_in.dim(0).set_estimate(0, 1);
                Selector_hi_in.set_estimate(1.0f);
                Selector1_a_in.set_estimate(1.0f);
                Weights_Value_fc_in.dim(3).set_estimate(0, 512);
                Weights_Value_fc_in.dim(2).set_estimate(0, 512);
                Weights_Value_fc_in.dim(1).set_estimate(0, 3);
                Weights_Value_fc_in.dim(0).set_estimate(0, 3);
                Selector_o_in.set_estimate(1.0f);
                Selector1_n_in.set_estimate(1.0f);
                Weights_Value_li_in.dim(3).set_estimate(0, 512);
                Weights_Value_li_in.dim(2).set_estimate(0, 512);
                Weights_Value_li_in.dim(1).set_estimate(0, 3);
                Weights_Value_li_in.dim(0).set_estimate(0, 3);
                Selector_b_in.set_estimate(1.0f);
                Selector1_b_in.set_estimate(1.0f);
                rtb_ImpAsg_InsertedFor_Out1_at_fcn.set_estimate(d1, 0, 7).set_estimate(d2, 0, 7).set_estimate(d3, 0, 512);
            }  else {
                // Default schedule
            }
        }

    private:
        Var d1{"d1"};
        Var d2{"d2"};
        Var d3{"d3"};
        Var d4{"d4"};
        Func rtb_MatrixConcatenate_clamped{"rtb_MatrixConcatenate_clamped"};
        Func rtb_ImpAsg_InsertedFor_Outpu_lq_func{"rtb_ImpAsg_InsertedFor_Outpu_lq_func"};
        Func rtb_ImpAsg_InsertedFor_Out_at_i_func{"rtb_ImpAsg_InsertedFor_Out_at_i_func"};
        Func rtb_ImpAsg_InsertedFor_Out1__ph_func{"rtb_ImpAsg_InsertedFor_Out1__ph_func"};
        Func rtb_ImpAsg_InsertedFor_Out1__ph_clamped{"rtb_ImpAsg_InsertedFor_Out1__ph_clamped"};
        Func rtb_ImpAsg_InsertedFor_Out1_a_n_func{"rtb_ImpAsg_InsertedFor_Out1_a_n_func"};
        Func rtb_ImpAsg_InsertedFor_Out1_a_n_clamped{"rtb_ImpAsg_InsertedFor_Out1_a_n_clamped"};
        Func rtb_ImpAsg_InsertedFor_Output_d_func{"rtb_ImpAsg_InsertedFor_Output_d_func"};
        Func rtb_ImpAsg_InsertedFor_Out_a_fm_func{"rtb_ImpAsg_InsertedFor_Out_a_fm_func"};
        Func rtb_ImpAsg_InsertedFor_Out1_a_h_func{"rtb_ImpAsg_InsertedFor_Out1_a_h_func"};
        Func rtb_ImpAsg_InsertedFor_Out1_a_h_clamped{"rtb_ImpAsg_InsertedFor_Out1_a_h_clamped"};
        Func rtb_ImpAsg_InsertedFor_Outpu_go_func{"rtb_ImpAsg_InsertedFor_Outpu_go_func"};
        Func rtb_ImpAsg_InsertedFor_Out_at_f_func{"rtb_ImpAsg_InsertedFor_Out_at_f_func"};
        Func rtb_ImpAsg_InsertedFor_Out1__kq_func{"rtb_ImpAsg_InsertedFor_Out1__kq_func"};
        Func rtb_ImpAsg_InsertedFor_Out1__dk_func{"rtb_ImpAsg_InsertedFor_Out1__dk_func"};
        Func rtb_ImpAsg_InsertedFor_Out1__dk_clamped{"rtb_ImpAsg_InsertedFor_Out1__dk_clamped"};
        Func rtb_ImpAsg_InsertedFor_Outpu_gz_func{"rtb_ImpAsg_InsertedFor_Outpu_gz_func"};
        Func rtb_ImpAsg_InsertedFor_Out_at_o_func{"rtb_ImpAsg_InsertedFor_Out_at_o_func"};
        Func rtb_ImpAsg_InsertedFor_Out1__fn_func{"rtb_ImpAsg_InsertedFor_Out1__fn_func"};
        Func rtb_ImpAsg_InsertedFor_Out1__fn_clamped{"rtb_ImpAsg_InsertedFor_Out1__fn_clamped"};
        Func rtb_ImpAsg_InsertedFor_Output_l_func{"rtb_ImpAsg_InsertedFor_Output_l_func"};
        Func rtb_ImpAsg_InsertedFor_Out_at_b_func{"rtb_ImpAsg_InsertedFor_Out_at_b_func"};
        Func rtb_ImpAsg_InsertedFor_Out1_a_a_func{"rtb_ImpAsg_InsertedFor_Out1_a_a_func"};
        Func rtb_ImpAsg_InsertedFor_Out1_a_d_func{"rtb_ImpAsg_InsertedFor_Out1_a_d_func"};
        Func rtb_ImpAsg_InsertedFor_Out1_a_d_clamped{"rtb_ImpAsg_InsertedFor_Out1_a_d_clamped"};
        Func rtb_ImpAsg_InsertedFor_Output_h_func{"rtb_ImpAsg_InsertedFor_Output_h_func"};
        Func rtb_ImpAsg_Inser_ge3aidxxc3fepd_func{"rtb_ImpAsg_Inser_ge3aidxxc3fepd_func"};
        Func rtb_ImpAsg_InsertedFor_Out1_a_f_func{"rtb_ImpAsg_InsertedFor_Out1_a_f_func"};
        Func rtb_ImpAsg_InsertedFor_Out1_a_f_clamped{"rtb_ImpAsg_InsertedFor_Out1_a_f_clamped"};
        Func rtb_ImpAsg_InsertedFor_Outpu_i0_func{"rtb_ImpAsg_InsertedFor_Outpu_i0_func"};
        Func rtb_ImpAsg_Insert_ge3aidxxc3fep_func{"rtb_ImpAsg_Insert_ge3aidxxc3fep_func"};
        Func rtb_ImpAsg_InsertedFor_Out1_a_d_clamped_1{"rtb_ImpAsg_InsertedFor_Out1_a_d_clamped_1"};
        Func rtb_ImpAsg_InsertedFor_Outpu_im_func{"rtb_ImpAsg_InsertedFor_Outpu_im_func"};
        Func rtb_ImpAsg_Inse_ge3aidxxc3fepdc_func{"rtb_ImpAsg_Inse_ge3aidxxc3fepdc_func"};
        Func rtb_ImpAsg_InsertedFor_Out1_a_p_func{"rtb_ImpAsg_InsertedFor_Out1_a_p_func"};
        Func rtb_ImpAsg_Inse_ke3scgxilhaxevx_func{"rtb_ImpAsg_Inse_ke3scgxilhaxevx_func"};
        Func rtb_ImpAsg_Inse_ke3scgxilhaxevx_clamped{"rtb_ImpAsg_Inse_ke3scgxilhaxevx_clamped"};
        Func rtb_ImpAsg_InsertedFor_Output_b_func{"rtb_ImpAsg_InsertedFor_Output_b_func"};
        Func rtb_ImpAsg_Inserte_ge3aidxxc3fe_func{"rtb_ImpAsg_Inserte_ge3aidxxc3fe_func"};
        Func rtb_ImpAsg_Insert_ke3scgxilhaxe_func{"rtb_ImpAsg_Insert_ke3scgxilhaxe_func"};
        Func rtb_ImpAsg_Insert_ke3scgxilhaxe_clamped{"rtb_ImpAsg_Insert_ke3scgxilhaxe_clamped"};
        Func rtb_ImpAsg_InsertedFor_Output_g_func{"rtb_ImpAsg_InsertedFor_Output_g_func"};
        Func rtb_ImpAsg_Inserted_ge3aidxxc3f_func{"rtb_ImpAsg_Inserted_ge3aidxxc3f_func"};
        Func rtb_ImpAsg_Inser_ke3scgxilhaxev_func{"rtb_ImpAsg_Inser_ke3scgxilhaxev_func"};
        Func rtb_ImpAsg_Inserte_ke3scgxilhax_func{"rtb_ImpAsg_Inserte_ke3scgxilhax_func"};
        Func rtb_ImpAsg_Inserte_ke3scgxilhax_clamped{"rtb_ImpAsg_Inserte_ke3scgxilhax_clamped"};
        Func rtb_ImpAsg_InsertedFor_Output_c_func{"rtb_ImpAsg_InsertedFor_Output_c_func"};
        Func rtb_ImpAsg_InsertedFo_ge3aidxxc_func{"rtb_ImpAsg_InsertedFo_ge3aidxxc_func"};
        Func rtb_ImpAsg_InsertedF_ke3scgxilh_func{"rtb_ImpAsg_InsertedF_ke3scgxilh_func"};
        Func rtb_ImpAsg_InsertedF_ke3scgxilh_clamped{"rtb_ImpAsg_InsertedF_ke3scgxilh_clamped"};
        Func rtb_ImpAsg_InsertedFor_Output_p_func{"rtb_ImpAsg_InsertedFor_Output_p_func"};
        Func rtb_ImpAsg_InsertedFor_ge3aidxx_func{"rtb_ImpAsg_InsertedFor_ge3aidxx_func"};
        Func rtb_ImpAsg_Inserte_ke3scgxilhax_clamped_1{"rtb_ImpAsg_Inserte_ke3scgxilhax_clamped_1"};
        Func rtb_ImpAsg_InsertedFor_Output_m_func{"rtb_ImpAsg_InsertedFor_Output_m_func"};
        Func rtb_ImpAsg_InsertedF_ge3aidxxc3_func{"rtb_ImpAsg_InsertedF_ge3aidxxc3_func"};
        Func rtb_ImpAsg_Inserted_ke3scgxilha_func{"rtb_ImpAsg_Inserted_ke3scgxilha_func"};
        Func rtb_ImpAsg_InsertedFo_ke3scgxil_func{"rtb_ImpAsg_InsertedFo_ke3scgxil_func"};
        Func rtb_ImpAsg_InsertedFo_ke3scgxil_clamped{"rtb_ImpAsg_InsertedFo_ke3scgxil_clamped"};
        Func rtb_ImpAsg_InsertedFor_Outpu_oo_func{"rtb_ImpAsg_InsertedFor_Outpu_oo_func"};
        Func rtb_ImpAsg_InsertedFor__ge3aidx_func{"rtb_ImpAsg_InsertedFor__ge3aidx_func"};
        Func rtb_ImpAsg_InsertedFor__ke3scgx_func{"rtb_ImpAsg_InsertedFor__ke3scgx_func"};
        Func rtb_ImpAsg_InsertedFor__ke3scgx_clamped{"rtb_ImpAsg_InsertedFor__ke3scgx_clamped"};
        Func rtb_ImpAsg_InsertedFor_Output_f_func{"rtb_ImpAsg_InsertedFor_Output_f_func"};
        Func rtb_ImpAsg_InsertedFor_O_ge3aid_func{"rtb_ImpAsg_InsertedFor_O_ge3aid_func"};
        Func rtb_ImpAsg_InsertedFor_ke3scgxi_func{"rtb_ImpAsg_InsertedFor_ke3scgxi_func"};
        Func rtb_ImpAsg_InsertedFor_O_ke3scg_func{"rtb_ImpAsg_InsertedFor_O_ke3scg_func"};
        Func rtb_ImpAsg_InsertedFor_O_ke3scg_clamped{"rtb_ImpAsg_InsertedFor_O_ke3scg_clamped"};
        Func rtb_ImpAsg_InsertedFor_Outpu_i1_func{"rtb_ImpAsg_InsertedFor_Outpu_i1_func"};
        Func rtb_ImpAsg_InsertedFor_Out_ge3a_func{"rtb_ImpAsg_InsertedFor_Out_ge3a_func"};
        Func rtb_ImpAsg_InsertedFor_Out_ke3s_func{"rtb_ImpAsg_InsertedFor_Out_ke3s_func"};
        Func rtb_ImpAsg_InsertedFor_Out_ke3s_clamped{"rtb_ImpAsg_InsertedFor_Out_ke3s_clamped"};
        Func rtb_ImpAsg_InsertedFor_Outpu_ox_func{"rtb_ImpAsg_InsertedFor_Outpu_ox_func"};
        Func rtb_ImpAsg_InsertedFor_Out__ge3_func{"rtb_ImpAsg_InsertedFor_Out__ge3_func"};
        Func rtb_ImpAsg_InsertedFor_O_ke3scg_clamped_1{"rtb_ImpAsg_InsertedFor_O_ke3scg_clamped_1"};
        Func rtb_ImpAsg_InsertedFor_Output_n_func{"rtb_ImpAsg_InsertedFor_Output_n_func"};
        Func rtb_ImpAsg_InsertedFor_Ou_ge3ai_func{"rtb_ImpAsg_InsertedFor_Ou_ge3ai_func"};
        Func rtb_ImpAsg_InsertedFor_Ou_ke3sc_func{"rtb_ImpAsg_InsertedFor_Ou_ke3sc_func"};
        Func rtb_ImpAsg_InsertedFor_Out1_ke3_func{"rtb_ImpAsg_InsertedFor_Out1_ke3_func"};
        Func rtb_ImpAsg_InsertedFor_Out1_ke3_clamped{"rtb_ImpAsg_InsertedFor_Out1_ke3_clamped"};
        Func rtb_ImpAsg_InsertedFor_Output_o_func{"rtb_ImpAsg_InsertedFor_Output_o_func"};
        Func rtb_ImpAsg_InsertedFor_Out_a_ge_func{"rtb_ImpAsg_InsertedFor_Out_a_ge_func"};
        Func rtb_ImpAsg_InsertedFor_Out1_a_k_func{"rtb_ImpAsg_InsertedFor_Out1_a_k_func"};
        Func rtb_ImpAsg_InsertedFor_Out1_a_k_clamped{"rtb_ImpAsg_InsertedFor_Out1_a_k_clamped"};
        Func rtb_ImpAsg_InsertedFor_Output_i_func{"rtb_ImpAsg_InsertedFor_Output_i_func"};
        Func rtb_ImpAsg_InsertedFor_Out_at_g_func{"rtb_ImpAsg_InsertedFor_Out_at_g_func"};
        Func rtb_ImpAsg_InsertedFor_Out1__ke_func{"rtb_ImpAsg_InsertedFor_Out1__ke_func"};
        Func rtb_ImpAsg_InsertedFor_Out1_at_func{"rtb_ImpAsg_InsertedFor_Out1_at_func"};
};
HALIDE_REGISTER_GENERATOR(resnet18Subset, resnet18SubsetGenerator)

[ivangarcia44]

This issue is reproducible without the Adams autoscheduler. Updated the title and description to reflect that this is a Halide issue, not an Adams autoscheduler issue. In addition to AMD, I was able to reproduce this in Intel. In a month from now, I will try this on Windows as well.

[abadams]

What schedule are you using in the case where it stalls without the autoscheduler? Does it also stall with the Mullapudi autoscheduler?

[ivangarcia44]

What schedule are you using in the case where it stalls without the autoscheduler? Does it also stall with the Mullapudi autoscheduler?

No autoscheduler is used. I did not try Mullapudi. If it fails with Adams and without autoscheduler I assume it will fail also with Mullapudi right?

Here are the commands I used which you can see also under the reproduction steps above (below the "Run plain Halide" section):

g++ resnet18Subset.cpp -std=c++17 -g -I $HALIDE_FOLDER/include/ -L $HALIDE_FOLDER/bin/ -lHalide -lpthread -ldl -rdynamic -fno-rtti -Wl,-rpath,$HALIDE_FOLDER/bin/ $HALIDE_FOLDER/tools/GenGen.cpp -o bin1/resnet18SubsetLib
./bin1/resnet18SubsetLib -f resnet18SubsetFun -g resnet18SubsetGenerator -e static_library,h,assembly,bitcode,cpp,html,cpp_stub,stmt,o,schedule target=host-enable_llvm_loop_opt -o bin1

[ivangarcia44]

What schedule are you using in the case where it stalls without the autoscheduler? Does it also stall with the Mullapudi autoscheduler?

I misread your question sorry, no schedule is used, you can see the full Halide generator class code above as well.

[abadams]

It's not really possible to use Halide without a schedule. The default schedule for a Func is to inline it into its consumers. This is a good default because it encourages you to use lots of small Funcs to decompose your code and have lots of options for scheduling, without paying the cost of having to mention them all in the schedule. This doesn't make sense for a pipeline output, so the default schedule for those is compute_root(). If you don't apply a schedule to any Funcs in a pipeline, it tries to recursively inline the entire pipeline into the output Func, which can require a combinatorially-large amount of compile time, so it stalling in that case is sort of working-as-intended. A just-make-it-compile-and-run schedule would be to call .compute_root() on every Func.

Adams 2019 uses a schedule search algorithm that can be slow for large pipelines. Mullapudi 2016 is a faster autoscheduler.

[ivangarcia44]

Thank you for the suggestion. We can't use Mullapudi at this point but it could be considered in the future. I will keep this issue open in case someone might want to volunteer to improve this in the Adams autoscheduler.

[ivangarcia44]

This issue is reproducible in Windows. Tried the pipeline reported in this issue with Adams autoscheduler and it has been running today since around 10am. It is 8:27 pm now and it is still running.

[ivangarcia44]

Following up with the last comment, the autoscheduler in Windows ran more than 1 day and crashed my Alienware machine. As originally reported, the same reproduction steps killed my Linux Debian 11 machine a few times. This issue is platform independent.