Merge branch 'halide:main' into main

Author: xFile3160

.devcontainer/Dockerfile

@@ -0,0 +1,32 @@
+FROM ubuntu:24.04
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+RUN apt-get update && \
+    ln -fs /usr/share/zoneinfo/America/New_York /etc/localtime && \
+    apt-get install -y tzdata && \
+    apt-get install -y \
+        build-essential \
+        cmake \
+        gdb \
+        git \
+        gnupg \
+        libcurl4-openssl-dev \
+        libedit-dev \
+        libicu-dev \
+        libjpeg-dev \
+        libncurses-dev \
+        libpng-dev \
+        lsb-release \
+        ninja-build \
+        pkg-config \
+        python3-dev \
+        software-properties-common \
+        wget \
+        zlib1g-dev && \
+    wget https://apt.llvm.org/llvm.sh && \
+    chmod +x llvm.sh && \
+    ./llvm.sh 21 all && \
+    apt-get install -y liblld-21-dev && \
+    apt-get clean && \
+    rm -rf llvm.sh /var/lib/apt/lists/* \

.devcontainer/devcontainer.json

@@ -0,0 +1,36 @@
+// Default Ubuntu-based DevContainer Template.
+// For more customization options, see https://containers.dev/implementors/json_reference
+// Also note this file is "JSON with Comments" (JSONC).
+{
+  "name": "Halide",
+  "build": {
+    "dockerfile": "Dockerfile"
+  },
+  "runArgs": [
+    "--userns=keep-id",
+    "--security-opt",
+    "label=disable"
+  ],
+  "customizations": {
+    "jetbrains": {
+      "backend": "CLion",
+      "settings": {
+        // IDE settings can be added via “Show context actions”|“Add currently modified settings from IDE”.
+        // A complete list of supported settings is also available through auto-completion
+      },
+      "plugins": [
+        // A set of plugin IDs.
+        // Plugin ID can be found on the corresponding plugin’s page at https://plugins.jetbrains.com.
+      ]
+    }
+  },
+  "features": {
+    "ghcr.io/devcontainers/features/git": {},
+    "ghcr.io/devcontainers/features/common-utils": {
+      "installZsh": false
+    }
+  },
+  // Comment out to connect as the root user.
+  "remoteUser": "ubuntu",
+  "containerUser": "root"
+}

.github/workflows/pip.yml

@@ -37,9 +37,9 @@ jobs:
             platform_tag: manylinux_x86_64
           - os: windows-latest
             platform_tag: win_amd64
-          - os: macos-13
+          - os: macos-15-intel
             platform_tag: macosx_x86_64
-          - os: macos-14
+          - os: macos-15
             platform_tag: macosx_arm64
 
     env:

apps/bgu/Makefile

@@ -16,11 +16,11 @@ $(GENERATOR_BIN)/bgu.generator: bgu_generator.cpp $(GENERATOR_DEPS)
 
 $(BIN)/%/bgu.a: $(GENERATOR_BIN)/bgu.generator
 	@mkdir -p $(@D)
-	$< -g bgu -f bgu -o $(BIN)/$* target=$*-no_runtime
+	$< -g bgu -f bgu -o $(BIN)/$* -e $(GENERATOR_OUTPUTS) target=$*-no_runtime
 
 $(BIN)/%/bgu_auto_schedule.a: $(GENERATOR_BIN)/bgu.generator
 	@mkdir -p $(@D)
-	$< -g bgu -f bgu_auto_schedule -o $(BIN)/$* target=$*-no_runtime autoscheduler=Mullapudi2016
+	$< -g bgu -f bgu_auto_schedule -o $(BIN)/$* -e $(GENERATOR_OUTPUTS) target=$*-no_runtime autoscheduler=Mullapudi2016
 
 $(BIN)/%/runtime.a: $(GENERATOR_BIN)/bgu.generator
 	@mkdir -p $(@D)

doc/Vulkan.md

@@ -171,6 +171,12 @@ To modify the default behavior of the runtime, the following environment
 variables can be used to adjust the configuration of the Vulkan backend 
 at execution time:
 
+`HL_VK_LOADER_LIB=...` can be used to specify the full path and filename 
+of the Vulkan loader library (e.g. `/usr/local/lib64/libvulkan.so.1`). 
+This can be useful if you need to override the default search path,
+or if the loader is installed in a custom location.  If not set, the 
+runtime will search across a list of known paths.
+
 `HL_VK_LAYERS=...` will tell Halide to choose a suitable Vulkan instance
 that supports the given list of layers. If not set, `VK_INSTANCE_LAYERS=...` 
 will be used instead. If neither are present, Halide will use the first 

python_bindings/src/halide/halide_/PyCallable.cpp

@@ -109,13 +109,11 @@ class PyCallable {
             } else {
                 argv[slot] = &scalar_storage[slot];
 
-                // clang-format off
-
-                #define HALIDE_HANDLE_TYPE_DISPATCH(CODE, BITS, TYPE, FIELD)                \
-                    case halide_type_t(CODE, BITS).as_u32():                                \
-                        scalar_storage[slot].u.FIELD = cast_to<TYPE>(value);                \
-                        cci[slot] = Callable::make_scalar_qcci(halide_type_t(CODE, BITS));   \
-                        break;
+#define HALIDE_HANDLE_TYPE_DISPATCH(CODE, BITS, TYPE, FIELD)               \
+    case halide_type_t(CODE, BITS).as_u32():                               \
+        scalar_storage[slot].u.FIELD = cast_to<TYPE>(value);               \
+        cci[slot] = Callable::make_scalar_qcci(halide_type_t(CODE, BITS)); \
+        break;
 
                 switch (((halide_type_t)c_arg.type).element_of().as_u32()) {
                     HALIDE_HANDLE_TYPE_DISPATCH(halide_type_float, 32, float, f32)
@@ -134,9 +132,7 @@ class PyCallable {
                     _halide_user_assert(0) << "Unsupported type in Callable argument list: " << c_arg.type << "\n";
                 }
 
-                #undef HALIDE_HANDLE_TYPE_DISPATCH
-
-                // clang-format on
+#undef HALIDE_HANDLE_TYPE_DISPATCH
             }
         };
 

python_bindings/src/halide/halide_/PyFunc.cpp

@@ -197,6 +197,8 @@ void define_func(py::module &m) {
             .def("type", &Func::type)
             .def("types", &Func::types)
 
+            .def("split_vars", &Func::split_vars)
+
             .def("bound", &Func::bound, py::arg("var"), py::arg("min"), py::arg("extent"))
 
             .def("reorder_storage", (Func & (Func::*)(const std::vector<Var> &)) & Func::reorder_storage, py::arg("dims"))

python_bindings/src/halide/halide_/PyFuncRef.cpp

@@ -18,7 +18,9 @@ void define_func_ref(py::module &m) {
         py::class_<FuncRef>(m, "FuncRef")
             .def("__getitem__", &FuncRef::operator[])
             .def("size", &FuncRef::size)
-            .def("__len__", &FuncRef::size);
+            .def("__len__", &FuncRef::size)
+            .def("type", &FuncRef::type)
+            .def("types", &FuncRef::types);
     add_binary_operators(func_ref_class);
 }
 

python_bindings/src/halide/halide_/PyStage.cpp

@@ -19,6 +19,21 @@ void define_stage(py::module &m) {
             .def("rfactor", static_cast<Func (Stage::*)(const RVar &, const Var &)>(&Stage::rfactor),
                  py::arg("r"), py::arg("v"))
 
+            .def("split_vars", [](const Stage &stage) -> py::list {
+                auto vars = stage.split_vars();
+                py::list result;
+                // Return a mixed-type list of Var and RVar objects, instead of
+                // a list of VarOrRVar objects.
+                for (const auto &v : vars) {
+                    if (v.is_rvar) {
+                        result.append(py::cast(v.rvar));
+                    } else {
+                        result.append(py::cast(v.var));
+                    }
+                }
+                return result;
+            })
+
             .def("unscheduled", &Stage::unscheduled);
 
     py::implicitly_convertible<Func, Stage>();

python_bindings/test/correctness/basics.py

@@ -103,7 +103,6 @@ def test_basics():
     blur_x.compute_at(blur_y, x).vectorize(x, 8)
     blur_y.compile_jit()
 
-
 def test_basics2():
     input = hl.ImageParam(hl.Float(32), 3, "input")
     hl.Param(hl.Float(32), "r_sigma", 0.1)
@@ -344,19 +343,30 @@ def test_typed_funcs():
     with assert_throws(hl.HalideError, "it is undefined"):
         assert f.dimensions() == 0
 
+    with assert_throws(hl.HalideError, "it is undefined"):
+        assert f[x, y].type() == hl.Int(32)
+
     f = hl.Func(hl.Int(32), 2, "f")
     assert not f.defined()
     assert f.type() == hl.Int(32)
     assert f.types() == [hl.Int(32)]
     assert f.outputs() == 1
     assert f.dimensions() == 2
+    assert f[x, y].type() == hl.Int(32)
+
+    with assert_throws(hl.HalideError, "has not yet been defined"):
+        # While we can ask for the type of f[x, y], because it's a
+        # typed Func, we still can't use it as an Expr
+        g = hl.Func("g")
+        g[x, y] = f[x, y]
 
     f = hl.Func([hl.Int(32), hl.Float(64)], 3, "f")
     assert not f.defined()
     with assert_throws(hl.HalideError, "it returns a Tuple"):
         assert f.type() == hl.Int(32)
 
     assert f.types() == [hl.Int(32), hl.Float(64)]
+    assert f[x, y].types() == [hl.Int(32), hl.Float(64)]
     assert f.outputs() == 2
     assert f.dimensions() == 3
 
@@ -597,6 +607,31 @@ def test_print_ir():
     p = hl.Pipeline()
     assert str(p) == "<halide.Pipeline Pipeline()>"
 
+def test_split_vars():
+    f = hl.Func("f")
+    (x, xo, xi) = hl.vars("x xo xi")
+    f[x] = x
+    r = hl.RDom([(0, 10), (0, 10)], "r")
+    f[x] += x + r.x + r.y
+
+    f.split(x, xo, xi, 8)
+
+    vars = f.split_vars()
+    assert len(vars) == 3
+    assert vars[0].name() == xi.name()
+    assert vars[1].name() == xo.name()
+    assert vars[2].name() == hl.Var.outermost().name()
+
+    (rxo, rxi) = (hl.RVar("rxo"), hl.RVar("rxi"))
+    f.update().split(r.x, rxo, rxi, 4)
+
+    vars = f.update().split_vars()
+    assert len(vars) == 5
+    assert isinstance(vars[0], hl.RVar) and vars[0].name() == rxi.name()
+    assert isinstance(vars[1], hl.RVar) and vars[1].name() == rxo.name()
+    assert isinstance(vars[2], hl.RVar) and vars[2].name() == r.y.name()
+    assert isinstance(vars[3], hl.Var) and vars[3].name() == x.name()
+    assert isinstance(vars[4], hl.Var) and vars[4].name() == hl.Var.outermost().name()
 
 if __name__ == "__main__":
     test_compiletime_error()
@@ -622,3 +657,4 @@ def test_print_ir():
     test_implicit_update_by_int()
     test_implicit_update_by_float()
     test_print_ir()
+    test_split_vars()