Advice for architecture of a code that uses Halide

[chkone]

How can I properly architecture a code that uses Halide around a collection of kernels to be able to benefit a proper autoschedule.

Let say I want to implement various reusable kernel:
Toy example for 1D Buffer:
Dot, WeightedArithemeticMean, Total:

Halide::Func	Total( Halide::Func&& a, Halide::Expr width )
{
	Halide::RDom oDom( 0, width );
	Halide::Func oTotal{ "Total" };
	oTotal() = Halide::sum( a( oDom ) );
	return oTotal;
}

Halide::Func	Dot( Halide::Func&& a, Halide::Func&& b, Halide::Expr&& width )
{
	Halide::Func oDot{ "Dot" };
	Halide::RDom oDom( 0, width );
	oDot() = Halide::sum( a( oDom )*b( oDom ) );
	return oDot;
}

Halide::Func	WeightedArithmeticMean( Halide::Func&& a, Halide::Func&& weights, Halide::Expr&& width )
{
	Halide::Func oWeightedArithmeticMean{ "WeightedArithmeticMean" };

	Halide::Func oTotalWeighted	{ "TotalWeighted" };
	oTotalWeighted	= Packages::Arithmetic::Dot( std::move( a ), std::move( weights ), std::move( width ) );
	Halide::Func oTotalWeights	{ "TotalWeights" };
	oTotalWeights		= Packages::Arithmetic::Total( std::move( weights ), width );

	oWeightedArithmeticMean() = oTotalWeighted()/oTotalWeights();
}

And for example for the autoschedule I do:

void Statistics_WeightedArithmeticMean::generate()
{
	Halide::Func fa{ "fa" };
	Halide::Func fw{ "fweights" };

	Halide::Expr oZero = 0;
	fa = Halide::BoundaryConditions::constant_exterior(a, oZero);
	fw = Halide::BoundaryConditions::constant_exterior(w, oZero);

	Halide::Func oWeightedArithmeticMean = WeightedArithmeticMean(std::move(fa), std::move(fw), a.width());

	y() = oWeightedArithmeticMean();
}

Statistics_WeightedArithmeticMean members':

Halide::GeneratorOutput< Halide::Buffer< ScalarType > >	y{ "y", 0 };
Halide::GeneratorInput< Halide::Buffer< ScalarType > >	a{ "a", 1 };
Halide::GeneratorInput< Halide::Buffer< ScalarType > >	w{ "weights", 1 };

Here the scheduler give me not inlined results with bunch of func:

    Func y = pipeline.get_func(10);
    Func ArithmeticMean_1 = pipeline.get_func(9);
    Func sum_1 = pipeline.get_func(8);
    Func Powed2 = pipeline.get_func(7);
    Func BufferShifted = pipeline.get_func(6);
    Func ArithmeticMean = pipeline.get_func(5);
    Func sum = pipeline.get_func(4);
    Func constant_exterior = pipeline.get_func(3);
    Func repeat_edge = pipeline.get_func(2);
    Func lambda_0 = pipeline.get_func(1);
    RVar r28_x(sum_1.update(0).get_schedule().dims()[0].var);
    RVar r8_x(sum.update(0).get_schedule().dims()[0].var);
    y
        .compute_root();
    sum_1
        .compute_root();
    sum_1.update(0);
    sum
        .compute_root();
    sum.update(0);

I would like to find a way to describe kernel & subkernel that take as input, Func or Buffer or GeneratorInput (with Expr?). Which abstract properly to have "clean" c_source or/and schedule.

Is it safe to send Func, Expr, Var by ref or do we need a copy (in the intention of apply a autoschedule)?

I would like to have those Kernel: Dot, Total, WeightedArithmeticMean to be called independently or as a sub-step in a larger AST.