Install only external registrations from numba's builtin_registry

Author: VijayKandiah

numba_cuda/numba/cuda/core/base.py

@@ -356,6 +356,63 @@ def install_registry(self, registry):
         self._insert_cast_defn(loader.new_registrations("casts"))
         self._insert_get_constant_defn(loader.new_registrations("constants"))
 
+    def install_external_registry(self, registry):
+        """
+        Install only the registrations that were defined outside
+        of the "numba." namespace (i.e., in third-party extensions).
+        This is useful for selectively installing implementations
+        from the shared builtin_registry without pulling in any CPU-specific
+        implementations from Numba.
+        """
+
+        def is_external(impl):
+            """Check if implementation is defined outside numba.* namespace."""
+            try:
+                module = impl.__module__
+                return not module.startswith("numba.")
+            except AttributeError:
+                # If we can't determine module, conservatively include registration
+                return True
+
+        try:
+            loader = self._registries[registry]
+        except KeyError:
+            loader = RegistryLoader(registry)
+            self._registries[registry] = loader
+
+        # Filter registrations
+        funcs = [
+            (impl, func, sig)
+            for impl, func, sig in loader.new_registrations("functions")
+            if is_external(impl)
+        ]
+        getattrs = [
+            (impl, attr, sig)
+            for impl, attr, sig in loader.new_registrations("getattrs")
+            if is_external(impl)
+        ]
+        setattrs = [
+            (impl, attr, sig)
+            for impl, attr, sig in loader.new_registrations("setattrs")
+            if is_external(impl)
+        ]
+        casts = [
+            (impl, sig)
+            for impl, sig in loader.new_registrations("casts")
+            if is_external(impl)
+        ]
+        constants = [
+            (impl, sig)
+            for impl, sig in loader.new_registrations("constants")
+            if is_external(impl)
+        ]
+
+        self.insert_func_defn(funcs)
+        self._insert_getattr_defn(getattrs)
+        self._insert_setattr_defn(setattrs)
+        self._insert_cast_defn(casts)
+        self._insert_get_constant_defn(constants)
+
     def insert_func_defn(self, defns):
         for impl, func, sig in defns:
             self._defns[func].append(impl, sig)

numba_cuda/numba/cuda/np/arrayobj.py

@@ -3018,7 +3018,6 @@ def _compatible_view(a, dtype):
 
 
 @overload(_compatible_view)
-@overload(_compatible_view, target="generic")
 def ol_compatible_view(a, dtype):
     """Determines if the array and dtype are compatible for forming a view."""
 

numba_cuda/numba/cuda/target.py

@@ -218,12 +218,12 @@ def load_additional_registries(self):
         self.install_registry(npdatetime.registry)
         self.install_registry(arrayobj.registry)
 
+        # Install only implementations that are defined outside of numba (i.e., in third-party extensions)
+        # from Numba's builtin_registry, i.e. exclude anything in "numba.*" namespace.
         if importlib.util.find_spec("numba.core.imputils") is not None:
-            from numba.core.imputils import (
-                builtin_registry as upstream_builtin_registry,
-            )
+            from numba.core.imputils import builtin_registry
 
-            self.install_registry(upstream_builtin_registry)
+            self.install_external_registry(builtin_registry)
 
     def codegen(self):
         return self._internal_codegen