SnoopPrecompile common methods

Author: chriselrod

Project.toml

@@ -1,18 +1,20 @@
 name = "ArrayInterface"
 uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9"
-version = "6.0.24"
+version = "6.0.25"
 
 [deps]
 ArrayInterfaceCore = "30b0a656-2188-435a-8636-2ec0e6a096e2"
 Compat = "34da2185-b29b-5c13-b0c7-acf172513d20"
 IfElse = "615f187c-cbe4-4ef1-ba3b-2fcf58d6d173"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
+SnoopPrecompile = "66db9d55-30c0-4569-8b51-7e840670fc0c"
 Static = "aedffcd0-7271-4cad-89d0-dc628f76c6d3"
 
 [compat]
 ArrayInterfaceCore = "0.1.3"
 Compat = "3, 4"
 IfElse = "0.1"
+SnoopPrecompile = "1"
 Static = "0.8"
 julia = "1.6"
 

lib/ArrayInterfaceCore/Project.toml

@@ -1,14 +1,16 @@
 name = "ArrayInterfaceCore"
 uuid = "30b0a656-2188-435a-8636-2ec0e6a096e2"
-version = "0.1.28"
+version = "0.1.29"
 
 [deps]
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
+SnoopPrecompile = "66db9d55-30c0-4569-8b51-7e840670fc0c"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 SuiteSparse = "4607b0f0-06f3-5cda-b6b1-a6196a1729e9"
 
 [compat]
 ArrayInterface = "6"
+SnoopPrecompile = "1"
 julia = "1.6"
 
 [extras]

lib/ArrayInterfaceCore/src/ArrayInterfaceCore.jl

@@ -1051,4 +1051,15 @@ stride_preserving_index(@nospecialize T::Type{<:Number}) = true
 end
 stride_preserving_index(@nospecialize T::Type) = false
 
+using SnoopPrecompile
+@precompile_setup begin
+    # Putting some things in `setup` can reduce the size of the
+    # precompile file and potentially make loading faster.
+    arrays = [rand(4), Base.oneto(5)]
+    @precompile_all_calls begin for x in arrays
+        known_first(x)
+        known_step(x)
+        known_last(x)
+    end end
+end
 end # module

src/ArrayInterface.jl

@@ -2,36 +2,43 @@ module ArrayInterface
 
 using ArrayInterfaceCore
 import ArrayInterfaceCore: allowed_getindex, allowed_setindex!, aos_to_soa, buffer,
-    parent_type, fast_matrix_colors, findstructralnz, has_sparsestruct,
-    issingular, isstructured, matrix_colors, restructure, lu_instance,
-    safevec, zeromatrix, undefmatrix, ColoringAlgorithm, fast_scalar_indexing, parameterless_type,
-    ndims_index, ndims_shape, is_splat_index, is_forwarding_wrapper, IndicesInfo, childdims,
-    parentdims, map_tuple_type, flatten_tuples, GetIndex, SetIndex!, defines_strides,
-    stride_preserving_index
+                           parent_type, fast_matrix_colors, findstructralnz,
+                           has_sparsestruct,
+                           issingular, isstructured, matrix_colors, restructure,
+                           lu_instance,
+                           safevec, zeromatrix, undefmatrix, ColoringAlgorithm,
+                           fast_scalar_indexing, parameterless_type,
+                           ndims_index, ndims_shape, is_splat_index, is_forwarding_wrapper,
+                           IndicesInfo, childdims,
+                           parentdims, map_tuple_type, flatten_tuples, GetIndex, SetIndex!,
+                           defines_strides,
+                           stride_preserving_index
 
 # ArrayIndex subtypes and methods
-import ArrayInterfaceCore: ArrayIndex, MatrixIndex, VectorIndex, BidiagonalIndex, TridiagonalIndex
+import ArrayInterfaceCore: ArrayIndex, MatrixIndex, VectorIndex, BidiagonalIndex,
+                           TridiagonalIndex
 # managing immutables
 import ArrayInterfaceCore: ismutable, can_change_size, can_setindex
 # constants
 import ArrayInterfaceCore: MatAdjTrans, VecAdjTrans, UpTri, LoTri
 # device pieces
 import ArrayInterfaceCore: AbstractDevice, AbstractCPU, CPUPointer, CPUTuple, CheckParent,
-    CPUIndex, GPU, can_avx, device
+                           CPUIndex, GPU, can_avx, device
 
 import ArrayInterfaceCore: known_first, known_step, known_last
 
 using Static
 using Static: Zero, One, nstatic, eq, ne, gt, ge, lt, le, eachop, eachop_tuple,
-    permute, invariant_permutation, field_type, reduce_tup, find_first_eq,
-    OptionallyStaticUnitRange, OptionallyStaticStepRange, OptionallyStaticRange, IntType,
-    SOneTo, SUnitRange
+              permute, invariant_permutation, field_type, reduce_tup, find_first_eq,
+              OptionallyStaticUnitRange, OptionallyStaticStepRange, OptionallyStaticRange,
+              IntType,
+              SOneTo, SUnitRange
 
 using IfElse
 
 using Base.Cartesian
 using Base: @propagate_inbounds, tail, OneTo, LogicalIndex, Slice, ReinterpretArray,
-    ReshapedArray, AbstractCartesianIndex
+            ReshapedArray, AbstractCartesianIndex
 
 using Base.Iterators: Pairs
 using LinearAlgebra
@@ -41,11 +48,11 @@ import Compat
 _add1(@nospecialize x) = x + oneunit(x)
 _sub1(@nospecialize x) = x - oneunit(x)
 
-@generated function merge_tuple_type(::Type{X}, ::Type{Y}) where {X<:Tuple,Y<:Tuple}
-    Tuple{X.parameters...,Y.parameters...}
+@generated function merge_tuple_type(::Type{X}, ::Type{Y}) where {X <: Tuple, Y <: Tuple}
+    Tuple{X.parameters..., Y.parameters...}
 end
 
-abstract type AbstractArray2{T,N} <: AbstractArray{T,N} end
+abstract type AbstractArray2{T, N} <: AbstractArray{T, N} end
 
 Base.size(A::AbstractArray2) = map(Int, ArrayInterface.size(A))
 Base.size(A::AbstractArray2, dim) = Int(ArrayInterface.size(A, dim))
@@ -54,7 +61,7 @@ function Base.axes(A::AbstractArray2)
     is_forwarding_wrapper(A) && return ArrayInterface.axes(parent(A))
     throw(ArgumentError("Subtypes of `AbstractArray2` must define an axes method"))
 end
-function Base.axes(A::AbstractArray2, dim::Union{Symbol,StaticSymbol})
+function Base.axes(A::AbstractArray2, dim::Union{Symbol, StaticSymbol})
     axes(A, to_dims(A, dim))
 end
 
@@ -64,7 +71,7 @@ function Base.strides(A::AbstractArray2)
 end
 Base.strides(A::AbstractArray2, dim) = Int(ArrayInterface.strides(A, dim))
 
-function Base.IndexStyle(::Type{T}) where {T<:AbstractArray2}
+function Base.IndexStyle(::Type{T}) where {T <: AbstractArray2}
     is_forwarding_wrapper(T) ? IndexStyle(parent_type(T)) : IndexCartesian()
 end
 
@@ -94,7 +101,7 @@ end
 @inline function _to_cartesian(a, i::IntType)
     @inbounds(CartesianIndices(ntuple(dim -> indices(a, dim), Val(ndims(a))))[i])
 end
-@inline function _to_linear(a, i::Tuple{IntType,Vararg{IntType}})
+@inline function _to_linear(a, i::Tuple{IntType, Vararg{IntType}})
     _strides2int(offsets(a), size_to_strides(size(a), static(1)), i) + static(1)
 end
 
@@ -106,7 +113,7 @@ Returns `static(true)` if `parent_type(T)` a type unique to `T`.
 has_parent(x) = has_parent(typeof(x))
 has_parent(::Type{T}) where {T} = _has_parent(parent_type(T), T)
 _has_parent(::Type{T}, ::Type{T}) where {T} = False()
-_has_parent(::Type{T1}, ::Type{T2}) where {T1,T2} = True()
+_has_parent(::Type{T1}, ::Type{T2}) where {T1, T2} = True()
 
 """
     is_lazy_conjugate(::AbstractArray) -> Bool
@@ -132,10 +139,10 @@ Examples
     False()
 
 """
-is_lazy_conjugate(::T) where {T<:AbstractArray} = _is_lazy_conjugate(T, False())
+is_lazy_conjugate(::T) where {T <: AbstractArray} = _is_lazy_conjugate(T, False())
 is_lazy_conjugate(::AbstractArray{<:Real}) = False()
 
-function _is_lazy_conjugate(::Type{T}, isconj) where {T<:AbstractArray}
+function _is_lazy_conjugate(::Type{T}, isconj) where {T <: AbstractArray}
     Tp = parent_type(T)
     if T !== Tp
         _is_lazy_conjugate(Tp, isconj)
@@ -144,7 +151,7 @@ function _is_lazy_conjugate(::Type{T}, isconj) where {T<:AbstractArray}
     end
 end
 
-function _is_lazy_conjugate(::Type{T}, isconj) where {T<:Adjoint}
+function _is_lazy_conjugate(::Type{T}, isconj) where {T <: Adjoint}
     Tp = parent_type(T)
     if T !== Tp
         _is_lazy_conjugate(Tp, !isconj)
@@ -161,17 +168,17 @@ Returns a new instance of `collection` with `item` inserted into at the given `i
 Base.@propagate_inbounds function insert(collection, index, item)
     @boundscheck checkbounds(collection, index)
     ret = similar(collection, length(collection) + 1)
-    @inbounds for i = firstindex(ret):(index-1)
+    @inbounds for i in firstindex(ret):(index - 1)
         ret[i] = collection[i]
     end
     @inbounds ret[index] = item
-    @inbounds for i = (index+1):lastindex(ret)
-        ret[i] = collection[i-1]
+    @inbounds for i in (index + 1):lastindex(ret)
+        ret[i] = collection[i - 1]
     end
     return ret
 end
 
-function insert(x::Tuple{Vararg{Any,N}}, index, item) where {N}
+function insert(x::Tuple{Vararg{Any, N}}, index, item) where {N}
     @boundscheck if !checkindex(Bool, StaticInt{1}():StaticInt{N}(), index)
         throw(BoundsError(x, index))
     end
@@ -197,7 +204,8 @@ Base.@propagate_inbounds function deleteat(collection::AbstractVector, index)
     end
     return unsafe_deleteat(collection, index)
 end
-Base.@propagate_inbounds function deleteat(collection::Tuple{Vararg{Any,N}}, index) where {N}
+Base.@propagate_inbounds function deleteat(collection::Tuple{Vararg{Any, N}},
+                                           index) where {N}
     @boundscheck if !checkindex(Bool, StaticInt{1}():StaticInt{N}(), index)
         throw(BoundsError(collection, index))
     end
@@ -210,7 +218,7 @@ function unsafe_deleteat(src::AbstractVector, index)
         if i < index
             dst[i] = src[i]
         else
-            dst[i] = src[i+1]
+            dst[i] = src[i + 1]
         end
     end
     return dst
@@ -241,8 +249,7 @@ end
 end
 
 @inline unsafe_deleteat(x::Tuple{T}, i) where {T} = ()
-@inline unsafe_deleteat(x::Tuple{T1,T2}, i) where {T1,T2} =
-    isone(i) ? (x[2],) : (x[1],)
+@inline unsafe_deleteat(x::Tuple{T1, T2}, i) where {T1, T2} = isone(i) ? (x[2],) : (x[1],)
 @inline function unsafe_deleteat(x::Tuple, i)
     if i === one(i)
         return tail(x)
@@ -262,4 +269,14 @@ include("indexing.jl")
 include("stridelayout.jl")
 include("broadcast.jl")
 
+using SnoopPrecompile
+@precompile_setup begin
+    # Putting some things in `setup` can reduce the size of the
+    # precompile file and potentially make loading faster.
+    arrays = [rand(4), Base.oneto(5)]
+    @precompile_all_calls begin for x in arrays
+        known_size(x)
+        known_length(x)
+    end end
+end
 end