|
|
|
|
@ -91,105 +91,106 @@ end
@@ -91,105 +91,106 @@ end
|
|
|
|
|
@test H.iupper == H.jupper == 10 |
|
|
|
|
end |
|
|
|
|
|
|
|
|
|
function tomain(x) |
|
|
|
|
g = gather(copy(x)) |
|
|
|
|
be = get_backend(g.values) |
|
|
|
|
if be isa SequentialBackend |
|
|
|
|
return g.values.parts[1] |
|
|
|
|
else # if be isa MPIBackend |
|
|
|
|
return g.values.part |
|
|
|
|
function default_local_values_csr(I,J,V,row_indices,col_indices) |
|
|
|
|
# Adapted from p_sparse_matrix.jl line 487 |
|
|
|
|
m = local_length(row_indices) |
|
|
|
|
n = local_length(col_indices) |
|
|
|
|
sparsecsr(I,J,V,m,n) |
|
|
|
|
end |
|
|
|
|
|
|
|
|
|
function distribute_as_parray(parts, backend) |
|
|
|
|
if backend == :debug |
|
|
|
|
parts = DebugArray(parts) |
|
|
|
|
elseif backend == :mpi |
|
|
|
|
parts = distribute_with_mpi(parts) |
|
|
|
|
else |
|
|
|
|
@assert backend == :native |
|
|
|
|
parts = collect(parts) |
|
|
|
|
end |
|
|
|
|
return parts |
|
|
|
|
end |
|
|
|
|
|
|
|
|
|
@testset "HYPREMatrix(::PSparseMatrix)" begin |
|
|
|
|
# Sequential backend |
|
|
|
|
function diag_data(backend, parts) |
|
|
|
|
is_seq = backend isa SequentialBackend |
|
|
|
|
rows = PRange(parts, 10) |
|
|
|
|
cols = PRange(parts, 10) |
|
|
|
|
I, J, V = map_parts(parts) do p |
|
|
|
|
function diag_data(parts) |
|
|
|
|
rows = uniform_partition(parts, 10) |
|
|
|
|
cols = uniform_partition(parts, 10) |
|
|
|
|
np = length(parts) |
|
|
|
|
IJV = map(parts) do p |
|
|
|
|
i = Int[] |
|
|
|
|
j = Int[] |
|
|
|
|
v = Float64[] |
|
|
|
|
if (is_seq && p == 1) || !is_seq |
|
|
|
|
if np == 1 |
|
|
|
|
# MPI case is special, we only have one MPI process. |
|
|
|
|
@assert p == 1 |
|
|
|
|
append!(i, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) |
|
|
|
|
append!(j, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) |
|
|
|
|
append!(v, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) |
|
|
|
|
elseif p == 1 |
|
|
|
|
@assert np == 2 |
|
|
|
|
append!(i, [1, 2, 3, 4, 5, 6]) |
|
|
|
|
append!(j, [1, 2, 3, 4, 5, 6]) |
|
|
|
|
append!(v, [1, 2, 3, 4, 5, 6]) |
|
|
|
|
end |
|
|
|
|
if (is_seq && p == 2) || !is_seq |
|
|
|
|
else |
|
|
|
|
@assert np == 2 |
|
|
|
|
@assert p == 2 |
|
|
|
|
append!(i, [4, 5, 6, 7, 8, 9, 10]) |
|
|
|
|
append!(j, [4, 5, 6, 7, 8, 9, 10]) |
|
|
|
|
append!(v, [4, 5, 6, 7, 8, 9, 10]) |
|
|
|
|
end |
|
|
|
|
return i, j, v |
|
|
|
|
end |
|
|
|
|
add_gids!(rows, I) |
|
|
|
|
assemble!(I, J, V, rows) |
|
|
|
|
add_gids!(cols, J) |
|
|
|
|
I, J, V = tuple_of_arrays(IJV) |
|
|
|
|
return I, J, V, rows, cols |
|
|
|
|
end |
|
|
|
|
|
|
|
|
|
backend = SequentialBackend() |
|
|
|
|
parts = get_part_ids(backend, 2) |
|
|
|
|
CSC = PSparseMatrix(diag_data(backend, parts)...; ids=:global) |
|
|
|
|
CSR = PSparseMatrix(sparsecsr, diag_data(backend, parts)...; ids=:global) |
|
|
|
|
|
|
|
|
|
@test tomain(CSC) == tomain(CSR) == |
|
|
|
|
Diagonal([1, 2, 3, 8, 10, 12, 7, 8, 9, 10]) |
|
|
|
|
|
|
|
|
|
map_parts(CSC.values, CSC.rows.partition, CSC.cols.partition, |
|
|
|
|
CSR.values, CSR.rows.partition, CSR.cols.partition, parts) do args... |
|
|
|
|
cscvalues, cscrows, csccols, csrvalues, csrrows, csrcols, p = args |
|
|
|
|
csc = Internals.to_hypre_data(cscvalues, cscrows, csccols) |
|
|
|
|
csr = Internals.to_hypre_data(csrvalues, csrrows, csrcols) |
|
|
|
|
if p == 1 |
|
|
|
|
for backend in [:native, :debug, :mpi] |
|
|
|
|
@testset "Backend=$backend" begin |
|
|
|
|
if backend == :mpi |
|
|
|
|
parts = 1:1 |
|
|
|
|
else |
|
|
|
|
parts = 1:2 |
|
|
|
|
end |
|
|
|
|
parts = distribute_as_parray(parts, backend) |
|
|
|
|
CSC = psparse!(diag_data(parts)...) |> fetch |
|
|
|
|
CSR = psparse!(default_local_values_csr, diag_data(parts)...) |> fetch |
|
|
|
|
|
|
|
|
|
for A in [CSC, CSR] |
|
|
|
|
map(local_values(A), A.row_partition, A.col_partition, parts) do values, rows, cols, p |
|
|
|
|
hypre_data = Internals.to_hypre_data(values, rows, cols) |
|
|
|
|
if backend == :mpi |
|
|
|
|
@assert p == 1 |
|
|
|
|
nrows = 10 |
|
|
|
|
ncols = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] |
|
|
|
|
rows = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] |
|
|
|
|
cols = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] |
|
|
|
|
values = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] |
|
|
|
|
elseif p == 1 |
|
|
|
|
nrows = 5 |
|
|
|
|
ncols = [1, 1, 1, 1, 1] |
|
|
|
|
rows = [1, 2, 3, 4, 5] |
|
|
|
|
cols = [1, 2, 3, 4, 5] |
|
|
|
|
values = [1, 2, 3, 8, 10] |
|
|
|
|
else # if p == 1 |
|
|
|
|
else |
|
|
|
|
@assert p == 2 |
|
|
|
|
nrows = 5 |
|
|
|
|
ncols = [1, 1, 1, 1, 1] |
|
|
|
|
rows = [6, 7, 8, 9, 10] |
|
|
|
|
cols = [6, 7, 8, 9, 10] |
|
|
|
|
values = [12, 7, 8, 9, 10] |
|
|
|
|
end |
|
|
|
|
@test csc[1]::HYPRE_Int == csr[1]::HYPRE_Int == nrows |
|
|
|
|
@test csc[2]::Vector{HYPRE_Int} == csr[2]::Vector{HYPRE_Int} == ncols |
|
|
|
|
@test csc[3]::Vector{HYPRE_BigInt} == csr[3]::Vector{HYPRE_BigInt} == rows |
|
|
|
|
@test csc[4]::Vector{HYPRE_BigInt} == csr[4]::Vector{HYPRE_BigInt} == cols |
|
|
|
|
@test csc[5]::Vector{HYPRE_Complex} == csr[5]::Vector{HYPRE_Complex} == values |
|
|
|
|
@test hypre_data[1]::HYPRE_Int == nrows |
|
|
|
|
@test hypre_data[2]::Vector{HYPRE_Int} == ncols |
|
|
|
|
@test hypre_data[3]::Vector{HYPRE_BigInt} == rows |
|
|
|
|
@test hypre_data[4]::Vector{HYPRE_BigInt} == cols |
|
|
|
|
@test hypre_data[5]::Vector{HYPRE_Complex} == values |
|
|
|
|
end |
|
|
|
|
end |
|
|
|
|
end |
|
|
|
|
|
|
|
|
|
# MPI backend |
|
|
|
|
backend = MPIBackend() |
|
|
|
|
parts = MPIData(1, MPI.COMM_WORLD, (1,)) # get_part_ids duplicates the comm |
|
|
|
|
CSC = PSparseMatrix(diag_data(backend, parts)...; ids=:global) |
|
|
|
|
CSR = PSparseMatrix(sparsecsr, diag_data(backend, parts)...; ids=:global) |
|
|
|
|
|
|
|
|
|
@test tomain(CSC) == tomain(CSR) == |
|
|
|
|
Diagonal([1, 2, 3, 8, 10, 12, 7, 8, 9, 10]) |
|
|
|
|
|
|
|
|
|
map_parts(CSC.values, CSC.rows.partition, CSC.cols.partition, |
|
|
|
|
CSR.values, CSR.rows.partition, CSR.cols.partition, parts) do args... |
|
|
|
|
cscvalues, cscrows, csccols, csrvalues, csrrows, csrcols, p = args |
|
|
|
|
csc = Internals.to_hypre_data(cscvalues, cscrows, csccols) |
|
|
|
|
csr = Internals.to_hypre_data(csrvalues, csrrows, csrcols) |
|
|
|
|
nrows = 10 |
|
|
|
|
ncols = fill(1, 10) |
|
|
|
|
rows = collect(1:10) |
|
|
|
|
cols = collect(1:10) |
|
|
|
|
values = [1, 2, 3, 8, 10, 12, 7, 8, 9, 10] |
|
|
|
|
@test csc[1]::HYPRE_Int == csr[1]::HYPRE_Int == nrows |
|
|
|
|
@test csc[2]::Vector{HYPRE_Int} == csr[2]::Vector{HYPRE_Int} == ncols |
|
|
|
|
@test csc[3]::Vector{HYPRE_BigInt} == csr[3]::Vector{HYPRE_BigInt} == rows |
|
|
|
|
@test csc[4]::Vector{HYPRE_BigInt} == csr[4]::Vector{HYPRE_BigInt} == cols |
|
|
|
|
@test csc[5]::Vector{HYPRE_Complex} == csr[5]::Vector{HYPRE_Complex} == values |
|
|
|
|
end |
|
|
|
|
|
|
|
|
|
end |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@testset "HYPREVector" begin |
|
|
|
|
h = HYPREVector(MPI.COMM_WORLD, 1, 5) |
|
|
|
|
@test h.ijvector != HYPRE_IJVector(C_NULL) |
|
|
|
|
@ -250,52 +251,47 @@ end
@@ -250,52 +251,47 @@ end
|
|
|
|
|
end |
|
|
|
|
|
|
|
|
|
@testset "HYPREVector(::PVector)" begin |
|
|
|
|
# Sequential backend |
|
|
|
|
backend = SequentialBackend() |
|
|
|
|
parts = get_part_ids(backend, 2) |
|
|
|
|
rows = PRange(parts, 10) |
|
|
|
|
for backend in [:native, :debug, :mpi] |
|
|
|
|
if backend == :mpi |
|
|
|
|
parts = distribute_as_parray(1:1, backend) |
|
|
|
|
else |
|
|
|
|
parts = distribute_as_parray(1:2, backend) |
|
|
|
|
end |
|
|
|
|
rows = uniform_partition(parts, 10) |
|
|
|
|
b = rand(10) |
|
|
|
|
I, V = map_parts(parts) do p |
|
|
|
|
if p == 1 |
|
|
|
|
return collect(1:6), b[1:6] |
|
|
|
|
IV = map(parts, rows) do p, owned |
|
|
|
|
if backend == :mpi |
|
|
|
|
row_indices = 1:10 |
|
|
|
|
elseif p == 1 |
|
|
|
|
row_indices = 1:6 |
|
|
|
|
else # p == 2 |
|
|
|
|
return collect(4:10), b[4:10] |
|
|
|
|
row_indices = 4:10 |
|
|
|
|
end |
|
|
|
|
values = zeros(length(row_indices)) |
|
|
|
|
for (i, row) in enumerate(row_indices) |
|
|
|
|
if row in owned |
|
|
|
|
values[i] = b[row] |
|
|
|
|
end |
|
|
|
|
add_gids!(rows, I) |
|
|
|
|
pb = PVector(I, V, rows; ids=:global) |
|
|
|
|
assemble!(pb) |
|
|
|
|
@test tomain(pb) == [i in 4:6 ? 2x : x for (i, x) in zip(eachindex(b), b)] |
|
|
|
|
end |
|
|
|
|
return collect(row_indices), values |
|
|
|
|
end |
|
|
|
|
I, V = tuple_of_arrays(IV) |
|
|
|
|
pb = pvector!(I, V, rows) |> fetch |
|
|
|
|
H = HYPREVector(pb) |
|
|
|
|
# Check for valid vector |
|
|
|
|
@test H.ijvector != HYPRE_IJVector(C_NULL) |
|
|
|
|
@test H.parvector != HYPRE_ParVector(C_NULL) |
|
|
|
|
pbc = fill!(copy(pb), 0) |
|
|
|
|
copy!(pbc, H) |
|
|
|
|
@test tomain(pbc) == tomain(pb) |
|
|
|
|
|
|
|
|
|
# Copy back, check if identical |
|
|
|
|
b_copy = copy!(similar(b), H) |
|
|
|
|
@test b_copy == b |
|
|
|
|
# Test copy to and from HYPREVector |
|
|
|
|
pb2 = 2 * pb |
|
|
|
|
H′ = copy!(H, pb2) |
|
|
|
|
@test H === H′ |
|
|
|
|
pbc = similar(pb) |
|
|
|
|
copy!(pbc, H) |
|
|
|
|
@test tomain(pbc) == 2 * tomain(pb) |
|
|
|
|
|
|
|
|
|
# MPI backend |
|
|
|
|
backend = MPIBackend() |
|
|
|
|
parts = get_part_ids(backend, 1) |
|
|
|
|
rows = PRange(parts, 10) |
|
|
|
|
I, V = map_parts(parts) do p |
|
|
|
|
return collect(1:10), b |
|
|
|
|
end |
|
|
|
|
add_gids!(rows, I) |
|
|
|
|
pb = PVector(I, V, rows; ids=:global) |
|
|
|
|
assemble!(pb) |
|
|
|
|
@test tomain(pb) == b |
|
|
|
|
H = HYPREVector(pb) |
|
|
|
|
@test H.ijvector != HYPRE_IJVector(C_NULL) |
|
|
|
|
@test H.parvector != HYPRE_ParVector(C_NULL) |
|
|
|
|
pbc = fill!(copy(pb), 0) |
|
|
|
|
copy!(pbc, H) |
|
|
|
|
@test tomain(pbc) == tomain(pb) |
|
|
|
|
@test pbc == 2*pb |
|
|
|
|
end |
|
|
|
|
end |
|
|
|
|
|
|
|
|
|
@testset "HYPRE(Matrix|Vector)?Assembler" begin |
|
|
|
|
@ -689,40 +685,55 @@ end
@@ -689,40 +685,55 @@ end
|
|
|
|
|
@test x ≈ A \ b atol=tol |
|
|
|
|
end |
|
|
|
|
|
|
|
|
|
function topartitioned(x::Vector, A::SparseMatrixCSC, b::Vector) |
|
|
|
|
parts = get_part_ids(SequentialBackend(), 1) |
|
|
|
|
rows = PRange(parts, size(A, 1)) |
|
|
|
|
cols = PRange(parts, size(A, 2)) |
|
|
|
|
II, JJ, VV, bb, xx = map_parts(parts) do _ |
|
|
|
|
function topartitioned(x::Vector, A::SparseMatrixCSC, b::Vector, backend) |
|
|
|
|
parts = distribute_as_parray(1:1, backend) |
|
|
|
|
n = size(A, 1) |
|
|
|
|
rows = uniform_partition(parts, n) |
|
|
|
|
cols = uniform_partition(parts, n) |
|
|
|
|
tmp = map(parts) do _ |
|
|
|
|
return findnz(A)..., b, x |
|
|
|
|
end |
|
|
|
|
add_gids!(rows, II) |
|
|
|
|
assemble!(II, JJ, VV, rows) |
|
|
|
|
add_gids!(cols, JJ) |
|
|
|
|
A_p = PSparseMatrix(II, JJ, VV, rows, cols; ids = :global) |
|
|
|
|
II, JJ, VV, bb, xx = tuple_of_arrays(tmp) |
|
|
|
|
A_p = psparse!(II, JJ, VV, rows, cols) |> fetch |
|
|
|
|
b_p = PVector(bb, rows) |
|
|
|
|
x_p = PVector(xx, cols) |
|
|
|
|
return x_p, A_p, b_p |
|
|
|
|
end |
|
|
|
|
|
|
|
|
|
@testset "solve with PartitionedArrays" begin |
|
|
|
|
for backend in [:native, :debug, :mpi] |
|
|
|
|
# Setup |
|
|
|
|
A = sprand(100, 100, 0.05); A = A'A + 5I |
|
|
|
|
b = rand(100) |
|
|
|
|
x = zeros(100) |
|
|
|
|
x_p, A_p, b_p = topartitioned(x, A, b) |
|
|
|
|
@test A == tomain(A_p) |
|
|
|
|
@test b == tomain(b_p) |
|
|
|
|
@test x == tomain(x_p) |
|
|
|
|
x_p, A_p, b_p = topartitioned(x, A, b, :native) |
|
|
|
|
# Data is distributed over a single process. We can then check the following |
|
|
|
|
# as local_values is the entire matrix/vector. |
|
|
|
|
map(local_values(x_p)) do x_l |
|
|
|
|
@test x_l == x |
|
|
|
|
end |
|
|
|
|
map(local_values(b_p)) do b_l |
|
|
|
|
@test b_l == b |
|
|
|
|
end |
|
|
|
|
map(local_values(A_p)) do A_l |
|
|
|
|
@test A_l == A |
|
|
|
|
end |
|
|
|
|
|
|
|
|
|
# Solve |
|
|
|
|
tol = 1e-9 |
|
|
|
|
pcg = HYPRE.PCG(; Tol = tol) |
|
|
|
|
## solve! |
|
|
|
|
HYPRE.solve!(pcg, x_p, A_p, b_p) |
|
|
|
|
@test tomain(x_p) ≈ A \ b atol=tol |
|
|
|
|
ref = A\b |
|
|
|
|
map(local_values(x_p)) do x |
|
|
|
|
@test x ≈ ref atol=tol |
|
|
|
|
end |
|
|
|
|
## solve |
|
|
|
|
x_p = HYPRE.solve(pcg, A_p, b_p) |
|
|
|
|
@test tomain(x_p) ≈ A \ b atol=tol |
|
|
|
|
map(local_values(x_p)) do x |
|
|
|
|
@test x ≈ ref atol=tol |
|
|
|
|
end |
|
|
|
|
end |
|
|
|
|
end |
|
|
|
|
|
|
|
|
|
@testset "solve with SparseMatrixCS(C|R)" begin |
|
|
|
|
|
Olav Møyner
3 years ago
committed by
GitHub