[SYCL] Move reduce/scan functors to functional.hpp

Avoid duplicated code in sub_group.hpp and sub_group_host.hpp.

Signed-off-by: John Pennycook <john.pennycook@intel.com>

Author: Pennycook

sycl/include/CL/sycl/intel/functional.hpp

@@ -0,0 +1,51 @@
+//==----------- functional.hpp --- SYCL functional -------------------------==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+namespace cl {
+namespace sycl {
+namespace intel {
+
+template <typename T = void> struct minimum {
+  T operator()(const T &lhs, const T &rhs) const {
+    return (lhs <= rhs) ? lhs : rhs;
+  }
+};
+
+template <> struct minimum<void> {
+  template <typename T> T operator()(const T &lhs, const T &rhs) const {
+    return (lhs <= rhs) ? lhs : rhs;
+  }
+};
+
+template <typename T = void> struct maximum {
+  T operator()(const T &lhs, const T &rhs) const {
+    return (lhs >= rhs) ? lhs : rhs;
+  }
+};
+
+template <> struct maximum<void> {
+  template <typename T> T operator()(const T &lhs, const T &rhs) const {
+    return (lhs >= rhs) ? lhs : rhs;
+  }
+};
+
+template <typename T = void> struct plus {
+  T operator()(const T &lhs, const T &rhs) const { return lhs + rhs; }
+};
+
+template <> struct plus<void> {
+  template <typename T> T operator()(const T &lhs, const T &rhs) const {
+    return lhs + rhs;
+  }
+};
+
+} // namespace intel
+} // namespace sycl
+} // namespace cl

sycl/include/CL/sycl/intel/sub_group.hpp

@@ -15,49 +15,13 @@
 #include <CL/sycl/id.hpp>
 #include <CL/sycl/range.hpp>
 #include <CL/sycl/types.hpp>
+#include <CL/sycl/intel/functional.hpp>
 #include <type_traits>
 #ifdef __SYCL_DEVICE_ONLY__
 
 namespace cl {
 namespace sycl {
 template <typename T, access::address_space Space> class multi_ptr;
-namespace intel {
-
-template <typename T = void> struct minimum {
-  T operator()(const T &lhs, const T &rhs) const {
-    return (lhs <= rhs) ? lhs : rhs;
-  }
-};
-
-template <> struct minimum<void> {
-  template <typename T> T operator()(const T &lhs, const T &rhs) const {
-    return (lhs <= rhs) ? lhs : rhs;
-  }
-};
-
-template <typename T = void> struct maximum {
-  T operator()(const T &lhs, const T &rhs) const {
-    return (lhs >= rhs) ? lhs : rhs;
-  }
-};
-
-template <> struct maximum<void> {
-  template <typename T> T operator()(const T &lhs, const T &rhs) const {
-    return (lhs >= rhs) ? lhs : rhs;
-  }
-};
-
-template <typename T = void> struct plus {
-  T operator()(const T &lhs, const T &rhs) const { return lhs + rhs; }
-};
-
-template <> struct plus<void> {
-  template <typename T> T operator()(const T &lhs, const T &rhs) const {
-    return lhs + rhs;
-  }
-};
-
-} // namespace intel
 
 namespace detail {
 

sycl/include/CL/sycl/intel/sub_group_host.hpp

@@ -12,47 +12,13 @@
 #include <CL/sycl/id.hpp>
 #include <CL/sycl/range.hpp>
 #include <CL/sycl/types.hpp>
+#include <CL/sycl/intel/functional.hpp>
 #ifndef __SYCL_DEVICE_ONLY__
 
 namespace cl {
 namespace sycl {
 template <typename T, access::address_space Space> class multi_ptr;
 namespace intel {
-
-template <typename T = void> struct minimum {
-  T operator()(const T &lhs, const T &rhs) const {
-    return (lhs <= rhs) ? lhs : rhs;
-  }
-};
-
-template <> struct minimum<void> {
-  template <typename T> T operator()(const T &lhs, const T &rhs) const {
-    return (lhs <= rhs) ? lhs : rhs;
-  }
-};
-
-template <typename T = void> struct maximum {
-  T operator()(const T &lhs, const T &rhs) const {
-    return (lhs >= rhs) ? lhs : rhs;
-  }
-};
-
-template <> struct maximum<void> {
-  template <typename T> T operator()(const T &lhs, const T &rhs) const {
-    return (lhs >= rhs) ? lhs : rhs;
-  }
-};
-
-template <typename T = void> struct plus {
-  T operator()(const T &lhs, const T &rhs) const { return lhs + rhs; }
-};
-
-template <> struct plus<void> {
-  template <typename T> T operator()(const T &lhs, const T &rhs) const {
-    return lhs + rhs;
-  }
-};
-
 struct sub_group {
   /* --- common interface members --- */