Merge pull request #158 from fverdugo/experimental

Major performance improvements

Author: fverdugo

CHANGELOG.md

@@ -5,6 +5,24 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.5.0] - 2024-07-26
+
+### Changed
+
+- `MPIArray` and `DebugArray` are now inmutable for performance reasons.
+
+### Fixed
+
+-  Many type instabilities.
+-  `mul!` (and also `consistent!`, `exchange!` ) allocation free for `MPIArray` (with `check-bounds=no`)
+
+### Removed
+
+- `OldPSparseMatrix` and related functionality.
+
+### Added
+
+- New method for `psparse` that accepts a sparse matrix type as first argument.
 
 ## [0.4.7] - 2024-07-18
 

PartitionedSolvers/CHANGELOG.md

@@ -6,7 +6,10 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [0.2.0] - Unreleased
+## [0.2.0] - 2025-07-26
+
+### Added
+- Support for PartitionedArrays v0.5.
 
 ### Changed
 

PartitionedSolvers/Project.toml

@@ -13,7 +13,7 @@ SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 [compat]
 
 IterativeSolvers = "0.9"
-PartitionedArrays = "0.4.4"
+PartitionedArrays = "0.4.4, 0.5"
 SparseArrays = "1"
 julia = "1.6"
 

Project.toml

@@ -1,7 +1,7 @@
 name = "PartitionedArrays"
 uuid = "5a9dfac6-5c52-46f7-8278-5e2210713be9"
 authors = ["Francesc Verdugo <f.verdugo.rojano@vu.nl> and contributors"]
-version = "0.4.7"
+version = "0.5.0"
 
 [deps]
 CircularArrays = "7a955b69-7140-5f4e-a0ed-f168c5e2e749"

docs/src/reference/primitives.md

@@ -28,14 +28,12 @@ allocate_multicast
 
 ```@docs
 scan
-scan!
 ```
 
 ## Reduction
 
 ```@docs
 reduction
-reduction!
 ```
 
 ## Exchange

src/PartitionedArrays.jl

@@ -132,13 +132,12 @@ export assemble
 export consistent
 export repartition
 export repartition!
+export renumber
 export find_local_indices
 include("p_vector.jl")
 
-export OldPSparseMatrix
 export SplitMatrix
 export PSparseMatrix
-export old_psparse
 export psparse
 export psparse!
 export split_format

src/debug_array.jl

@@ -58,9 +58,10 @@ function Base.getindex(a::DebugArray,i::Int)
     a.items[i]
 end
 function Base.setindex!(a::DebugArray,v,i::Int)
-    scalar_indexing_action(a)
-    a.items[i] = v
-    v
+    error("DebugArray is inmutable for performance reasons")
+    #scalar_indexing_action(a)
+    #a.items[i] = v
+    #v
 end
 linear_indices(a::DebugArray) = DebugArray(collect(LinearIndices(a)))
 cartesian_indices(a::DebugArray) = DebugArray(collect(CartesianIndices(a)))
@@ -96,21 +97,29 @@ end
 getany(a::DebugArray) = getany(a.items)
 
 function Base.similar(a::DebugArray,::Type{T},dims::Dims) where T
-  DebugArray(similar(a.items,T,dims))
+    error("DebugArray is inmutable for performance reasons")
+    #DebugArray(similar(a.items,T,dims))
 end
 
 function Base.copyto!(b::DebugArray,a::DebugArray)
-    copyto!(b.items,a.items)
-    b
+    error("DebugArray is inmutable for performance reasons")
+    #copyto!(b.items,a.items)
+    #b
 end
 
 function Base.map(f,args::DebugArray...)
     DebugArray(map(f,map(i->i.items,args)...))
 end
 
+function Base.foreach(f,args::DebugArray...)
+    foreach(f,map(i->i.items,args)...)
+    nothing
+end
+
 function Base.map!(f,r::DebugArray,args::DebugArray...)
-    map!(f,r.items,map(i->i.items,args)...)
-    r
+    error("DebugArray is inmutable for performance reasons")
+    #map!(f,r.items,map(i->i.items,args)...)
+    #r
 end
 
 function Base.all(a::DebugArray)
@@ -121,42 +130,101 @@ function Base.all(p::Function,a::DebugArray)
     all(b)
 end
 
+#function allocate_gather_impl(snd::DebugArray,destination)
+#    rcv = allocate_gather_impl(snd.items,destination)
+#    DebugArray(rcv)
+#end
+
 function gather_impl!(
     rcv::DebugArray, snd::DebugArray,
-    destination, ::Type{T}) where T
-    gather_impl!(rcv.items,snd.items,destination,T)
+    destination)
+    gather_impl!(rcv.items,snd.items,destination)
 end
 
-function gather_impl!(
-    rcv::DebugArray, snd::DebugArray,
-    destination, ::Type{T}) where T <: AbstractVector
-    gather_impl!(rcv.items,snd.items,destination,T)
+#function setup_scatter_impl(snd::DebugArray,source)
+#    setup_scatter_impl(snd.items,source)
+#end
+
+function scatter_impl(snd::DebugArray,source)
+    rcv = scatter_impl(snd.items,source)
+    DebugArray(rcv)
+end
+
+function scatter_impl!(rcv::DebugArray,snd::DebugArray,source,::Type{T}) where T
+    error("In place scatter only for vectors")
+end
+
+function scatter_impl!(rcv::DebugArray,snd::DebugArray,source,::Type{T}) where T<:AbstractVector
+    scatter_impl!(rcv.items,snd.items,source)
+    rcv
+end
+
+#function setup_multicast_impl(snd::DebugArray,source)
+#    setup_multicast_impl(snd.items,source)
+#end
+
+function multicast_impl(snd::DebugArray,source)
+    rcv = multicast_impl(snd.items,source)
+    DebugArray(rcv)
 end
 
-function scatter_impl!(
-    rcv::DebugArray,snd::DebugArray,
-    source,::Type{T}) where T
-    scatter_impl!(rcv.items,snd.items,source,T)
+function multicast_impl!(rcv::DebugArray,snd::DebugArray,source,::Type{T}) where T
+    error("In place multicast only for vectors")
 end
 
-function scatter_impl!(
-    rcv::DebugArray,snd::DebugArray,
-    source,::Type{T}) where T<:AbstractVector
-    scatter_impl!(rcv.items,snd.items,source,T)
+function multicast_impl!(rcv::DebugArray,snd::DebugArray,source,::Type{T}) where T<:AbstractVector
+    multicast_impl!(rcv.items,snd.items,source)
+    rcv
 end
 
-function multicast_impl!(
-    rcv::DebugArray,snd::DebugArray,
-    source,::Type{T}) where T
-    multicast_impl!(rcv.items,snd.items,source,T)
+#function setup_scatter_impl(op,a::DebugArray,init,type)
+#    setup_scatter_impl(op,a.items,init,type)
+#end
+
+function scan_impl(op,a::DebugArray,init,type)
+    b = scan_impl(op,a.items,init,type)
+    DebugArray(b)
 end
 
-function multicast_impl!(
-    rcv::DebugArray,snd::DebugArray,
-    source,::Type{T}) where T<:AbstractVector
-    multicast_impl!(rcv.items,snd.items,source,T)
+#function setup_reduction_impl(op,a::DebugArray,destination)
+#    setup_reduction_impl(op,a.items,destination)
+#end
+
+function reduction_impl(op,a::DebugArray,destination;kwargs...)
+    b = reduction_impl(op,a.items,destination;kwargs...)
+    DebugArray(b)
 end
 
+#function gather_impl!(
+#    rcv::DebugArray, snd::DebugArray,
+#    destination, ::Type{T}) where T <: AbstractVector
+#    gather_impl!(rcv.items,snd.items,destination,T)
+#end
+
+#function scatter_impl!(
+#    rcv::DebugArray,snd::DebugArray,
+#    source,::Type{T}) where T
+#    scatter_impl!(rcv.items,snd.items,source,T)
+#end
+#
+#function scatter_impl!(
+#    rcv::DebugArray,snd::DebugArray,
+#    source,::Type{T}) where T<:AbstractVector
+#    scatter_impl!(rcv.items,snd.items,source,T)
+#end
+#
+#function multicast_impl!(
+#    rcv::DebugArray,snd::DebugArray,
+#    source,::Type{T}) where T
+#    multicast_impl!(rcv.items,snd.items,source,T)
+#end
+#
+#function multicast_impl!(
+#    rcv::DebugArray,snd::DebugArray,
+#    source,::Type{T}) where T<:AbstractVector
+#    multicast_impl!(rcv.items,snd.items,source,T)
+#end
+
 Base.reduce(op,a::DebugArray;kwargs...) = reduce(op,a.items;kwargs...)
 Base.sum(a::DebugArray) = reduce(+,a)
 Base.collect(a::DebugArray) = collect(a.items)
@@ -166,29 +234,51 @@ function is_consistent(graph::ExchangeGraph{<:DebugArray})
     is_consistent(g)
 end
 
-function exchange_impl!(
-    rcv::DebugArray,
-    snd::DebugArray,
-    graph::ExchangeGraph{<:DebugArray},
-    ::Type{T}) where T
-    g = ExchangeGraph(graph.snd.items,graph.rcv.items)
-    @async begin
-        yield() # This is to make more likely to have errors if we don't wait
-        exchange_impl!(rcv.items,snd.items,g,T) |> wait
-        rcv
-    end
+function allocate_exchange_impl(
+    snd::DebugArray,graph::ExchangeGraph{<:DebugArray})
+    graph2 = ExchangeGraph(graph.snd.items,graph.rcv.items)
+    rcv = allocate_exchange_impl(snd.items,graph2)
+    DebugArray(rcv)
+end
+
+function setup_exchange_impl(
+    rcv::DebugArray,snd::DebugArray,graph::ExchangeGraph{<:DebugArray})
+    graph2 = ExchangeGraph(graph.snd.items,graph.rcv.items)
+    setup_exchange_impl(rcv.items,snd.items,graph2)
 end
 
 function exchange_impl!(
-    rcv::DebugArray,
-    snd::DebugArray,
-    graph::ExchangeGraph{<:DebugArray},
-    ::Type{T}) where T <: AbstractVector
-    g = ExchangeGraph(graph.snd.items,graph.rcv.items)
-    @async begin
-        yield() # This is to make more likely to have errors if we don't wait
-        exchange_impl!(rcv.items,snd.items,g,T) |> wait
-        rcv
-    end
+    rcv::DebugArray,snd::DebugArray,graph::ExchangeGraph{<:DebugArray},setup)
+    graph2 = ExchangeGraph(graph.snd.items,graph.rcv.items)
+    exchange_impl!(rcv.items,snd.items,graph2,setup)
+    @fake_async rcv
 end
 
+#function exchange_impl!(
+#    rcv::DebugArray,
+#    snd::DebugArray,
+#    graph::ExchangeGraph{<:DebugArray},
+#    setup,
+#    ::Type{T}) where T
+#    g = ExchangeGraph(graph.snd.items,graph.rcv.items)
+#    @fake_async begin
+#        yield() # This is to make more likely to have errors if we don't wait
+#        exchange_impl!(rcv.items,snd.items,g,setup,T) |> wait
+#        rcv
+#    end
+#end
+#
+#function exchange_impl!(
+#    rcv::DebugArray,
+#    snd::DebugArray,
+#    graph::ExchangeGraph{<:DebugArray},
+#    setup,
+#    ::Type{T}) where T <: AbstractVector
+#    g = ExchangeGraph(graph.snd.items,graph.rcv.items)
+#    @fake_async begin
+#        yield() # This is to make more likely to have errors if we don't wait
+#        exchange_impl!(rcv.items,snd.items,g,setup,T) |> wait
+#        rcv
+#    end
+#end
+