Change warmup strategy for sliding window

apps/blur/halide_blur_generator.cpp

@@ -82,6 +82,7 @@ class HalideBlur : public Halide::Generator<HalideBlur> {
             }
         } else if (get_target().has_feature(Target::HVX)) {
             // Hexagon schedule.
+            // TODO: Try using a schedule like the CPU one below.
             const int vector_size = 128;
 
             blur_y.compute_root()
@@ -96,8 +97,17 @@ class HalideBlur : public Halide::Generator<HalideBlur> {
                 .vectorize(x, vector_size);
         } else {
             // CPU schedule.
-            blur_y.split(y, y, yi, 8).parallel(y).vectorize(x, 8);
-            blur_x.store_at(blur_y, y).compute_at(blur_y, yi).vectorize(x, 8);
+            // Compute blur_x as needed at each vector of the output.
+            // Halide will store blur_x in a circular buffer so its
+            // results can be re-used.
+            blur_y
+                .split(y, y, yi, 32)
+                .parallel(y)
+                .vectorize(x, 16);
+            blur_x
+                .store_at(blur_y, y)
+                .compute_at(blur_y, x)
+                .vectorize(x, 16);
         }
     }
 };

apps/blur/test.cpp

@@ -159,8 +159,8 @@ int main(int argc, char **argv) {
     const bool is_hexagon = strstr(md->target, "hvx_128") || strstr(md->target, "hvx_64");
 
     // The Hexagon simulator can't allocate as much memory as the above wants.
-    const int width = is_hexagon ? 648 : 6408;
-    const int height = is_hexagon ? 482 : 4802;
+    const int width = is_hexagon ? 648 : 2568;
+    const int height = is_hexagon ? 482 : 1922;
 
     Buffer<uint16_t> input(width, height);
 

apps/camera_pipe/camera_pipe_generator.cpp

@@ -530,15 +530,15 @@ void CameraPipe::generate() {
             .compute_at(processed, yi)
             .store_at(processed, yo)
             .prefetch(input, y, 2)
-            .fold_storage(y, 16)
+            .fold_storage(y, 4)
             .tile(x, y, x, y, xi, yi, 2 * vec, 2)
             .vectorize(xi)
             .unroll(yi);
 
         deinterleaved
             .compute_at(processed, yi)
             .store_at(processed, yo)
-            .fold_storage(y, 8)
+            .fold_storage(y, 4)
             .reorder(c, x, y)
             .vectorize(x, 2 * vec, TailStrategy::RoundUp)
             .unroll(c);

apps/local_laplacian/local_laplacian_generator.cpp

@@ -148,7 +148,7 @@ class LocalLaplacian : public Halide::Generator<LocalLaplacian> {
                 outGPyramid[j]
                     .store_at(output, yo)
                     .compute_at(output, y)
-                    .fold_storage(y, 8)
+                    .fold_storage(y, 4)
                     .vectorize(x, 8);
             }
             outGPyramid[0].compute_at(output, y).vectorize(x, 8);

src/FuseGPUThreadLoops.cpp

@@ -349,8 +349,12 @@ class ExtractSharedAndHeapAllocations : public IRMutator {
                 // repeated dependence on the block var
                 s.size = solve_expression(s.size, op->name).result;
                 s.size = simplify(common_subexpression_elimination(s.size));
-                auto result = is_monotonic(s.size, op->name);
-                if (result == Monotonic::Unknown) {
+                switch (is_monotonic(s.size, op->name)) {
+                case Monotonic::Unknown:
+                    // TODO: if bounds_of_expr_in_scope becomes more
+                    // powerful than is_monotonic, it might be better
+                    // to call it here. That would be risky though, as
+                    // it's not exact.
                     debug(1)
                         << "Shared allocation for " << s.name
                         << " has a size that is non-monontonic in the gpu block variable " << op->name
@@ -359,19 +363,19 @@ class ExtractSharedAndHeapAllocations : public IRMutator {
                         get_compiler_logger()->record_non_monotonic_loop_var(op->name, s.size);
                     }
                     precompute_allocation_size(s);
-                } else {
-                    auto interval_bounds = bounds_of_expr_in_scope(s.size, scope);
-                    user_assert(interval_bounds.has_upper_bound())
-                        << "Couldn't infer bounds for " << s.name << " shared memory allocation\n";
-                    // In theory we could precompute the allocation
-                    // size if there's no upper bound too, but for the
-                    // assert above to fail we'd have to encounter an
-                    // expression that is_monotonic detects as
-                    // increasing, decreasing, or constant, but is
-                    // somehow unbounded. It's probable that no such
-                    // expression exists. is_monotonic is generally
-                    // less capable than bounds_of_expr_in_scope.
-                    s.size = interval_bounds.max;
+                    break;
+                case Monotonic::Increasing:
+                    s.size = substitute(op->name, simplify(op->min + op->extent - 1), s.size);
+                    break;
+                case Monotonic::Constant:
+                    // The size expression used the variable, but we
+                    // may have successfully eliminated it above, or
+                    // is_monotonic might have detected that the
+                    // dependence is false somehow. Just treat it as
+                    // decreasing...
+                case Monotonic::Decreasing:
+                    s.size = substitute(op->name, op->min, s.size);
+                    break;
                 }
             }
             if (in_threads && op->is_parallel()) {

src/Interval.cpp

@@ -157,5 +157,91 @@ Expr Interval::neg_inf_noinline() {
     return Interval::neg_inf_expr;
 }
 
+ConstantInterval::ConstantInterval() = default;
+
+ConstantInterval::ConstantInterval(int64_t min, int64_t max)
+    : min(min), max(max), min_defined(true), max_defined(true) {
+    internal_assert(min <= max);
+}
+
+ConstantInterval ConstantInterval::everything() {
+    return ConstantInterval();
+}
+
+ConstantInterval ConstantInterval::single_point(int64_t x) {
+    return ConstantInterval(x, x);
+}
+
+ConstantInterval ConstantInterval::bounded_below(int64_t min) {
+    ConstantInterval result(min, min);
+    result.max_defined = false;
+    return result;
+}
+
+ConstantInterval ConstantInterval::bounded_above(int64_t max) {
+    ConstantInterval result(max, max);
+    result.min_defined = false;
+    return result;
+}
+
+bool ConstantInterval::is_everything() const {
+    return !min_defined && !max_defined;
+}
+
+bool ConstantInterval::is_single_point() const {
+    return min_defined && max_defined && min == max;
+}
+
+bool ConstantInterval::is_single_point(int64_t x) const {
+    return min_defined && max_defined && min == x && max == x;
+}
+
+bool ConstantInterval::has_upper_bound() const {
+    return max_defined;
+}
+
+bool ConstantInterval::has_lower_bound() const {
+    return min_defined;
+}
+
+bool ConstantInterval::is_bounded() const {
+    return has_upper_bound() && has_lower_bound();
+}
+
+bool ConstantInterval::operator==(const ConstantInterval &other) const {
+    if (min_defined != other.min_defined || max_defined != other.max_defined) {
+        return false;
+    }
+    return (!min_defined || min == other.min) && (!max_defined || max == other.max);
+}
+
+void ConstantInterval::include(const ConstantInterval &i) {
+    if (max_defined && i.max_defined) {
+        max = std::max(max, i.max);
+    } else {
+        max_defined = false;
+    }
+    if (min_defined && i.min_defined) {
+        min = std::min(min, i.min);
+    } else {
+        min_defined = false;
+    }
+}
+
+void ConstantInterval::include(int64_t x) {
+    if (max_defined) {
+        max = std::max(max, x);
+    }
+    if (min_defined) {
+        min = std::min(min, x);
+    }
+}
+
+ConstantInterval ConstantInterval::make_union(const ConstantInterval &a, const ConstantInterval &b) {
+    ConstantInterval result = a;
+    result.include(b);
+    return result;
+}
+
 }  // namespace Internal
 }  // namespace Halide

src/Interval.h

@@ -110,6 +110,63 @@ struct Interval {
     static Expr neg_inf_noinline();
 };
 
+/** A class to represent ranges of integers. Can be unbounded above or below, but
+ * they cannot be empty. */
+struct ConstantInterval {
+    /** The lower and upper bound of the interval. They are included
+     * in the interval. */
+    int64_t min = 0, max = 0;
+    bool min_defined = false, max_defined = false;
+
+    /* A default-constructed Interval is everything */
+    ConstantInterval();
+
+    /** Construct an interval from a lower and upper bound. */
+    ConstantInterval(int64_t min, int64_t max);
+
+    /** The interval representing everything. */
+    static ConstantInterval everything();
+
+    /** Construct an interval representing a single point. */
+    static ConstantInterval single_point(int64_t x);
+
+    /** Construct intervals bounded above or below. */
+    static ConstantInterval bounded_below(int64_t min);
+    static ConstantInterval bounded_above(int64_t max);
+
+    /** Is the interval the entire range */
+    bool is_everything() const;
+
+    /** Is the interval just a single value (min == max) */
+    bool is_single_point() const;
+
+    /** Is the interval a particular single value */
+    bool is_single_point(int64_t x) const;
+
+    /** Does the interval have a finite least upper bound */
+    bool has_upper_bound() const;
+
+    /** Does the interval have a finite greatest lower bound */
+    bool has_lower_bound() const;
+
+    /** Does the interval have a finite upper and lower bound */
+    bool is_bounded() const;
+
+    /** Expand the interval to include another Interval */
+    void include(const ConstantInterval &i);
+
+    /** Expand the interval to include a point */
+    void include(int64_t x);
+
+    /** Construct the smallest interval containing two intervals. */
+    static ConstantInterval make_union(const ConstantInterval &a, const ConstantInterval &b);
+
+    /** Equivalent to same_as. Exists so that the autoscheduler can
+     * compare two map<string, Interval> for equality in order to
+     * cache computations. */
+    bool operator==(const ConstantInterval &other) const;
+};
+
 }  // namespace Internal
 }  // namespace Halide