From 3f569be00160a1059e8c74c97dffee93094cf82b Mon Sep 17 00:00:00 2001 From: GiggleLiu Date: Thu, 29 Aug 2019 10:20:20 +0800 Subject: [PATCH 01/14] fix julia 1.2 compiling issue. --- src/instruct.jl | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/src/instruct.jl b/src/instruct.jl index d76db6e..4e0d0ed 100644 --- a/src/instruct.jl +++ b/src/instruct.jl @@ -483,3 +483,30 @@ function YaoBase.instruct!( end return state end + +@static if VERSION == v"1.2" + function YaoBase.instruct!( + state::AbstractVecOrMat{T}, + operator::AbstractMatrix{T}, + locs::NTuple{M, Int}, + control_locs::NTuple{C, Int} = (), + control_bits::NTuple{C, Int} = ()) where {T<:Number, M, C} + + U = sort_unitary(operator, locs) + locs_raw, ic = _prepare_instruct(state, U, locs, control_locs, control_bits) + + return _instruct!(state, autostatic(U), locs_raw, ic) + end + + YaoBase.instruct!(state::AbstractVecOrMat{T}, g::AbstractMatrix{T}, locs::Tuple{Int}) where T<:Number = + instruct!(state, g, locs...) + + function YaoBase.instruct!( + state::AbstractVecOrMat{T}, + operator::AbstractMatrix{T}, + locs::Tuple{}, + control_locs::NTuple{C, Int}=(), + control_bits::NTuple{C, Int}=()) where {T<:Number, M, C} + return state + end +end From 7d2cfc8a2396d19d5033ade624fb6bacb6726772 Mon Sep 17 00:00:00 2001 From: GiggleLiu Date: Thu, 29 Aug 2019 14:05:02 +0800 Subject: [PATCH 02/14] a better fix --- .travis.yml | 2 +- src/instruct.jl | 101 ++++++++++------------------------------------- test/instruct.jl | 5 +-- 3 files changed, 23 insertions(+), 85 deletions(-) diff --git a/.travis.yml b/.travis.yml index a6ab585..1b4985c 100644 --- a/.travis.yml +++ b/.travis.yml @@ -5,7 +5,7 @@ os: - osx julia: - 1.0 - - 1.1 + - 1.2 - nightly matrix: allow_failures: diff --git a/src/instruct.jl b/src/instruct.jl index 4e0d0ed..65869ab 100644 --- a/src/instruct.jl +++ b/src/instruct.jl @@ -17,41 +17,6 @@ A list of symbol for specialized gates/operators. """ const SPECIALIZATION_LIST = Symbol[:X, :Y, :Z, :S, :T, :Sdag, :Tdag] -function YaoBase.instruct!( - state::AbstractVecOrMat{T1}, - operator::AbstractMatrix{T2}, - locs::Tuple{}, - control_locs::NTuple{C, Int}=(), - control_bits::NTuple{C, Int}=()) where {T1, T2, M, C} - return state -end - -function YaoBase.instruct!( - state::AbstractVecOrMat{T1}, - operator::AbstractMatrix{T2}, - locs::NTuple{M, Int}, - control_locs::NTuple{C, Int}=(), - control_bits::NTuple{C, Int}=()) where {T1, T2, M, C} - - @warn "Element Type Mismatch: register $(T1), operator $(T2). Converting operator to match, this may cause performance issue" - return instruct!(state, copyto!(similar(operator, T1), operator), locs, control_locs, control_bits) -end - -function YaoBase.instruct!(state::AbstractVecOrMat{T1}, U1::AbstractMatrix{T2}, loc::Int) where {T1, T2} - @warn "Element Type Mismatch: register $(T1), operator $(T2). Converting operator to match, this may cause performance issue" - return instruct!(state, copyto!(similar(U1, T1), U1), loc) -end - -function YaoBase.instruct!(state::AbstractVecOrMat{T1}, U1::SDPermMatrix{T2}, loc::Int) where {T1, T2} - @warn "Element Type Mismatch: register $(T1), operator $(T2). Converting operator to match, this may cause performance issue" - return instruct!(state, copyto!(similar(U1, T1), U1), loc) -end - -function YaoBase.instruct!(state::AbstractVecOrMat{T1}, U1::SDDiagonal{T2}, loc::Int) where {T1, T2} - @warn "Element Type Mismatch: register $(T1), operator $(T2). Converting operator to match, this may cause performance issue" - return instruct!(state, copyto!(similar(U1, T1), U1), loc) -end - function _prepare_instruct(state, U, locs::NTuple{M}, control_locs, control_bits::NTuple{C}) where {M, C} N, MM = log2dim1(state), size(U, 1) @@ -64,25 +29,28 @@ function _prepare_instruct(state, U, locs::NTuple{M}, control_locs, control_bits end function YaoBase.instruct!( - state::AbstractVecOrMat{T}, - operator::AbstractMatrix{T}, + state::AbstractVecOrMat{T1}, + operator::AbstractMatrix{T2}, locs::Tuple{}, - control_locs::NTuple{C, Int} = (), - control_bits::NTuple{C, Int} = ()) where {T, M, C} + control_locs::NTuple{C, Int}=(), + control_bits::NTuple{C, Int}=()) where {T1, T2, M, C} return state end function YaoBase.instruct!( - state::AbstractVecOrMat{T}, - operator::AbstractMatrix{T}, + state::AbstractVecOrMat{T1}, + operator::AbstractMatrix{T2}, locs::NTuple{M, Int}, - control_locs::NTuple{C, Int} = (), - control_bits::NTuple{C, Int} = ()) where {T, M, C} - - U = sort_unitary(operator, locs) - locs_raw, ic = _prepare_instruct(state, U, locs, control_locs, control_bits) + control_locs::NTuple{C, Int}=(), + control_bits::NTuple{C, Int}=()) where {T1, T2, M, C} - return _instruct!(state, autostatic(U), locs_raw, ic) + if T2!=T1 + @warn "Element Type Mismatch: register $(T1), operator $(T2). Converting operator to match, this may cause performance issue" + operator = copyto!(similar(operator, T1), operator) + end + operator = sort_unitary(operator, locs) + locs_raw, ic = _prepare_instruct(state, operator, locs, control_locs, control_bits) + return _instruct!(state, autostatic(operator), locs_raw, ic) end function _instruct!(state::AbstractVecOrMat{T}, U::AbstractMatrix{T}, locs_raw::SVector, ic::IterControl) where T @@ -108,9 +76,9 @@ YaoBase.instruct!(state::AbstractVecOrMat, U::IMatrix, locs::Tuple{Int}) = state YaoBase.instruct!(state::AbstractVecOrMat, g::AbstractMatrix, locs::Tuple{Int}) = instruct!(state, g, locs...) -function YaoBase.instruct!(state::AbstractVecOrMat{T}, U1::AbstractMatrix{T}, loc::Int) where T +function YaoBase.instruct!(state::AbstractVecOrMat{T1}, U1::AbstractMatrix{T2}, loc::Int) where {T1, T2} a, c, b, d = U1 - instruct_kernel(state, loc, 1<<(loc-1), 1< Date: Thu, 29 Aug 2019 14:09:49 +0800 Subject: [PATCH 03/14] increase version number --- Project.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Project.toml b/Project.toml index 14d00e5..39cdbc8 100644 --- a/Project.toml +++ b/Project.toml @@ -1,6 +1,6 @@ name = "YaoArrayRegister" uuid = "e600142f-9330-5003-8abb-0ebd767abc51" -version = "0.4.0" +version = "0.4.1" [deps] BitBasis = "50ba71b6-fa0f-514d-ae9a-0916efc90dcf" From 86d74bd46f6a46d43e3fd7496fb6d5cc3abe71a0 Mon Sep 17 00:00:00 2001 From: GiggleLiu Date: Fri, 30 Aug 2019 09:10:35 +0800 Subject: [PATCH 04/14] using transposed storage by default --- src/register.jl | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/src/register.jl b/src/register.jl index 761e821..8f23db3 100644 --- a/src/register.jl +++ b/src/register.jl @@ -1,5 +1,6 @@ using YaoBase, BitBasis import BitBasis: BitStr, BitStr64 +using LinearAlgebra: Transpose export ArrayReg, AdjointArrayReg, @@ -143,6 +144,9 @@ function Base.copyto!(dst::AdjointArrayReg, src::AdjointArrayReg) return dst end +Base.convert(::Type{Transpose{T, Matrix{T}}}, arr::AbstractMatrix{T}) where T = transpose(Matrix(transpose(arr))) +Base.convert(t::Type{Transpose{T, Matrix{T}}}, arr::Transpose{T}) where T = invoke(convert, Tuple{Type{Transpose{T, Matrix{T}}}, Transpose}, t, arr) + # register interface YaoBase.nqubits(r::ArrayReg{B}) where B = log2i(length(r.state) ÷ B) YaoBase.nactive(r::ArrayReg) = log2dim1(r.state) @@ -333,7 +337,14 @@ product_state(total::Int, bit_config::Integer; nbatch::Int=1) = product_state(Co product_state(::Type{T}, bit_str::BitStr; nbatch::Int=1) where T = ArrayReg{nbatch}(T, bit_str) function product_state(::Type{T}, total::Int, bit_config::Integer; nbatch::Int=1) where T - return ArrayReg{nbatch}(onehot(T, total, bit_config, nbatch)) + if nbatch == 1 + raw = onehot(T, total, bit_config, nbatch) + else + raw = zeros(T, nbatch, 1< Date: Fri, 30 Aug 2019 09:18:40 +0800 Subject: [PATCH 05/14] fix batched_kron! --- src/utils.jl | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/utils.jl b/src/utils.jl index 44fce1a..b9da183 100644 --- a/src/utils.jl +++ b/src/utils.jl @@ -221,3 +221,9 @@ end end state end + +#### Yao Base patch #### +using YaoBase +function YaoBase.batched_kron!(C::Array{T, 3}, A::AbstractArray{T1, 3}, B::AbstractArray{T2, 3}) where {T, T1, T2} + YaoBase.batched_kron!(C, convert(Array{T,3}, A), convert(Array{T,3}, B)) +end From c27752997cf53c0ee8120b881b2d35e52d5b6b43 Mon Sep 17 00:00:00 2001 From: Roger-luo Date: Wed, 18 Sep 2019 16:58:25 -0400 Subject: [PATCH 06/14] change benchmark --- benchmark/runbench.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/benchmark/runbench.jl b/benchmark/runbench.jl index 2ac6533..2dd8810 100644 --- a/benchmark/runbench.jl +++ b/benchmark/runbench.jl @@ -1,6 +1,6 @@ using PkgBenchmark -current = BenchmarkConfig(id="multithreading", env = Dict("JULIA_NUM_THREADS"=>4), juliacmd=`julia -O3`) +current = BenchmarkConfig(id="transpose_storage", env = Dict("JULIA_NUM_THREADS"=>4), juliacmd=`julia -O3`) baseline = BenchmarkConfig(id="master", env = Dict("JULIA_NUM_THREADS"=>1), juliacmd=`julia -O3`) results = judge("YaoArrayRegister", current, baseline) export_markdown("report.md", results) From a1e660d56fbdb8aaf392fa8420a2849d886a988f Mon Sep 17 00:00:00 2001 From: Roger-luo Date: Wed, 18 Sep 2019 19:13:23 -0400 Subject: [PATCH 07/14] update benchmark --- benchmark/runbench.jl | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/benchmark/runbench.jl b/benchmark/runbench.jl index 2dd8810..17d59ac 100644 --- a/benchmark/runbench.jl +++ b/benchmark/runbench.jl @@ -1,6 +1,6 @@ using PkgBenchmark -current = BenchmarkConfig(id="transpose_storage", env = Dict("JULIA_NUM_THREADS"=>4), juliacmd=`julia -O3`) -baseline = BenchmarkConfig(id="master", env = Dict("JULIA_NUM_THREADS"=>1), juliacmd=`julia -O3`) +current = BenchmarkConfig(id="transpose_storage", juliacmd=`julia -O3`) +baseline = BenchmarkConfig(id="master", juliacmd=`julia -O3`) results = judge("YaoArrayRegister", current, baseline) export_markdown("report.md", results) From f3ed607eccfe4f08d5b427e5b7ec9f89e320dfa5 Mon Sep 17 00:00:00 2001 From: Roger-luo Date: Mon, 23 Sep 2019 21:01:18 -0400 Subject: [PATCH 08/14] add benchmark for batch instruct --- benchmark/benchmarks.jl | 131 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 131 insertions(+) diff --git a/benchmark/benchmarks.jl b/benchmark/benchmarks.jl index cc3647a..877343a 100644 --- a/benchmark/benchmarks.jl +++ b/benchmark/benchmarks.jl @@ -10,6 +10,9 @@ using LinearAlgebra, SparseArrays bench(n, U, loc::Tuple) = @benchmarkable instruct!(st, $U, $loc) setup=(st=statevec(rand_state($n))) bench(n, U, loc::Tuple, control_locs::Tuple, control_bits::Tuple) = @benchmarkable instruct!(st, $U, $loc, $control_locs, $control_bits) setup=(st=statevec(rand_state($n))) +bench(n, nbatch::Int, U, loc::Tuple) = @benchmarkable instruct!(st, $U, $loc) setup=(st=statevec(rand_state($n, nbatch=$nbatch))) +bench(n, nbatch::Int, U, loc::Tuple, control_locs::Tuple, control_bits::Tuple) = @benchmarkable instruct!(st, $U, $loc, $control_locs, $control_bits) setup=(st=statevec(rand_state($n, nbatch=$nbatch))) + const SUITE = BenchmarkGroup() SUITE["specialized"] = BenchmarkGroup() @@ -135,3 +138,131 @@ for T in [ComplexF64], n in 1:2:10, m in 3:2:6, U in matrices(T, 1<1, m)) end + + +# batched +SUITE["batched specialized"] = BenchmarkGroup() + +@info "generating benchmark for batched specialized operators for single qubits" +# Specialized Gate Instruction +SUITE["batched specialized"]["single qubit"] = BenchmarkGroup() +## single qubit benchmark +for U in YaoArrayRegister.SPECIALIZATION_LIST, n in 5:4:15, nbatch in 10:20:100 + SUITE["batched specialized"]["single qubit"][string(U), n, nbatch] = bench(n, nbatch, Val(U), (1, )) +end + +SUITE["batched specialized"]["single control"] = BenchmarkGroup() +for U in YaoArrayRegister.SPECIALIZATION_LIST, n in 5:4:15, nbatch in 10:20:100 + SUITE["batched specialized"]["single control"][string(U), n, nbatch, (2, ), (1, )] = + bench(n, nbatch, Val(U), (1, ), (2, ), (1, )) +end + +SUITE["batched specialized"]["multi control"] = BenchmarkGroup() + +for U in YaoArrayRegister.SPECIALIZATION_LIST, n in 5:4:15, nbatch in 10:20:100 + control_locs = Tuple(2:n); control_bits = ntuple(x->1, n-1) + SUITE["batched specialized"]["multi control"][string(U), n, nbatch, 2:n, control_locs] = + bench(n, nbatch, Val(U), (1, ), control_locs, control_bits) +end + +SUITE["specialized"]["multi qubit"] = BenchmarkGroup() +const location_sparsity = 0.4 +@info "generating benchmark for specialized operators for multi qubits" +## multi qubit benchmark +for U in YaoArrayRegister.SPECIALIZATION_LIST, n in 5:4:15, nbatch in 10:20:100 + perms = randperm(n)[1:ceil(Int, location_sparsity * n)] + SUITE["batched specialized"]["multi qubit"][string(U), n, nbatch] = bench(n, nbatch, Val(U), Tuple(perms)) +end + +SUITE["batched specialized"]["multi qubit multi control"] = BenchmarkGroup() +SUITE["batched specialized"]["single qubit multi control"] = BenchmarkGroup() + +const control_rate = 0.3 +for U in YaoArrayRegister.SPECIALIZATION_LIST, n in 5:4:15, nbatch in 10:20:100 + num_controls = ceil(Int, n * control_rate) + perms = randperm(n) + control_locs = Tuple(perms[1:num_controls]); control_bits = ntuple(x->rand(0:1), num_controls) + perms = perms[num_controls+1:num_controls+round(Int, location_sparsity * n)] + + SUITE["batched specialized"]["multi qubit multi control"][string(U), n, nbatch, num_controls] = bench(n, nbatch, Val(U), Tuple(perms), control_locs, control_bits) + SUITE["batched specialized"]["single qubit multi control"][string(U), n, nbatch, num_controls] = bench(n, nbatch, Val(U), (perms[1], ), control_locs, control_bits) +end + +for n in 4:4:25 + SUITE["batched specialized"]["multi qubit"]["SWAP", n, nbatch] = bench(n, nbatch, Val(:SWAP), (1, 2)) + SUITE["batched specialized"]["multi qubit"]["SWAP", "random", n, nbatch] = bench(n, nbatch, Val(:SWAP), Tuple(randperm(n)[1:2])) +end + +# General Instructions (matrices based) +SUITE["batched matrices"] = BenchmarkGroup() +SUITE["batched matrices"]["contiguous"] = BenchmarkGroup() +SUITE["batched matrices"]["contiguous"]["ordered"] = BenchmarkGroup() +SUITE["batched matrices"]["contiguous"]["random"] = BenchmarkGroup() + +SUITE["batched matrices"]["in-contiguous"] = BenchmarkGroup() +SUITE["batched matrices"]["in-contiguous"]["ordered"] = BenchmarkGroup() +SUITE["batched matrices"]["in-contiguous"]["random"] = BenchmarkGroup() + +SUITE["batched matrices"]["single qubit"] = BenchmarkGroup() +SUITE["batched matrices"]["single qubit"]["ordered"] = BenchmarkGroup() +SUITE["batched matrices"]["single qubit"]["random"] = BenchmarkGroup() + + +## General Matrix Instruction +function matrices(::Type{T}, N) where T + list = Any[ + rand_unitary(T, N), # dense matrices + # SparseMatrixCSC + sprand_hermitian(T, N, 0.1), + # PermMatrix + pmrand(T, N), + Diagonal(rand(T, N)) + ] + if N < 100 + # StaticArrays + push!(list, @SArray(rand(T, N, N))) + push!(list, @MArray(rand(T, N, N))) + end + return list +end + +# default test type is ComplexF64 +matrices(N) = matrices(ComplexF64, N) + +@info "generating benchmark for batched contiguous matrices locs" +### contiguous +for n in 1:2:5, T in [ComplexF64], U in matrices(T, 1<1, m)) + + perms = randperm(n+m) + SUITE["batched matrices"]["controlled"]["random"][n, nbatch, m, string(T), string(typeof(U))] = bench(n+m, nbatch, U, Tuple(perms[1:n]), Tuple(perms[n+1:n+m]), ntuple(x->1, m)) +end From 21e9e25d0debc2bb998923bdaee838520b5df851 Mon Sep 17 00:00:00 2001 From: Roger-luo Date: Mon, 23 Sep 2019 21:05:59 -0400 Subject: [PATCH 09/14] fix typo --- benchmark/benchmarks.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/benchmark/benchmarks.jl b/benchmark/benchmarks.jl index 877343a..b5dc362 100644 --- a/benchmark/benchmarks.jl +++ b/benchmark/benchmarks.jl @@ -165,7 +165,7 @@ for U in YaoArrayRegister.SPECIALIZATION_LIST, n in 5:4:15, nbatch in 10:20:100 bench(n, nbatch, Val(U), (1, ), control_locs, control_bits) end -SUITE["specialized"]["multi qubit"] = BenchmarkGroup() +SUITE["batched specialized"]["multi qubit"] = BenchmarkGroup() const location_sparsity = 0.4 @info "generating benchmark for specialized operators for multi qubits" ## multi qubit benchmark From 86e85418e0729dc2e9a133466d5e22e371e78caa Mon Sep 17 00:00:00 2001 From: Roger-luo Date: Mon, 23 Sep 2019 21:09:38 -0400 Subject: [PATCH 10/14] fix nbatch --- benchmark/benchmarks.jl | 56 ++++++++++++++++++++--------------------- 1 file changed, 28 insertions(+), 28 deletions(-) diff --git a/benchmark/benchmarks.jl b/benchmark/benchmarks.jl index b5dc362..4e8cc4d 100644 --- a/benchmark/benchmarks.jl +++ b/benchmark/benchmarks.jl @@ -10,8 +10,8 @@ using LinearAlgebra, SparseArrays bench(n, U, loc::Tuple) = @benchmarkable instruct!(st, $U, $loc) setup=(st=statevec(rand_state($n))) bench(n, U, loc::Tuple, control_locs::Tuple, control_bits::Tuple) = @benchmarkable instruct!(st, $U, $loc, $control_locs, $control_bits) setup=(st=statevec(rand_state($n))) -bench(n, nbatch::Int, U, loc::Tuple) = @benchmarkable instruct!(st, $U, $loc) setup=(st=statevec(rand_state($n, nbatch=$nbatch))) -bench(n, nbatch::Int, U, loc::Tuple, control_locs::Tuple, control_bits::Tuple) = @benchmarkable instruct!(st, $U, $loc, $control_locs, $control_bits) setup=(st=statevec(rand_state($n, nbatch=$nbatch))) +bench(n, B::Int, U, loc::Tuple) = @benchmarkable instruct!(st, $U, $loc) setup=(st=statevec(rand_state($n, nbatch=$B))) +bench(n, B::Int, U, loc::Tuple, control_locs::Tuple, control_bits::Tuple) = @benchmarkable instruct!(st, $U, $loc, $control_locs, $control_bits) setup=(st=statevec(rand_state($n, nbatch=$B))) const SUITE = BenchmarkGroup() @@ -147,48 +147,48 @@ SUITE["batched specialized"] = BenchmarkGroup() # Specialized Gate Instruction SUITE["batched specialized"]["single qubit"] = BenchmarkGroup() ## single qubit benchmark -for U in YaoArrayRegister.SPECIALIZATION_LIST, n in 5:4:15, nbatch in 10:20:100 - SUITE["batched specialized"]["single qubit"][string(U), n, nbatch] = bench(n, nbatch, Val(U), (1, )) +for U in YaoArrayRegister.SPECIALIZATION_LIST, n in 5:4:15, B in 10:20:100 + SUITE["batched specialized"]["single qubit"][string(U), n, B] = bench(n, B, Val(U), (1, )) end SUITE["batched specialized"]["single control"] = BenchmarkGroup() -for U in YaoArrayRegister.SPECIALIZATION_LIST, n in 5:4:15, nbatch in 10:20:100 - SUITE["batched specialized"]["single control"][string(U), n, nbatch, (2, ), (1, )] = - bench(n, nbatch, Val(U), (1, ), (2, ), (1, )) +for U in YaoArrayRegister.SPECIALIZATION_LIST, n in 5:4:15, B in 10:20:100 + SUITE["batched specialized"]["single control"][string(U), n, B, (2, ), (1, )] = + bench(n, B, Val(U), (1, ), (2, ), (1, )) end SUITE["batched specialized"]["multi control"] = BenchmarkGroup() -for U in YaoArrayRegister.SPECIALIZATION_LIST, n in 5:4:15, nbatch in 10:20:100 +for U in YaoArrayRegister.SPECIALIZATION_LIST, n in 5:4:15, B in 10:20:100 control_locs = Tuple(2:n); control_bits = ntuple(x->1, n-1) - SUITE["batched specialized"]["multi control"][string(U), n, nbatch, 2:n, control_locs] = - bench(n, nbatch, Val(U), (1, ), control_locs, control_bits) + SUITE["batched specialized"]["multi control"][string(U), n, B, 2:n, control_locs] = + bench(n, B, Val(U), (1, ), control_locs, control_bits) end SUITE["batched specialized"]["multi qubit"] = BenchmarkGroup() const location_sparsity = 0.4 @info "generating benchmark for specialized operators for multi qubits" ## multi qubit benchmark -for U in YaoArrayRegister.SPECIALIZATION_LIST, n in 5:4:15, nbatch in 10:20:100 +for U in YaoArrayRegister.SPECIALIZATION_LIST, n in 5:4:15, B in 10:20:100 perms = randperm(n)[1:ceil(Int, location_sparsity * n)] - SUITE["batched specialized"]["multi qubit"][string(U), n, nbatch] = bench(n, nbatch, Val(U), Tuple(perms)) + SUITE["batched specialized"]["multi qubit"][string(U), n, B] = bench(n, B, Val(U), Tuple(perms)) end SUITE["batched specialized"]["multi qubit multi control"] = BenchmarkGroup() SUITE["batched specialized"]["single qubit multi control"] = BenchmarkGroup() const control_rate = 0.3 -for U in YaoArrayRegister.SPECIALIZATION_LIST, n in 5:4:15, nbatch in 10:20:100 +for U in YaoArrayRegister.SPECIALIZATION_LIST, n in 5:4:15, B in 10:20:100 num_controls = ceil(Int, n * control_rate) perms = randperm(n) control_locs = Tuple(perms[1:num_controls]); control_bits = ntuple(x->rand(0:1), num_controls) perms = perms[num_controls+1:num_controls+round(Int, location_sparsity * n)] - SUITE["batched specialized"]["multi qubit multi control"][string(U), n, nbatch, num_controls] = bench(n, nbatch, Val(U), Tuple(perms), control_locs, control_bits) - SUITE["batched specialized"]["single qubit multi control"][string(U), n, nbatch, num_controls] = bench(n, nbatch, Val(U), (perms[1], ), control_locs, control_bits) + SUITE["batched specialized"]["multi qubit multi control"][string(U), n, B, num_controls] = bench(n, B, Val(U), Tuple(perms), control_locs, control_bits) + SUITE["batched specialized"]["single qubit multi control"][string(U), n, B, num_controls] = bench(n, B, Val(U), (perms[1], ), control_locs, control_bits) end -for n in 4:4:25 +for n in 5:4:15, B in 10:20:100 SUITE["batched specialized"]["multi qubit"]["SWAP", n, nbatch] = bench(n, nbatch, Val(:SWAP), (1, 2)) SUITE["batched specialized"]["multi qubit"]["SWAP", "random", n, nbatch] = bench(n, nbatch, Val(:SWAP), Tuple(randperm(n)[1:2])) end @@ -231,28 +231,28 @@ matrices(N) = matrices(ComplexF64, N) @info "generating benchmark for batched contiguous matrices locs" ### contiguous -for n in 1:2:5, T in [ComplexF64], U in matrices(T, 1<1, m)) +for T in [ComplexF64], n in 1:2:5, m in 3:2:6, U in matrices(T, 1<1, m)) perms = randperm(n+m) - SUITE["batched matrices"]["controlled"]["random"][n, nbatch, m, string(T), string(typeof(U))] = bench(n+m, nbatch, U, Tuple(perms[1:n]), Tuple(perms[n+1:n+m]), ntuple(x->1, m)) + SUITE["batched matrices"]["controlled"]["random"][n, B, m, string(T), string(typeof(U))] = bench(n+m, B, U, Tuple(perms[1:n]), Tuple(perms[n+1:n+m]), ntuple(x->1, m)) end From 1f16f80547d893fdcfb16ffd47fbb8cb8223f80a Mon Sep 17 00:00:00 2001 From: Roger-luo Date: Mon, 23 Sep 2019 21:13:54 -0400 Subject: [PATCH 11/14] fix another typo --- benchmark/benchmarks.jl | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/benchmark/benchmarks.jl b/benchmark/benchmarks.jl index 4e8cc4d..04ed965 100644 --- a/benchmark/benchmarks.jl +++ b/benchmark/benchmarks.jl @@ -189,8 +189,8 @@ for U in YaoArrayRegister.SPECIALIZATION_LIST, n in 5:4:15, B in 10:20:100 end for n in 5:4:15, B in 10:20:100 - SUITE["batched specialized"]["multi qubit"]["SWAP", n, nbatch] = bench(n, nbatch, Val(:SWAP), (1, 2)) - SUITE["batched specialized"]["multi qubit"]["SWAP", "random", n, nbatch] = bench(n, nbatch, Val(:SWAP), Tuple(randperm(n)[1:2])) + SUITE["batched specialized"]["multi qubit"]["SWAP", n, B] = bench(n, B, Val(:SWAP), (1, 2)) + SUITE["batched specialized"]["multi qubit"]["SWAP", "random", n, B] = bench(n, B, Val(:SWAP), Tuple(randperm(n)[1:2])) end # General Instructions (matrices based) From f151952d666aba44b7b4344bcfb83f2a212a970b Mon Sep 17 00:00:00 2001 From: Roger-luo Date: Mon, 23 Sep 2019 21:54:24 -0400 Subject: [PATCH 12/14] reduce batch size --- benchmark/benchmarks.jl | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/benchmark/benchmarks.jl b/benchmark/benchmarks.jl index 04ed965..4d394bf 100644 --- a/benchmark/benchmarks.jl +++ b/benchmark/benchmarks.jl @@ -147,19 +147,19 @@ SUITE["batched specialized"] = BenchmarkGroup() # Specialized Gate Instruction SUITE["batched specialized"]["single qubit"] = BenchmarkGroup() ## single qubit benchmark -for U in YaoArrayRegister.SPECIALIZATION_LIST, n in 5:4:15, B in 10:20:100 +for U in YaoArrayRegister.SPECIALIZATION_LIST, n in 5:4:15, B in 10:20:60 SUITE["batched specialized"]["single qubit"][string(U), n, B] = bench(n, B, Val(U), (1, )) end SUITE["batched specialized"]["single control"] = BenchmarkGroup() -for U in YaoArrayRegister.SPECIALIZATION_LIST, n in 5:4:15, B in 10:20:100 +for U in YaoArrayRegister.SPECIALIZATION_LIST, n in 5:4:15, B in 10:20:60 SUITE["batched specialized"]["single control"][string(U), n, B, (2, ), (1, )] = bench(n, B, Val(U), (1, ), (2, ), (1, )) end SUITE["batched specialized"]["multi control"] = BenchmarkGroup() -for U in YaoArrayRegister.SPECIALIZATION_LIST, n in 5:4:15, B in 10:20:100 +for U in YaoArrayRegister.SPECIALIZATION_LIST, n in 5:4:15, B in 10:20:60 control_locs = Tuple(2:n); control_bits = ntuple(x->1, n-1) SUITE["batched specialized"]["multi control"][string(U), n, B, 2:n, control_locs] = bench(n, B, Val(U), (1, ), control_locs, control_bits) @@ -169,7 +169,7 @@ SUITE["batched specialized"]["multi qubit"] = BenchmarkGroup() const location_sparsity = 0.4 @info "generating benchmark for specialized operators for multi qubits" ## multi qubit benchmark -for U in YaoArrayRegister.SPECIALIZATION_LIST, n in 5:4:15, B in 10:20:100 +for U in YaoArrayRegister.SPECIALIZATION_LIST, n in 5:4:15, B in 10:20:60 perms = randperm(n)[1:ceil(Int, location_sparsity * n)] SUITE["batched specialized"]["multi qubit"][string(U), n, B] = bench(n, B, Val(U), Tuple(perms)) end @@ -178,7 +178,7 @@ SUITE["batched specialized"]["multi qubit multi control"] = BenchmarkGroup() SUITE["batched specialized"]["single qubit multi control"] = BenchmarkGroup() const control_rate = 0.3 -for U in YaoArrayRegister.SPECIALIZATION_LIST, n in 5:4:15, B in 10:20:100 +for U in YaoArrayRegister.SPECIALIZATION_LIST, n in 5:4:15, B in 10:20:60 num_controls = ceil(Int, n * control_rate) perms = randperm(n) control_locs = Tuple(perms[1:num_controls]); control_bits = ntuple(x->rand(0:1), num_controls) @@ -188,7 +188,7 @@ for U in YaoArrayRegister.SPECIALIZATION_LIST, n in 5:4:15, B in 10:20:100 SUITE["batched specialized"]["single qubit multi control"][string(U), n, B, num_controls] = bench(n, B, Val(U), (perms[1], ), control_locs, control_bits) end -for n in 5:4:15, B in 10:20:100 +for n in 5:4:15, B in 10:20:60 SUITE["batched specialized"]["multi qubit"]["SWAP", n, B] = bench(n, B, Val(:SWAP), (1, 2)) SUITE["batched specialized"]["multi qubit"]["SWAP", "random", n, B] = bench(n, B, Val(:SWAP), Tuple(randperm(n)[1:2])) end @@ -231,7 +231,7 @@ matrices(N) = matrices(ComplexF64, N) @info "generating benchmark for batched contiguous matrices locs" ### contiguous -for n in 1:2:5, T in [ComplexF64], U in matrices(T, 1<1, m)) perms = randperm(n+m) From 4f21e28f7117de95d030e252440e10954abd2393 Mon Sep 17 00:00:00 2001 From: GiggleLiu Date: Tue, 8 Oct 2019 03:18:41 +0800 Subject: [PATCH 13/14] revert changes, add transpose storage --- src/instruct.jl | 2 +- src/register.jl | 18 +++++------------- src/utils.jl | 5 +++++ test/instruct.jl | 4 ++++ test/register.jl | 5 +++++ 5 files changed, 20 insertions(+), 14 deletions(-) diff --git a/src/instruct.jl b/src/instruct.jl index 0934a61..7ccb835 100644 --- a/src/instruct.jl +++ b/src/instruct.jl @@ -438,7 +438,7 @@ function YaoBase.instruct!( a = T(cos(theta/2)) c = T(-im * sin(theta/2)) e = T(exp(-im/2*theta)) - for b in itercontrol(log2i(size(state, 1)), [control_locs...], [control_bits...]) + for b in itercontrol(log2i(size(state, 1)), Int[control_locs...], Int[control_bits...]) if b&mask1==0 i = b+1 i_ = b ⊻ mask12 + 1 diff --git a/src/register.jl b/src/register.jl index 8f23db3..7c3f4d1 100644 --- a/src/register.jl +++ b/src/register.jl @@ -1,10 +1,10 @@ using YaoBase, BitBasis import BitBasis: BitStr, BitStr64 -using LinearAlgebra: Transpose export ArrayReg, AdjointArrayReg, ArrayRegOrAdjointArrayReg, + transpose_storage, # YaoBase nqubits, nactive, @@ -130,6 +130,8 @@ to `copy`. """ ArrayReg(r::ArrayReg{B}) where B = ArrayReg{B}(copy(r.state)) +transpose_storage(reg::ArrayReg{B}) where B = ArrayReg{B}(transpose(Matrix(transpose(reg.state)))) + Base.copy(r::ArrayReg) = ArrayReg(r) Base.similar(r::ArrayRegOrAdjointArrayReg{B}) where B = ArrayReg{B}(similar(state(r))) @@ -144,9 +146,6 @@ function Base.copyto!(dst::AdjointArrayReg, src::AdjointArrayReg) return dst end -Base.convert(::Type{Transpose{T, Matrix{T}}}, arr::AbstractMatrix{T}) where T = transpose(Matrix(transpose(arr))) -Base.convert(t::Type{Transpose{T, Matrix{T}}}, arr::Transpose{T}) where T = invoke(convert, Tuple{Type{Transpose{T, Matrix{T}}}, Transpose}, t, arr) - # register interface YaoBase.nqubits(r::ArrayReg{B}) where B = log2i(length(r.state) ÷ B) YaoBase.nactive(r::ArrayReg) = log2dim1(r.state) @@ -337,14 +336,7 @@ product_state(total::Int, bit_config::Integer; nbatch::Int=1) = product_state(Co product_state(::Type{T}, bit_str::BitStr; nbatch::Int=1) where T = ArrayReg{nbatch}(T, bit_str) function product_state(::Type{T}, total::Int, bit_config::Integer; nbatch::Int=1) where T - if nbatch == 1 - raw = onehot(T, total, bit_config, nbatch) - else - raw = zeros(T, nbatch, 1< Date: Wed, 9 Oct 2019 02:32:21 +0800 Subject: [PATCH 14/14] revert changes --- src/register.jl | 41 ++++++++++++++++++++++++++--------------- test/register.jl | 22 ++++++++++++++++++++++ 2 files changed, 48 insertions(+), 15 deletions(-) diff --git a/src/register.jl b/src/register.jl index 7c3f4d1..e86ec0b 100644 --- a/src/register.jl +++ b/src/register.jl @@ -130,7 +130,8 @@ to `copy`. """ ArrayReg(r::ArrayReg{B}) where B = ArrayReg{B}(copy(r.state)) -transpose_storage(reg::ArrayReg{B}) where B = ArrayReg{B}(transpose(Matrix(transpose(reg.state)))) +transpose_storage(reg::ArrayReg{B,T,<:Transpose}) where {B,T} = ArrayReg{B}(copy(reg.state)) +transpose_storage(reg::ArrayReg{B,T}) where {B,T} = ArrayReg{B}(transpose(copy(transpose(reg.state)))) Base.copy(r::ArrayReg) = ArrayReg(r) Base.similar(r::ArrayRegOrAdjointArrayReg{B}) where B = ArrayReg{B}(similar(state(r))) @@ -305,7 +306,7 @@ ArrayReg{2, Complex{Float32}, Array...} product_state(bit_str::BitStr; nbatch::Int=1) = product_state(ComplexF64, bit_str; nbatch=nbatch) """ - product_state([T=ComplexF64], total::Int, bit_config::Integer; nbatch=1) + product_state([T=ComplexF64], total::Int, bit_config::Integer; nbatch=1, no_transpose_storage=false) Create an [`ArrayReg`](@ref) with bit configuration `bit_config`, total number of bits `total`. See also [`zero_state`](@ref), [`rand_state`](@ref), [`uniform_state`](@ref). @@ -331,12 +332,19 @@ ArrayReg{1, Complex{Float32}, Array...} This interface will not check whether the number of required digits for the bit configuration matches the total number of bits. """ -product_state(total::Int, bit_config::Integer; nbatch::Int=1) = product_state(ComplexF64, total, bit_config; nbatch=nbatch) +product_state(total::Int, bit_config::Integer; kwargs...) = product_state(ComplexF64, total, bit_config; kwargs...) -product_state(::Type{T}, bit_str::BitStr; nbatch::Int=1) where T = ArrayReg{nbatch}(T, bit_str) +product_state(::Type{T}, bit_str::BitStr{N}; kwargs...) where {T,N} = product_state(T, N, buffer(bit_str); kwargs...) -function product_state(::Type{T}, total::Int, bit_config::Integer; nbatch::Int=1) where T - return ArrayReg{nbatch}(onehot(T, total, bit_config, nbatch)) +function product_state(::Type{T}, total::Int, bit_config::Integer; nbatch::Int=1, no_transpose_storage::Bool=false) where T + if nbatch == 1 || no_transpose_storage + raw = onehot(T, total, bit_config, nbatch) + else + raw = zeros(T, nbatch, 1<