producer's bound seems to be inferred incorrectly

[zhouwangpei123]

The size of output_a is the same as output_b. when i do tiles( each tile is 512x32 ), I expecte the buffer allocated for w_sum_wsz(which is the producer for both output_a and output_b) is (512+window_size) x (32 + window_size). But from stmt file, it seems that the buffer size allocated for each tile is (output_b.extent.0 + window_size) * (32 + window_size).

code example:

class GuidedFilterCoeff : public Halide::Generator<GuidedFilterCoeff> {

public:

    Input<Buffer<uint16_t, 2>> input {"input"};
    Input<int32_t> wsz{"window_size"};
    Input<float_t> e{"epsilon"};
    Output<Buffer<uint16_t, 2>> output_a{"output_a"};
    Output<Buffer<uint16_t, 2>> output_b{"output_b"};

    void generate() {
        Var x, y, xo, yo, xi, yi, t, xi_i, xi_o;
        Expr hwsz = wsz >> 1;
        Expr inv = 1.f / ((2*hwsz+1) * (2*hwsz+1));
        Func sum_wsz{"sum_wsz"};
        Func square_sum_wsz{"square_sum_wsz"};
        Func weight{"weight"};
        Func w_sum_wsz{"w_sum_wsz"};
        Func wave_sum_wsz{"wave_sum_wsz"};
        Func wvar_sum_wsz{"wvar_sum_wsz"};
        Func average{"average"}, variance{"variance"};
        Func input_clamped{"input_clamped"};

        input_clamped = BoundaryConditions::repeat_edge(input);

        RDom r(-hwsz, wsz, -hwsz, wsz);

        //sum and sqaure_sum  over window
        sum_wsz(x, y) = sum(cast(Int(32), input_clamped(x+r.x, y+r.y)));
        square_sum_wsz(x, y) = sum(pow(cast(Int(32), input_clamped(x+r.x, y+r.y)), 2));

        //average and variance
        average(x, y)  = cast(Int(32), sum_wsz(x, y)) * inv;
        variance(x, y) = cast(Int(32), square_sum_wsz(x, y)) * inv - pow(average(x, y), 2);
        weight(x, y) = cast(Int(32), 1024.F * variance(x, y) / (variance(x, y)+e) );

        //weighted average and variance
        w_sum_wsz(x, y) = sum(weight(x+r.x, y+r.y));
        wave_sum_wsz(x, y) = sum(weight(x+r.x, y+r.y) * average(x+r.x, y+r.y));
        wvar_sum_wsz(x, y) = sum(weight(x+r.x, y+r.y) * variance(x+r.x, y+r.y));

        //normalize 
        output_b(x, y) = cast(UInt(16), wave_sum_wsz(x, y) / w_sum_wsz(x, y));
        output_a(x, y) = cast(UInt(16), wvar_sum_wsz(x, y) / w_sum_wsz(x, y));
  
        if (!auto_schedule) {

            if (get_target().has_gpu_feature()) {
                //TODO

            } else {
                const int vec = 8;

                /*Schedule 1: 234ms on Intel(R) Core(TM) i7-7700 CPU @ 3.60GHz*/
                output_a
                    .compute_root()
                    .tile(x, y, xo, yo, xi, yi, 512, 32)
                    .fuse(xo, yo, t)
                    .parallel(t)
                    .vectorize(xi, vec);
                output_b
                    .compute_root()
                    .tile(x, y, xo, yo, xi, yi, 512, 32)
                    .fuse(xo, yo, t)
                    .parallel(t)
                    .vectorize(xi, vec);
                output_b.compute_with(output_a, t);

                w_sum_wsz
                    .compute_at(output_a, t)
                    .split(x, xo, xi, 8)
                    .vectorize(xi, vec);
                wave_sum_wsz
                    .compute_at(output_a, t)
                    .split(x, xo, xi, 8)
                    .vectorize(xi, vec);
                wvar_sum_wsz
                    .compute_at(output_a, t)
                    .split(x, xo, xi, 8)
                    .vectorize(xi, vec);

                variance
                    .compute_at(output_a, t)
                    .split(x, xo, xi, 8)
                    .vectorize(xi, vec);
                average
                    .compute_at(output_a, t)
                    .split(x, xo, xi, 8)
                    .vectorize(xi, vec);
                weight
                    .compute_at(output_a, t)
                    .split(x, xo, xi, 8)
                    .vectorize(xi, vec);

                sum_wsz
                    .compute_at(output_a, t)
                    .split(x, xo, xi, 8)
                    .vectorize(xi, vec);
                square_sum_wsz
                    .compute_at(output_a, t)
                    .split(x, xo, xi, 8)
                    .vectorize(xi, vec);
            }

        }
    }
};

part of stmt file

if (output_a.s0.v0.v2.fused.v6 < output_a.s0.v0.v2.fused.v6.prologue) {
 let output_b.s0.v1.min_1.s = min((output_a.s0.v0.v2.fused.v6/t11235)*32, output_b.extent.1 + -32)
 let output_b.s0.v1.max_1.s = min(min(min(output_b.s0.v0.v2.v6.loop_max.s + -1, output_a.s0.v0.v2.fused.v6)/t11235, output_a.s0.v0.v2.fused.v6/t11235)*32, output_b.extent.1 + -32)
 let output_a.s0.v1.min_1.s = min((output_a.s0.v0.v2.fused.v6/t11236)*32, output_a.extent.1 + -32)
 let output_a.s0.v0.min_1.s = min((output_a.s0.v0.v2.fused.v6 % t11236)*512, output_a.extent.0 + -512)
 let output_a.s0.v0.max_1.s = min((output_a.s0.v0.v2.fused.v6 % t11236)*512, output_a.extent.0 + -512)
 let w_sum_wsz.s0.v1.max_1.s = max(output_a.min.1 + output_a.s0.v1.min_1.s, output_b.min.1 + output_b.s0.v1.max_1.s)
 let w_sum_wsz.s0.v1.min_1 = min(output_a.min.1 + output_a.s0.v1.min_1.s, output_b.min.1 + output_b.s0.v1.min_1.s)
 let w_sum_wsz.s0.v0.max_1.s = max(output_b.extent.0 + output_b.min.0, (output_a.min.0 + output_a.s0.v0.max_1.s) + 512)
 let w_sum_wsz.s0.v0.min_1 = min(output_a.min.0 + output_a.s0.v0.min_1.s, output_b.min.0)
 let weight.s0.v1.min_1 = w_sum_wsz.s0.v1.min_1 - t11253
 let weight.s0.v0.min_1 = w_sum_wsz.s0.v0.min_1 - t11253
 let sum_wsz.v0.min_realized = min((t11237 + w_sum_wsz.s0.v0.max_1.s) + -9, weight.s0.v0.min_1)
 let sum_wsz.v0.extent_realized.s.s = let t11689 = (t11237 + w_sum_wsz.s0.v0.max_1.s) in min(((((t11689 - weight.s0.v0.min_1) + -2)/8)*8) + weight.s0.v0.min_1, t11689 + -9)
 allocate sum_wsz[int32 * ((sum_wsz.v0.extent_realized.s.s - sum_wsz.v0.min_realized) + 8) * (((t11237 + w_sum_wsz.s0.v1.max_1.s) - weight.s0.v1.min_1) + 31)] if ((output_a.s0.v0.v2.fused.v6 + 1) <= t11240)
 if ((output_a.s0.v0.v2.fused.v6 + 1) <= t11240) {
  produce sum_wsz {
   let t11261 = t11237 + w_sum_wsz.s0.v0.max_1.s
   let t11256 = ((t11261 - weight.s0.v0.min_1) + 6)/8
   let t11255 = (t11237 + w_sum_wsz.s0.v1.max_1.s) - weight.s0.v1.min_1
   let t11259 = weight.s0.v1.min_1 - input.min.1
   let t11260 = sum_wsz.v0.extent_realized.s.s - sum_wsz.v0.min_realized
   let t11258 = t11237 + t11253
   for (sum_wsz.s0.v1.rebased, 0, t11255 + 31) {
    let t11263 = ((t11260 + 8)*sum_wsz.s0.v1.rebased) - sum_wsz.v0.min_realized
    let t11262 = sum_wsz.s0.v1.rebased + t11259
    for (sum_wsz.s0.v0.v2, 0, t11256) {
     let sum_wsz.s0.v0.v4.base = min((sum_wsz.s0.v0.v2*8) + weight.s0.v0.min_1, t11261 + -9)
     allocate sum[int32 * 8]
     produce sum {
      sum[ramp(0, 1, 8)] = x8(0)
      for (sum.s1.r10$y.rebased, 0, t11258) {
       let sum.s1.r10$y = sum.s1.r10$y.rebased - t11253
       let t11264 = (max(min(sum.s1.r10$y + t11262, input.extent.1 + -1), 0)*input.stride.1) - input.min.0
       for (sum.s1.r10$x.rebased, 0, t11258) {
        let sum.s1.r10$x = sum.s1.r10$x.rebased - t11253
        sum[ramp(0, 1, 8)] = sum[ramp(0, 1, 8)] + int32x8(input[max(min(ramp(sum.s1.r10$x + sum_wsz.s0.v0.v4.base, 1, 8), x8(t11241 + -1)), x8(input.min.0)) + x8(t11264)])
       }
      }
     }
     consume sum {
      sum_wsz[ramp(sum_wsz.s0.v0.v4.base + t11263, 1, 8)] = sum[ramp(0, 1, 8)]
     }
     free sum
    }
   }
  }
 }

[steven-johnson]

There's nothing in your schedule that tells Halide that output_a and output_b are required to have identical dimensions. Try adding something like

for (int i = 0; i < 2; i++) output_b.dim(i).set_extent(output_a.dim(i).extent());

[zhouwangpei123]

I add the suggested lines in my schedule, it doesn't seem to work.

                for ( int i = 0 ; i < 2; i++ ) {
                    output_b.dim(i).set_min(output_a.dim(i).min());
                    output_b.dim(i).set_extent(output_a.dim(i).extent());
                }

after modification, the the buffer size for w_sum_x (for each 512x32 tile ) is (output_a.extent.0 + window_size) * (32 + window_size).

stmt file:

let output_b.s0.v1.min_1.s = min((output_a.s0.v0.v2.fused.v6/t6351)*32, output_a.extent.1 + -32)
let output_b.s0.v1.max_1.s = min((output_a.s0.v0.v2.fused.v6/t6351)*32, output_a.extent.1 + -32)
let output_a.s0.v1.min_1.s = min((output_a.s0.v0.v2.fused.v6/t6351)*32, output_a.extent.1 + -32)
let output_a.s0.v0.min_1.s = min((output_a.s0.v0.v2.fused.v6 % t6351)*512, output_a.extent.0 + -512)
let output_a.s0.v0.max_1.s = min((output_a.s0.v0.v2.fused.v6 % t6351)*512, output_a.extent.0 + -512)
let weight.s0.v1.min_1 = (output_a.min.1 - t6367) + output_b.s0.v1.min_1.s
let variance.s0.v1.min_1 = (output_a.min.1 - t6367) + output_a.s0.v1.min_1.s
let average.s0.v1.min_1 = (output_a.min.1 - t6367) + output_b.s0.v1.min_1.s
let sum_wsz.v0.min_realized = min(output_a.min.0 - t6367, ((output_a.extent.0 + output_a.min.0) + t6352) + -9)
let sum_wsz.v0.extent_realized.s.s = let t6600 = ((output_a.extent.0 + output_a.min.0) + t6352) in min((((((t6367 - output_a.min.0) + t6600) + -2)/8)*8) + (output_a.min.0 - t6367), t6600 + -9)
allocate sum_wsz[int32 * ((sum_wsz.v0.extent_realized.s.s - sum_wsz.v0.min_realized) + 8) * ((((output_a.min.1 + t6352) + output_b.s0.v1.max_1.s) - average.s0.v1.min_1) + 31)]
produce sum_wsz {
 let sum_wsz.s0.v1.prologue = min(max(input.min.1 + t6367, average.s0.v1.min_1), ((output_a.min.1 + t6352) + output_b.s0.v1.max_1.s) + 31)
 let sum_wsz.s0.v1.epilogue = let t6601 = (input.min.1 + t6367) in (let t6602 = ((output_a.min.1 + t6352) + output_b.s0.v1.max_1.s) in max(min(min(t6601 + input.extent.1, t6602 + 31), ((input.extent.1 + input.min.1) - t6352) + 1), min(max(t6601, average.s0.v1.min_1), t6602 + 31)))
 let t6376 = (output_a.extent.0 + output_a.min.0) + t6352
 let t6370 = (((t6367 - output_a.min.0) + t6376) + 6)/8
 let t6375 = sum_wsz.v0.extent_realized.s.s - sum_wsz.v0.min_realized
 let t6369 = sum_wsz.s0.v1.prologue - average.s0.v1.min_1
 let t6371 = output_a.min.0 - t6367
 let t6374 = average.s0.v1.min_1 - input.min.1
 let t6373 = t6352 + t6367
 for (sum_wsz.s0.v1.rebased, 0, t6369) {
  let t6378 = ((t6375 + 8)*sum_wsz.s0.v1.rebased) - sum_wsz.v0.min_realized
  let t6377 = sum_wsz.s0.v1.rebased + t6374
  for (sum_wsz.s0.v0.v2, 0, t6370) {
   let sum_wsz.s0.v0.v4.base = min((sum_wsz.s0.v0.v2*8) + t6371, t6376 + -9)
   allocate sum[int32 * 8]
   produce sum {
    sum[ramp(0, 1, 8)] = x8(0)
    for (sum.s1.r10$y.rebased, 0, t6373) {
     let sum.s1.r10$y = sum.s1.r10$y.rebased - t6367
     let t6379 = (max(min(sum.s1.r10$y + t6377, input.extent.1 + -1), 0)*input.stride.1) - input.min.0
     for (sum.s1.r10$x.rebased, 0, t6373) {
      let sum.s1.r10$x = sum.s1.r10$x.rebased - t6367
      sum[ramp(0, 1, 8)] = sum[ramp(0, 1, 8)] + int32x8(input[max(min(ramp(sum.s1.r10$x + sum_wsz.s0.v0.v4.base, 1, 8), x8(t6359 + -1)), x8(input.min.0)) + x8(t6379)])
     }
    }
   }
   consume sum {
    sum_wsz[ramp(sum_wsz.s0.v0.v4.base + t6378, 1, 8)] = sum[ramp(0, 1, 8)]
   }
   free sum
  }
 }

Looking forward for your reply, best wishes!