Replace O(N) recursive sequence_map_inverse with O(1) pack expansion

Use constexpr loop in find_source_index to locate permutation inverse
indices, then expand via pack expansion for O(1) template instantiation
depth instead of O(N) recursive template instantiation.

Author: tenpercent

include/ck/utility/sequence.hpp

@@ -525,31 +525,46 @@ struct is_valid_sequence_map : is_same<typename arithmetic_sequence_gen<0, SeqMa
 {
 };
 
-template <typename SeqMap>
-struct sequence_map_inverse
+// Invert a permutation sequence using O(1) template instantiations
+// For X2Y = {a, b, c, ...}, computes Y2X where Y2X[X2Y[i]] = i
+//
+// Uses a single constexpr member function instead of N template instantiations.
+// The function is called N times via pack expansion, but only one function exists.
+namespace detail {
+// TODO: Replace with std::array when HIPRTC supports it
+template <typename T, index_t N>
+struct ConstexprArray
 {
-    template <typename X2Y, typename WorkingY2X, index_t XBegin, index_t XRemain>
-    struct sequence_map_inverse_impl
-    {
-        static constexpr auto new_y2x =
-            WorkingY2X::Modify(X2Y::At(Number<XBegin>{}), Number<XBegin>{});
+    T data[N];
 
-        using type =
-            typename sequence_map_inverse_impl<X2Y, decltype(new_y2x), XBegin + 1, XRemain - 1>::
-                type;
-    };
+    constexpr const T& operator[](index_t i) const { return data[i]; }
+};
+} // namespace detail
+
+template <index_t... Is>
+struct sequence_map_inverse<Sequence<Is...>>
+{
+    private:
+    static constexpr detail::ConstexprArray<index_t, sizeof...(Is)> values = {{Is...}};
 
-    template <typename X2Y, typename WorkingY2X, index_t XBegin>
-    struct sequence_map_inverse_impl<X2Y, WorkingY2X, XBegin, 0>
+    static constexpr index_t find_inverse(index_t target)
     {
-        using type = WorkingY2X;
-    };
+        for(index_t i = 0; i < static_cast<index_t>(sizeof...(Is)); ++i)
+        {
+            if(values[i] == target)
+                return i;
+        }
+        return -1; // should not reach for valid permutation
+    }
 
-    using type =
-        typename sequence_map_inverse_impl<SeqMap,
-                                           typename uniform_sequence_gen<SeqMap::Size(), 0>::type,
-                                           0,
-                                           SeqMap::Size()>::type;
+    template <index_t... Positions>
+    static constexpr auto compute(Sequence<Positions...>)
+    {
+        return Sequence<find_inverse(Positions)...>{};
+    }
+
+    public:
+    using type = decltype(compute(make_index_sequence<sizeof...(Is)>{}));
 };
 
 template <index_t... Xs, index_t... Ys>