Implement canonicalize and canonicalize_rref routines.

Author: Hamiltonian-Action

benchmark/KernelAbstractions/README.md

@@ -4,7 +4,7 @@
 2. Ensure that all the packages listed in `implementation/imports.jl` are installed as this is not handled automatically.
 3. Ensure that the backend package(s) listed in the pertinent `benchmark_platform_*.jl` script are properly setup and configured.
 4. Pass said script as an argument to julia (optionally, also set the number of executing host threads) and await for the benchmark to conclude.
-5. Navigate to the newly created directory in order to inspect the results.
+5. Navigate to the newly created directory (hierarchy) and find the matching platform/timestamp pair in order to inspect the results.
 
 # Noteworthy Details
 

benchmark/KernelAbstractions/benchmark_platform_CUDA.jl

@@ -1,9 +1,8 @@
 include("implementation/benchmark_platform.jl")
 
-using Dates: value, now, UNIXEPOCH
 using CUDA: CuArray, devices, synchronize
 const AT = CuArray
-const path = "CUDA_benchmark_" * string(value(now()) - UNIXEPOCH)
+const path = "QuantumClifford_benchmarks/CUDA"
 
 const can_run = length(devices()) > 0
 

benchmark/KernelAbstractions/benchmark_platform_OpenCL.jl

@@ -1,10 +1,9 @@
 include("implementation/benchmark_platform.jl")
 
-using Dates: value, now, UNIXEPOCH
 import pocl_jll
 using OpenCL: CLArray, cl.devices, cl.platforms, cl.finish, cl.queue
 const AT = CLArray
-const path = "OpenCL_benchmark_" * string(value(now()) - UNIXEPOCH)
+const path = "QuantumClifford_benchmarks/OpenCL"
 
 const can_run = any(length(devices(platform)) > 0 for platform in platforms())
 

benchmark/KernelAbstractions/benchmark_platform_ROCm.jl

@@ -1,9 +1,8 @@
 include("implementation/benchmark_platform.jl")
 
-using Dates: value, now, UNIXEPOCH
 using AMDGPU: ROCArray, devices, synchronize
 const AT = ROCArray
-const path = "ROCm_benchmark_" * string(value(now()) - UNIXEPOCH)
+const path = "QuantumClifford_benchmarks/ROCm"
 
 const can_run = length(devices()) > 0
 

benchmark/KernelAbstractions/implementation/benchmark_KA_mul_leftright.jl

@@ -1,27 +1,35 @@
 # This must be done explicitly as they are not exported.
 using QuantumClifford: mul_left!, mul_right!, Tableau
 
-@inline host_f(x, y; phases::Val{phase_B} = Val(true)) where {phase_B} =
+@inline function host_f!(
+    x, y;
+    phases::Val{phase_B} = Val(default_phases)
+    ) where {phase_B}
+
     mul_left!(x, y; phases = phases)
 
-@inline function device_f(
+end
+
+@inline function device_f!(
     x, y, synchronize;
-    phases::Val{phase_B} = Val(true),
+    phases::Val{phase_B} = Val(default_phases),
+    primary_axis::Val{primary_axis_E} = Val(default_primary_axis),
     block_size::Val{block_SZ} = Val(default_block_size),
     batch_size::Val{batch_SZ} = Val(default_batch_size)
-    ) where {phase_B, block_SZ, batch_SZ}
+    ) where {phase_B, primary_axis_E, block_SZ, batch_SZ}
 
     mul_left!(
         x, y;
-        phases = phases, block_size = block_size, batch_size = batch_size
+        phases = phases, primary_axis = primary_axis,
+        block_size = block_size, batch_size = batch_size
         )
     synchronize()
 
 end
 
 @inline function benchmark_KA_mul_pauli_pauli(
     AT, synchronize, path;
-    phases::Val{phase_B} = Val(true)
+    phases::Val{phase_B} = Val(default_phases)
     ) where {phase_B}
 
     host_time = zeros(Float64, length(n_MiB))
@@ -46,17 +54,17 @@ end
             d_p2 = copy(d_p1)
             synchronize()
             # Trigger compilation before benchmarking.
-            host_f(h_p1, h_p2; phases = phases)
-            host_time[i] = @belapsed host_f(
+            host_f!(h_p1, h_p2; phases = phases)
+            host_time[i] = @belapsed host_f!(
                 $h_p1, $h_p2; phases = $phases
                 ) evals = evals samples = samples seconds = seconds
             for (j, size) in enumerate(batch_sizes)
-                device_f(
+                device_f!(
                     d_p1, d_p2, synchronize;
                     phases = phases, batch_size = Val(size)
                     )
                 device_time[j, i] =
-                    @belapsed device_f(
+                    @belapsed device_f!(
                         $d_p1, $d_p2, $synchronize;
                         phases = $phases, batch_size = Val($size)
                         ) evals = evals samples = samples seconds = seconds
@@ -72,28 +80,30 @@ end
     string(Sys.CPU_THREADS) * ", Device block size = $default_block_size"
     xlabel = "Pauli operator size (MiB)"
     label = hcat(("Device - batch size = " .* string.(batch_sizes))..., "Host")
+    path *= "/pauli_pauli"
+    mkpath(path)
 
     plot(
         n_MiB, 10^3 .* hcat(device_cat..., host_time);
         shape = :circle, xticks = n_MiB, xscale = :log2, yscale = :log10,
         title = title, label = label, xlabel = xlabel, ylabel = "Runtime (ms)",
         background_color = :transparent
         )
-    savefig("$path/runtime_pauli_pauli_phase_$phase_B.$format")
+    savefig("$path/runtime.$format")
 
     plot(
         n_MiB, map(x -> host_time ./ x, device_cat);
         shape = :circle, xticks = n_MiB, xscale = :log2, title = title,
         label = hcat(label[1 : end - 1]...), xlabel = xlabel,
         ylabel = "Ratio (host/device)", background_color = :transparent
         )
-    savefig("$path/ratio_pauli_pauli_phase_$phase_B.$format")
+    savefig("$path/ratio.$format")
 
 end
 
 @inline function benchmark_KA_mul_tableau_pauli(
     AT, synchronize, path;
-    phases::Val{phase_B} = Val(true)
+    phases::Val{phase_B} = Val(default_phases)
     ) where {phase_B}
 
     host_time = zeros(Float64, length(n_MiB))
@@ -126,17 +136,17 @@ end
                 )
             synchronize()
             # Trigger compilation before benchmarking.
-            host_f(h_t, h_p; phases = phases)
-            host_time[i] = @belapsed host_f(
+            host_f!(h_t, h_p; phases = phases)
+            host_time[i] = @belapsed host_f!(
                 $h_t, $h_p; phases = $phases
                 ) evals = evals samples = samples seconds = seconds
             for (j, size) in enumerate(batch_sizes)
-                device_f(
+                device_f!(
                     d_t, d_p, synchronize;
                     phases = phases, batch_size = Val(size)
                     )
                 device_time[j, i] =
-                    @belapsed device_f(
+                    @belapsed device_f!(
                         $d_t, $d_p, $synchronize;
                         phases = $phases, batch_size = Val($size)
                         ) evals = evals samples = samples seconds = seconds
@@ -152,32 +162,33 @@ end
     string(Sys.CPU_THREADS) * ", Device block size = $default_block_size"
     xlabel = "Tableau size (MiB)"
     label = hcat(("Device - batch size = " .* string.(batch_sizes))..., "Host")
+    path *= "/tableau_pauli"
+    mkpath(path)
 
     plot(
         n_MiB, 10^3 .* hcat(device_cat..., host_time);
         shape = :circle, xticks = n_MiB, xscale = :log2, yscale = :log10,
         title = title, label = label, xlabel = xlabel, ylabel = "Runtime (ms)",
         background_color = :transparent
         )
-    savefig("$path/runtime_tableau_pauli_phase_$phase_B.$format")
+    savefig("$path/runtime.$format")
 
     plot(
         n_MiB, map(x -> host_time ./ x, device_cat);
         shape = :circle, xticks = n_MiB, xscale = :log2, title = title,
         label = hcat(label[1 : end - 1]...), xlabel = xlabel,
         ylabel = "Ratio (host/device)", background_color = :transparent
         )
-    savefig("$path/ratio_tableau_pauli_phase_$phase_B.$format")
+    savefig("$path/ratio.$format")
 
 end
 
 @inline function benchmark_KA_mul_leftright(
     AT, synchronize, path;
-    phases::Val{phase_B} = Val(true)
+    phases::Val{phase_B} = Val(default_phases)
     ) where {phase_B}
 
-    path = "$path/mul_leftright"
-    mkpath(path)
+    path *= "/mul_leftright/phase_$phase_B"
     benchmark_KA_mul_pauli_pauli(AT, synchronize, path; phases = phases)
     benchmark_KA_mul_tableau_pauli(AT, synchronize, path; phases = phases)
 

benchmark/KernelAbstractions/implementation/benchmark_platform.jl

@@ -4,6 +4,7 @@ include("utilities.jl")
 include("benchmark_KA_mul_leftright.jl")
 
 @inline function benchmark_platform(AT, synchronize, path)
+    path *= "/" * string(value(now()) - UNIXEPOCH)
     benchmark_KA_mul_leftright(AT, synchronize, path; phases = Val(true))
     benchmark_KA_mul_leftright(AT, synchronize, path; phases = Val(false))
 end

benchmark/KernelAbstractions/implementation/definitions.jl

@@ -16,6 +16,9 @@ const n_MiB = [2^i for i = 1:10]
 # TODO: Keep these or remove them now that a good default has been set?
 const batch_sizes = [1, 4, 8, 16, 32, 64]
 
-# These values are inaccessible since they originate from a package extension.
-const default_block_size = 256
-const default_batch_size = 32
+# These values originate from a package extension, hence the query.
+const KAExt = Base.get_extension(QuantumClifford, :QuantumCliffordKAExt)
+const default_phases = KAExt.default_phases
+const default_primary_axis = KAExt.default_primary_axis
+const default_block_size = KAExt.default_block_size
+const default_batch_size = KAExt.default_batch_size

benchmark/KernelAbstractions/implementation/imports.jl

@@ -2,6 +2,7 @@
 import Atomix, GPUArraysCore, KernelAbstractions
 
 using BenchmarkTools: @belapsed
+using Dates: value, now, UNIXEPOCH
 # Assists in reducing resource demands.
 using GPUArrays: AllocCache, @cached, unsafe_free!
 using Plots: plot, savefig

benchmark/KernelAbstractions/implementation/utilities.jl

@@ -1,5 +1,9 @@
 # Works even when broadcasting on zero-dimensional arrays.
-@inline u32(v) = map(x -> UInt32(x), v)
+@inline function u32(v)
+    return map(x -> UInt32(x), v)
+end
 
 # By definition, the size of (unsigned) char is set to unity.
-@inline bit_count(::Type{T}) where {T} = sizeof(T) * count_zeros(zero(Cuchar))
+@inline function bit_count(::Type{T}) where {T}
+    return sizeof(T) * count_zeros(zero(Cuchar))
+end

ext/QuantumCliffordKAExt/QuantumCliffordKAExt.jl

@@ -7,6 +7,7 @@ include("definitions.jl")
 include("../../src/throws.jl")
 include("utilities.jl")
 include("mul_leftright.jl")
+include("canonicalization.jl")
 
 end
 #=============================================================================#