Merge branch 'master' into SimdCartesianPartition and performance optimize

1. Use `ReshapedArray` rather than `reshape` to make high-dimension cases with small size faster.

Author: N5N3

base/multidimensional.jl

@@ -591,16 +591,14 @@ module IteratorsMD
         CartesianIndices(intersect.(a.indices, b.indices))
 
     # Views of reshaped CartesianIndices are used for partitions — ensure these are fast
-    const CartesianPartition{T<:CartesianIndex, P<:CartesianIndices, R<:ReshapedArray{T,1,P}} = SubArray{T,1,R,<:Tuple{AbstractUnitRange{Int}},false}
-    eltype(::Type{PartitionIterator{T}}) where {T<:ReshapedArrayLF} = SubArray{eltype(T), 1, T, Tuple{UnitRange{Int}}, true}
-    eltype(::Type{PartitionIterator{T}}) where {T<:ReshapedArray} = SubArray{eltype(T), 1, T, Tuple{UnitRange{Int}}, false}
+    const CartesianPartition{T<:CartesianIndex, P<:CartesianIndices, R<:ReshapedArray{T,1,P}} = SubArray{T,1,R,<:Tuple{AbstractUnitRange{Int}}}
+    eltype(::Type{PartitionIterator{T}}) where {T<:ReshapedArray} = SubArray{eltype(T), 1, T, Tuple{UnitRange{Int}}, IndexStyle(T) == IndexLinear()}
     Iterators.IteratorEltype(::Type{<:PartitionIterator{T}}) where {T<:ReshapedArray} = Iterators.IteratorEltype(T)
 
     eltype(::Type{PartitionIterator{T}}) where {T<:OneTo} = UnitRange{eltype(T)}
     eltype(::Type{PartitionIterator{T}}) where {T<:Union{UnitRange, StepRange, StepRangeLen, LinRange}} = T
     Iterators.IteratorEltype(::Type{<:PartitionIterator{T}}) where {T<:Union{OneTo, UnitRange, StepRange, StepRangeLen, LinRange}} = Iterators.IteratorEltype(T)
 
-
     @inline function iterate(iter::CartesianPartition)
         isempty(iter) && return nothing
         f = first(iter)
@@ -612,19 +610,26 @@ module IteratorsMD
         return I, (I, n+1)
     end
 
-    @inline function _splitlinear(piter::CartesianIndices, oiter::CartesianIndices, i::Int)
-        ci = Base._to_subscript_indices(piter, i)
-        ci[1], Base._to_linear_index(oiter, tail(ci)...)
-    end
     @inline function simd_outer_range(iter::CartesianPartition)
-        # In general, the CartesianPartition might start and stop in the middle of the outer
+        # CartesianPartition might start and stop in the middle of the outer
         # dimensions, thus the outer range itself is a CartesianPartition.
         piter = iter.parent.parent
         ax1, oiter = split(piter, Val(1))
         vindʷ = only(iter.indices)
+        @inline function _splitlinear(piter::CartesianIndices, oiter::CartesianIndices, i::Int)
+            ci = Base._to_subscript_indices(piter, i)
+            ci[1], Base._to_linear_index(oiter, tail(ci)...)
+        end
         fl, vl = _splitlinear(piter, oiter, first(vindʷ))
         fr, vr = _splitlinear(piter, oiter, last(vindʷ))
-        outer = @inbounds view(oiter, vl:vr)
+        @inline function _view(oiter::CartesianIndices, ind::AbstractUnitRange)
+            # we dont have #40344 for 1.6 and 1.7, force this return a CartesianIndices{1}
+            ndims(oiter) == 1 && return @inbounds CartesianIndices((oiter.indices[1][ind],)) 
+            # there's no need to make outer range fast-indexable
+            oiter′ = ReshapedArray(oiter, (length(oiter),), ())
+            @inbounds view(oiter′, ind)
+        end
+        outer = _view(oiter, vl:vr)
         # Use Generator to make inner loop branchless
         @inline function genouter(i::Int, I::CartesianIndex)
             l = i == 1 ? fl : firstindex(ax1)