Move vectorize_pred to test/correctness, fix failing_with_issue build

Issue #3357 now passes. Rewrote the test to initialize f/g with
cast<A>(0) rather than undef so all positions are deterministic and
the full output is compared. Widened to W = vec_width * 4, H = 1000
to cover more predicate-edge conditions.

Update 3292 and 3293 to the current JITUserContext* allocator API
(set_custom_allocator was removed). Add EXPECT_FAILURE so ctest treats
the still-crashing tests as known failures. Comment out 4283 whose
source file does not exist.

Enable add_subdirectory(failing_with_issue) in test/CMakeLists.txt.

Author: kjg0724

test/CMakeLists.txt

@@ -65,7 +65,7 @@ if (WITH_TEST_RUNTIME)
     add_subdirectory(runtime)
 endif ()
 
-# FIXME: failing_with_issue is dead code :)
+add_subdirectory(failing_with_issue)
 
 Halide_feature(WITH_TEST_FUZZ "Build fuzz tests" ON)
 if (WITH_TEST_FUZZ)

test/correctness/CMakeLists.txt

@@ -350,6 +350,7 @@ tests(GROUPS correctness
       vectorize_guard_with_if.cpp
       vectorize_mixed_widths.cpp
       vectorize_nested.cpp
+      vectorize_pred.cpp
       vectorize_varying_allocation_size.cpp
       vectorized_assert.cpp
       vectorized_gpu_allocation.cpp

test/correctness/vectorize_pred.cpp

@@ -0,0 +1,81 @@
+#include "Halide.h"
+#include <cstdio>
+
+using namespace Halide;
+
+template<typename T>
+T tolerance() {
+    return 0;
+}
+
+template<>
+float tolerance<float>() {
+    return 1e-7f;
+}
+
+
+template<typename T>
+bool equals(T a, T b, T epsilon = tolerance<T>()) {
+    T error = std::abs(a - b);
+    return error <= epsilon;
+}
+
+template<typename A>
+bool test(int vec_width) {
+
+    int W = vec_width * 4;
+    int H = 1000;
+
+    Buffer<A> input(W, H + 20);
+    for (int y = 0; y < H + 20; y++) {
+        for (int x = 0; x < W; x++) {
+            input(x, y) = (A)((rand() & 0xffff) * 0.125 + 1.0);
+        }
+    }
+
+    Var x("x"), y("y");
+    Func f("f"), g("g");
+
+    RDom r(0, W, 0, H);
+    r.where((r.x * r.y) % 8 < 7);
+
+    Expr e = input(r.x, r.y);
+    for (int i = 1; i < 5; i++) {
+        e = e + input(r.x, r.y + i);
+    }
+
+    for (int i = 5; i >= 0; i--) {
+        e = e + input(r.x, r.y + i);
+    }
+
+    f(x, y) = cast<A>(0);
+    f(r.x, r.y) = e;
+    g(x, y) = cast<A>(0);
+    g(r.x, r.y) = e;
+    f.update(0).vectorize(r.x);
+
+    Buffer<A> outputg = g.realize({W, H});
+    Buffer<A> outputf = f.realize({W, H});
+
+    for (int j = 0; j < H; j++) {
+        for (int i = 0; i < W; i++) {
+            if (!equals(outputf(i, j), outputg(i, j))) {
+                std::cout << type_of<A>() << " x " << vec_width << " failed at "
+                          << i << " " << j << ": "
+                          << outputf(i, j) << " vs " << outputg(i, j) << "\n"
+                          << "Failure!\n";
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
+int main(int argc, char **argv) {
+    if (!test<float>(4)) return 1;
+    if (!test<float>(8)) return 1;
+
+    printf("Success!\n");
+    return 0;
+}

test/failing_with_issue/3292_async_specialize.cpp

@@ -7,15 +7,15 @@ using namespace Halide;
 
 size_t custom_malloc_size = 0;
 
-void *my_malloc(void *user_context, size_t x) {
+void *my_malloc(JITUserContext *user_context, size_t x) {
     custom_malloc_size = x;
     void *orig = malloc(x + 32);
     void *ptr = (void *)((((size_t)orig + 32) >> 5) << 5);
     ((void **)ptr)[-1] = orig;
     return ptr;
 }
 
-void my_free(void *user_context, void *ptr) {
+void my_free(JITUserContext *user_context, void *ptr) {
     free(((void **)ptr)[-1]);
 }
 
@@ -49,7 +49,8 @@ int main(int argc, char **argv) {
         // automatic storage folding refused to fold this (the case
         // above).
 
-        g.set_custom_allocator(my_malloc, my_free);
+        g.jit_handlers().custom_malloc = my_malloc;
+        g.jit_handlers().custom_free = my_free;
 
         Buffer<int> im = g.realize({100, 1000});
 

test/failing_with_issue/3293_storage_folding_async.cpp

@@ -7,15 +7,15 @@ using namespace Halide;
 
 size_t custom_malloc_size = 0;
 
-void *my_malloc(void *user_context, size_t x) {
+void *my_malloc(JITUserContext *user_context, size_t x) {
     custom_malloc_size = x;
     void *orig = malloc(x + 32);
     void *ptr = (void *)((((size_t)orig + 32) >> 5) << 5);
     ((void **)ptr)[-1] = orig;
     return ptr;
 }
 
-void my_free(void *user_context, void *ptr) {
+void my_free(JITUserContext *user_context, void *ptr) {
     free(((void **)ptr)[-1]);
 }
 
@@ -51,7 +51,8 @@ int main(int argc, char **argv) {
         // automatic storage folding refused to fold this (the case
         // above).
 
-        h.set_custom_allocator(my_malloc, my_free);
+        h.jit_handlers().custom_malloc = my_malloc;
+        h.jit_handlers().custom_free = my_free;
 
         Buffer<int> im = h.realize({100, 1000});
 

test/failing_with_issue/CMakeLists.txt

@@ -1,7 +1,8 @@
 tests(GROUPS failing_with_issue
+      EXPECT_FAILURE
       SOURCES
       3292_async_specialize.cpp
       3293_storage_folding_async.cpp
-      3357_vectorize_pred.cpp
-      4283_store_at_gpu.cpp
+      # 3357_vectorize_pred.cpp  # moved to test/correctness/vectorize_pred.cpp
+      # 4283_store_at_gpu.cpp  # TODO: test file missing, tracked in issue #4283
       )