Update benchmarks with final scripts

Author: utkarsh530

benchmarks/CPU_vs_GPU/Manifest.toml

@@ -0,0 +1,10 @@
+[deps]
+CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba"
+KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c"
+Optimization = "7f7a1694-90dd-40f0-9382-eb1efda571ba"
+OptimizationBBO = "3e6eede4-6085-4f62-9a71-46d9bc1eb92b"
+OptimizationFlux = "253f991c-a7b2-45f8-8852-8b9a9df78a86"
+OptimizationOptimJL = "36348300-93cb-4f02-beb5-3c3902f8871e"
+OptimizationOptimisers = "42dfb2eb-d2b4-4451-abcd-913932933ac1"
+PSOGPU = "ab63da0c-63b4-40fa-a3b7-d2cba5be6419"
+StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"

benchmarks/CPU_vs_GPU/Project.toml

@@ -1,9 +1,13 @@
+using Pkg
+
+Pkg.activate(@__DIR__)
+
 using PSOGPU, StaticArrays, KernelAbstractions, Optimization
 using CUDA
 
 device!(2)
 
-N = 3
+N = 10
 function rosenbrock(x, p)
     sum(p[2] * (x[i + 1] - x[i]^2)^2 + (p[1] - x[i])^2 for i in 1:(length(x) - 1))
 end
@@ -35,9 +39,33 @@ sol = solve(prob,
 @show sol.objective
 @show sol.stats.time
 
+sol = solve(prob,
+    ParallelPSOKernel(n_particles; backend = CUDABackend(), global_update = true),
+    maxiters = 500)
+
+@show sol.objective
+@show sol.stats.time
+
+sol = solve(prob,
+    PSOGPU.HybridPSO(; backend = CUDABackend(),
+        pso = PSOGPU.ParallelPSOKernel(n_particles;
+            global_update = false,
+            backend = CUDABackend()),
+        local_opt = PSOGPU.LBFGS()), maxiters = 500,
+    local_maxiters = 30)
+
+@show sol.objective
+@show sol.stats.time
+
 cpu_times = Float64[]
 gpu_sync_times = Float64[]
 gpu_async_times = Float64[]
+gpu_queue_lock_times = Float64[]
+
+using Random
+rng = Random.default_rng()
+
+Random.seed!(rng, 0)
 
 Ns = [2^i for i in 3:2:20]
 for n_particles in Ns
@@ -108,17 +136,61 @@ for n_particles in Ns
         opt, Val(opt.global_update); maxiters = 500)
 
     push!(gpu_async_times, el_time)
+
+    opt = ParallelPSOKernel(n_particles; backend, global_update = true)
+
+    gpu_init_gbest = KernelAbstractions.allocate(backend, typeof(init_gbest), (1,))
+    copyto!(gpu_init_gbest, [init_gbest])
+
+    PSOGPU.vectorized_solve!(prob,
+        gpu_init_gbest,
+        backend_particles,
+        opt, Val(opt.global_update); maxiters = 500)
+
+    el_time = @elapsed PSOGPU.vectorized_solve!(prob,
+        gpu_init_gbest,
+        backend_particles,
+        opt, Val(opt.global_update); maxiters = 500)
+
+    push!(gpu_queue_lock_times, el_time)
+end
+
+gpu_hybrid_times = Float64[]
+
+Random.seed!(rng, 0)
+
+for n_particles in Ns
+    @info n_particles
+
+    sol = solve(prob,
+        PSOGPU.HybridPSO(; backend = CUDABackend(),
+            pso = PSOGPU.ParallelPSOKernel(n_particles;
+                global_update = false,
+                backend = CUDABackend()),
+            local_opt = PSOGPU.LBFGS()), maxiters = 500,
+        local_maxiters = 30)
+
+    sol = solve(prob,
+        PSOGPU.HybridPSO(; backend = CUDABackend(),
+            pso = PSOGPU.ParallelPSOKernel(n_particles;
+                global_update = false,
+                backend = CUDABackend()),
+            local_opt = PSOGPU.LBFGS()), maxiters = 500,
+        local_maxiters = 30)
+
+    push!(gpu_hybrid_times, sol.stats.time)
 end
 
 @show cpu_times
 @show gpu_sync_times
 @show gpu_async_times
+@show gpu_queue_lock_times
 
 using Plots
 
 xticks = 10 .^ round.(range(1, 7, length = 13), digits = 2)
 
-yticks = 10 .^ round.(range(1, -3, length = 11), digits = 2)
+yticks = 10 .^ round.(range(1, -3, length = 9), digits = 2)
 
 plt = plot(Ns,
     gpu_sync_times,
@@ -127,14 +199,15 @@ plt = plot(Ns,
     linewidth = 2,
     label = "ParallelSyncPSOKernel: GPU",
     ylabel = "Time (s)",
-    xlabel = "Trajectories",
-    title = "Bechmarking the 10D Rosenbrock Problem",
+    xlabel = "No. of Particles",
+    title = "Benchmarking the 10D Rosenbrock Problem",
     legend = :topleft,
     xticks = xticks,
     yticks = yticks,
     marker = :circle,
-    dpi = 600,
-    color = :Green)
+    dpi = 600
+    # color = :Green
+)
 
 plt = plot!(Ns,
     cpu_times,
@@ -143,17 +216,168 @@ plt = plot!(Ns,
     linewidth = 2,
     label = "ParallelSyncPSOKernel: CPU",
     marker = :circle,
-    color = :Orange)
+    ls = :dash
+    # color = :Orange
+)
 
 plt = plot!(Ns,
     gpu_async_times,
     xaxis = :log,
     yaxis = :log,
     linewidth = 2,
     label = "ParallelPSOKernel (Async): GPU",
-    marker = :circle,
-    color = :Green)
+    marker = :circle
+    # color = :Green
+)
+
+plt = plot!(Ns,
+    gpu_queue_lock_times,
+    xaxis = :log,
+    yaxis = :log,
+    linewidth = 2,
+    label = "ParallelPSOKernel (Queue-lock): GPU",
+    marker = :circle
+    # color = :Green
+)
+
+plt = plot!(Ns,
+    gpu_hybrid_times,
+    xaxis = :log,
+    yaxis = :log,
+    linewidth = 2,
+    label = "HybridPSO-LBFGS: GPU",
+    marker = :circle
+    # color = :Green
+)
+
+savefig("benchmark_hybrid.svg")
+
+using Statistics
 
 @show mean(cpu_times ./ gpu_sync_times)
 
 @show mean(cpu_times ./ gpu_async_times)
+
+@show mean(cpu_times ./ gpu_queue_lock_times)
+
+@show mean(cpu_times ./ gpu_hybrid_times)
+
+@show mean(gpu_sync_times ./ gpu_queue_lock_times)
+
+# cpu_times_total = Float64[]
+# gpu_sync_times_total = Float64[]
+# gpu_async_times_total = Float64[]
+# gpu_queue_lock_times_total = Float64[]
+# gpu_hybrid_times_total = Float64[]
+
+# for n_particles in Ns
+#     @info n_particles
+
+#     sol = solve(prob, ParallelSyncPSOKernel(n_particles; backend = CPU()), maxiters = 500)
+
+#     el_time = @elapsed solve(prob, ParallelSyncPSOKernel(n_particles; backend = CPU()), maxiters = 500)
+
+#     push!(cpu_times_total, el_time)
+
+#     sol = solve(prob,
+#         ParallelSyncPSOKernel(n_particles; backend = CUDABackend()),
+#         maxiters = 500)
+
+#     el_time = @elapsed solve(prob,
+#                              ParallelSyncPSOKernel(n_particles; backend = CUDABackend()),
+#                               maxiters = 500)
+
+#     push!(gpu_sync_times_total, el_time)
+
+#     sol = solve(prob,
+#         ParallelPSOKernel(n_particles; backend = CUDABackend(), global_update = false),
+#         maxiters = 500)
+
+#     el_time = @elapsed solve(prob,
+#                 ParallelPSOKernel(n_particles; backend = CUDABackend(), global_update = false),
+#                 maxiters = 500)
+
+#     push!(gpu_async_times_total, el_time)
+
+#     sol = solve(prob,
+#         ParallelPSOKernel(n_particles; backend = CUDABackend(), global_update = true),
+#         maxiters = 500)
+
+#     el_time = @elapsed solve(prob,
+#     ParallelPSOKernel(n_particles; backend = CUDABackend(), global_update = true),
+#     maxiters = 500)
+
+#     push!(gpu_queue_lock_times_total, el_time)
+
+#     sol = solve(prob,
+#         PSOGPU.HybridPSO(; backend = CUDABackend(),
+#         pso = PSOGPU.ParallelPSOKernel(n_particles; global_update = false, backend = CUDABackend()),
+#         local_opt = PSOGPU.LBFGS()), maxiters = 500,
+#         local_maxiters = 30)
+
+#     el_time = @elapsed solve(prob,
+#     PSOGPU.HybridPSO(; backend = CUDABackend(),
+#     pso = PSOGPU.ParallelPSOKernel(n_particles; global_update = false, backend = CUDABackend()),
+#     local_opt = PSOGPU.LBFGS()), maxiters = 500,
+#     local_maxiters = 30)
+
+#     push!(gpu_hybrid_times_total, el_time)
+
+# end
+
+# plt = plot(Ns,
+#     gpu_sync_times_total,
+#     xaxis = :log,
+#     yaxis = :log,
+#     linewidth = 2,
+#     label = "ParallelSyncPSOKernel: GPU",
+#     ylabel = "Time (s)",
+#     xlabel = "No. of Particles",
+#     title = "Bechmarking the 10D Rosenbrock Problem",
+#     legend = :topleft,
+#     xticks = xticks,
+#     yticks = yticks,
+#     marker = :circle,
+#     dpi = 600,
+#     # color = :Green
+#     )
+
+# plt = plot!(Ns,
+#     cpu_times_total,
+#     xaxis = :log,
+#     yaxis = :log,
+#     linewidth = 2,
+#     label = "ParallelSyncPSOKernel: CPU",
+#     marker = :circle,
+#     # color = :Orange
+#     )
+
+# plt = plot!(Ns,
+#     gpu_async_times_total,
+#     xaxis = :log,
+#     yaxis = :log,
+#     linewidth = 2,
+#     label = "ParallelPSOKernel (Async): GPU",
+#     marker = :circle,
+#     # color = :Green
+#     )
+
+# plt = plot!(Ns,
+#     gpu_queue_lock_times_total,
+#     xaxis = :log,
+#     yaxis = :log,
+#     linewidth = 2,
+#     label = "ParallelPSOKernel (Queue-lock): GPU",
+#     marker = :circle,
+#     # color = :Green
+#     )
+
+# plt = plot!(Ns,
+#     gpu_hybrid_times_total,
+#     xaxis = :log,
+#     yaxis = :log,
+#     linewidth = 2,
+#     label = "HybridPSO-LBFGS: GPU",
+#     marker = :circle,
+#     # color = :Green
+#     )