From 5edc917bec69e076a6fe0f490d888bc042c1fe79 Mon Sep 17 00:00:00 2001
From: serge-sans-paille <serge.guelton@telecom-bretagne.eu>
Date: Wed, 12 Apr 2023 17:21:36 +0200
Subject: [PATCH] Introduce cstride_slice<N>, constant stride slice

It's very rare to have non-constant stride, and using a constant unlocks
various optimization, including potential improvement for #2095
---
 pythran/backend.py                            |  17 +-
 .../pythonic/include/types/numpy_gexpr.hpp    |  73 +++--
 pythran/pythonic/include/types/slice.hpp      | 129 +++++++-
 pythran/pythonic/include/types/tuple.hpp      |  11 +
 pythran/pythonic/types/numpy_gexpr.hpp        |  10 +-
 pythran/pythonic/types/slice.hpp              | 279 +++++++++++++++++-
 pythran/pythonic/types/tuple.hpp              |  79 ++---
 pythran/types/types.py                        |  14 +-
 8 files changed, 531 insertions(+), 81 deletions(-)

diff --git a/pythran/backend.py b/pythran/backend.py
index 65cb3e185..6089a50c2 100644
--- a/pythran/backend.py
+++ b/pythran/backend.py
@@ -1088,12 +1088,19 @@ def visit_Slice(self, node):
                    else 'pythonic::builtins::None')
             args.append(arg)
 
-        if node.step is None or (isnum(node.step) and node.step.value == 1):
-            if self.all_positive(node.lower) and self.all_positive(node.upper):
-                builder = "pythonic::types::fast_contiguous_slice({},{})"
+        nstep = node.step
+        if nstep is None or (isnum(nstep) and nstep.value > 0):
+            if nstep is None or nstep.value == 1:
+                if self.all_positive(node.lower) and self.all_positive(node.upper):
+                    builder = "pythonic::types::fast_contiguous_slice({0},{1})"
+                else:
+                    builder = "pythonic::types::contiguous_slice({0},{1})"
+                step = 1
             else:
-                builder = "pythonic::types::contiguous_slice({},{})"
-            return builder.format(args[0], args[1])
+                builder = "pythonic::types::cstride_slice<{2}>({0},{1})"
+                step = nstep.value
+
+            return builder.format(args[0], args[1], step)
         else:
             return "pythonic::types::slice({},{},{})".format(*args)
 
diff --git a/pythran/pythonic/include/types/numpy_gexpr.hpp b/pythran/pythonic/include/types/numpy_gexpr.hpp
index 6dc7c6327..8c5f0b332 100644
--- a/pythran/pythonic/include/types/numpy_gexpr.hpp
+++ b/pythran/pythonic/include/types/numpy_gexpr.hpp
@@ -161,6 +161,11 @@ namespace types
     static constexpr size_t value = 0;
   };
 
+  template <long stride>
+  struct count_long<cstride_normalized_slice<stride>> {
+    static constexpr size_t value = 0;
+  };
+
   template <class T, class... Types>
   struct count_long<T, Types...> {
     static constexpr size_t value =
@@ -511,6 +516,13 @@ namespace types
       : gexpr_shape<pshape<Tys..., std::integral_constant<long, 1>>,
                     pshape<oTys...>, S...> {
   };
+  template <class... Tys, class... oTys, class... S, long stride>
+  struct gexpr_shape<pshape<Tys...>,
+                     pshape<std::integral_constant<long, 1>, oTys...>,
+                     cstride_normalized_slice<stride>, S...>
+      : gexpr_shape<pshape<Tys..., std::integral_constant<long, 1>>,
+                    pshape<oTys...>, S...> {
+  };
   template <class... Tys, class... oTys, class... S>
   struct gexpr_shape<pshape<Tys...>,
                      pshape<std::integral_constant<long, 1>, oTys...>,
@@ -546,11 +558,9 @@ namespace types
     static_assert(
         utils::all_of<std::is_same<S, normalize_t<S>>::value...>::value,
         "all slices are normalized");
-    static_assert(
-        utils::all_of<(std::is_same<S, long>::value ||
-                       std::is_same<S, contiguous_normalized_slice>::value ||
-                       std::is_same<S, normalized_slice>::value)...>::value,
-        "all slices are valid");
+    static_assert(utils::all_of<(std::is_same<S, long>::value ||
+                                 is_normalized_slice<S>::value)...>::value,
+                  "all slices are valid");
     static_assert(std::decay<Arg>::type::value >= sizeof...(S),
                   "slicing respects array shape");
 
@@ -572,6 +582,11 @@ namespace types
     static constexpr size_t value =
         std::remove_reference<Arg>::type::value - count_long<S...>::value;
 
+    using last_arg_stride_t =
+        decltype(std::declval<Arg>().template strides<sizeof...(S) - 1>());
+    using last_slice_t =
+        typename std::tuple_element<sizeof...(S) - 1, std::tuple<S...>>::type;
+
     // It is not possible to vectorize everything. We only vectorize if the
     // last dimension is contiguous, which happens if
     // 1. Arg is an ndarray (this is too strict)
@@ -580,18 +595,15 @@ namespace types
     static const bool is_vectorizable =
         std::remove_reference<Arg>::type::is_vectorizable &&
         (sizeof...(S) < std::remove_reference<Arg>::type::value ||
-         std::is_same<contiguous_normalized_slice,
-                      typename std::tuple_element<
-                          sizeof...(S) - 1, std::tuple<S...>>::type>::value);
+         std::is_same<contiguous_normalized_slice, last_slice_t>::value);
     static const bool is_flat =
         std::remove_reference<Arg>::type::is_flat && value == 1 &&
-         utils::all_of<std::is_same<contiguous_normalized_slice, S>::value...>::value;
+        utils::all_of<
+            std::is_same<contiguous_normalized_slice, S>::value...>::value;
     static const bool is_strided =
         std::remove_reference<Arg>::type::is_strided ||
         (((sizeof...(S) - count_long<S...>::value) == value) &&
-         !std::is_same<contiguous_normalized_slice,
-                       typename std::tuple_element<
-                           sizeof...(S) - 1, std::tuple<S...>>::type>::value);
+         !std::is_same<contiguous_normalized_slice, last_slice_t>::value);
 
     using value_type =
         typename std::decay<decltype(numpy_iexpr_helper<value>::get(
@@ -614,7 +626,21 @@ namespace types
 
     shape_t _shape;
     dtype *buffer;
-    array<long, value> _strides;
+
+    template <long stride>
+    static constexpr types::pshape<std::integral_constant<long, stride>>
+        last_stride(cstride_normalized_slice<stride>);
+    static constexpr types::pshape<std::integral_constant<long, 1>>
+        last_stride(contiguous_normalized_slice);
+    static constexpr types::array<long, 1> last_stride(...);
+
+    sutils::concat_t<types::array<long, value - 1>,
+                     typename std::conditional<
+                         sizeof...(S) == std::decay<Arg>::type::value,
+                         decltype(last_stride(std::declval<last_slice_t>())),
+                         types::array<long, 1>>::type>
+        _strides; // strides
+
     template <size_t I>
     auto shape() const -> decltype(std::get<I>(_shape))
     {
@@ -636,17 +662,11 @@ namespace types
     numpy_gexpr(numpy_gexpr<Argp, S...> const &other);
 
     template <size_t J, class Slice>
-    typename std::enable_if<
-        std::is_same<Slice, normalized_slice>::value ||
-            std::is_same<Slice, contiguous_normalized_slice>::value,
-        void>::type
+    typename std::enable_if<is_normalized_slice<Slice>::value, void>::type
     init_shape(Slice const &s, utils::int_<1>, utils::int_<J>);
 
     template <size_t I, size_t J, class Slice>
-    typename std::enable_if<
-        std::is_same<Slice, normalized_slice>::value ||
-            std::is_same<Slice, contiguous_normalized_slice>::value,
-        void>::type
+    typename std::enable_if<is_normalized_slice<Slice>::value, void>::type
     init_shape(Slice const &s, utils::int_<I>, utils::int_<J>);
 
     template <size_t J>
@@ -877,9 +897,14 @@ namespace types
 
     explicit operator bool() const;
 
-
-    dtype* data() { return buffer;}
-    const dtype* data() const { return buffer;}
+    dtype *data()
+    {
+      return buffer;
+    }
+    const dtype *data() const
+    {
+      return buffer;
+    }
     long flat_size() const;
     long size() const;
     ndarray<dtype, shape_t> copy() const
diff --git a/pythran/pythonic/include/types/slice.hpp b/pythran/pythonic/include/types/slice.hpp
index d9e0d357a..b987a39c2 100644
--- a/pythran/pythonic/include/types/slice.hpp
+++ b/pythran/pythonic/include/types/slice.hpp
@@ -49,18 +49,27 @@ namespace types
   };
 
   struct slice;
+  template <long stride>
+  struct cstride_slice;
+  template <long stride>
+  struct cstride_normalized_slice;
   struct contiguous_slice;
   struct fast_contiguous_slice;
   struct contiguous_normalized_slice;
 
   struct normalized_slice {
     long lower, upper, step;
-    normalized_slice();
+    normalized_slice() = default;
     normalized_slice(long lower, long upper, long step = 1);
 
     normalized_slice operator*(normalized_slice const &other) const;
     normalized_slice operator*(contiguous_normalized_slice const &other) const;
+    template <long stride>
+    normalized_slice
+    operator*(cstride_normalized_slice<stride> const &other) const;
     normalized_slice operator*(slice const &other) const;
+    template <long stride>
+    normalized_slice operator*(cstride_slice<stride> const &other) const;
     normalized_slice operator*(contiguous_slice const &other) const;
     normalized_slice operator*(fast_contiguous_slice const &other) const;
 
@@ -77,6 +86,9 @@ namespace types
 
     slice operator*(slice const &other) const;
 
+    template <long stride>
+    slice operator*(cstride_slice<stride> const &other) const;
+
     slice operator*(contiguous_slice const &other) const;
 
     slice operator*(fast_contiguous_slice const &other) const;
@@ -97,6 +109,79 @@ namespace types
     long get(long i) const;
   };
 
+  template <long stride>
+  struct cstride_normalized_slice {
+    long lower, upper;
+    static constexpr long step = stride;
+    cstride_normalized_slice();
+    cstride_normalized_slice(long lower, long upper, long = 0);
+
+    normalized_slice operator*(normalized_slice const &other) const;
+    cstride_normalized_slice
+    operator*(contiguous_normalized_slice const &other) const;
+    template <long other_stride>
+    typename std::conditional<(stride < 256 && other_stride < 256),
+                              cstride_normalized_slice<stride * other_stride>,
+                              normalized_slice>::type
+    operator*(cstride_normalized_slice<other_stride> const &other) const;
+
+    normalized_slice operator*(slice const &other) const;
+    template <long other_stride>
+    typename std::conditional<(stride < 256 && other_stride < 256),
+                              cstride_normalized_slice<stride * other_stride>,
+                              normalized_slice>::type
+    operator*(cstride_slice<other_stride> const &other) const;
+    cstride_normalized_slice operator*(contiguous_slice const &other) const;
+    cstride_normalized_slice
+    operator*(fast_contiguous_slice const &other) const;
+
+    long size() const;
+    inline long get(long i) const;
+  };
+
+  template <long stride>
+  constexpr long cstride_normalized_slice<stride>::step;
+
+  template <long stride>
+  struct cstride_slice {
+    using normalized_type = cstride_normalized_slice<stride>;
+
+    bound<long> lower, upper;
+    static constexpr long step = stride;
+
+    cstride_slice(none<long> lower, none<long> upper);
+    cstride_slice();
+
+    slice operator*(slice const &other) const;
+
+    template <long other_stride>
+    typename std::conditional<(stride < 256 && other_stride < 256),
+                              cstride_slice<stride * other_stride>, slice>::type
+    operator*(cstride_slice<other_stride> const &other) const;
+
+    cstride_slice operator*(contiguous_slice const &other) const;
+
+    cstride_slice operator*(fast_contiguous_slice const &other) const;
+
+    /*
+       Normalize change a[:-1] to a[:len(a)-1] to have positif index.
+       It also check for value bigger than len(a) to fit the size of the
+       container
+       */
+    cstride_normalized_slice<stride> normalize(long max_size) const;
+
+    /*
+     * An assert is raised when we can't compute the size without more
+     * informations.
+     */
+    long size() const;
+
+    long get(long i) const;
+  };
+
+  template <long stride>
+  constexpr long cstride_slice<stride>::step;
+
   struct contiguous_normalized_slice {
     long lower, upper;
     static constexpr long step = 1;
@@ -105,11 +190,17 @@ namespace types
 
     contiguous_normalized_slice
     operator*(contiguous_normalized_slice const &other) const;
+    template <long stride>
+    cstride_normalized_slice<stride>
+    operator*(cstride_normalized_slice<stride> const &other) const;
     contiguous_normalized_slice operator*(contiguous_slice const &other) const;
     contiguous_normalized_slice
     operator*(fast_contiguous_slice const &other) const;
     normalized_slice operator*(normalized_slice const &other) const;
     normalized_slice operator*(slice const &other) const;
+    template <long stride>
+    cstride_normalized_slice<stride>
+    operator*(cstride_slice<stride> const &other) const;
 
     long size() const;
 
@@ -167,6 +258,11 @@ namespace types
     using type = normalized_slice;
   };
 
+  template <long stride>
+  struct normalized<cstride_slice<stride>> {
+    using type = cstride_normalized_slice<stride>;
+  };
+
   template <>
   struct normalized<contiguous_slice> {
     using type = contiguous_normalized_slice;
@@ -189,6 +285,23 @@ namespace types
   template <>
   struct is_slice<slice> : std::true_type {
   };
+  template <long stride>
+  struct is_slice<cstride_slice<stride>> : std::true_type {
+  };
+
+  template <class S>
+  struct is_normalized_slice : std::false_type {
+  };
+  template <>
+  struct is_normalized_slice<contiguous_normalized_slice> : std::true_type {
+  };
+  template <>
+  struct is_normalized_slice<normalized_slice> : std::true_type {
+  };
+  template <long stride>
+  struct is_normalized_slice<cstride_normalized_slice<stride>>
+      : std::true_type {
+  };
 
   template <class S>
   using normalize_t = typename normalized<S>::type;
@@ -253,7 +366,7 @@ namespace types
   template <class S>
   typename std::enable_if<is_slice<S>::value, std::ostream &>::type
   operator<<(std::ostream &os, S const &s);
-}
+} // namespace types
 namespace builtins
 {
   template <class T>
@@ -271,7 +384,7 @@ namespace builtins
   {
     return s.step;
   }
-}
+} // namespace builtins
 PYTHONIC_NS_END
 
 #ifdef ENABLE_PYTHON_MODULE
@@ -295,6 +408,16 @@ struct to_python<types::contiguous_normalized_slice> {
   static PyObject *convert(types::contiguous_normalized_slice const &n);
 };
 
+template <long stride>
+struct to_python<types::cstride_slice<stride>> {
+  static PyObject *convert(types::cstride_slice<stride> const &n);
+};
+
+template <long stride>
+struct to_python<types::cstride_normalized_slice<stride>> {
+  static PyObject *convert(types::cstride_normalized_slice<stride> const &n);
+};
+
 template <>
 struct to_python<types::slice> {
   static PyObject *convert(types::slice const &n);
diff --git a/pythran/pythonic/include/types/tuple.hpp b/pythran/pythonic/include/types/tuple.hpp
index 72a7c42e6..66557c0f4 100644
--- a/pythran/pythonic/include/types/tuple.hpp
+++ b/pythran/pythonic/include/types/tuple.hpp
@@ -88,6 +88,8 @@ namespace types
 
   struct slice;
   struct contiguous_slice;
+  template <long stride>
+  struct cstride_slice;
 
   /* helper to extract the tail of a tuple, && pop the head */
   template <int Offset, class T, size_t... N>
@@ -276,6 +278,10 @@ namespace types
     template <class T, size_t N>
     dynamic_tuple<T> operator()(array<T, N> const &b, slice const &s);
 
+    template <class T, size_t N, long stride>
+    dynamic_tuple<T> operator()(array<T, N> const &b,
+                                cstride_slice<stride> const &s);
+
     template <class T, size_t N>
     dynamic_tuple<T> operator()(array<T, N> const &b,
                                 contiguous_slice const &s);
@@ -1209,6 +1215,11 @@ namespace sutils
       : concat<types::array<long, N - 1>, types::pshape<long, Ty1s...>> {
   };
 
+  template <size_t N, size_t M>
+  struct concat<types::array<long, N>, types::array<long, M>> {
+    using type = types::array<long, N + M>;
+  };
+
   template <class... Tys>
   using concat_t = typename concat<Tys...>::type;
 
diff --git a/pythran/pythonic/types/numpy_gexpr.hpp b/pythran/pythonic/types/numpy_gexpr.hpp
index 1f2f0c6f4..fb2fc57c0 100644
--- a/pythran/pythonic/types/numpy_gexpr.hpp
+++ b/pythran/pythonic/types/numpy_gexpr.hpp
@@ -274,10 +274,7 @@ namespace types
 
   template <class Arg, class... S>
   template <size_t J, class Slice>
-  typename std::enable_if<
-      std::is_same<Slice, normalized_slice>::value ||
-          std::is_same<Slice, contiguous_normalized_slice>::value,
-      void>::type
+  typename std::enable_if<is_normalized_slice<Slice>::value, void>::type
   numpy_gexpr<Arg, S...>::init_shape(Slice const &s, utils::int_<1>,
                                      utils::int_<J>)
   {
@@ -290,10 +287,7 @@ namespace types
 
   template <class Arg, class... S>
   template <size_t I, size_t J, class Slice>
-  typename std::enable_if<
-      std::is_same<Slice, normalized_slice>::value ||
-          std::is_same<Slice, contiguous_normalized_slice>::value,
-      void>::type
+  typename std::enable_if<is_normalized_slice<Slice>::value, void>::type
   numpy_gexpr<Arg, S...>::init_shape(Slice const &s, utils::int_<I>,
                                      utils::int_<J>)
   {
diff --git a/pythran/pythonic/types/slice.hpp b/pythran/pythonic/types/slice.hpp
index d4b196fb3..05276f41a 100644
--- a/pythran/pythonic/types/slice.hpp
+++ b/pythran/pythonic/types/slice.hpp
@@ -30,9 +30,6 @@ namespace types
     }
   } // namespace details
 
-  inline normalized_slice::normalized_slice()
-  {
-  }
   inline normalized_slice::normalized_slice(long lower, long upper, long step)
       : lower(lower), upper(upper), step(step)
   {
@@ -50,6 +47,13 @@ namespace types
     return {lower + step * other.lower, lower + step * other.upper,
             step * other.step};
   }
+  template <long stride>
+  inline normalized_slice normalized_slice::operator*(
+      cstride_normalized_slice<stride> const &other) const
+  {
+    return {lower + step * other.lower, lower + step * other.upper,
+            step * other.step};
+  }
   inline normalized_slice normalized_slice::operator*(slice const &other) const
   {
     return (*this) * other.normalize(size());
@@ -59,6 +63,12 @@ namespace types
   {
     return (*this) * other.normalize(size());
   }
+  template <long stride>
+  inline normalized_slice
+  normalized_slice::operator*(cstride_slice<stride> const &other) const
+  {
+    return (*this) * other.normalize(size());
+  }
 
   inline long normalized_slice::size() const
   {
@@ -215,7 +225,238 @@ namespace types
     assert(!upper.is_none() && !lower.is_none());
     return (long)lower + i * sstep;
   }
+  //
+
+  template <long stride>
+  inline cstride_normalized_slice<stride>::cstride_normalized_slice(long lower,
+                                                                    long upper,
+                                                                    long)
+      : lower(lower), upper(upper)
+  {
+  }
+
+  template <long stride>
+  inline normalized_slice cstride_normalized_slice<stride>::operator*(
+      normalized_slice const &other) const
+  {
+    return {lower + step * other.lower, lower + step * other.upper,
+            step * other.step};
+  }
+
+  template <long stride>
+  template <long other_stride>
+  inline
+      typename std::conditional<(stride < 256 && other_stride < 256),
+                                cstride_normalized_slice<stride * other_stride>,
+                                normalized_slice>::type
+      cstride_normalized_slice<stride>::operator*(
+          cstride_normalized_slice<other_stride> const &other) const
+  {
+    return {lower + step * other.lower, lower + step * other.upper,
+            step * other.step};
+  }
+
+  template <long stride>
+  inline cstride_normalized_slice<stride>
+  cstride_normalized_slice<stride>::operator*(
+      contiguous_normalized_slice const &other) const
+  {
+    return {lower + step * other.lower, lower + step * other.upper};
+  }
+
+  template <long stride>
+  inline normalized_slice
+  cstride_normalized_slice<stride>::operator*(slice const &other) const
+  {
+    return (*this) * other.normalize(size());
+  }
+
+  template <long stride>
+  template <long other_stride>
+  inline
+      typename std::conditional<(stride < 256 && other_stride < 256),
+                                cstride_normalized_slice<stride * other_stride>,
+                                normalized_slice>::type
+      cstride_normalized_slice<stride>::operator*(
+          cstride_slice<other_stride> const &other) const
+  {
+    return (*this) * other.normalize(size());
+  }
+
+  template <long stride>
+  inline cstride_normalized_slice<stride>
+  cstride_normalized_slice<stride>::operator*(
+      contiguous_slice const &other) const
+  {
+    return (*this) * other.normalize(size());
+  }
+
+  template <long stride>
+  inline long cstride_normalized_slice<stride>::size() const
+  {
+    return std::max(0L, details::roundup_divide(upper - lower, step));
+  }
+
+  template <long stride>
+  inline long cstride_normalized_slice<stride>::get(long i) const
+  {
+    return lower + i * step;
+  }
+
+  template <long stride>
+  inline cstride_slice<stride>::cstride_slice(none<long> lower,
+                                              none<long> upper)
+      : lower(lower), upper(upper)
+  {
+  }
+
+  template <long stride>
+  inline cstride_slice<stride>::cstride_slice()
+      : lower(builtins::None), upper(builtins::None)
+  {
+  }
+
+  template <long stride>
+  inline slice cstride_slice<stride>::operator*(slice const &other) const
+  {
+    // We do not implement these because it requires to know the "end"
+    // value of the slice which is ! possible if it is ! "step == 1" slice
+    // TODO: We can skip these constraints if we know begin, end && step.
+    long ostep = (other.step.is_none()) ? 1 : (long)other.step;
+    bound<long> new_lower;
+    if (other.lower.is_none() || (long)other.lower == 0) {
+      if (ostep > 0)
+        new_lower = lower;
+      else {
+        if (upper.is_none() || (long)upper == -1)
+          new_lower = none_type{};
+        else
+          new_lower = (long)upper + 1;
+      }
+    } else {
+      none<long> ref = ((long)other.lower > 0) ? lower : upper;
+      if (ref.is_none) {
+        new_lower = (long)other.lower * step;
+      } else
+        new_lower = (long)ref + (long)other.lower * step;
+    }
+
+    long new_step = step * ostep;
+
+    bound<long> new_upper;
+    if (other.upper.is_none()) {
+      if (ostep > 0)
+        new_upper = upper;
+      else {
+        if (lower.is_none() || (long)lower == 0)
+          new_upper = none_type{};
+        else
+          new_upper = (long)lower - 1;
+      }
+    } else {
+      none<long> ref = ((long)other.upper > 0) ? lower : upper;
+      if (ref.is_none) {
+        new_upper = (long)other.upper * step;
+      } else
+        new_upper = (long)ref + (long)other.upper * step;
+    }
+    return {new_lower, new_upper, new_step};
+  }
+
+  template <long stride>
+  template <long other_stride>
+  inline typename std::conditional<(stride < 256 && other_stride < 256),
+                                   cstride_slice<stride * other_stride>,
+                                   slice>::type
+  cstride_slice<stride>::operator*(
+      cstride_slice<other_stride> const &other) const
+  {
+    bound<long> new_lower;
+    if (other.lower.is_none() || (long)other.lower == 0) {
+      new_lower = lower;
+    } else {
+      none<long> ref = ((long)other.lower > 0) ? lower : upper;
+      if (ref.is_none) {
+        new_lower = (long)other.lower * step;
+      } else
+        new_lower = (long)ref + (long)other.lower * step;
+    }
+
+    long new_step = step * other.step;
+
+    bound<long> new_upper;
+    if (other.upper.is_none()) {
+      new_upper = upper;
+    } else {
+      none<long> ref = ((long)other.upper > 0) ? lower : upper;
+      if (ref.is_none) {
+        new_upper = (long)other.upper * step;
+      } else
+        new_upper = (long)ref + (long)other.upper * step;
+    }
+    return {new_lower, new_upper, new_step};
+  }
+
+  /*
+     Normalize change a[:-1] to a[:len(a)-1] to have positif index.
+     It also check for value bigger than len(a) to fit the size of the
+     container
+     */
+  template <long stride>
+  inline cstride_normalized_slice<stride>
+  cstride_slice<stride>::normalize(long max_size) const
+  {
+    long normalized_upper;
+    if (upper.is_none()) {
+      normalized_upper = max_size;
+    } else {
+      if (upper < 0L)
+        normalized_upper = std::max(-1L, max_size + upper);
+      else if (upper > max_size)
+        normalized_upper = max_size;
+      else
+        normalized_upper = (long)upper;
+    }
+
+    long normalized_lower;
+    if (lower.is_none())
+      normalized_lower = 0L;
+    else if (lower < 0L)
+      normalized_lower = std::max(0L, max_size + lower);
+    else if (lower > max_size)
+      normalized_lower = max_size;
+    else
+      normalized_lower = (long)lower;
+
+    return {normalized_lower, normalized_upper};
+  }
 
+  /*
+   * An assert is raised when we can't compute the size without more
+   * informations.
+   */
+  template <long stride>
+  inline long cstride_slice<stride>::size() const
+  {
+    assert(!(upper.is_none() && lower.is_none()));
+    long len;
+    if (upper.is_none()) {
+      len = -(long)lower;
+    } else if (lower.is_none()) {
+      len = upper;
+    } else
+      len = upper - lower;
+    return std::max(0L, details::roundup_divide(len, step));
+  }
+
+  template <long stride>
+  inline long cstride_slice<stride>::get(long i) const
+  {
+    assert(!upper.is_none() && !lower.is_none());
+    return (long)lower + i * step;
+  }
+
+  //
   inline contiguous_normalized_slice::contiguous_normalized_slice()
   {
   }
@@ -244,6 +485,14 @@ namespace types
     return (*this) * other.normalize(size());
   }
 
+  template <long stride>
+  inline cstride_normalized_slice<stride>
+  contiguous_normalized_slice::operator*(
+      cstride_normalized_slice<stride> const &other) const
+  {
+    return {lower + step * other.lower, lower + step * other.upper};
+  }
+
   inline normalized_slice
   contiguous_normalized_slice::operator*(normalized_slice const &other) const
   {
@@ -251,6 +500,14 @@ namespace types
                             lower + step * other.upper, step * other.step);
   }
 
+  template <long stride>
+  inline cstride_normalized_slice<stride>
+  contiguous_normalized_slice::operator*(
+      cstride_slice<stride> const &other) const
+  {
+    return (*this) * other.normalize(size());
+  }
+
   inline normalized_slice
   contiguous_normalized_slice::operator*(slice const &other) const
   {
@@ -577,6 +834,22 @@ to_python<types::contiguous_slice>::convert(types::contiguous_slice const &v)
                      ::to_python(types::none_type{}));
 }
 
+template <long stride>
+inline PyObject *to_python<types::cstride_normalized_slice<stride>>::convert(
+    types::cstride_normalized_slice<stride> const &v)
+{
+  return PySlice_New(::to_python(v.lower), ::to_python(v.upper),
+                     ::to_python(v.step));
+}
+
+template <long stride>
+inline PyObject *to_python<types::cstride_slice<stride>>::convert(
+    types::cstride_slice<stride> const &v)
+{
+  return PySlice_New(::to_python(v.lower), ::to_python(v.upper),
+                     ::to_python(v.step));
+}
+
 inline PyObject *
 to_python<types::normalized_slice>::convert(types::normalized_slice const &v)
 {
diff --git a/pythran/pythonic/types/tuple.hpp b/pythran/pythonic/types/tuple.hpp
index 5d0ebab5f..d96822224 100644
--- a/pythran/pythonic/types/tuple.hpp
+++ b/pythran/pythonic/types/tuple.hpp
@@ -4,16 +4,16 @@
 #include "pythonic/include/types/tuple.hpp"
 
 #include "pythonic/types/assignable.hpp"
-#include "pythonic/types/traits.hpp"
-#include "pythonic/types/nditerator.hpp"
 #include "pythonic/types/dynamic_tuple.hpp"
+#include "pythonic/types/ndarray.hpp"
+#include "pythonic/types/nditerator.hpp"
+#include "pythonic/types/traits.hpp"
 #include "pythonic/utils/int_.hpp"
-#include "pythonic/utils/seq.hpp"
 #include "pythonic/utils/nested_container.hpp"
-#include "pythonic/types/ndarray.hpp"
+#include "pythonic/utils/seq.hpp"
 
-#include <tuple>
 #include <algorithm>
+#include <tuple>
 
 namespace std
 {
@@ -27,7 +27,7 @@ namespace std
   {
     return self.first == get<0>(other) && self.second == get<1>(other);
   }
-}
+} // namespace std
 
 template <class... Types0, class... Types1>
 std::tuple<Types0..., Types1...> operator+(std::tuple<Types0...> const &t0,
@@ -133,8 +133,8 @@ namespace types
   }
 
   template <typename T, size_t N, class V>
-  typename array_base<T, N, V>::const_iterator array_base<T, N, V>::end() const
-      noexcept
+  typename array_base<T, N, V>::const_iterator
+  array_base<T, N, V>::end() const noexcept
   {
     return {data() + N};
   }
@@ -175,8 +175,8 @@ namespace types
   }
 
   template <typename T, size_t N, class V>
-  typename array_base<T, N, V>::const_iterator array_base<T, N, V>::cend() const
-      noexcept
+  typename array_base<T, N, V>::const_iterator
+  array_base<T, N, V>::cend() const noexcept
   {
     return {&(buffer[N])};
   }
@@ -236,7 +236,7 @@ namespace types
   template <typename T, size_t N, class V>
   template <class vectorizer>
   typename array_base<T, N, V>::simd_iterator
-      array_base<T, N, V>::vbegin(vectorizer) const
+  array_base<T, N, V>::vbegin(vectorizer) const
   {
     return {&buffer[0]};
   }
@@ -244,7 +244,7 @@ namespace types
   template <typename T, size_t N, class V>
   template <class vectorizer>
   typename array_base<T, N, V>::simd_iterator
-      array_base<T, N, V>::vend(vectorizer) const
+  array_base<T, N, V>::vend(vectorizer) const
   {
     using vector_type = typename xsimd::batch<dtype>;
     static const std::size_t vector_size = vector_type::size;
@@ -253,8 +253,8 @@ namespace types
 #endif
 
   template <typename T, size_t N, class V>
-  typename array_base<T, N, V>::reference array_base<T, N, V>::
-  operator[](long __n)
+  typename array_base<T, N, V>::reference
+  array_base<T, N, V>::operator[](long __n)
   {
     auto const index = __n < 0 ? (__n + size()) : __n;
     assert(0 <= index && index < size());
@@ -262,8 +262,8 @@ namespace types
   }
 
   template <typename T, size_t N, class V>
-  typename array_base<T, N, V>::const_reference array_base<T, N, V>::
-  operator[](long __n) const noexcept
+  typename array_base<T, N, V>::const_reference
+  array_base<T, N, V>::operator[](long __n) const noexcept
   {
     auto const index = __n < 0 ? (__n + size()) : __n;
     assert(0 <= index && index < size());
@@ -303,8 +303,8 @@ namespace types
   }
 
   template <typename T, size_t N, class V>
-  typename array_base<T, N, V>::const_pointer array_base<T, N, V>::data() const
-      noexcept
+  typename array_base<T, N, V>::const_pointer
+  array_base<T, N, V>::data() const noexcept
   {
     return &(buffer[0]);
   }
@@ -333,8 +333,8 @@ namespace types
 
   template <typename T, size_t N, class V>
   template <class Tp, size_t M>
-  array_base<typename __combined<T, Tp>::type, N + M, V> array_base<T, N, V>::
-  operator+(array_base<Tp, M, V> const &other) const
+  array_base<typename __combined<T, Tp>::type, N + M, V>
+  array_base<T, N, V>::operator+(array_base<Tp, M, V> const &other) const
   {
     array_base<typename __combined<T, Tp>::type, N + M, V> result;
     auto next = std::copy(begin(), end(), result.begin());
@@ -412,6 +412,18 @@ namespace types
       tmp[j] = b[ns.lower + j * ns.step];
     return {&tmp[0], &tmp[ns.size()]};
   }
+
+  template <class T, size_t N, long stride>
+  dynamic_tuple<T> array_base_slicer::operator()(array<T, N> const &b,
+                                                 cstride_slice<stride> const &s)
+  {
+    cstride_normalized_slice<stride> ns = s.normalize(b.size());
+    array<T, N> tmp;
+    for (long j = 0; j < ns.size(); ++j)
+      tmp[j] = b[ns.lower + j * ns.step];
+    return {&tmp[0], &tmp[ns.size()]};
+  }
+
   template <class T, size_t N>
   dynamic_tuple<T> array_base_slicer::operator()(array<T, N> const &b,
                                                  contiguous_slice const &s)
@@ -426,7 +438,7 @@ namespace types
     contiguous_normalized_slice cns = s.normalize(b.size());
     return {&b[cns.lower], &b[cns.upper]};
   }
-}
+} // namespace types
 PYTHONIC_NS_END
 
 /* hashable tuples, as proposed in
@@ -441,8 +453,9 @@ namespace
   }
 
   template <size_t index, class... types>
-  size_t hash_impl<index, types...>::
-  operator()(size_t a, const std::tuple<types...> &t) const
+  size_t
+  hash_impl<index, types...>::operator()(size_t a,
+                                         const std::tuple<types...> &t) const
   {
     using nexttype =
         typename std::tuple_element<index, std::tuple<types...>>::type;
@@ -459,22 +472,22 @@ namespace
     size_t b = std::hash<nexttype>()(std::get<0>(t));
     return hash_combiner(a, b);
   }
-}
+} // namespace
 
 /* specialize std::hash */
 namespace std
 {
   template <class... Types>
-  size_t hash<std::tuple<Types...>>::
-  operator()(std::tuple<Types...> const &t) const
+  size_t
+  hash<std::tuple<Types...>>::operator()(std::tuple<Types...> const &t) const
   {
     const size_t begin = std::tuple_size<std::tuple<Types...>>::value - 1;
     return hash_impl<begin, Types...>()(1, t); // 1 should be some largervalue
   }
 
   template <typename T, size_t N, class V>
-  size_t hash<pythonic::types::array_base<T, N, V>>::
-  operator()(pythonic::types::array_base<T, N, V> const &l) const
+  size_t hash<pythonic::types::array_base<T, N, V>>::operator()(
+      pythonic::types::array_base<T, N, V> const &l) const
   {
     size_t seed = 0;
     hash<T> h;
@@ -482,7 +495,7 @@ namespace std
       seed ^= h(iter) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
     return seed;
   }
-}
+} // namespace std
 
 PYTHONIC_NS_BEGIN
 
@@ -500,7 +513,7 @@ namespace types
   {
     os << std::get<0>(t);
   }
-}
+} // namespace types
 PYTHONIC_NS_END
 
 namespace std
@@ -510,14 +523,14 @@ namespace std
   {
     os << '(';
     pythonic::types::print_tuple(os, t,
-                                 pythonic::utils::int_<sizeof...(Args)-1>());
+                                 pythonic::utils::int_<sizeof...(Args) - 1>());
     return os << ')';
   }
-}
+} // namespace std
 #ifdef ENABLE_PYTHON_MODULE
 
-#include "pythonic/include/utils/seq.hpp"
 #include "pythonic/include/utils/fwd.hpp"
+#include "pythonic/include/utils/seq.hpp"
 #include "pythonic/python/core.hpp"
 
 PYTHONIC_NS_BEGIN
diff --git a/pythran/types/types.py b/pythran/types/types.py
index 22d3c2791..e58664c04 100644
--- a/pythran/types/types.py
+++ b/pythran/types/types.py
@@ -483,12 +483,16 @@ def visit_Slice(self, node):
         Also visit subnodes as they may contains relevant typing information.
         """
         self.generic_visit(node)
-        if node.step is None or (isnum(node.step) and node.step.value == 1):
-            if all(self.range_values[p].low >= 0
-                   for p in (node.lower, node.upper)):
-                ntype = "pythonic::types::fast_contiguous_slice"
+        nstep = node.step
+        if nstep is None or (isnum(nstep) and nstep.value > 0):
+            if nstep is None or nstep.value == 1:
+                if all(self.range_values[p].low >= 0
+                       for p in (node.lower, node.upper)):
+                    ntype = "pythonic::types::fast_contiguous_slice"
+                else:
+                    ntype = "pythonic::types::contiguous_slice"
             else:
-                ntype = "pythonic::types::contiguous_slice"
+                ntype = "pythonic::types::cstride_slice<{}>".format(nstep.value)
             self.result[node] = self.builder.NamedType(ntype)
         else:
             self.result[node] = self.builder.NamedType(