diff --git a/.gitattributes b/.gitattributes index 8aff49f..e9f7119 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1,2 +1,3 @@ input/AB->ABBBBBBBBB.txt filter=lfs diff=lfs merge=lfs -text input/AB->ABBBBBBB.txt filter=lfs diff=lfs merge=lfs -text +*.zip filter=lfs diff=lfs merge=lfs -text diff --git a/.gitea/workflows/julia-package-ci.yml b/.gitea/workflows/julia-package-ci.yml index b7887e6..0447d96 100644 --- a/.gitea/workflows/julia-package-ci.yml +++ b/.gitea/workflows/julia-package-ci.yml @@ -46,6 +46,7 @@ jobs: run: | julia --project=examples/ -e 'using Pkg; Pkg.develop(Pkg.PackageSpec(path=pwd())); Pkg.instantiate(); Pkg.precompile()' julia --project=examples/ -t 4 -e 'include("examples/import_bench.jl")' -O3 + julia --project=examples/ -t 4 -e 'include("examples/ab5.jl")' -O3 docs: runs-on: ubuntu-22.04 diff --git a/.gitignore b/.gitignore index e3791a7..81167a2 100644 --- a/.gitignore +++ b/.gitignore @@ -30,3 +30,7 @@ Manifest.toml .julia **/.ipynb_checkpoints/ *.bkp + +*.sif + +data/hemera_temp diff --git a/Project.toml b/Project.toml index 722043e..c495944 100644 --- a/Project.toml +++ b/Project.toml @@ -1,11 +1,12 @@ +authors = ["Anton Reinhard "] name = "MetagraphOptimization" uuid = "3e869610-d48d-4942-ba70-c1b702a33ca4" -authors = ["Anton Reinhard "] version = "0.1.0" [deps] AccurateArithmetic = "22286c92-06ac-501d-9306-4abd417d9753" CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" +Combinatorics = "861a8166-3701-5b0c-9a16-15d98fcdc6aa" DataStructures = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8" ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" JuliaFormatter = "98e50ef6-434e-11e9-1051-2b60c6c9e899" @@ -19,6 +20,7 @@ StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" UUIDs = "cf7118a7-6976-5b1a-9a39-7adc72f591a4" [extras] +CUDA_Runtime_jll = "76a88914-d11a-5bdc-97e0-2f5a05c973a2" Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" [targets] diff --git a/data/evaluate.jl b/data/evaluate.jl new file mode 100644 index 0000000..4fab38b --- /dev/null +++ b/data/evaluate.jl @@ -0,0 +1,170 @@ +using CSV +using DataFrames +using Plots +using StatsPlots +using LaTeXStrings + +if (length(ARGS) < 1) + println("Please use with \"input_file.csv\"") +end + +processes = [ + "QED Process: 'ke->ke'", + "QED Process: 'ke->kke'", + "QED Process: 'ke->kkke'", + #"QED Process: 'ke->kkkke'", + #"QED Process: 'ke->kkkkke'", + #"QED Process: 'ke->kkkkkke'", + #"QED Process: 'ke->kkkkkkke'", + "ABC Process: 'AB->AB'", + "ABC Process: 'AB->ABBB'", + #"ABC Process: 'AB->ABBBBB'", +] + +function proc_to_n(str::AbstractString) + parts = split(str, "'") + parts = split(parts[2], "->") + k_count = count(c -> c == 'k', parts[2]) + return k_count +end + +function beautify_title(str::AbstractString) + parts = split(str, "'") + + preprefix = parts[1] + infix = parts[2] + sufsuffix = parts[3] + + parts = split(infix, "->") + + prefix = parts[1] + suffix = parts[2] + + k_count = count(c -> c == 'k', suffix) + B_count = count(c -> c == 'B', suffix) + + if k_count == 1 || B_count == 1 + new_suffix = suffix + elseif k_count >= 1 + new_suffix = replace(suffix, r"k+" => "k^$k_count") + elseif B_count >= 1 + new_suffix = replace(suffix, r"B+" => "B^$B_count") + end + + return preprefix * L"%$prefix \rightarrow %$new_suffix" * sufsuffix +end + +input_file = ARGS[1] +df = CSV.read(input_file, DataFrame) +n_inputs = df[:, "n_inputs"][1] + +# plotting with threads as x axis +for process_name in processes + title_string = "$(beautify_title(process_name)), $n_inputs samples" + println("$title_string") + + process_no_opt = process_name * " not optimized" + process_red = process_name * " reduced" + process_tape_no_opt = process_name * " not optimized tape" + process_tape_red = process_name * " reduced tape" + + df_no_opt = filter(:process_name => x -> x == process_no_opt, df) + df_red = filter(:process_name => x -> x == process_red, df) + df_tape_no_opt = filter(:process_name => x -> x == process_tape_no_opt, df) + df_tape_red = filter(:process_name => x -> x == process_tape_red, df) + + @df df_no_opt scatter(:cpu_threads, :cpu_time, label = "unoptimized function", markershape = :circle) + @df df_red scatter!(:cpu_threads, :cpu_time, label = "reduced function", markershape = :rect) + @df df_tape_no_opt scatter!(:cpu_threads, :cpu_time, label = "unoptimized tape", markershape = :utriangle) + @df df_tape_red scatter!(:cpu_threads, :cpu_time, label = "reduced tape", markershape = :star) + + plot!( + title = title_string, + yscale = :linear, + legend = :outerright, + legendcolumns = 1, + legend_font_pointsize = 10, + size = (800, 600), + ylabel = "execution time (s)", + xlabel = "threads (#)", + ) + + savefig("$(process_name)_time.pdf") + + + @df df_no_opt scatter(:cpu_threads, :cpu_rate, label = "unoptimized function", markershape = :circle) + @df df_red scatter!(:cpu_threads, :cpu_rate, label = "reduced function", markershape = :rect) + @df df_tape_no_opt scatter!(:cpu_threads, :cpu_rate, label = "unoptimized tape", markershape = :utriangle) + @df df_tape_red scatter!(:cpu_threads, :cpu_rate, label = "reduced tape", markershape = :star) + + plot!( + title = "Sample rate, " * title_string, + yscale = :log10, + legend = :outerright, + legendcolumns = 1, + legend_font_pointsize = 10, + size = (800, 600), + ylabel = "rate (" * L"s^{-1}" * ")", + xlabel = "threads (#)", + ) + + savefig("$(process_name)_rate.pdf") + + + @df df_no_opt scatter(:cpu_threads, :cpu_gflops, label = "unoptimized function", markershape = :circle) + @df df_red scatter!(:cpu_threads, :cpu_gflops, label = "reduced function", markershape = :rect) + @df df_tape_no_opt scatter!(:cpu_threads, :cpu_gflops, label = "unoptimized tape", markershape = :utriangle) + @df df_tape_red scatter!(:cpu_threads, :cpu_gflops, label = "reduced tape", markershape = :star) + + plot!( + title = "CPU performance, " * title_string, + yscale = :linear, + legend = :outerright, + legendcolumns = 1, + legend_font_pointsize = 10, + size = (800, 600), + ylabel = "CPU performance (GFLOPS)", + xlabel = "threads (#)", + ) + + savefig("$(process_name)_performance.pdf") + +end + +# plotting with process size as x axis +THREADS = [1, 2, 4, 8, 16] + +for threads in THREADS + title_string = "$threads threads, $n_inputs samples" + + df_filt = filter(:cpu_threads => x -> x == threads, df) + df_filt = filter(:process_name => x -> proc_to_n(x) >= 1, df_filt) + + df_filt.process_size = @. proc_to_n(df_filt.process_name) + + df_no_opt = filter(:process_name => x -> match(r" not optimized$", x) !== nothing, df_filt) + df_red = filter(:process_name => x -> match(r" reduced$", x) !== nothing, df_filt) + df_tape_no_opt = filter(:process_name => x -> match(r" not optimized tape$", x) !== nothing, df_filt) + df_tape_red = filter(:process_name => x -> match(r" reduced tape$", x) !== nothing, df_filt) + + + @df df_no_opt scatter(:process_size, :graph_gen_time, label = "graph generation time") + @df df_red scatter!(:process_size, :optimization_time, label = "optimization time") + @df df_no_opt scatter!(:process_size, :function_generation_time, label = "unoptimized function generation time") + @df df_tape_no_opt scatter!(:process_size, :function_generation_time, label = "unoptimized tape generation time") + @df df_red scatter!(:process_size, :function_generation_time, label = "reduced function generation time") + @df df_tape_red scatter!(:process_size, :function_generation_time, label = "reduced tape generation time") + + plot!( + title = "function generation times, " * title_string, + yscale = :log10, + legend = :outerbottom, + legendcolumns = 2, + legend_font_pointsize = 10, + size = (800, 600), + ylabel = "time (s)", + xlabel = "process size (#)", + ) + + savefig("gen_times_$(threads)_threads.pdf") +end diff --git a/data/evaluate_cpu_gpu_exec.jl b/data/evaluate_cpu_gpu_exec.jl new file mode 100644 index 0000000..801eff0 --- /dev/null +++ b/data/evaluate_cpu_gpu_exec.jl @@ -0,0 +1,143 @@ +using CSV +using DataFrames +using Plots +using StatsPlots +using LaTeXStrings + +if (length(ARGS) < 1) + println("Please use with \"input_file.csv\"") +end + +processes = [ + "QED Process: 'ke->ke'", + "QED Process: 'ke->kke'", + "QED Process: 'ke->kkke'", + "QED Process: 'ke->kkkke'", + "QED Process: 'ke->kkkkke'", + #"QED Process: 'ke->kkkkkke'", + #"QED Process: 'ke->kkkkkkke'", + "ABC Process: 'AB->AB'", + "ABC Process: 'AB->ABBB'", + "ABC Process: 'AB->ABBBBB'", +] + +function proc_to_n(str::AbstractString) + parts = split(str, "'") + parts = split(parts[2], "->") + k_count = count(c -> c == 'k', parts[2]) + return k_count +end + +function abc_proc_to_n(str::AbstractString) + parts = split(str, "'") + parts = split(parts[2], "->") + b_count = count(c -> c == 'B', parts[2]) + return b_count +end + +function beautify_title(str::AbstractString) + parts = split(str, "'") + + preprefix = parts[1] + infix = parts[2] + sufsuffix = parts[3] + + parts = split(infix, "->") + + prefix = parts[1] + suffix = parts[2] + + k_count = count(c -> c == 'k', suffix) + B_count = count(c -> c == 'B', suffix) + + if k_count == 1 || B_count == 1 + new_suffix = suffix + elseif k_count >= 1 + new_suffix = replace(suffix, r"k+" => "k^$k_count") + elseif B_count >= 1 + new_suffix = replace(suffix, r"B+" => "B^$B_count") + end + + return preprefix * L"%$prefix \rightarrow %$new_suffix" * sufsuffix +end + +input_file = ARGS[1] +df = CSV.read(input_file, DataFrame) +n_inputs = df[:, "n_inputs"][1] + + + +title_string = "QED N-Photon Compton Scattering\nCalculate 1,048,576 (\$2^{20}\$) Matrix Elements" + +df_filt = filter(:process_name => x -> proc_to_n(x) >= 1, df) + +df_filt.process_size = @. proc_to_n(df_filt.process_name) + +df_red = filter(:process_name => x -> match(r" reduced$", x) !== nothing, df_filt) + +@df df_red scatter( + :process_size, + :cpu_time, + yerror = :cpu_std, + label = "CPU execution time, 32 threads (s)", + markersize = 6, +) +@df df_red scatter!( + :process_size, + :gpu_time, + yerror = :gpu_std, + label = "GPU execution time, A100 80GB (s)", + markersize = 6, +) + +plot!( + #title = title_string, + yscale = :log10, + legend = :outerbottom, + legendcolumns = 2, + legend_font_pointsize = 10, + size = (800, 600), + ylabel = "time (s)", + xlabel = "process size (#)", +) + +savefig("cpu_vs_gpu_qed.pdf") + + + + +title_string = "\$AB\\rightarrow AB^n\$ ABC Processes\nCalculate 1,048,576 (\$2^{20}\$) Matrix Elements" + +df_filt = filter(:process_name => x -> abc_proc_to_n(x) >= 1, df) + +df_filt.process_size = @. abc_proc_to_n(df_filt.process_name) + +df_red = filter(:process_name => x -> match(r" reduced$", x) !== nothing, df_filt) + +@df df_red scatter( + :process_size, + :cpu_time, + yerror = :cpu_std, + label = "CPU execution time, 32 threads (s)", + markersize = 6, +) +@df df_red scatter!( + :process_size, + :gpu_time, + yerror = :gpu_std, + label = "GPU execution time, A100 80GB (s)", + markersize = 6, +) + +plot!( + #title = title_string, + yscale = :log10, + legend = :outerbottom, + legendcolumns = 2, + legend_font_pointsize = 10, + size = (800, 600), + ylabel = "time (s)", + xlabel = "process size (#)", +) + +savefig("cpu_vs_gpu_abc.pdf") diff --git a/data/evaluate_full_node_bench.jl b/data/evaluate_full_node_bench.jl new file mode 100644 index 0000000..1d6bfa5 --- /dev/null +++ b/data/evaluate_full_node_bench.jl @@ -0,0 +1,212 @@ +using CSV +using DataFrames +using Plots +using StatsPlots +using LaTeXStrings + +if (length(ARGS) < 1) + println("Please use with \"input_file.csv\"") +end + +processes = [ + "QED Process: 'ke->ke'", + "QED Process: 'ke->kke'", + "QED Process: 'ke->kkke'", + "QED Process: 'ke->kkkke'", + "QED Process: 'ke->kkkkke'", +] + +function proc_to_n(str::AbstractString) + parts = split(str, "'") + parts = split(parts[2], "->") + k_count = count(c -> c == 'k', parts[2]) + return k_count +end + +function beautify_title(str::AbstractString) + parts = split(str, "'") + + preprefix = parts[1] + infix = parts[2] + sufsuffix = parts[3] + + parts = split(infix, "->") + + prefix = parts[1] + suffix = parts[2] + + k_count = count(c -> c == 'k', suffix) + B_count = count(c -> c == 'B', suffix) + + if k_count == 1 || B_count == 1 + new_suffix = suffix + elseif k_count >= 1 + new_suffix = replace(suffix, r"k+" => "k^$k_count") + elseif B_count >= 1 + new_suffix = replace(suffix, r"B+" => "B^$B_count") + end + + return "QED Compton Scattering Process " * L"%$prefix \rightarrow %$new_suffix" * sufsuffix +end + +input_file = ARGS[1] +df = CSV.read(input_file, DataFrame) +n_inputs = df[:, "n_inputs"][1] +gpus = df.gpu_devices[1] +cpus = df.cpu_threads[1] + +power = Int(round(log2(n_inputs))) + +chunk_sizes = [ + "\$2^{10}\$", + "\$2^{11}\$", + "\$2^{12}\$", + "\$2^{13}\$", + "\$2^{14}\$", + "\$2^{15}\$", + "\$2^{16}\$", + "\$2^{17}\$", + "\$2^{18}\$", + "\$2^{19}\$", + "\$2^{20}\$", +] + +best_times = Vector{Float64}() +best_times_std = Vector{Float64}() + +# plotting with threads as x axis +for process_name in processes + df_filt = filter(:process_name => x -> x == process_name, df) + + df_filt.cpu_ratio = df_filt.cpu_chunks ./ (df_filt.cpu_chunks .+ df_filt.gpu_chunks) .* 100.0 + df_filt.gpu_ratio = df_filt.gpu_chunks ./ (df_filt.cpu_chunks .+ df_filt.gpu_chunks) .* 100.0 + + push!(best_times, minimum(df_filt.time)) + + bar(chunk_sizes, df_filt.cpu_ratio, label = "workload completed by \$$(cpus)\$ CPU threads (%)") + bar!( + chunk_sizes, + [100 for _ in chunk_sizes], + label = "workload completed by $(gpus) GPUs (%)", + fillto = df_filt.cpu_ratio, + ) + + plot!( + #title = "$(beautify_title(process_name))\nComputing $(n_inputs) (\$2^{$(power)}\$) Matrix Elements", + yscale = :linear, + #xticks = [1024 4096 16384 65536 262144 1048576], + ylim = (0, 105), + legend = :outerbottom, + legendcolumns = 1, + legend_font_pointsize = 10, + #size = (800, 600), + ylabel = "contribution (%)", + xlabel = "chunk size (#)", + ) + + savefig("full_node_chunk_size_$(proc_to_n(process_name))k_ratio.pdf") + + + scatter( + chunk_sizes, + df_filt.rate, + label = "total execution rate (\$s^{-1}\$)", + #title = "$(beautify_title(process_name))\nComputing $(n_inputs) (\$2^{$(power)}\$) Matrix Elements", + ylim = (0, :auto), + #yscale = :log10, + #xticks = [1024 4096 16384 65536 262144 1048576], + legend = :outerbottom, + legendcolumns = 1, + legend_font_pointsize = 10, + #size = (800, 600), + ylabel = "rate (\$s^{-1}\$)", + xlabel = "chunk size (#)", + markersize = 7, + ) + + savefig("full_node_chunk_size_$(proc_to_n(process_name))k_rate.pdf") + + + scatter( + chunk_sizes, + df_filt.time, + yerror = df_filt.std, + label = "total execution time (s)", + #title = "$(beautify_title(process_name))\nComputing $(n_inputs) (\$2^{$(power)}\$) Matrix Elements", + #xticks = [1024 4096 16384 65536 262144 1048576], + ylim = (0, maximum(df_filt.time) * 1.05), + legend = :outerbottom, + legendcolumns = 1, + legend_font_pointsize = 10, + #size = (800, 600), + ylabel = "time (s)", + xlabel = "chunk size (#)", + markersize = 7, + ) + + savefig("full_node_chunk_size_$(proc_to_n(process_name))k_time.pdf") + +end + + +# plotting with process size as x axis +A100_rates = [2.530045276927587e9, 1.16972304616864e9, 2.0002725972692013e8, 3.495722925446318e7, 4.792187095617111e6] +CPU_32threads_rates = + [3.2691139045711152e7, 1.1578342663759507e7, 3.1670680975577887e6, 731037.7069429948, 115001.5594731802] + +theory_rates = (A100_rates .+ CPU_32threads_rates) .* 4 + +scatter( + proc_to_n.(processes), + best_times, + label = "full node best achieved time (s)", + #title = "QED N-Photon Compton Scattering\nComputing $(n_inputs) (\$2^{$(power)}\$) Matrix Elements", + ylim = (0, maximum(best_times) * 1.05), + legend = :outerbottom, + legendcolumns = 1, + legend_font_pointsize = 10, + #size = (800, 600), + ylabel = "time (s)", + xlabel = "process size (#)", + markersize = 7, +) + +savefig("full_node_process_best_time.pdf") + + +scatter( + proc_to_n.(processes), + (n_inputs ./ best_times), + label = "full node best achieved rate (\$s^{-1}\$)", + #title = "QED N-Photon Compton Scattering\nComputing $(n_inputs) (\$2^{$(power)}\$) Matrix Elements", + ylim = (0, maximum(n_inputs ./ best_times) * 1.05), + legend = :outerbottom, + legendcolumns = 1, + legend_font_pointsize = 10, + #size = (800, 600), + ylabel = "rate (\$s^{-1}\$)", + xlabel = "process size (#)", + markersize = 7, +) + +savefig("full_node_process_best_rate.pdf") + + + +scatter( + proc_to_n.(processes), + [(n_inputs ./ best_times) theory_rates], + label = ["full node best achieved rate (\$s^{-1}\$)" "theoretical rate from previous benchmarks (\$s^{-1}\$)"], + #title = "QED N-Photon Compton Scattering\nComputing $(n_inputs) (\$2^{$(power)}\$) Matrix Elements", + #ylim = (0, max(maximum(n_inputs ./ best_times), maximum(theory_rates)) * 1.05), + yscale = :log10, + legend = :outerbottom, + legendcolumns = 1, + legend_font_pointsize = 10, + #size = (800, 600), + ylabel = "rate (\$s^{-1}\$)", + xlabel = "process size (#)", + markersize = 7, +) + +savefig("full_node_process_best_rate_plus_theory.pdf") diff --git a/data/evaluate_gen.jl b/data/evaluate_gen.jl new file mode 100644 index 0000000..737faf3 --- /dev/null +++ b/data/evaluate_gen.jl @@ -0,0 +1,232 @@ +using CSV +using DataFrames +using Plots +using StatsPlots +using LaTeXStrings + +if (length(ARGS) < 1) + println("Please use with \"input_file.csv\"") +end + +function proc_to_n(str::AbstractString) + parts = split(str, "->") + k_count = count(c -> c == 'k', parts[2]) + return k_count +end + +input_file = ARGS[1] +df = CSV.read(input_file, DataFrame) + +# plotting with process size as x axis +THREADS = [1] + +for threads in THREADS + title_string = "n-photon Compton diagram generation" + + df_filt = filter(:cpu_threads => x -> x == threads, df) + df_filt = filter(:process_name => x -> proc_to_n(x) >= 1, df_filt) + + # ns -> s + df_filt.graph_gen_mean = @. df_filt.graph_gen_mean / 1e9 + df_filt.graph_gen_std = @. df_filt.graph_gen_std / 1e9 + + # B -> MB (not MiB since the log scale is base 10) + df_filt.graph_mem = @. df_filt.graph_mem / 1e6 + df_filt.graph_mem_reduced = @. df_filt.graph_mem_reduced / 1e6 + + df_filt.process_size = @. proc_to_n(df_filt.process_name) + l = length(df_filt.process_size) + + println(df_filt[!, :process_size]) + println(df_filt[!, :graph_mem]) + println(df_filt[!, :graph_mem_reduced]) + + + @df df_filt scatter(:process_size, :graph_mem, label = "unreduced graph", markersize = 7) + scatter!( + df_filt[!, :process_size], + df_filt[!, :graph_mem_reduced], + label = "reduced graph", + markershape = :square, + markersize = 7, + ) + + plot!( + title = "n-photon Compton diagram memory footprint", + yscale = :log10, + legend = :outerbottom, + minorgrid = true, + xticks = :process_size, + #yticks = [1e-3, 1e-1, 1e1, 1e3], + xgrid = false, + xminorticks = false, + legendcolumns = 1, + legend_font_pointsize = 12, + fontsize = 12, + size = (800, 600), + ylabel = "memory footprint (MB)", + xlabel = "process size (#)", + ) + + savefig("gen_memory_$(threads).pdf") + + @df df_filt scatter( + :process_size, + :graph_gen_mean, + yerror = :graph_gen_std, + label = "graph generation time", + markersize = 7, + ) + scatter!( + df_filt[!, :process_size], + df_filt[!, :graph_elapsed_reduce], + label = "graph reduction time", + markershape = :square, + markersize = 7, + ) + + plot!( + title = title_string, + yscale = :log10, + legend = :outerbottom, + minorgrid = true, + xticks = :process_size, + yticks = [1e-3, 1e-1, 1e1, 1e3], + xgrid = false, + xminorticks = false, + legendcolumns = 1, + legend_font_pointsize = 12, + fontsize = 12, + size = (800, 600), + ylabel = "time (s)", + xlabel = "process size (#)", + ) + + savefig("gen_times_$(threads)_threads.pdf") + exit(0) + + # graph size + title_string = "n-photon Compton unreduced graph size" + + @df df_filt scatter(:process_size, :graph_nodes, label = "nodes", markershape = :circle) + @df df_filt scatter!(:process_size, :graph_edges, label = "edges", markershape = :square) + @df df_filt scatter!(:process_size, :graph_u_nodes, label = "U-nodes", markershape = :star) + @df df_filt scatter!(:process_size, :graph_v_nodes, label = "V-nodes", markershape = :utriangle) + @df df_filt scatter!(:process_size[2:end], :graph_s1_nodes[2:end], label = "S1-nodes", markershape = :x) + @df df_filt scatter!(:process_size, :graph_s2_nodes, label = "S2-nodes", markershape = :diamond) + + plot!( + title = title_string, + yscale = :log10, + legend = :outerbottom, + yminorgrid = true, + xticks = :process_size, + yticks = [1e1, 1e3, 1e5, 1e7], + xgrid = false, + xminorticks = false, + legendcolumns = 2, + legend_font_pointsize = 10, + size = (800, 600), + ylabel = "(#)", + xlabel = "process size (#)", + ) + + savefig("compton_graph_size_unreduced.pdf") + + + # graph size + title_string = "n-photon Compton reduced graph size" + + @df df_filt scatter(:process_size, :graph_nodes_reduced, label = "nodes", markershape = :circle) + @df df_filt scatter!(:process_size, :graph_edges_reduced, label = "edges", markershape = :square) + @df df_filt scatter!(:process_size, :graph_u_nodes_reduced, label = "U-nodes", markershape = :star) + @df df_filt scatter!(:process_size, :graph_v_nodes_reduced, label = "V-nodes", markershape = :utriangle) + @df df_filt scatter!(:process_size[2:end], :graph_s1_nodes_reduced[2:end], label = "S1-nodes", markershape = :x) + @df df_filt scatter!(:process_size, :graph_s2_nodes_reduced, label = "S2-nodes", markershape = :diamond) + + plot!( + title = title_string, + yscale = :log10, + legend = :outerbottom, + yminorgrid = true, + xticks = :process_size, + yticks = [1e1, 1e2, 1e3, 1e4, 1e5, 1e6], + xgrid = false, + xminorticks = false, + legendcolumns = 2, + legend_font_pointsize = 10, + size = (800, 600), + ylabel = "(#)", + xlabel = "process size (#)", + ) + + savefig("compton_graph_size_reduced.pdf") + + + # graph size versus + title_string = "n-photon Compton graph sizes" + + @df df_filt scatter(:process_size, :graph_nodes, label = "nodes", markershape = :circle) + @df df_filt scatter!(:process_size, :graph_edges, label = "edges", markershape = :square) + @df df_filt scatter!(:process_size, :graph_nodes_reduced, label = "nodes (after reduction)", markershape = :star) + @df df_filt scatter!( + :process_size, + :graph_edges_reduced, + label = "edges (after reduction)", + markershape = :utriangle, + ) + + plot!( + title = title_string, + yscale = :log10, + legend = :outerbottom, + yminorgrid = true, + xticks = :process_size, + yticks = [1e1, 1e2, 1e3, 1e4, 1e5, 1e6], + xgrid = false, + xminorticks = false, + legendcolumns = 2, + legend_font_pointsize = 10, + size = (800, 600), + ylabel = "(#)", + xlabel = "process size (#)", + ) + + savefig("compton_graph_size_versus.pdf") + +end + +# for a specific process, plot times with threads as x +process = "ke->kkkkkkkke" +title_string = "n-photon Compton diagram generation times, $process" + +df_filt = filter(:process_name => x -> x == process, df) +df_filt.graph_gen_mean = @. df_filt.graph_gen_mean / 1e9 +df_filt.graph_gen_std = @. df_filt.graph_gen_std / 1e9 + +@df df_filt scatter( + :cpu_threads, + :graph_gen_mean, + yerror = :graph_gen_std, + label = "graph generation time", + markersize = 7, +) + +plot!( + title = title_string, + yscale = :linear, + legend = :outerbottom, + minorgrid = true, + xticks = :cpu_threads, + #yticks = [1e-3, 1e-2, 1e-1, 1e-0, 1e1], + ylim = (0, max(df_filt[!, :graph_gen_mean]...) * 1.1), + xgrid = false, + xminorticks = false, + legendcolumns = 1, + legend_font_pointsize = 10, + size = (800, 600), + ylabel = "time (s)", + xlabel = "process size (#)", +) + +savefig("gen_times_$(process).pdf") diff --git a/data/evaluate_gen_one_sided_comparison.jl b/data/evaluate_gen_one_sided_comparison.jl new file mode 100644 index 0000000..a40b0c7 --- /dev/null +++ b/data/evaluate_gen_one_sided_comparison.jl @@ -0,0 +1,52 @@ +using CSV +using DataFrames +using Plots +using StatsPlots +using LaTeXStrings + +if (length(ARGS) < 2) + println("Please use with \"input_file.csv\" \"input_file_onesided.csv\"") +end + +function proc_to_n(str::AbstractString) + parts = split(str, "->") + k_count = count(c -> c == 'k', parts[2]) + return k_count +end + +input_file = ARGS[1] +input_file_onesided = ARGS[2] +df = CSV.read(input_file, DataFrame) +df2 = CSV.read(input_file_onesided, DataFrame) + + +df_filt = filter(:process_name => x -> proc_to_n(x) >= 1 && proc_to_n(x) <= 7, df) +df_filt.process_size = @. proc_to_n(df_filt.process_name) + +df_filt2 = filter(:process_name => x -> proc_to_n(x) >= 1 && proc_to_n(x) <= 7, df2) +df_filt2.process_size = @. proc_to_n(df_filt2.process_name) + + +# graph size +title_string = "n-photon Compton reduced graph size" + +@df df_filt scatter(:process_size, :graph_nodes_reduced, label = "nodes, two-sided generation", markershape = :circle) +@df df_filt2 scatter!(:process_size, :graph_nodes_reduced, label = "nodes, one-sided generation", markershape = :square) + +plot!( + title = title_string, + yscale = :log10, + legend = :outerbottom, + yminorgrid = true, + xticks = :process_size, + yticks = [1e1, 1e2, 1e3, 1e4, 1e5, 1e6], + xgrid = false, + xminorticks = false, + legendcolumns = 2, + legend_font_pointsize = 10, + size = (800, 600), + ylabel = "(#)", + xlabel = "process size (#)", +) + +savefig("compton_diagram_gen_comparison.pdf") diff --git a/data/evaluate_gpu.jl b/data/evaluate_gpu.jl new file mode 100644 index 0000000..ae0084b --- /dev/null +++ b/data/evaluate_gpu.jl @@ -0,0 +1,130 @@ +using CSV +using DataFrames +using Plots +using StatsPlots +using LaTeXStrings + +if (length(ARGS) < 1) + println("Please use with \"input_file.csv\"") +end + +processes = [ + "QED Process: 'ke->ke'", + "QED Process: 'ke->kke'", + "QED Process: 'ke->kkke'", + "QED Process: 'ke->kkkke'", + "QED Process: 'ke->kkkkke'", + "ABC Process: 'AB->AB'", + "ABC Process: 'AB->ABBB'", + "ABC Process: 'AB->ABBBBB'", +] + +function proc_to_n(str::AbstractString) + parts = split(str, "'") + parts = split(parts[2], "->") + k_count = count(c -> c == 'k', parts[2]) + return k_count +end + +function beautify_title(str::AbstractString) + parts = split(str, "'") + + preprefix = parts[1] + infix = parts[2] + sufsuffix = parts[3] + + parts = split(infix, "->") + + prefix = parts[1] + suffix = parts[2] + + k_count = count(c -> c == 'k', suffix) + B_count = count(c -> c == 'B', suffix) + + if k_count == 1 || B_count == 1 + new_suffix = suffix + elseif k_count >= 1 + new_suffix = replace(suffix, r"k+" => "k^$k_count") + elseif B_count >= 1 + new_suffix = replace(suffix, r"B+" => "B^$B_count") + end + + return preprefix * L"%$prefix \rightarrow %$new_suffix" * sufsuffix +end + +input_file = ARGS[1] +df = CSV.read(input_file, DataFrame) +n_inputs = df[:, "n_inputs"][1] +gpu_name = df[:, "gpu_name"][1] +if (gpu_name == "") + println("Results file did not execute everything on GPU! (or didn't write gpu name)") + exit(0) +end + +# plotting with process size as x axis +title_string = "GPU $gpu_name, $n_inputs samples" + +df_filt = filter(:process_name => x -> proc_to_n(x) >= 1, df) +df_filt.gpu_rate = df_filt.gpu_rate +df_filt.gpu_time = df_filt.gpu_time +df_filt.gpu_gflops = df_filt.gpu_gflops + +df_filt.process_size = @. proc_to_n(df_filt.process_name) + +df_no_opt = filter(:process_name => x -> match(r" not optimized$", x) !== nothing, df_filt) +df_red = filter(:process_name => x -> match(r" reduced$", x) !== nothing, df_filt) + +@df df_no_opt scatter(:process_size, :gpu_rate, label = "unoptimized function execution rate", markersize = 7) +@df df_red scatter!(:process_size, :gpu_rate, label = "reduced function execution rate", markersize = 7) + +plot!( + #title = title_string * ", sample rate", + yscale = :log10, + legend = :outerbottom, + xticks = [1, 2, 3, 4, 5], + legendcolumns = 2, + legend_font_pointsize = 10, + size = (800, 600), + ylabel = "rate (" * L"s^{-1}" * ")", + xlabel = "process size (#)", +) + +savefig("gpu_rate_$(gpu_name).pdf") + + + +@df df_no_opt scatter(:process_size, :gpu_time, label = "unoptimized function execution time", markersize = 7) +@df df_red scatter!(:process_size, :gpu_time, label = "reduced function execution time", markersize = 7) + +plot!( + #title = title_string * ", execution time", + yscale = :log10, + legend = :outerbottom, + xticks = [1, 2, 3, 4, 5], + legendcolumns = 2, + legend_font_pointsize = 10, + size = (800, 600), + ylabel = "time (s)", + xlabel = "process size (#)", +) + +savefig("gpu_times_$(gpu_name).pdf") + + + +@df df_no_opt scatter(:process_size, :gpu_gflops, label = "unoptimized function", markersize = 7) +@df df_red scatter!(:process_size, :gpu_gflops, label = "reduced function", markersize = 7) + +plot!( + #title = title_string * ", GFLOPS", + yscale = :linear, + legend = :outerbottom, + xticks = [1, 2, 3, 4, 5], + legendcolumns = 2, + legend_font_pointsize = 10, + size = (800, 600), + ylabel = "performance (GFLOPS)", + xlabel = "process size (#)", +) + +savefig("gpu_perf_$(gpu_name).pdf") diff --git a/data/evaluate_reduce_bench.jl b/data/evaluate_reduce_bench.jl new file mode 100644 index 0000000..dc0b33a --- /dev/null +++ b/data/evaluate_reduce_bench.jl @@ -0,0 +1,279 @@ +using Plots +using StatsPlots +using CSV +using DataFrames +using LaTeXStrings + + +if (length(ARGS) < 2) + println("Please use with \"input_file.csv\" \"input_file_gpu.csv\"") +end + + +function proc_to_n(str::AbstractString) + parts = split(str, "'") + parts = split(parts[2], "->") + k_count = count(c -> c == 'k', parts[2]) + return k_count +end + +function beautify_title(str::AbstractString) + parts = split(str, "->") + + prefix = parts[1] + suffix = parts[2] + + k_count = count(c -> c == 'k', suffix) + B_count = count(c -> c == 'B', suffix) + + if k_count == 1 || B_count == 1 + new_suffix = suffix + elseif k_count >= 1 + new_suffix = replace(suffix, r"k+" => "k^$k_count") + elseif B_count >= 1 + new_suffix = replace(suffix, r"B+" => "B^$B_count") + end + + return L"%$prefix \rightarrow %$new_suffix" +end + +processes = ["ke->ke", "ke->kke", "ke->kkke", "ke->kkkke", "ke->kkkkke", "AB->AB", "AB->ABBB", "AB->ABBBBB"] + +input_file = ARGS[1] +input_file_gpu = ARGS[2] +df = CSV.read(input_file, DataFrame) +df_gpu = CSV.read(input_file_gpu, DataFrame) +n_inputs = 2^20 + +#= +for process in processes + df_filt = filter(:process => x -> x == process, df) + df_filt_gpu = filter(:process => x -> x == process, df_gpu) + + # add dummy factors to get the numbers in similar orders of magnitude + df_filt.cumulative_optimization_time = df_filt.cumulative_optimization_time .* 1e4 + df_filt_gpu.cumulative_optimization_time = df_filt_gpu.cumulative_optimization_time .* 1e4 + df_filt_gpu.gpu_t = df_filt_gpu.gpu_t .* 1e3 + + cpu = !isempty(df_filt) + gpu = !isempty(df_filt_gpu) + + ymax = 0.0 + + if cpu + @df df_filt scatter( + :operations, + :cumulative_optimization_time, + label = "Cumulative Optimization Time (x10000) (s)", + markersize = 4, + ) + ymax = max(df_filt[!, :cpu_st_t]..., df_filt[!, :cumulative_optimization_time]...) * 1.1 * 1e4 + @df df_filt scatter!( + :operations, + :cpu_st_t, + label = "Single-Threaded Execution (s)", + markersize = 4, + markershape = :square, + ) + end + + if gpu + if !cpu + @df df_filt_gpu scatter( + :operations, + :cumulative_optimization_time, + label = "Cumulative Optimization Time (x10000) (s)", + markersize = 4, + ) + ymax = max(df_filt_gpu[!, :gpu_t]..., df_filt_gpu[!, :cumulative_optimization_time]...) * 1.1 * 1e4 + end + + @df df_filt_gpu scatter!( + :operations, + :gpu_t, + label = "GPU Execution (x1000) (s)", + markersize = 4, + markershape = :diamond, + ) + end + + if cpu || gpu + plot!( + title = ("$(beautify_title(process)) Reduction Progression ($(n_inputs) Inputs)"), + xscale = :linear, + yscale = :linear, + #ylim = (0, ymax), + legend = :outerbottom, + minorgrid = true, + xticks = :process_size, + #yticks = [1e-3, 1e-1, 1e1, 1e3], + xgrid = false, + xminorticks = false, + legendcolumns = 1, + legend_font_pointsize = 12, + fontsize = 12, + size = (800, 600), + xlabel = "optimizer steps (#)", + ylabel = "time (s)", + ) + + savefig("$(String(process))_reduction_bench.pdf") + end +end + + +# ABC vs QED +AB_process = "AB->ABBB" +abc_label = "\$A + B \\rightarrow A + 3B\$" + +QED_process = "ke->kkkke" +qed_label = "\$e^- + \\gamma \\rightarrow e^- + 4\\gamma\$" + +df_filt_AB = filter(:process => x -> x == AB_process, df) +df_filt_QED = filter(:process => x -> x == QED_process, df) + +max_AB = max(df_filt_AB[!, :operations]...) +max_QED = max(df_filt_QED[!, :operations]...) + +df_filt_AB.reduction_progress = df_filt_AB.operations ./ max_AB .* 100.0 +df_filt_QED.reduction_progress = df_filt_QED.operations ./ max_QED .* 100.0 + +df_filt_AB.relative_performance = df_filt_AB.cpu_st_t ./ df_filt_AB[!, :cpu_st_t][1] .* 100.0 +df_filt_QED.relative_performance = df_filt_QED.cpu_st_t ./ df_filt_QED[!, :cpu_st_t][1] .* 100.0 + +@df df_filt_AB scatter(:reduction_progress, :relative_performance, label = abc_label, markersize = 4) +@df df_filt_QED scatter!(:reduction_progress, :relative_performance, label = qed_label, markersize = 4) + +plot!( + #title = ("Relative Performance of $(beautify_title(QED_process)) versus $(beautify_title(AB_process)) on CPU"), + xscale = :linear, + yscale = :linear, + #ylim = (0, ymax), + legend = :outerbottom, + minorgrid = true, + xticks = :process_size, + #yticks = [1e-3, 1e-1, 1e1, 1e3], + xgrid = false, + xminorticks = false, + legendcolumns = 1, + legend_font_pointsize = 12, + fontsize = 12, + size = (800, 600), + xlabel = "reduction progress (%)", + ylabel = "relative time taken (%)", +) + +savefig("reduction_bench_relative.pdf") + + +# ABC vs QED on GPU +AB_process = "AB->ABBB" +abc_label = "\$A + B \\rightarrow A + 3B\$" + +QED_process = "ke->kkkke" +qed_label = "\$e^- + \\gamma \\rightarrow e^- + 4\\gamma\$" + +df_filt_AB = filter(:process => x -> x == AB_process, df_gpu) +df_filt_QED = filter(:process => x -> x == QED_process, df_gpu) + +max_AB = max(df_filt_AB[!, :operations]...) +max_QED = max(df_filt_QED[!, :operations]...) + +df_filt_AB.reduction_progress = df_filt_AB.operations ./ max_AB .* 100.0 +df_filt_QED.reduction_progress = df_filt_QED.operations ./ max_QED .* 100.0 + +df_filt_AB.relative_performance = df_filt_AB.gpu_t ./ df_filt_AB[!, :gpu_t][1] .* 100.0 +df_filt_QED.relative_performance = df_filt_QED.gpu_t ./ df_filt_QED[!, :gpu_t][1] .* 100.0 + +df_filt_AB.relative_std = df_filt_AB.gpu_s ./ df_filt_AB[!, :gpu_t][1] .* 100.0 +df_filt_QED.relative_std = df_filt_QED.gpu_s ./ df_filt_QED[!, :gpu_t][1] .* 100.0 + +@df df_filt_AB scatter( + :reduction_progress, + :relative_performance, + yerror = :relative_std, + label = abc_label, + markersize = 4, +) +@df df_filt_QED scatter!( + :reduction_progress, + :relative_performance, + yerror = :relative_std, + label = qed_label, + markersize = 4, +) + +plot!( + #title = "Relative Performance of $(beautify_title(QED_process)) versus $(beautify_title(AB_process)) on GPU (A100)", + xscale = :linear, + yscale = :linear, + #ylim = (0, ymax), + legend = :outerbottom, + minorgrid = true, + xticks = :process_size, + #yticks = [1e-3, 1e-1, 1e1, 1e3], + xgrid = false, + xminorticks = false, + legendcolumns = 1, + legend_font_pointsize = 12, + fontsize = 12, + size = (800, 600), + xlabel = "reduction progress (%)", + ylabel = "relative time taken (%)", +) + +savefig("reduction_bench_relative_gpu.pdf") +=# + +QED_process = "ke->kkke" +QED_label = "\$\\e^- + \\gamma \\rightarrow \\e^- + 3\\gamma\$" + +df_filt_QED_GPU = filter(:process => x -> x == QED_process, df_gpu) +df_filt_QED_CPU = filter(:process => x -> x == QED_process, df) + +max_QED = max(df_filt_QED_CPU[!, :operations]...) + +df_filt_QED_GPU.reduction_progress = df_filt_QED_GPU.operations ./ max_QED .* 100.0 +df_filt_QED_CPU.reduction_progress = df_filt_QED_CPU.operations ./ max_QED .* 100.0 + +df_filt_QED_GPU.relative_performance = df_filt_QED_GPU.gpu_t ./ df_filt_QED_GPU[!, :gpu_t][1] .* 100.0 +df_filt_QED_CPU.relative_performance = df_filt_QED_CPU.cpu_st_t ./ df_filt_QED_CPU[!, :cpu_st_t][1] .* 100.0 + +df_filt_QED_GPU.relative_std = df_filt_QED_GPU.gpu_s ./ df_filt_QED_GPU[!, :gpu_t][1] .* 100.0 +df_filt_QED_CPU.relative_std = df_filt_QED_CPU.cpu_st_s ./ df_filt_QED_CPU[!, :cpu_st_t][1] .* 100.0 + +@df df_filt_QED_CPU scatter( + :reduction_progress, + :relative_performance, + yerror = :relative_std, + label = "CPU relative time taken (%)", + markersize = 4, +) +@df df_filt_QED_GPU scatter!( + :reduction_progress, + :relative_performance, + yerror = :relative_std, + label = "GPU relative time taken (%)", + markersize = 4, +) + +plot!( + #title = "Relative Performance of $(beautify_title(QED_process)) on CPU versus GPU", + xscale = :linear, + yscale = :linear, + ylim = (0, :auto), + legend = :outerbottom, + minorgrid = true, + xticks = :process_size, + #yticks = [1e-3, 1e-1, 1e1, 1e3], + xgrid = false, + xminorticks = false, + legendcolumns = 1, + legend_font_pointsize = 12, + fontsize = 12, + size = (800, 600), + xlabel = "reduction progress (%)", + ylabel = "relative time taken (%)", +) + +savefig("reduction_bench_relative_cpu_vs_gpu.pdf") diff --git a/data/qed_ke-kke_reduction_optimizer.csv b/data/qed_ke-kke_reduction_optimizer.csv deleted file mode 100644 index 794ca46..0000000 --- a/data/qed_ke-kke_reduction_optimizer.csv +++ /dev/null @@ -1,16 +0,0 @@ -operations,graph_nodes,graph_edges,graph_ce,graph_dt,graph_ci,gen_func_t,cpu_compile_t,cpu_st_t,cpu_mt_t,gpu_compile_t,gpu_t -0,77,101,252.0,6240.0,0.04038461538461539,0.02087051,8.691e-6,3.405098066,0.244763721,1.565749515,0.936213163 -1,76,99,246.0,6240.0,0.03942307692307692,0.020658734,9.36e-6,3.244313848,0.230460257,1.548012602,0.887605389 -2,75,97,240.0,6240.0,0.038461538461538464,0.045333482,8.74e-6,3.163679857,0.217614064,1.52780456,0.816496837 -3,74,95,234.0,6240.0,0.0375,0.020314034,9.081e-6,2.956421016,0.183415997,1.524262179,0.793770075 -4,73,93,228.0,6240.0,0.03653846153846154,0.033579409,8.52e-6,2.845414866,0.19168374,1.50907807,0.742734411 -5,72,92,228.0,6144.0,0.037109375,0.019736718,8.87e-6,2.827109937,0.207452606,1.497203204,0.719774022 -6,71,90,222.0,6144.0,0.0361328125,0.043612693,1.01e-5,2.62776692,0.166492497,1.602060948,0.668929854 -7,70,89,222.0,6048.0,0.03670634920634921,0.042731148,1.053e-5,2.631288029,0.185812224,1.514154792,0.694503947 -8,69,87,216.0,6048.0,0.03571428571428571,0.042148711,8.19e-6,2.493343257,0.183595081,1.506478504,0.652420896 -9,68,86,216.0,5952.0,0.036290322580645164,0.041568955,8.571e-6,2.487317627,0.147773078,1.472141844,0.653143947 -10,67,85,216.0,5856.0,0.036885245901639344,0.041307868,9.13e-6,2.491634709,0.175728138,1.482162906,0.63058774 -11,66,84,216.0,5760.0,0.0375,0.041265756,8.43e-6,2.516916643,0.180420842,1.463053866,0.650627815 -12,65,83,205.0,5760.0,0.035590277777777776,0.039711293,9.22e-6,2.479664249,0.178013433,1.459566956,0.652477867 -13,64,82,205.0,5664.0,0.03619350282485876,0.030866093,8.87e-6,2.485424881,0.179983608,1.564961227,0.647932468 -14,63,81,205.0,5568.0,0.03681752873563218,0.029946916,8.93e-6,2.469922022,0.179443854,1.485935831,0.651804318 diff --git a/data/qed_ke-kkke_greedy_optimizer_GlobalMetricEstimator().csv b/data/qed_ke-kkke_greedy_optimizer_GlobalMetricEstimator().csv deleted file mode 100644 index eb191bd..0000000 --- a/data/qed_ke-kkke_greedy_optimizer_GlobalMetricEstimator().csv +++ /dev/null @@ -1,176 +0,0 @@ -operations,graph_nodes,graph_edges,graph_ce,graph_dt,graph_ci,gen_func_t,cpu_compile_t,cpu_st_t,cpu_mt_t,gpu_compile_t,gpu_t -0,356,493,1399.0,30528.0,0.0458267819706499,0.077070556,2.6761e-5,17.804336617,0.960385595,10.618577031,4.95440474 -1,354,491,1399.0,30432.0,0.04597134595162986,1.030851104,2.37e-5,17.726472964,0.933074463,2.174912444,4.959474851 -2,352,489,1399.0,30336.0,0.04611682489451477,0.376282553,2.3861e-5,17.935912907,0.968087391,2.238665483,4.912705328 -3,350,487,1399.0,30240.0,0.04626322751322751,0.076651194,4.2451e-5,17.976779783,0.977130996,2.246167674,4.954520005 -4,348,485,1399.0,30144.0,0.04641056263269639,0.223709216,2.8031e-5,17.67129111,0.97799748,2.175788856,4.923999491 -5,346,483,1399.0,30048.0,0.04655883919062833,0.076034997,4.3191e-5,17.766336956,0.967055891,2.187609178,4.922574669 -6,344,481,1399.0,29952.0,0.04670806623931624,0.398917781,4.3422e-5,17.709032771,0.971142926,2.170963978,4.917191185 -7,342,479,1399.0,29856.0,0.04685825294748124,0.352569343,4.3801e-5,17.690255833,0.952966242,2.159295978,4.945842152 -8,340,477,1399.0,29760.0,0.04700940860215054,0.117620751,4.2992e-5,17.905787431,0.749896479,2.19940915,4.922882222 -9,338,475,1399.0,29664.0,0.04716154261057174,0.318053898,2.3481e-5,17.522775542,0.745113955,2.202366151,4.928734427 -10,336,473,1399.0,29568.0,0.047314664502164504,0.184069985,2.3381e-5,17.529935879,0.74637911,2.238397648,4.919919125 -11,334,471,1399.0,29472.0,0.047468783930510315,0.086029218,2.365e-5,17.560859257,0.75559668,2.249242933,4.956561058 -12,332,469,1399.0,29376.0,0.04762391067538126,0.077326472,2.4361e-5,17.559317648,0.746726769,2.1818156,4.938490196 -13,330,467,1399.0,29280.0,0.047780054644808743,0.169738661,2.342e-5,17.517109121,0.751453942,2.187781478,4.923659727 -14,328,465,1399.0,29184.0,0.047937225877192985,0.077817676,2.315e-5,17.533304215,0.745481303,2.209343496,4.960503415 -15,326,463,1399.0,29088.0,0.04809543454345434,0.171584444,2.352e-5,17.579912576,0.754778436,2.210370024,4.934281254 -16,324,461,1399.0,28992.0,0.04825469094922737,0.084223667,2.305e-5,17.570464754,0.751290178,2.22797709,4.939806799 -17,322,459,1399.0,28896.0,0.04841500553709856,0.123005102,2.3661e-5,17.605650973,0.756929676,2.269940175,4.937928844 -18,320,457,1399.0,28800.0,0.04857638888888889,0.086677986,2.37e-5,17.5539199,0.746367967,2.264938904,4.959258096 -19,318,455,1399.0,28704.0,0.04873885172798216,0.12293158,2.3711e-5,17.609395222,0.755783994,2.264754078,4.92827168 -20,316,453,1399.0,28608.0,0.04890240492170023,0.124475123,2.4281e-5,17.597716228,0.75106304,2.20218749,4.933120236 -21,314,451,1399.0,28512.0,0.04906705948372615,0.112172177,2.6391e-5,17.623178954,0.755694751,2.186417905,4.921509117 -22,312,449,1399.0,28416.0,0.04923282657657658,0.219362642,2.321e-5,17.593459902,0.747914841,2.168628993,4.952994795 -23,310,447,1399.0,28320.0,0.049399717514124294,0.080729209,2.358e-5,17.571675834,0.755489634,2.209531477,4.951190234 -24,308,445,1399.0,28224.0,0.049567743764172334,0.080235835,2.3271e-5,17.615791747,0.750314688,2.21464245,4.949496195 -25,306,443,1399.0,28128.0,0.049736916951080776,0.124106403,2.374e-5,17.60716179,0.753826187,2.186184237,4.920128786 -26,304,441,1399.0,28032.0,0.04990724885844749,0.080715608,2.3781e-5,17.581988477,0.750266997,2.209826064,4.937813884 -27,302,439,1399.0,27936.0,0.05007875143184422,0.080606465,2.4071e-5,17.633096607,0.749125265,2.198599437,4.935320693 -28,300,437,1399.0,27840.0,0.0502514367816092,0.081056137,2.3781e-5,17.564695624,0.746230293,2.225110355,4.939656214 -29,298,435,1399.0,27744.0,0.05042531718569781,0.096545225,2.379e-5,17.58144781,0.747458632,2.263551336,4.924245431 -30,296,433,1399.0,27648.0,0.050600405092592594,0.120638697,2.383e-5,17.574370836,0.748933285,2.234417803,4.915183371 -31,294,431,1399.0,27552.0,0.0507767131242741,0.125073582,2.393e-5,17.627352699,0.754384428,2.214199106,4.938130459 -32,292,429,1399.0,27456.0,0.05095425407925408,0.12314953,2.468e-5,17.697160429,0.796488763,2.261473826,4.956976138 -33,290,427,1399.0,27360.0,0.051133040935672516,0.125481487,2.354e-5,17.636971006,0.748416796,2.222200724,4.948970096 -34,288,425,1399.0,27264.0,0.051313086854460094,0.094052012,2.4301e-5,17.62971842,0.805139938,2.205015347,4.959455536 -35,286,423,1399.0,27168.0,0.051494405182567725,0.08136377,2.4041e-5,17.621304482,0.747718686,2.244362062,4.941432169 -36,284,421,1399.0,27072.0,0.05167700945626478,0.080217839,2.3921e-5,17.61427713,0.747754586,2.212103901,4.933185029 -37,282,417,1399.0,26976.0,0.051860913404507714,0.126372199,2.376e-5,17.601417663,0.750036789,2.163344775,4.926698186 -38,280,414,1399.0,26880.0,0.052046130952380955,0.125444544,2.476e-5,17.612452443,0.748155225,2.195259021,4.91594575 -39,278,412,1399.0,26784.0,0.05223267622461171,0.083158944,2.4551e-5,17.599589645,0.741671021,2.208064301,4.9351555 -40,276,410,1399.0,26688.0,0.05242056354916067,0.083321959,2.4101e-5,17.567124159,0.748238012,2.197233222,4.954754226 -41,274,408,1399.0,26592.0,0.052609807460890494,0.084803792,2.3901e-5,17.549365204,0.754817994,2.229499405,4.94957165 -42,272,405,1399.0,26496.0,0.05280042270531401,0.127648261,2.3851e-5,17.582852416,0.750759497,2.230398721,4.937220319 -43,270,401,1399.0,26400.0,0.052992424242424244,0.128445184,2.428e-5,17.596647819,0.75777713,2.160922996,4.937371146 -44,268,399,1399.0,26304.0,0.053185827250608275,0.129526096,2.5081e-5,17.594476326,0.746906342,2.219401891,4.93357998 -45,266,397,1399.0,26208.0,0.05338064713064713,0.129819495,2.4731e-5,17.568331366,0.750368555,2.18948505,4.922275732 -46,264,394,1399.0,26112.0,0.05357689950980392,0.087649075,2.462e-5,17.585414218,0.751605626,2.198684054,4.941424565 -47,262,391,1399.0,26016.0,0.05377460024600246,0.089110637,2.4551e-5,17.614139291,0.750622403,2.168793662,4.953321773 -48,260,389,1399.0,25920.0,0.053973765432098766,0.090307061,2.45e-5,17.633806293,0.749096576,2.224521298,4.930813246 -49,258,387,1399.0,25824.0,0.054174411400247834,0.133480181,2.461e-5,17.634768586,0.756613261,2.201452177,4.972809945 -50,256,385,1399.0,25728.0,0.05437655472636816,0.134254424,2.425e-5,17.606323938,0.748779206,2.216818872,4.939295094 -51,254,382,1399.0,25632.0,0.05458021223470662,0.134016868,2.4531e-5,17.5926305,0.75625873,2.227679889,4.968213894 -52,252,379,1399.0,25536.0,0.054785401002506263,0.135650945,2.4601e-5,17.642803637,0.751975585,2.226011125,4.9285844 -53,250,375,1399.0,25440.0,0.054992138364779876,0.136647933,2.4161e-5,17.799738254,0.76667472,2.165144989,4.930427128 -54,248,373,1399.0,25344.0,0.05520044191919192,0.123103164,2.4461e-5,17.745879754,0.760526742,2.161495227,4.940492285 -55,246,370,1399.0,25248.0,0.05541032953105197,0.09476826,2.3511e-5,17.596131758,0.756924114,2.180021837,4.954121771 -56,244,365,1399.0,25152.0,0.05562181933842239,0.095345787,2.4171e-5,17.612023424,0.747989147,2.215139082,4.945396527 -57,242,362,1399.0,25056.0,0.05583492975734355,0.139570128,2.3801e-5,17.630922372,0.750668446,2.186529739,4.961981394 -58,240,359,1399.0,24960.0,0.05604967948717949,0.097466916,2.4451e-5,17.61078772,0.7485922,2.217673752,4.95291513 -59,238,357,1399.0,24864.0,0.05626608751608752,0.138599302,2.3601e-5,17.586404505,0.756929027,2.233374301,4.935342135 -60,236,352,1399.0,24768.0,0.05648417312661499,0.147210964,2.4911e-5,17.650436019,0.74908103,2.157077946,4.937714591 -61,234,350,1399.0,24672.0,0.05670395590142672,0.099491094,2.3601e-5,17.608002511,0.756924473,2.165309665,4.932434479 -62,232,348,1399.0,24576.0,0.056925455729166664,0.141929827,2.454e-5,17.605756917,0.749178717,2.234082435,4.957629943 -63,230,344,1399.0,24480.0,0.057148692810457515,0.142483983,2.4211e-5,17.623883273,0.758216784,2.210078838,4.930940098 -64,228,341,1399.0,24384.0,0.057373687664041995,0.101524943,2.4371e-5,17.662312587,0.751128917,2.22449657,4.96708528 -65,226,339,1399.0,24288.0,0.05760046113306983,0.102619253,2.3831e-5,17.610112922,0.758167777,2.187456785,4.957519684 -66,224,337,1399.0,24192.0,0.05782903439153439,0.10351088,2.3401e-5,17.611932402,0.749178457,2.236980212,4.933450322 -67,222,335,1399.0,24096.0,0.05805942895086321,0.148780402,2.3711e-5,17.636035095,0.75707833,2.252138664,4.951632995 -68,220,333,1399.0,24000.0,0.058291666666666665,0.148311059,2.4851e-5,17.617252052,0.750104986,2.22330739,4.9243139 -69,218,329,1399.0,23904.0,0.05852576974564926,0.151678794,2.4181e-5,17.627742278,0.755299894,2.248062201,4.951401482 -70,216,326,1399.0,23808.0,0.05876176075268817,0.15082361,2.3851e-5,17.647410652,0.752445605,2.240948426,4.949599133 -71,214,323,1399.0,23712.0,0.05899966261808367,0.153382492,2.4011e-5,17.654743596,0.752802907,2.253819342,4.966250371 -72,212,320,1399.0,23616.0,0.05923949864498645,0.151516131,2.3931e-5,17.672908543,0.750257716,2.220003155,4.944782327 -73,210,317,1399.0,23520.0,0.059481292517006804,0.154244628,2.386e-5,17.60330678,0.750422813,2.211295295,4.943727837 -74,208,313,1399.0,23424.0,0.05972506830601093,0.153767234,2.4291e-5,17.640950842,0.74988433,2.24794966,4.952712228 -75,206,311,1399.0,23328.0,0.05997085048010974,0.155927375,2.406e-5,17.589128666,0.749120129,2.253801308,4.953014816 -76,204,306,1399.0,23232.0,0.06021866391184573,0.15464184,2.4521e-5,17.662616581,0.750484429,2.227511412,4.924026259 -77,202,304,1399.0,23136.0,0.06046853388658368,0.157807248,2.4041e-5,17.611953814,0.755679546,2.178734374,4.943974526 -78,200,301,1399.0,23040.0,0.06072048611111111,0.155978707,2.4051e-5,17.624250437,0.794935481,2.247188963,4.940403894 -79,198,298,1399.0,22944.0,0.06097454672245467,0.158377905,2.5091e-5,17.634938402,0.754743461,2.245248812,4.919902064 -80,196,296,1399.0,22848.0,0.061230742296918765,0.158750786,2.4511e-5,17.6360904,0.750867213,2.200032233,4.942215648 -81,194,293,1399.0,22752.0,0.061489099859353025,0.161152794,2.4831e-5,17.780761042,0.765338482,2.204873372,4.939655562 -82,192,290,1399.0,22656.0,0.061749646892655365,0.160175486,2.318e-5,17.798147683,0.76168194,2.230891056,4.955801153 -83,190,287,1399.0,22560.0,0.06201241134751773,0.159868767,2.4791e-5,17.764165058,0.796377137,2.239618185,4.928054627 -84,188,283,1399.0,22464.0,0.06227742165242165,0.160933577,2.4221e-5,17.798426962,0.848255338,2.218112612,4.932433146 -85,186,280,1399.0,22368.0,0.06254470672389127,0.163393917,2.4371e-5,17.808464853,0.765692696,2.213490844,4.943298137 -86,184,277,1399.0,22272.0,0.06281429597701149,0.163792118,2.4261e-5,17.805783627,0.761027705,2.232891092,4.919454211 -87,182,275,1399.0,22176.0,0.06308621933621934,0.162177953,2.43e-5,17.797665375,0.761040026,2.236586089,4.951072155 -88,180,271,1399.0,22080.0,0.06336050724637682,0.165377424,2.557e-5,17.805099359,0.763146286,2.212611436,4.921150887 -89,178,268,1399.0,21984.0,0.06363719068413391,0.166754373,2.5141e-5,17.770997205,0.764361801,2.199943181,4.934748884 -90,176,266,1399.0,21888.0,0.06391630116959064,0.167241957,2.4571e-5,17.770223198,0.759580227,2.247867501,4.935730147 -91,174,264,1399.0,21792.0,0.06419787077826726,0.169623073,2.5e-5,17.771153368,0.750276145,2.243455929,4.939933808 -92,172,261,1399.0,21696.0,0.06448193215339233,0.168358288,2.5181e-5,17.799224982,0.760906435,2.210000929,4.943923374 -93,170,259,1399.0,21600.0,0.06476851851851852,0.170287483,2.529e-5,17.79271252,0.763151029,2.205444892,4.924953813 -94,168,254,1399.0,21504.0,0.06505766369047619,0.168986856,2.5021e-5,17.775583682,0.760237647,2.222811993,4.951301097 -95,166,250,1399.0,21408.0,0.06534940209267563,0.171662521,2.4401e-5,17.636022254,0.749599438,2.234944605,4.958431762 -96,164,246,1399.0,21312.0,0.06564376876876876,0.170911431,2.4481e-5,17.633556045,0.788097892,2.198060879,4.922871993 -97,162,244,1399.0,21216.0,0.06594079939668175,0.172387252,2.4781e-5,17.620254381,0.799269067,2.202436673,4.936411908 -98,160,241,1399.0,21120.0,0.0662405303030303,0.171830017,2.581e-5,17.656653806,0.750275098,2.200933622,4.94776375 -99,158,238,1399.0,21024.0,0.06654299847792998,0.174560093,2.447e-5,17.625724723,0.756745741,2.249721096,4.958786002 -100,156,235,1399.0,20928.0,0.06684824159021406,0.178996759,2.453e-5,17.669194606,0.749422535,2.218089817,4.960858653 -101,154,231,1399.0,20832.0,0.0671562980030722,0.175032127,2.3871e-5,17.642586975,0.754643863,2.194675279,4.944134534 -102,152,229,1399.0,20736.0,0.06746720679012345,0.176393906,2.4731e-5,17.592973556,0.749943551,2.229565622,4.927935661 -103,150,225,1399.0,20640.0,0.06778100775193799,0.178017631,2.412e-5,17.630568322,0.755272802,2.221125776,4.952348991 -104,148,223,1399.0,20544.0,0.0680977414330218,0.175897841,2.36e-5,17.661766307,0.749293633,2.2201698,4.963634779 -105,146,221,1399.0,20448.0,0.06841744913928012,0.178367362,2.5001e-5,17.654508999,0.755361234,2.185187066,4.938710949 -106,144,218,1399.0,20352.0,0.06874017295597484,0.178791594,2.502e-5,17.649520916,0.749748217,2.238645461,4.955141284 -107,142,216,1399.0,20256.0,0.06906595576619273,0.175900502,2.3291e-5,17.648252045,0.755157659,2.250102545,4.948078116 -108,140,212,1399.0,20160.0,0.06939484126984127,0.180050739,2.3901e-5,17.642556024,0.751139061,2.195233955,4.92102672 -109,138,210,1399.0,20064.0,0.06972687400318979,0.182587052,2.492e-5,17.631301401,0.754040144,2.177296385,4.948297571 -110,136,207,1399.0,19968.0,0.07006209935897435,0.181449712,2.4401e-5,17.618787463,0.748940439,2.251932822,4.950366155 -111,134,203,1399.0,19872.0,0.07040056360708534,0.183466877,2.407e-5,17.658532693,0.756589176,2.240568188,4.97337861 -112,132,201,1399.0,19776.0,0.0707423139158576,0.181545084,2.485e-5,17.63441504,0.751343023,2.183033772,4.975534251 -113,130,199,1399.0,19680.0,0.07108739837398374,0.177809314,2.417e-5,17.627163359,0.754577307,2.211080446,4.977438563 -114,128,195,1399.0,19584.0,0.07143586601307189,0.183038393,2.5541e-5,17.63366534,0.751510139,2.237832092,4.969644912 -115,126,191,1399.0,19488.0,0.07178776683087028,0.186344151,2.4971e-5,17.711808739,0.759177,2.236586017,4.951292022 -116,124,187,1399.0,19392.0,0.07214315181518152,0.184833587,2.475e-5,17.648467279,0.749564641,2.179772409,4.97017709 -117,122,183,1399.0,19296.0,0.07250207296849089,0.193249355,2.3811e-5,17.639230223,0.755564354,2.195109482,4.982434629 -118,120,180,1399.0,19200.0,0.07286458333333333,0.186818046,2.372e-5,17.635977046,0.750626058,2.243877912,4.972608068 -119,118,177,1399.0,19104.0,0.07323073701842546,0.189204719,2.4961e-5,17.791522288,0.766082656,2.242948358,4.980365418 -120,116,173,1399.0,19008.0,0.07360058922558922,0.186391669,2.4181e-5,17.645956891,0.750893368,2.197914806,4.98745469 -121,114,171,1399.0,18912.0,0.07397419627749577,0.19060573,2.4701e-5,17.771140583,0.765197694,2.20643796,4.959618561 -122,112,169,1399.0,18816.0,0.0743516156462585,0.188466188,2.381e-5,17.795228145,0.759434429,2.26208531,4.965068853 -123,110,165,1399.0,18720.0,0.07473290598290598,0.191524927,2.3841e-5,17.779734215,0.767242896,2.242967333,4.950554681 -124,108,161,1399.0,18624.0,0.07511812714776632,0.189450326,2.3601e-5,17.807849571,0.762371273,2.196711688,4.966122065 -125,106,157,1399.0,18528.0,0.0755073402417962,0.191473057,2.357e-5,17.632877767,0.755845465,2.188474891,4.977562868 -126,104,153,1399.0,18432.0,0.0759006076388889,0.191382079,2.3851e-5,17.775729988,0.758861116,2.278116886,4.979965119 -127,102,151,1399.0,18336.0,0.07629799301919721,0.192296369,2.394e-5,17.777918793,0.764981303,2.224818047,4.949944943 -128,100,149,1399.0,18240.0,0.07669956140350877,0.191424719,2.4331e-5,17.856475915,0.76057459,2.201588049,4.941974925 -129,98,146,1399.0,18144.0,0.07710537918871252,0.194280932,2.3951e-5,17.779963845,0.766401736,2.223182601,4.961465017 -130,96,142,1399.0,18048.0,0.07751551418439716,0.192850597,2.3861e-5,17.765033828,0.760509569,2.250897799,4.967399083 -131,94,138,1399.0,17952.0,0.07793003565062388,0.194741823,2.38e-5,17.778261696,0.764271609,2.248898068,4.975998565 -132,92,136,1399.0,17856.0,0.07834901433691756,0.193567295,2.5281e-5,17.791322862,0.759809249,2.216694812,4.962092553 -133,90,132,1399.0,17760.0,0.07877252252252252,0.196949912,2.4641e-5,17.775924767,0.766636532,2.192664527,4.943809886 -134,88,129,1399.0,17664.0,0.07920063405797101,0.19423328,2.4491e-5,17.775940481,0.759698903,2.241454301,4.965419114 -135,86,125,1399.0,17568.0,0.07963342440801457,0.196021362,2.4541e-5,17.749824568,0.77002309,2.244133161,4.973507276 -136,84,123,1399.0,17472.0,0.08007097069597069,0.195945063,2.4791e-5,17.793381264,0.758984676,2.223761942,4.967845004 -137,82,120,1399.0,17376.0,0.0805133517495396,0.196404909,2.5491e-5,17.781126567,0.76777764,2.208548873,4.942758101 -138,80,116,1399.0,17280.0,0.08096064814814814,0.197313346,2.469e-5,17.785944557,0.814271788,2.200296465,4.939179018 -139,78,114,1399.0,17184.0,0.08141294227188083,0.155633427,2.5181e-5,17.79491891,0.767423131,2.233213884,4.963944358 -140,76,111,1399.0,17088.0,0.08187031835205992,0.194686919,2.4311e-5,17.835512877,0.761171578,2.216772786,4.968370761 -141,74,108,1399.0,16992.0,0.0823328625235405,0.19895497,2.4301e-5,17.80769545,0.768202031,2.212642548,4.971369432 -142,72,106,1399.0,16896.0,0.08280066287878787,0.197589165,2.4241e-5,17.817799582,0.760097766,2.219367009,4.967751237 -143,70,102,1399.0,16800.0,0.08327380952380953,0.200103786,2.425e-5,17.804210307,0.767108387,2.264925155,4.965506236 -144,68,99,1399.0,16704.0,0.08375239463601533,0.196633322,2.5371e-5,17.822197608,0.762852947,2.20877412,4.971541033 -145,66,97,1399.0,16608.0,0.08423651252408478,0.200144552,2.4801e-5,17.823667792,0.766965999,2.209992675,4.969252216 -146,64,93,1399.0,16512.0,0.08472625968992248,0.199816644,2.4901e-5,17.838429006,0.764432365,2.241092809,4.961995819 -147,62,89,1399.0,16416.0,0.08522173489278752,0.187325579,2.5321e-5,17.811923957,0.767393244,2.227406228,4.960056608 -148,60,85,1399.0,16320.0,0.08572303921568628,0.198893612,2.4451e-5,17.82940565,0.760747136,2.209815727,4.971563658 -149,58,83,1399.0,16224.0,0.08623027613412229,0.201039293,2.4651e-5,17.817639935,0.767607352,2.210546374,4.97066195 -150,56,81,1399.0,16128.0,0.08674355158730158,0.199841932,2.414e-5,17.82203287,0.760048809,2.243550629,4.954439346 -151,54,79,1399.0,16032.0,0.0872629740518962,0.2011596,2.4741e-5,17.804574042,0.767800679,2.250206119,4.955980994 -152,52,75,1399.0,15936.0,0.08778865461847389,0.19971389,2.4331e-5,17.829821975,0.762018993,2.205143141,4.970086548 -153,50,73,1399.0,15840.0,0.08832070707070708,0.201368798,2.4881e-5,17.836101646,0.767371477,2.218711432,4.96364023 -154,48,71,1399.0,15744.0,0.08885924796747967,0.200798594,2.4491e-5,17.830384655,0.765407907,2.286796949,4.939295093 -155,46,67,1399.0,15648.0,0.08940439672801637,0.202551163,2.5121e-5,17.827221721,0.768466657,2.262575248,4.943430916 -156,44,65,1399.0,15552.0,0.08995627572016461,0.198816901,2.578e-5,17.840506569,0.760760306,2.220630133,4.952844324 -157,42,63,1399.0,15456.0,0.09051501035196688,0.201424744,2.5021e-5,17.814439397,0.767553139,2.196934945,4.958506547 -158,40,59,1399.0,15360.0,0.09108072916666667,0.202145126,2.565e-5,17.808712307,0.76137146,2.235801178,4.949559042 -159,38,55,1399.0,15264.0,0.0916535639412998,0.201663393,2.4591e-5,17.784477195,0.766209648,2.249329555,4.964028527 -160,36,53,1399.0,15168.0,0.09223364978902954,0.199579456,2.5461e-5,17.900752023,0.761934363,2.209582978,4.950507063 -161,34,48,1399.0,15072.0,0.09282112526539278,0.159541692,2.5211e-5,17.769415534,0.935609132,2.216664395,4.962977201 -162,32,44,1399.0,14976.0,0.09341613247863248,0.201979445,2.5581e-5,17.802148727,0.758630938,2.257162782,4.954367291 -163,30,40,1399.0,14880.0,0.09401881720430108,0.203381244,2.5411e-5,17.808584074,0.768160516,2.239967841,4.949515694 -164,28,35,1399.0,14784.0,0.09462932900432901,0.200707381,2.5071e-5,17.811958674,0.765546396,2.222827481,4.962523474 -165,26,31,1399.0,14688.0,0.09524782135076253,0.203476579,2.4431e-5,17.791537057,0.759747517,2.210172596,4.96717851 -166,24,29,1399.0,14592.0,0.09587445175438597,0.38619058,2.5161e-5,17.784565893,0.765981903,2.205094732,4.970469758 -167,22,25,1399.0,14496.0,0.09650938189845475,0.209174268,2.6071e-5,17.886396985,0.762283972,2.251379768,4.9348063 -168,20,21,1399.0,14400.0,0.09715277777777778,0.184182012,2.5331e-5,17.791795342,0.760972528,2.229551257,4.941190792 -169,18,17,1399.0,14304.0,0.09780480984340045,0.203935864,2.572e-5,17.823665061,0.762353868,2.199132836,4.965200905 -170,16,15,1399.0,14208.0,0.09846565315315316,0.200164969,2.4631e-5,17.792385586,0.76804392,2.174965407,4.972074439 -171,14,13,1399.0,14112.0,0.09913548752834467,0.204567903,2.5071e-5,17.806154396,0.759505453,2.2340466,4.972671228 -172,12,11,1399.0,14016.0,0.09981449771689498,0.201861418,2.5971e-5,18.529840195,0.789347616,2.23167521,4.947890089 -173,10,9,1399.0,13920.0,0.1005028735632184,0.202902727,2.4951e-5,17.865867105,0.761004999,2.194876208,4.93177029 -174,8,7,1399.0,13824.0,0.10120081018518519,0.198079003,2.4651e-5,17.791197743,0.767399089,2.226370372,4.951979965 diff --git a/data/qed_ke-kkke_reduction_optimizer.csv b/data/qed_ke-kkke_reduction_optimizer.csv deleted file mode 100644 index bd41fbf..0000000 --- a/data/qed_ke-kkke_reduction_optimizer.csv +++ /dev/null @@ -1,82 +0,0 @@ -operations,graph_nodes,graph_edges,graph_ce,graph_dt,graph_ci,gen_func_t,cpu_compile_t,cpu_st_t,cpu_mt_t,gpu_compile_t,gpu_t -0,356,493,1399.0,30528.0,0.0458267819706499,0.084389903,2.4971e-5,17.802549835,0.960409581,2.406448706,4.927079076 -1,351,483,1369.0,30528.0,0.044844077568134175,0.126855933,2.9211e-5,16.868735557,0.927387188,2.257632484,4.697683068 -2,346,478,1369.0,30048.0,0.04556043663471779,0.08319682,3.5431e-5,16.871399152,0.834869326,2.264361993,4.701280771 -3,341,473,1314.0,30048.0,0.04373003194888179,0.124422234,2.392e-5,16.454231193,0.856669072,2.271991539,4.68580348 -4,336,463,1284.0,30048.0,0.042731629392971246,0.121696991,2.2921e-5,15.881542683,0.816430136,2.213686135,4.449106524 -5,331,458,1284.0,29568.0,0.04342532467532467,0.124024888,2.314e-5,15.879200155,0.799333453,2.194093083,4.435654931 -6,326,448,1254.0,29568.0,0.04241071428571429,0.121610951,2.2e-5,15.325702423,0.833341953,2.203843882,4.199677306 -7,321,438,1224.0,29568.0,0.041396103896103896,0.118972208,2.1631e-5,14.367273685,0.711553932,2.16189756,3.948872646 -8,316,433,1224.0,29088.0,0.04207920792079208,0.074826839,2.2031e-5,14.367107152,0.792981221,2.169096496,3.961630969 -9,311,428,1169.0,29088.0,0.04018839383938394,0.116237162,2.15e-5,14.416973472,0.788583102,2.092186151,3.946339564 -10,306,418,1139.0,29088.0,0.03915704070407041,0.114647398,2.031e-5,13.671420757,0.745657392,2.037551329,3.657411205 -11,301,408,1109.0,29088.0,0.03812568756875687,0.11434652,1.951e-5,13.093103664,0.686554396,2.065489584,3.441139671 -12,296,403,1109.0,28608.0,0.03876538031319911,0.112282663,1.8991e-5,13.11525848,0.705183633,2.0639299,3.422598036 -13,291,398,1109.0,28128.0,0.039426905574516495,0.111549203,1.9661e-5,13.08100601,0.700772882,2.065935946,3.41679234 -14,286,388,1079.0,28128.0,0.0383603526734926,0.109881396,1.907e-5,11.871746271,0.665244638,2.063828106,3.187580585 -15,281,378,1049.0,28128.0,0.037293799772468716,0.108444747,1.7961e-5,10.963517612,0.62180291,2.037926216,2.935137574 -16,276,373,1049.0,27648.0,0.03794126157407408,0.107959773,1.874e-5,11.021594456,0.541779823,2.003876106,2.931304737 -17,271,368,1049.0,27168.0,0.03861160188457008,0.105629068,1.8241e-5,11.017450178,0.581974375,2.017201027,2.952118903 -18,266,363,1049.0,26688.0,0.0393060551558753,0.107303406,1.8301e-5,11.028597789,0.556078309,2.037535226,2.911405619 -19,261,358,994.0,26688.0,0.03724520383693045,0.106584986,1.7111e-5,10.789192026,0.525275525,2.011931363,2.931360979 -20,256,353,939.0,26688.0,0.035184352517985615,0.105743463,1.7521e-5,10.50283261,0.535253087,1.962456949,2.941274646 -21,255,351,933.0,26688.0,0.03495953237410072,0.105189187,1.7471e-5,10.739591259,0.555102576,2.013201521,2.896175037 -22,254,350,933.0,26592.0,0.035085740072202165,0.105895137,1.6631e-5,10.68514711,0.571809578,1.974934611,2.890503396 -23,253,348,927.0,26592.0,0.0348601083032491,0.104181459,1.817e-5,10.344271645,0.572483889,2.002875753,2.842241926 -24,252,347,927.0,26496.0,0.034986413043478264,0.103568232,1.7471e-5,10.363216025,0.602207417,1.943794016,2.811132729 -25,247,342,927.0,26016.0,0.035631918819188195,0.102006829,1.669e-5,10.360319761,0.588967585,1.942523675,2.838431844 -26,246,340,921.0,26016.0,0.03540129151291513,0.103244544,1.672e-5,10.140255758,0.565172778,1.980058606,2.776594151 -27,245,339,921.0,25920.0,0.03553240740740741,0.102991317,1.723e-5,10.166352736,0.588556746,2.025713505,2.754827976 -28,244,337,915.0,25920.0,0.03530092592592592,0.102527335,1.6261e-5,9.965044496,0.527648944,1.966870364,2.708992883 -29,243,335,909.0,25920.0,0.035069444444444445,0.101020632,1.6541e-5,9.899918186,0.530837495,1.99964346,2.686936268 -30,242,334,909.0,25824.0,0.03519981412639405,0.099846559,1.614e-5,9.924451078,0.532149983,1.992832633,2.667590089 -31,241,333,909.0,25728.0,0.035331156716417914,0.103293156,1.634e-5,9.893503718,0.500188044,1.971455575,2.661440862 -32,236,328,909.0,25248.0,0.036002851711026615,0.110948742,1.5851e-5,9.916889596,0.515528547,2.014256204,2.691654688 -33,235,326,903.0,25248.0,0.03576520912547528,0.099799239,1.658e-5,9.667648582,0.561210643,1.981308261,2.647665444 -34,234,324,897.0,25248.0,0.035527566539923956,0.099455409,1.6561e-5,9.588166052,0.544847505,1.932560182,2.56349283 -35,233,323,897.0,25152.0,0.035663167938931296,0.103335368,1.6271e-5,9.590387462,0.542413718,1.965145602,2.559435691 -36,232,321,891.0,25152.0,0.03542461832061069,0.097770562,1.6571e-5,9.362808632,0.543288523,2.017894491,2.498672404 -37,231,320,891.0,25056.0,0.03556034482758621,0.100428616,1.5941e-5,9.340302395,0.548822639,1.994799194,2.525394 -38,230,319,891.0,24960.0,0.03569711538461538,0.056667955,1.5341e-5,9.356871677,0.537041949,1.921246656,2.507595034 -39,225,314,891.0,24480.0,0.036397058823529414,0.099323026,1.636e-5,9.383625024,0.506403697,1.972101141,2.529248938 -40,220,309,836.0,24480.0,0.03415032679738562,0.096789665,1.645e-5,9.524601658,0.473707387,1.980933173,2.524768525 -41,215,304,836.0,24000.0,0.034833333333333334,0.053463925,1.671e-5,9.520567128,0.487585179,1.942542795,2.535491481 -42,214,302,830.0,24000.0,0.034583333333333334,0.096303802,1.6011e-5,9.137262758,0.4297148,1.950560163,2.478408276 -43,213,301,830.0,23904.0,0.034722222222222224,0.070596338,1.6901e-5,9.143790565,0.492842898,1.949332161,2.476752284 -44,212,299,824.0,23904.0,0.034471218206157964,0.09696925,1.612e-5,9.089211511,0.456930617,2.022026121,2.419473874 -45,211,297,818.0,23904.0,0.03422021419009371,0.052526649,1.536e-5,8.807671694,0.471203239,1.970488502,2.372441242 -46,210,296,818.0,23808.0,0.03435819892473118,0.096716114,1.5701e-5,8.806210783,0.451452844,1.960073481,2.387451098 -47,209,295,818.0,23712.0,0.034497300944669365,0.05145174,1.6061e-5,8.867215342,0.450895098,1.968012818,2.394204111 -48,204,290,818.0,23232.0,0.03521005509641873,0.093248236,1.9521e-5,8.844517253,0.476030278,1.963827031,2.389413849 -49,203,288,812.0,23232.0,0.034951790633608815,0.093881584,1.527e-5,8.849095772,0.446415074,1.974782212,2.332439097 -50,202,287,812.0,23136.0,0.03509681881051176,0.050473481,1.5851e-5,8.784636116,0.469233287,1.953068913,2.321316886 -51,201,285,806.0,23136.0,0.034837482710926695,0.092750242,1.5541e-5,8.632088328,0.491467054,1.945455141,2.29300329 -52,200,284,806.0,23040.0,0.03498263888888889,0.092540087,1.7161e-5,8.637677414,0.471865872,1.975464118,2.259260411 -53,199,282,800.0,23040.0,0.034722222222222224,0.092944049,1.5261e-5,8.624992966,0.478249573,1.931707577,2.232058939 -54,198,281,800.0,22944.0,0.03486750348675035,0.091660013,1.575e-5,8.680034605,0.429976994,2.022314921,2.224544849 -55,197,279,794.0,22944.0,0.03460599721059972,0.092591389,1.582e-5,8.266084761,0.442472956,1.949268775,2.165130527 -56,196,278,794.0,22848.0,0.03475140056022409,0.090376966,1.529e-5,8.26930839,0.438461132,1.960119483,2.169387658 -57,191,273,739.0,22848.0,0.03234418767507003,0.090398736,1.589e-5,8.061516101,0.468233752,1.825342557,2.144808638 -58,186,268,739.0,22368.0,0.03303826895565093,0.090566151,1.5781e-5,8.051685873,0.472555774,1.827021946,2.175475243 -59,185,266,733.0,22368.0,0.03277002861230329,0.046301524,1.4931e-5,7.809555195,0.466519375,1.819191936,2.095906173 -60,184,264,727.0,22368.0,0.03250178826895565,0.087977349,1.4771e-5,7.825535183,0.452072238,1.820734702,2.06485156 -61,183,263,727.0,22272.0,0.032641882183908046,0.08908488,1.4591e-5,7.77560322,0.445728609,1.804235078,2.06763398 -62,182,262,727.0,22176.0,0.03278318903318903,0.076517376,1.461e-5,7.754359737,0.421063625,1.812681957,2.076417548 -63,181,260,721.0,22176.0,0.032512626262626264,0.088983767,1.4091e-5,7.616158878,0.422402602,1.868182992,2.016601005 -64,180,259,721.0,22080.0,0.03265398550724638,0.089172453,1.467e-5,7.63910266,0.402654247,1.844390793,2.031385412 -65,175,254,666.0,22080.0,0.03016304347826087,0.091971222,1.3851e-5,7.35822511,0.443635961,1.719023302,2.007792679 -66,170,249,666.0,21600.0,0.030833333333333334,0.073480651,1.3871e-5,7.291999508,0.434965958,1.750073777,1.999358953 -67,169,247,660.0,21600.0,0.030555555555555555,0.085309774,1.7211e-5,7.245192983,0.412650069,1.744681817,1.962798523 -68,168,245,654.0,21600.0,0.03027777777777778,0.089043539,1.367e-5,7.024436477,0.421292773,1.722710908,1.890918459 -69,167,243,648.0,21600.0,0.03,0.084353527,1.428e-5,6.8832018,0.415786727,1.715216258,1.830282141 -70,166,242,648.0,21504.0,0.030133928571428572,0.084367977,1.3441e-5,6.899982477,0.419080281,1.707637056,1.843529005 -71,165,241,648.0,21408.0,0.030269058295964126,0.085701815,1.4031e-5,6.936174291,0.377346024,1.704252961,1.85218872 -72,164,240,648.0,21312.0,0.030405405405405407,0.083910355,1.3601e-5,6.9051589,0.389477478,1.75740328,1.867258596 -73,159,235,593.0,21312.0,0.0278246996996997,0.082135195,1.3351e-5,7.031037571,0.356084586,1.631072,1.797434919 -74,154,230,593.0,20832.0,0.028465821812596007,0.080356395,1.358e-5,7.040766129,0.405151789,1.620631997,1.781269114 -75,153,228,587.0,20832.0,0.02817780337941628,0.066967517,1.3391e-5,6.644186555,0.395240289,1.641155866,1.743666486 -76,152,226,581.0,20832.0,0.02788978494623656,0.080763676,1.298e-5,6.633937959,0.388869331,1.630064054,1.701302723 -77,151,225,581.0,20736.0,0.028018904320987654,0.080671833,1.2781e-5,6.622133299,0.392564435,1.625932508,1.711411428 -78,150,224,581.0,20640.0,0.02814922480620155,0.080368195,1.358e-5,6.599986437,0.397419271,1.657700695,1.694756709 -79,149,222,575.0,20640.0,0.027858527131782947,0.080015475,1.298e-5,6.281191715,0.37819019,1.622522233,1.656839741 -80,148,221,575.0,20544.0,0.027988707165109036,0.065331671,1.334e-5,6.313635402,0.380955078,1.627111603,1.638795233 diff --git a/data/qed_ke-kkkkke_reduction_optimizer.csv b/data/qed_ke-kkkkke_reduction_optimizer.csv deleted file mode 100644 index 9432121..0000000 --- a/data/qed_ke-kkkkke_reduction_optimizer.csv +++ /dev/null @@ -1,79 +0,0 @@ -operations,graph_nodes,graph_edges,graph_ce,graph_dt,graph_ci,gen_func_t,cpu_compile_t,cpu_st_t,cpu_mt_t,gpu_compile_t,gpu_t -0,15866,21617,66249.0,1.314048e6,0.050415966540035065,6.468999136,0.001398329,8.478099553,0.43958521,0.0,0.0 -10,14676,19713,60656.0,1.279776e6,0.0473957942639962,5.993535435,0.000745961,7.192805963,0.417393835,0.0,0.0 -20,13774,18527,56334.0,1.243296e6,0.04531020770596865,5.489738392,0.000682889,6.652182167,0.336339503,0.0,0.0 -30,13352,17940,53276.0,1.236672e6,0.04308013765978368,5.169906767,0.000675318,6.370526843,0.313517861,0.0,0.0 -40,12714,17168,51163.0,1.199712e6,0.042646068389746876,4.845906388,0.000634457,6.124306725,0.311820244,0.0,0.0 -50,12004,16270,48473.0,1.163232e6,0.04167096503534978,4.433653313,0.000596017,5.760561483,0.320897852,0.0,0.0 -60,11750,15983,48022.0,1.144224e6,0.04196905501020779,4.316924709,0.000596237,5.738809149,0.283214404,0.0,0.0 -70,11538,15697,47325.0,1.133184e6,0.04176285581158929,4.201152631,0.000554855,5.438337093,0.313985744,0.0,0.0 -80,11434,15550,46814.0,1.129536e6,0.04144533684628024,4.216359254,0.000553545,5.429706297,0.268223845,0.0,0.0 -90,11066,15085,46232.0,1.10352e6,0.041895026823256486,3.924567625,0.000560535,5.412444055,0.274917428,0.0,0.0 -100,10848,14847,44297.0,1.100352e6,0.04025711772232885,3.848048388,0.000527955,5.127227854,0.294706757,0.0,0.0 -110,10462,14382,42261.0,1.084512e6,0.038967756926617685,3.674674179,0.000509054,4.922064369,0.276530272,0.0,0.0 -120,10304,14191,41810.0,1.07472e6,0.038903156170909635,3.58233155,0.000516074,5.02371138,0.266906519,0.0,0.0 -130,10200,14067,41437.0,1.068864e6,0.03876732680677804,3.529160319,0.000501634,4.863804478,0.24639169,0.0,0.0 -140,10042,13871,40956.0,1.059552e6,0.03865407266467337,3.346890818,0.000488403,4.753116119,0.254509861,0.0,0.0 -150,9956,13765,40583.0,1.055424e6,0.038451844945727974,3.41847396,0.000500654,4.756966153,0.255966291,0.0,0.0 -160,9906,13690,40433.0,1.053024e6,0.03839703558513386,3.405093274,0.000496774,4.812050085,0.24421971,0.0,0.0 -170,9838,13597,40283.0,1.048896e6,0.038405142168527674,3.348340057,0.000481363,4.669473296,0.234701411,0.0,0.0 -180,9242,12790,37708.0,1.02336e6,0.03684724828017511,3.063089187,0.000449352,4.335668832,0.228471471,0.0,0.0 -190,9120,12648,37082.0,1.017984e6,0.03642689865459575,2.994073054,0.000429002,4.181894908,0.224361729,0.0,0.0 -200,9052,12555,36932.0,1.013856e6,0.03642726383233911,3.046147594,0.000427282,4.151250123,0.212513705,0.0,0.0 -210,8912,12405,36366.0,1.005792e6,0.03615658108237091,2.937579863,0.000433982,4.261727394,0.214012817,0.0,0.0 -220,8808,12281,35993.0,999936.0,0.035995303699436765,2.892146284,0.000432382,4.198423468,0.219749812,0.0,0.0 -230,8626,12061,35765.0,986112.0,0.03626869970145379,2.752333211,0.000414672,4.035044142,0.241721263,0.0,0.0 -240,8426,11841,34336.0,980256.0,0.03502758463095355,2.714773746,0.000414522,4.036870861,0.235365769,0.0,0.0 -250,8118,11464,33416.0,961728.0,0.03474579090969588,2.579966689,0.000402461,3.870568035,0.20937257,0.0,0.0 -260,7942,11242,32634.0,953664.0,0.034219599355747934,2.520293442,0.000391581,3.72881432,0.191238985,0.0,0.0 -270,7838,11100,32153.0,949536.0,0.0338618019748593,2.456319106,0.000383211,3.635092003,0.187908484,0.0,0.0 -280,7716,10940,31672.0,943680.0,0.033562224482875554,2.402192681,0.00037687,3.594882506,0.194062713,0.0,0.0 -290,7576,10772,30745.0,939552.0,0.032723042471305475,2.338714319,0.00037334,3.556085038,0.194369971,0.0,0.0 -300,7376,10529,30487.0,924480.0,0.0329774575977847,2.279512925,0.00036552,3.504723807,0.191079171,0.0,0.0 -310,7218,10310,29868.0,917376.0,0.03255807869401423,2.207692656,0.000355539,3.30937664,0.181261073,0.0,0.0 -320,7078,10137,29417.0,909312.0,0.03235083227759009,2.147511905,0.000352659,3.30461376,0.18005858,0.0,0.0 -330,6860,9848,28991.0,895200.0,0.032384941912421805,2.078259266,0.00033941,3.211808988,0.172834084,0.0,0.0 -340,6702,9611,28264.0,889824.0,0.03176358470888625,2.069880378,0.000318959,3.033092324,0.154811992,0.0,0.0 -350,6616,9505,27891.0,885696.0,0.03149048883589855,2.005510172,0.000326369,3.008426711,0.173417779,0.0,0.0 -360,6512,9391,27325.0,881088.0,0.03101279327377061,1.968347618,0.000315789,2.921325386,0.168873786,0.0,0.0 -370,6426,9280,27175.0,875232.0,0.03104891046031224,1.92734893,0.000315548,2.990437001,0.181187901,0.0,0.0 -380,6358,9187,27025.0,871104.0,0.031023850194695467,1.889258172,0.000308689,2.846738111,0.181651873,0.0,0.0 -390,6272,9081,26652.0,866976.0,0.030741335400287898,1.840892272,0.000329279,2.825270586,0.177422669,0.0,0.0 -400,6204,8993,26532.0,862368.0,0.03076644773460982,1.820608708,0.000296329,2.759355249,0.175583708,0.0,0.0 -410,6118,8864,26274.0,858240.0,0.030613814317673377,1.783961229,0.000290708,2.707626007,0.172954176,0.0,0.0 -420,6014,8740,25901.0,852384.0,0.030386539400082593,1.774576254,0.000288998,2.694176581,0.173939173,0.0,0.0 -430,5928,8629,25498.0,848736.0,0.030042321758473777,1.7065974,0.000284277,2.675798329,0.170062674,0.0,0.0 -440,5842,8523,25125.0,844608.0,0.029747527847238008,1.685087395,0.000287118,2.688215586,0.166480549,0.0,0.0 -450,5738,8399,24752.0,838752.0,0.02951051085422151,1.673553823,0.000274969,2.523253333,0.167824913,0.0,0.0 -460,5670,8316,24662.0,833664.0,0.02958266159987717,1.625105871,0.000272178,2.52817126,0.164730041,0.0,0.0 -470,5548,8161,24211.0,827328.0,0.029264088729016785,1.583826656,0.000262318,2.419247276,0.160768733,0.0,0.0 -480,5426,8006,23760.0,820992.0,0.028940598690364826,1.58433006,0.000264708,2.454129792,0.155746163,0.0,0.0 -490,5358,7918,23640.0,816384.0,0.028956961429915332,1.520887155,0.000253268,2.329551174,0.153813499,0.0,0.0 -500,5272,7807,23237.0,812736.0,0.02859108000629971,1.488167166,0.000248837,2.282665244,0.154234105,0.0,0.0 -510,5150,7647,22756.0,806880.0,0.028202458853856832,1.448681065,0.000247727,2.275316917,0.149501885,0.0,0.0 -520,5028,7487,22022.0,803232.0,0.02741673638500458,1.43939862,0.000236057,2.14942739,0.146771977,0.0,0.0 -530,4906,7350,21679.0,795168.0,0.02726342106322186,1.367826149,0.000242258,2.188588822,0.148076932,0.0,0.0 -540,4838,7257,21529.0,791040.0,0.027216069983818772,1.341798982,0.000230357,2.096237881,0.141709174,0.0,0.0 -550,4752,7151,21156.0,786912.0,0.02688483591557887,1.339939443,0.000227267,2.062687036,0.13782156,0.0,0.0 -560,4684,7068,21066.0,781824.0,0.026944683202357565,1.327848904,0.000222317,2.00294804,0.139508498,0.0,0.0 -570,4634,6993,20916.0,779424.0,0.02683520137948023,1.276183945,0.000224717,2.021180753,0.13573571,0.0,0.0 -580,4548,6882,20766.0,773568.0,0.026844440307768676,1.235522514,0.000212457,1.917354147,0.128401984,0.0,0.0 -590,4498,6807,20616.0,771168.0,0.026733474418025645,1.267249751,0.000212506,1.899792552,0.133449083,0.0,0.0 -600,4376,6657,20195.0,764352.0,0.0264210730134807,1.209891149,0.000205326,1.850663451,0.129490109,0.0,0.0 -610,4326,6582,20045.0,761952.0,0.026307431439250767,1.18887911,0.000203196,1.819359467,0.129183977,0.0,0.0 -620,4204,6422,19564.0,756096.0,0.02587502116133401,1.172245936,0.000212366,1.757557943,0.125887084,0.0,0.0 -630,3836,5980,17558.0,741504.0,0.02367890126014155,1.043747354,0.000175996,1.554965777,0.115650062,0.0,0.0 -640,3732,5856,17438.0,733440.0,0.023775632635253053,1.010298683,0.000174715,1.562411059,0.113877446,0.0,0.0 -650,3628,5714,16957.0,729312.0,0.023250680093019175,0.985957627,0.000170445,1.474744854,0.110990727,0.0,0.0 -660,3506,5549,16446.0,723936.0,0.022717477788091765,0.948042334,0.000161975,1.420057878,0.106426767,0.0,0.0 -670,3420,5448,16103.0,719328.0,0.0223861715378798,0.921840457,0.000156765,1.356400004,0.10491163,0.0,0.0 -680,3316,5319,15700.0,713952.0,0.021990273855945496,0.892707383,0.000162605,1.335548894,0.100909488,0.0,0.0 -690,3212,5200,15357.0,707616.0,0.02170244878578212,0.89578919,0.000149085,1.299462304,0.099173414,0.0,0.0 -700,2916,4871,13850.0,693792.0,0.019962755407960886,0.781393124,0.000134984,1.179737113,0.096642976,0.0,0.0 -710,2722,4598,13123.0,684960.0,0.019158782994627425,0.725161332,0.000122213,1.056813282,0.08619269,0.0,0.0 -720,2636,4492,12750.0,680832.0,0.018727086858432038,0.701632434,0.000128984,1.019551067,0.085388434,0.0,0.0 -730,2532,4373,12407.0,674496.0,0.018394475282284845,0.675037355,0.000119134,0.993660466,0.082709493,0.0,0.0 -740,2428,4231,11926.0,670368.0,0.017790228650532244,0.6435086,0.000109403,0.927737064,0.078423743,0.0,0.0 -750,2342,4125,11553.0,666240.0,0.017340597982708934,0.619218823,0.000106693,0.883708241,0.075467284,0.0,0.0 -760,2274,4032,11403.0,662112.0,0.017222161809482384,0.635081649,0.000103493,0.919860114,0.074058132,0.0,0.0 -770,2234,3977,11313.0,659712.0,0.017148392025611175,0.593953439,0.000110543,0.84404911,0.077019298,0.0,0.0 diff --git a/data/results.zip b/data/results.zip new file mode 100644 index 0000000..01e350d --- /dev/null +++ b/data/results.zip @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a427c68dc810e8d7f54fdfc3971763469a0ac8fba51ec2127567c073abbeccf5 +size 1238069 diff --git a/docs/Project.toml b/docs/Project.toml index 340c2ff..2ec6be9 100644 --- a/docs/Project.toml +++ b/docs/Project.toml @@ -2,3 +2,4 @@ Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4" DocumenterTools = "35a29f4d-8980-5a13-9543-d66fff28ecb8" MetagraphOptimization = "3e869610-d48d-4942-ba70-c1b702a33ca4" +QEDprocesses = "46de9c38-1bb3-4547-a1ec-da24d767fdad" diff --git a/examples/Project.toml b/examples/Project.toml index 0a5d779..526709a 100644 --- a/examples/Project.toml +++ b/examples/Project.toml @@ -5,5 +5,6 @@ CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" MetagraphOptimization = "3e869610-d48d-4942-ba70-c1b702a33ca4" Plots = "91a5bcdd-55d7-5caf-9e0b-520d859cae80" +QEDbase = "10e22c08-3ccb-4172-bfcf-7d7aa3d04d93" QEDprocesses = "46de9c38-1bb3-4547-a1ec-da24d767fdad" StatsPlots = "f3b207a7-027a-5e70-b257-86293d7955fd" diff --git a/examples/full_node_bench.jl b/examples/full_node_bench.jl new file mode 100644 index 0000000..3697f8f --- /dev/null +++ b/examples/full_node_bench.jl @@ -0,0 +1,249 @@ +using MetagraphOptimization +using CUDA +using UUIDs +using DataFrames +using CSV +using Random +using BenchmarkTools +using Dates + +using Base.Threads + + +function log(x...) + println(now(), " ", join(x, " ")...) + flush(stdout) + return nothing +end + +results_filename = "full_node_bench.csv" + +df = DataFrame( + process_name = String[], + cpu_threads = Int[], + gpu_devices = Int[], + n_inputs = Int[], + chunk_size = Int[], + time = Float64[], + std = Float64[], + rate = Float64[], + cpu_chunks = Float64[], + gpu_chunks = Float64[], + memory_est = Float64[], +) + +# if they exist, read existing results and append new ones +if isfile(results_filename) + df = CSV.read(results_filename, DataFrame) +end + +nInputs = 2^26 + +lck = ReentrantLock() + +progress = 1 +cpu_chunks = 0 +gpu_chunks = 0 + +chunkSizes = [1024, 4096, 16384, 65536, 262144, 1048576] # 2^10 to 2^20 + +function cpu_worker(compute_func, inputs, chunk_size) + global progress + global cpu_chunks + global lck + quit = false + work_start = 0 + work_end = 0 + while true + lock(lck) do + if progress >= nInputs + quit = true + else + work_start = progress + progress = progress + chunk_size + work_end = min(progress - 1, nInputs) + cpu_chunks = cpu_chunks + 1 + #log("CPU Worker $(Threads.threadid()) computing $(cpu_chunks)th cpu chunk ($work_start, $work_end)") + end + end + if quit + break + end + + for i in work_start:work_end + compute_func(inputs[i]) + end + end + + #log("CPU Worker on $(Threads.threadid()) finished!") + + return nothing +end + +# called with a specific device selected +function gpu_worker(kernel!, inputs, chunk_size) + global progress + global gpu_chunks + global lck + cuOutputs = CuVector{ComplexF64}() + resize!(cuOutputs, chunk_size) + + quit = false + work_start = 0 + work_end = 0 + while true + lock(lck) do + if progress >= nInputs + quit = true + else + work_start = progress + progress = progress + chunk_size + work_end = min(progress - 1, nInputs) + gpu_chunks = gpu_chunks + 1 + #log("GPU Worker $(CUDA.device()) computing $(gpu_chunks)th gpu chunk ($work_start, $work_end)") + end + end + if quit + break + end + + cuInputs = CuVector(inputs[work_start:work_end]) + ts = 32 + bs = Int(chunk_size / 32) + @cuda threads = ts blocks = bs always_inline = true kernel!(cuInputs, cuOutputs, chunk_size) + CUDA.device_synchronize() + end + + #log("GPU Worker on Device $(CUDA.device()) finished!") + + return nothing +end + +cpu_gpu_ratio = Vector{Tuple{Int, Int}}() + +function full_compute(compute_func, kernel!, inputs, chunk_size) + global progress + progress = 1 + global cpu_chunks + cpu_chunks = 0 + global gpu_chunks + gpu_chunks = 0 + + tasks = Vector() + + for dev in CUDA.devices() + t = Threads.@spawn device!(dev) do + gpu_worker(kernel!, inputs, chunk_size) + return nothing + end + push!(tasks, t) + end + + for i in 1:(Threads.nthreads() - length(CUDA.devices())) + t = Threads.@spawn cpu_worker(compute_func, inputs, chunk_size) + push!(tasks, t) + end + + for t in tasks + wait(t) + end + + push!(cpu_gpu_ratio, (cpu_chunks, gpu_chunks)) + return nothing +end + +function bench(compute_function, kernel!, inputs, chunk_size) + global cpu_gpu_ratio + empty!(cpu_gpu_ratio) + + bench = @benchmark begin + full_compute($compute_function, $kernel!, $inputs, $chunk_size) + end gcsample = true seconds = 60 + + time = median(bench.times) / 1e9 + s = std(bench.times) / 1e9 + rate = length(inputs) / time + + med_cpu_chunks = median(getindex.(cpu_gpu_ratio, 1)) + med_gpu_chunks = median(getindex.(cpu_gpu_ratio, 2)) + mem_estimate = bench.memory + + log("CPU/GPU ratios: $(cpu_gpu_ratio)") + + return (time, rate, s, med_cpu_chunks, med_gpu_chunks, mem_estimate) +end + +function full_node_bench(process::MetagraphOptimization.AbstractProcessDescription, func, kernel!, chunk_size, inputs) + process_name = string(process) + log("\n--- Benchmarking $(process_name) on $(nInputs) with chunk size $(chunk_size) ---") + + log("Available Cuda Devices:") + display.(CUDA.devices()) + + log("Benchmarking full node...") + (time, rate, s, med_cpu_chunks, med_gpu_chunks, mem_estimate) = bench(func, kernel!, inputs, chunk_size) + log( + "Benchmarking complete with median time $(time), $(med_cpu_chunks) cpu chunks, and $(med_gpu_chunks) gpu chunks.", + ) + + push!( + df, + Dict( + :process_name => process_name, + :cpu_threads => Threads.nthreads() - length(CUDA.devices()), + :gpu_devices => length(CUDA.devices()), + :n_inputs => nInputs, + :chunk_size => chunk_size, + :time => time, + :std => s, + :rate => rate, + :cpu_chunks => med_cpu_chunks, + :gpu_chunks => med_gpu_chunks, + :memory_est => mem_estimate, + ), + ) + + return nothing +end + +# use "mock" machine that only uses cpu for compilation +machine = Machine( + [ + MetagraphOptimization.NumaNode( + 0, + 1, + MetagraphOptimization.default_strategy(MetagraphOptimization.NumaNode), + -1.0, + UUIDs.uuid1(), + ), + ], + [-1.0;;], +) + +optimizer = ReductionOptimizer() +processes = ["ke->ke", "ke->kke", "ke->kkke", "ke->kkkke", "ke->kkkkke"] + +for proc in processes + process = parse_process(proc, QEDModel()) + graph = gen_graph(process) + optimize_to_fixpoint!(optimizer, graph) + compute_func = get_compute_function(graph, process, machine) + kernel! = get_cuda_kernel(graph, process, machine) + + log("Generating $nInputs inputs with $(Threads.nthreads()) threads...") + inputs = Vector{typeof(gen_process_input(process))}() + resize!(inputs, nInputs) + procs = Vector{typeof(process)}() + for i in 1:Threads.nthreads() + push!(procs, copy(process)) + end + + @inbounds Threads.@threads for i in eachindex(inputs) + inputs[i] = gen_process_input(procs[Threads.nthreads()]) + end + + for chunk_size in chunkSizes + full_node_bench(process, compute_func, kernel!, chunk_size, inputs) + CSV.write(results_filename, df) + end +end; diff --git a/examples/import_bench.jl b/examples/import_bench.jl index 5143504..d4cb0b6 100644 --- a/examples/import_bench.jl +++ b/examples/import_bench.jl @@ -34,9 +34,10 @@ function import_bench() bench_txt("AB->ABBB.txt") bench_txt("AB->ABBBBB.txt") bench_txt("AB->ABBBBBBB.txt") - #bench_txt("AB->ABBBBBBBBB.txt") + bench_txt("AB->ABBBBBBBBB.txt") bench_txt("ABAB->ABAB.txt") - return bench_txt("ABAB->ABC.txt") + bench_txt("ABAB->ABC.txt") + return nothing end import_bench() diff --git a/examples/qed_bench.jl b/examples/qed_bench.jl index 67934fa..b9d899a 100644 --- a/examples/qed_bench.jl +++ b/examples/qed_bench.jl @@ -2,44 +2,117 @@ using MetagraphOptimization using LIKWID using CUDA using UUIDs +using DataFrames +using CSV +using Random +using BenchmarkTools +using Dates -function cpu_bench(compute_function, inputs) - compute_function.(inputs[begin:10]) # make sure it's compiled +DISABLE_GPU = false - time = @elapsed Threads.@threads for i in eachindex(inputs) - @invokelatest compute_function(inputs[i]) - end - rate = length(inputs) / time - return (time, rate) +function log(x...) + println(now(), " ", join(x, " ")...) + return flush(stdout) end -function gpu_bench(compute_function, inputs) - CUDA.@sync compute_function.(inputs[begin:10]) # make sure it's compiled +results_filename = "bench_results_$(Threads.nthreads()).csv" - time = @elapsed CUDA.@sync compute_function.(inputs) +df = DataFrame( + process_name = String[], + graph_gen_time = Float64[], + optimization_time = Float64[], + function_generation_time = Float64[], + graph_nodes = Int[], + graph_edges = Int[], + graph_mem = Float64[], + cpu_threads = Int[], + n_inputs = Int[], + nflops_likwid = Int[], + cpu_time = Float64[], + cpu_std = Float64[], + cpu_rate = Float64[], + cpu_gflops = Float64[], + gpu_name = String[], + gpu_time = Float64[], + gpu_std = Float64[], + gpu_rate = Float64[], + gpu_gflops = Float64[], +) + +# if they exist, read existing results and append new ones +if isfile(results_filename) + df = CSV.read(results_filename, DataFrame) +end + +nInputs = 2^20 + +function cpu_bench(compute_function, inputs) + bench = @benchmark begin + @inbounds Threads.@threads for i in eachindex($inputs) + @invokelatest $compute_function($inputs[i]) + end + end gcsample = true samples = 20 evals = 1 + + time = median(bench.times) / 1e9 + s = std(bench.times) / 1e9 rate = length(inputs) / time - return (time, rate) + return (time, rate, s) +end + +function gpu_bench(kernel!, inputs) + n = length(inputs) + outputs = CuVector{ComplexF64}() + resize!(outputs, n) + ts = 32 + bs = Int(n / ts) + bench = @benchmark begin + @cuda threads = $ts blocks = $bs always_inline = true $kernel!($inputs, $outputs, $n) + CUDA.device_synchronize() + end gcsample = true samples = 20 evals = 1 + + time = median(bench.times) / 1e9 + s = std(bench.times) / 1e9 + rate = length(inputs) / time + + return (time, rate, s) end function bench_process( process::MetagraphOptimization.AbstractProcessDescription, + process_name::String, + graph::DAG, func, - io::IO = stdout; - use_likwid = true, + kernel!, + gen_time::Float64, + opt_time::Float64, + func_time::Float64; + use_likwid = false, + use_gpu = true, ) - println(io, "\n--- Benchmarking $(process) ---") + log("\n--- Benchmarking $(process_name) ---") + if DISABLE_GPU + use_gpu = false + end - NFLOPs = GraphProperties(graph).computeEffort + graph_props = GraphProperties(graph) + NFLOPs = graph_props.computeEffort + nflops_likwid = 0 if use_likwid input = gen_process_input(process) func(input) # compile first + + # get rid of annoying output to console + oldstd = stdout + redirect_stdout(devnull) _, events = @perfmon "FLOPS_DP" func(input) + redirect_stdout(oldstd) # recover original stdout + NFLOPs = first(events["FLOPS_DP"])["RETIRED_SSE_AVX_FLOPS_ALL"] + nflops_likwid = NFLOPs end - nInputs = 10000000 # ten million - println(io, "Generating $nInputs inputs with $(Threads.nthreads()) threads...") + log("Generating $nInputs inputs with $(Threads.nthreads()) threads...") inputs = Vector{typeof(gen_process_input(process))}() resize!(inputs, nInputs) @@ -48,35 +121,76 @@ function bench_process( push!(processes, copy(process)) end - Threads.@threads for i in eachindex(inputs) + @inbounds Threads.@threads for i in eachindex(inputs) inputs[i] = gen_process_input(processes[Threads.nthreads()]) end - println(io, "Benchmarking CPU with $(Threads.nthreads()) threads...") - (time_cpu, rate_cpu) = cpu_bench(func, inputs) - flops_cpu = (rate_cpu * NFLOPs) / 1024^3 + log("Benchmarking CPU with $(Threads.nthreads()) threads...") + (time_cpu, rate_cpu, std_cpu) = cpu_bench(func, inputs) + flops_cpu = (rate_cpu * NFLOPs) / 10^9 - println(io, "Benchmarking GPU...") - cuInputs = CuArray(inputs) - (time_gpu, rate_gpu) = gpu_bench(func, cuInputs) - flops_gpu = (rate_gpu * NFLOPs) / 1024^3 + time_gpu = 0.0 + std_gpu = 0.0 + rate_gpu = 0.0 + flops_gpu = 0.0 + gpu_name = "none" + if use_gpu + log("Benchmarking GPU...") + gpu_name = "$(name(first(CUDA.devices())))" + cuInputs = CuArray(inputs) + (time_gpu, rate_gpu, std_gpu) = gpu_bench(kernel!, cuInputs) + flops_gpu = (rate_gpu * NFLOPs) / 10^9 + else + log("Skipping GPU...") + end - println(io, "\nBenchmark Summary for $(process):") + log("\nBenchmark Summary for $(process):") if use_likwid - println(io, "Measured FLOPS by LIKWID: $NFLOPs") + log("Measured FLOPS by LIKWID: $NFLOPs") else - println(io, "Total graph compute effort: $NFLOPs") + log("Total graph compute effort: $NFLOPs") end - println(io, "Total input size: $(bytes_to_human_readable(Base.summarysize(inputs)))") - println(io, "CPU, $(Threads.nthreads()) threads") - println(io, " Time: $time_cpu") - println(io, " Rate: $rate_cpu") - println(io, " GFLOPS: $flops_cpu") - println(io, "GPU, $(name(first(CUDA.devices())))") - println(io, " Time: $time_gpu") - println(io, " Rate: $rate_gpu") - return println(io, " GFLOPS: $flops_gpu") + log("Total input size: $(bytes_to_human_readable(Base.summarysize(inputs)))") + log("CPU, $(Threads.nthreads()) threads") + log(" Time: $time_cpu") + log(" Rate: $rate_cpu") + log(" GFLOPS: $flops_cpu") + if use_gpu + log("GPU, $gpu_name") + log(" Time: $time_gpu") + log(" Rate: $rate_gpu") + log(" GFLOPS: $flops_gpu") + end + + if (process_name != "warmup") + push!( + df, + Dict( + :process_name => process_name, + :graph_gen_time => gen_time, + :optimization_time => opt_time, + :function_generation_time => func_time, + :graph_nodes => graph_props.noNodes, + :graph_edges => graph_props.noEdges, + :graph_mem => MetagraphOptimization.mem(graph), + :cpu_threads => Threads.nthreads(), + :n_inputs => nInputs, + :nflops_likwid => nflops_likwid, + :cpu_time => time_cpu, + :cpu_std => std_cpu, + :cpu_rate => rate_cpu, + :cpu_gflops => flops_cpu, + :gpu_name => gpu_name, + :gpu_time => time_gpu, + :gpu_std => std_gpu, + :gpu_rate => rate_gpu, + :gpu_gflops => flops_gpu, + ), + ) + end + + return nothing end # use "mock" machine that only uses cpu @@ -92,57 +206,67 @@ machine = Machine( ], [-1.0;;], ) -optimizer = ReductionOptimizer() # sadly cannot put these in functions because the world age must increase after the function is created which happens only in the global scope -# compton -process = parse_process("ke->ke", QEDModel()) -graph = gen_graph(process) -optimize_to_fixpoint!(optimizer, graph) -compute_func = get_compute_function(graph, process, machine) -bench_process(process, compute_func) +## -- WARMUP TO COMPILE FUNCTIONS first +#= +optimizer = RandomWalkOptimizer(MersenneTwister(0)) # 2-photon compton process = parse_process("ke->kke", QEDModel()) -graph = gen_graph(process) -optimize_to_fixpoint!(optimizer, graph) -compute_func = get_compute_function(graph, process, machine) -bench_process(process, compute_func) +gen_time = @elapsed graph = gen_graph(process) +opt_time = @elapsed optimize!(optimizer, graph, 200) +func_gen_time = @elapsed compute_func = get_compute_function(graph, process, machine) +kernel! = get_cuda_kernel(graph, process, machine) +bench_process(process, "warmup", graph, compute_func, kernel!, gen_time, opt_time, func_gen_time) -# 3-photon compton -process = parse_process("ke->kkke", QEDModel()) -graph = gen_graph(process) -optimize_to_fixpoint!(optimizer, graph) -compute_func = get_compute_function(graph, process, machine) -bench_process(process, compute_func) - -# AB->AB -process = parse_process("AB->AB", ABCModel()) -graph = parse_dag("input/AB->AB.txt", ABCModel()) -optimize_to_fixpoint!(optimizer, graph) -compute_func = get_compute_function(graph, process, machine) -bench_process(process, compute_func) +optimizer = ReductionOptimizer() # AB->AB^3 process = parse_process("AB->ABBB", ABCModel()) -graph = parse_dag("input/AB->ABBB.txt", ABCModel()) -optimize_to_fixpoint!(optimizer, graph) -compute_func = get_compute_function(graph, process, machine) -bench_process(process, compute_func) +gen_time = @elapsed graph = parse_dag("input/AB->ABBB.txt", ABCModel()) +opt_time = @elapsed optimize_to_fixpoint!(optimizer, graph) +func_gen_time = @elapsed compute_func = get_compute_function(graph, process, machine) +kernel! = get_cuda_kernel(graph, process, machine) +bench_process(process, "warmup", graph, compute_func, kernel!, gen_time, opt_time, func_gen_time) +=# +## -- WARMUP END -exit(0) +optimizer = ReductionOptimizer() -# 4-photon compton -process = parse_process("ke->kkkke", QEDModel()) -graph = gen_graph(process) -optimize_to_fixpoint!(optimizer, graph) -compute_func = get_compute_function(graph, process, machine) -bench_process(process, compute_func) +processes = ["ke->ke", "ke->kke", "ke->kkke", "ke->kkkke", "ke->kkkkke"] -# AB->AB^5 -process = parse_process("AB->ABBBBB", ABCModel()) -graph = parse_dag("input/AB->ABBBBB.txt", ABCModel()) -optimize_to_fixpoint!(optimizer, graph) -compute_func = get_compute_function(graph, process, machine) -bench_process(process, compute_func) +for process_str in processes + # compton + process = parse_process(process_str, QEDModel()) + gen_time = @elapsed graph = gen_graph(process) + func_gen_time = @elapsed compute_func = get_compute_function(graph, process, machine) + kernel! = get_cuda_kernel(graph, process, machine) + bench_process(process, "$process not optimized", graph, compute_func, kernel!, gen_time, 0.0, func_gen_time) + + opt_time = @elapsed optimize_to_fixpoint!(optimizer, graph) + func_gen_time = @elapsed compute_func = get_compute_function(graph, process, machine) + kernel! = get_cuda_kernel(graph, process, machine) + bench_process(process, "$process reduced", graph, compute_func, kernel!, gen_time, opt_time, func_gen_time) + + CSV.write(results_filename, df) +end + +processes = ["AB->AB", "AB->ABBB", "AB->ABBBBB", "AB->ABBBBBBB"] + +for process_str in processes + # AB->AB + process = parse_process(process_str, ABCModel()) + gen_time = @elapsed graph = parse_dag("input/$(process_str).txt", ABCModel()) + func_gen_time = @elapsed compute_func = get_compute_function(graph, process, machine) + kernel! = get_cuda_kernel(graph, process, machine) + bench_process(process, "$process not optimized", graph, compute_func, kernel!, gen_time, 0.0, func_gen_time) + + opt_time = @elapsed optimize_to_fixpoint!(optimizer, graph) + func_gen_time = @elapsed compute_func = get_compute_function(graph, process, machine) + kernel! = get_cuda_kernel(graph, process, machine) + bench_process(process, "$process reduced", graph, compute_func, kernel!, gen_time, opt_time, func_gen_time) + + CSV.write(results_filename, df) +end diff --git a/examples/qed_bench_reduction_steps.jl b/examples/qed_bench_reduction_steps.jl new file mode 100644 index 0000000..da47680 --- /dev/null +++ b/examples/qed_bench_reduction_steps.jl @@ -0,0 +1,163 @@ +using MetagraphOptimization +using CUDA +using UUIDs +using BenchmarkTools +using DataFrames +using CSV + +results_filename = "bench_results_reduction_steps.csv" + +df = DataFrame( + threads = Int[], + process = String[], + operations = Int[], + cumulative_optimization_time = Float64[], + graph_nodes = Int[], + graph_edges = Int[], + graph_ce = Float64[], + graph_dt = Float64[], + graph_ci = Float64[], + gen_func_t = Float64[], + cpu_compile_t = Float64[], + cpu_st_t = Float64[], + cpu_mt_t = Float64[], + gpu_compile_t = Float64[], + gpu_t = Float64[], +) + +# if they exist, read existing results and append new ones +if isfile(results_filename) + df = CSV.read(results_filename, DataFrame) +end + +function bench(func, inputs) + compile_time = @elapsed func(inputs[1]) + + single_thread = @benchmark $func.($inputs) + multi_threaded = @benchmark Threads.@threads for i in eachindex($inputs) + $func($inputs[i]) + end + + return ( + cpu_compile_time = compile_time, + gpu_compile_time = 0.0, + cpu_single_thread_time = mean(single_thread.times) / 1e9, + cpu_multi_thread_time = mean(multi_threaded.times) / 1e9, + gpu_time = 0.0, + ) +end + +# preparation of machine +machine = Machine( + [ + MetagraphOptimization.NumaNode( + 0, + 1, + MetagraphOptimization.default_strategy(MetagraphOptimization.NumaNode), + -1.0, + UUIDs.uuid1(), + ), + ], + [-1.0;;], +) + +# bench and produce data +n_inputs = 50_000 +optimizer = ReductionOptimizer() +processes = [("ke->kke", 5), ("ke->ke", 1), ("ke->kke", 1), ("ke->kkke", 1), ("ke->kkkke", 1), ("ke->kkkkke", 1)] + +for (process_str, STEPSIZE) in processes + n = 0 + opt_time_cum = 0 + + process = parse_process(process_str, QEDModel()) + graph = gen_graph(process) + inputs = [gen_process_input(process) for _ in 1:n_inputs] + + get_compute_function(graph, process, machine) + + while true + func_gen_time = @elapsed func = get_compute_function(graph, process, machine) + res = bench(func, inputs) + + graph_properties = get_properties(graph) + push!( + df, + ( + Threads.nthreads(), + process_str, + n, + opt_time_cum, + graph_properties.noNodes, + graph_properties.noEdges, + graph_properties.computeEffort, + graph_properties.data, + graph_properties.computeIntensity, + func_gen_time, + res.cpu_compile_time, + res.cpu_single_thread_time, + res.cpu_multi_thread_time, + res.gpu_compile_time, + res.gpu_time, + ), + ) + CSV.write(results_filename, df) + + if fixpoint_reached(optimizer, graph) + break + end + + opt_time_cum += @elapsed optimize!(optimizer, graph, STEPSIZE) + n += STEPSIZE + end +end + +CSV.write(results_filename, df) + +for (process_str, STEPSIZE) in [("AB->AB", 1), ("AB->ABBB", 1), ("AB->ABBBBB", 1)] + n = 0 + opt_time_cum = 0 + + process = parse_process(process_str, ABCModel()) + graph = parse_dag("input/$process_str.txt", ABCModel()) + inputs = [gen_process_input(process) for _ in 1:n_inputs] + + get_compute_function(graph, process, machine) + + while true + func_gen_time = @elapsed func = get_compute_function(graph, process, machine) + res = bench(func, inputs) + + graph_properties = get_properties(graph) + push!( + df, + ( + Threads.nthreads(), + process_str, + n, + opt_time_cum, + graph_properties.noNodes, + graph_properties.noEdges, + graph_properties.computeEffort, + graph_properties.data, + graph_properties.computeIntensity, + func_gen_time, + res.cpu_compile_time, + res.cpu_single_thread_time, + res.cpu_multi_thread_time, + res.gpu_compile_time, + res.gpu_time, + ), + ) + CSV.write(results_filename, df) + + if fixpoint_reached(optimizer, graph) + break + end + + opt_time_cum += @elapsed optimize!(optimizer, graph, STEPSIZE) + n += STEPSIZE + end +end + +CSV.write(results_filename, df) diff --git a/examples/qed_bench_reduction_steps_gpu.jl b/examples/qed_bench_reduction_steps_gpu.jl new file mode 100644 index 0000000..2cc0d7c --- /dev/null +++ b/examples/qed_bench_reduction_steps_gpu.jl @@ -0,0 +1,208 @@ +using MetagraphOptimization +using CUDA +using UUIDs +using BenchmarkTools +using DataFrames +using CSV +using Dates + +results_filename = "bench_results_reduction_steps_gpu.csv" + +df = DataFrame( + threads = Int[], + process = String[], + operations = Int[], + cumulative_optimization_time = Float64[], + graph_nodes = Int[], + graph_edges = Int[], + graph_ce = Float64[], + graph_dt = Float64[], + graph_ci = Float64[], + cpu_st_t = Float64[], + cpu_st_s = Float64[], + cpu_mt_t = Float64[], + cpu_mt_s = Float64[], + cpu_mem = Float64[], + gpu_t = Float64[], + gpu_s = Float64[], + gpu_mem = Float64[], +) + +# if they exist, read existing results and append new ones +if isfile(results_filename) + df = CSV.read(results_filename, DataFrame) +end + +function log(x...) + println(now(), " ", join(x, " ")...) + return flush(stdout) +end + +function bench(func, kernel!, inputs) + # gpu part + n = length(inputs) + cu_inputs = CuVector(inputs) + cu_outputs = CuVector{ComplexF64}() + resize!(cu_outputs, n) + ts = 32 + bs = Int(n / ts) + bench = @benchmark begin + @cuda threads = $ts blocks = $bs always_inline = true $kernel!($cu_inputs, $cu_outputs, $n) + CUDA.device_synchronize() + end gcsample = true samples = 20 evals = 1 + + gpu_time = median(bench.times) / 1e9 + gpu_std = std(bench.times) / 1e9 + gpu_mem = bench.memory + + # cpu part + single_thread = @benchmark $func.($inputs) + multi_threaded = @benchmark Threads.@threads for i in eachindex($inputs) + $func($inputs[i]) + end + + cpu_st_time = median(single_thread.times) / 1e9 + cpu_st_std = std(single_thread.times) / 1e9 + cpu_mt_time = median(multi_threaded.times) / 1e9 + cpu_mt_std = std(multi_threaded.times) / 1e9 + cpu_mem = std(single_thread.times) + + + return ( + cpu_single_thread_time = cpu_st_time, + cpu_single_thread_std = cpu_st_std, + cpu_multi_thread_time = cpu_mt_time, + cpu_multi_thread_std = cpu_mt_std, + cpu_mem = cpu_mem, + gpu_time = gpu_time, + gpu_std = gpu_std, + gpu_mem = gpu_mem, + ) +end + +log("Available CUDA devices:") +for dev in CUDA.devices() + display(dev) +end + +# preparation of machine +machine = Machine( + [ + MetagraphOptimization.NumaNode( + 0, + 1, + MetagraphOptimization.default_strategy(MetagraphOptimization.NumaNode), + -1.0, + UUIDs.uuid1(), + ), + ], + [-1.0;;], +) + + +# bench and produce data +n_inputs = 2^16 +optimizer = ReductionOptimizer() +processes = [("ke->ke", 1), ("ke->kke", 1), ("ke->kkke", 1), ("ke->kkkke", 5)] + +for (process_str, STEPSIZE) in processes + n = 0 + opt_time_cum = 0 + + process = parse_process(process_str, QEDModel()) + graph = gen_graph(process) + inputs = Vector([gen_process_input(process) for _ in 1:n_inputs]) + + get_compute_function(graph, process, machine) + + while true + func = get_compute_function(graph, process, machine) + kernel! = get_cuda_kernel(graph, process, machine) + res = bench(func, kernel!, inputs) + + graph_properties = get_properties(graph) + push!( + df, + ( + Threads.nthreads(), + process_str, + n, + opt_time_cum, + graph_properties.noNodes, + graph_properties.noEdges, + graph_properties.computeEffort, + graph_properties.data, + graph_properties.computeIntensity, + res.cpu_single_thread_time, + res.cpu_single_thread_std, + res.cpu_multi_thread_time, + res.cpu_multi_thread_std, + res.cpu_mem, + res.gpu_time, + res.gpu_std, + res.gpu_mem, + ), + ) + CSV.write(results_filename, df) + + if fixpoint_reached(optimizer, graph) + break + end + + opt_time_cum += @elapsed optimize!(optimizer, graph, STEPSIZE) + n += STEPSIZE + end +end + +CSV.write(results_filename, df) + +for (process_str, STEPSIZE) in [("AB->AB", 1), ("AB->ABBB", 1), ("AB->ABBBBB", 1)] + n = 0 + opt_time_cum = 0 + + process = parse_process(process_str, ABCModel()) + graph = parse_dag("input/$process_str.txt", ABCModel()) + inputs = Vector([gen_process_input(process) for _ in 1:n_inputs]) + + get_compute_function(graph, process, machine) + + while true + func = get_compute_function(graph, process, machine) + kernel! = get_cuda_kernel(graph, process, machine) + res = bench(func, kernel!, inputs) + + graph_properties = get_properties(graph) + push!( + df, + ( + Threads.nthreads(), + process_str, + n, + opt_time_cum, + graph_properties.noNodes, + graph_properties.noEdges, + graph_properties.computeEffort, + graph_properties.data, + graph_properties.computeIntensity, + res.cpu_single_thread_time, + res.cpu_single_thread_std, + res.cpu_multi_thread_time, + res.cpu_multi_thread_std, + res.cpu_mem, + res.gpu_time, + res.gpu_std, + res.gpu_mem, + ), + ) + CSV.write(results_filename, df) + + if fixpoint_reached(optimizer, graph) + break + end + + opt_time_cum += @elapsed optimize!(optimizer, graph, STEPSIZE) + n += STEPSIZE + end +end + +CSV.write(results_filename, df) diff --git a/examples/qed_bench_tape.jl b/examples/qed_bench_tape.jl new file mode 100644 index 0000000..ecf9487 --- /dev/null +++ b/examples/qed_bench_tape.jl @@ -0,0 +1,232 @@ +using MetagraphOptimization +using LIKWID +using UUIDs +using DataFrames +using CSV +using Random +using BenchmarkTools +using Dates + +function log(x...) + println(now(), " ", join(x, " ")...) + return flush(stdout) +end + +results_filename = "bench_results_tape_$(Threads.nthreads()).csv" + +df = DataFrame( + process_name = String[], + graph_gen_time = Float64[], + optimization_time = Float64[], + function_generation_time = Float64[], + graph_nodes = Int[], + graph_edges = Int[], + graph_mem = Float64[], + cpu_threads = Int[], + n_inputs = Int[], + nflops_likwid = Int[], + cpu_time = Float64[], + cpu_rate = Float64[], + cpu_gflops = Float64[], + cpu_std = Float64[], + gpu_name = String[], + gpu_time = Float64[], + gpu_std = Float64[], + gpu_rate = Float64[], + gpu_gflops = Float64[], +) + +# if they exist, read existing results and append new ones +if isfile(results_filename) + df = CSV.read(results_filename, DataFrame) +end + +nInputs = 1_000_000 + +# use "mock" machine that only uses cpu +machine = Machine( + [ + MetagraphOptimization.NumaNode( + 0, + 1, + MetagraphOptimization.default_strategy(MetagraphOptimization.NumaNode), + -1.0, + UUIDs.uuid1(), + ), + ], + [-1.0;;], +) + + +function cpu_bench(tape, inputs) + bench = @benchmark begin + @inbounds Threads.@threads for i in eachindex($inputs) + execute_tape($tape, $inputs[i]) + end + end gcsample = true seconds = 300 + + time = mean(bench.times) / 1e9 + s = std(bench.times) / 1e9 + rate = length(inputs) / time + + return (time, rate, s) +end + +function bench_process( + process::MetagraphOptimization.AbstractProcessDescription, + process_name::String, + graph::DAG, + gen_time::Float64, + opt_time::Float64, + io::IO = stdout; + use_likwid = false, +) + log("\n--- Benchmarking $(process_name) ---") + + func_time = @elapsed tape = gen_tape(graph, process, machine) + + graph_props = GraphProperties(graph) + NFLOPs = graph_props.computeEffort + nflops_likwid = 0 + if use_likwid + input = gen_process_input(process) + + # get rid of annoying output to console + oldstd = stdout + redirect_stdout(devnull) + _, events = @perfmon "FLOPS_DP" execute_tape(tape, input) + redirect_stdout(oldstd) # recover original stdout + + NFLOPs = first(events["FLOPS_DP"])["RETIRED_SSE_AVX_FLOPS_ALL"] + nflops_likwid = NFLOPs + end + + log("Generating $nInputs inputs with $(Threads.nthreads()) threads...") + + inputs = Vector{typeof(gen_process_input(process))}() + resize!(inputs, nInputs) + processes = Vector{typeof(process)}() + for i in 1:Threads.nthreads() + push!(processes, copy(process)) + end + + @inbounds Threads.@threads for i in eachindex(inputs) + inputs[i] = gen_process_input(processes[Threads.nthreads()]) + end + + log("Benchmarking CPU with $(Threads.nthreads()) threads...") + (time_cpu, rate_cpu, std_cpu) = cpu_bench(tape, inputs) + flops_cpu = (rate_cpu * NFLOPs) / 10^9 + + log("\nBenchmark Summary for $(process):") + + if use_likwid + log("Measured FLOPS by LIKWID: $NFLOPs") + else + log("Total graph compute effort: $NFLOPs") + end + log("Total input size: $(bytes_to_human_readable(Base.summarysize(inputs)))") + log("CPU, $(Threads.nthreads()) threads") + log(" Time: $time_cpu") + log(" Rate: $rate_cpu") + log(" GFLOPS: $flops_cpu") + + if (process_name != "warmup") + push!( + df, + Dict( + :process_name => process_name, + :graph_gen_time => gen_time, + :optimization_time => opt_time, + :function_generation_time => func_time, + :graph_nodes => graph_props.noNodes, + :graph_edges => graph_props.noEdges, + :graph_mem => MetagraphOptimization.mem(graph), + :cpu_threads => Threads.nthreads(), + :n_inputs => nInputs, + :nflops_likwid => nflops_likwid, + :cpu_time => time_cpu, + :cpu_std => std_cpu, + :cpu_rate => rate_cpu, + :cpu_gflops => flops_cpu, + :gpu_name => "none", + :gpu_time => 0.0, + :gpu_std => 0.0, + :gpu_rate => 0.0, + :gpu_gflops => 0.0, + ), + ) + end + + return nothing +end + +function bench_qed(process_string::String, skip_unoptimized = false) + optimizer = ReductionOptimizer() + + process = parse_process(process_string, QEDModel()) + gen_time = @elapsed graph = gen_graph(process) + opt_time = 0.0 + if !skip_unoptimized + bench_process(process, "$process not optimized tape", graph, gen_time, opt_time) + end + + opt_time = @elapsed optimize_to_fixpoint!(optimizer, graph) + bench_process(process, "$process reduced tape", graph, gen_time, opt_time) + + return nothing +end + +function bench_abc(process_string::String) + optimizer = ReductionOptimizer() + + process = parse_process(process_string, ABCModel()) + gen_time = @elapsed graph = parse_dag("input/$process_string.txt", ABCModel()) + bench_process(process, "$process not optimized tape", graph, gen_time, 0.0) + + opt_time = @elapsed optimize_to_fixpoint!(optimizer, graph) + bench_process(process, "$process reduced tape", graph, gen_time, opt_time) + + return nothing +end + +# sadly cannot put these in functions because the world age must increase after the function is created which happens only in the global scope + +## -- WARMUP TO COMPILE FUNCTIONS first +optimizer = ReductionOptimizer() + +process = parse_process("ke->kke", QEDModel()) +gen_time = @elapsed graph = gen_graph(process) +opt_time = @elapsed optimize_to_fixpoint!(optimizer, graph) +bench_process(process, "warmup", graph, gen_time, opt_time) + +# AB->AB^3 +process = parse_process("AB->ABBB", ABCModel()) +gen_time = @elapsed graph = parse_dag("input/AB->ABBB.txt", ABCModel()) +opt_time = @elapsed optimize_to_fixpoint!(optimizer, graph) +bench_process(process, "warmup", graph, gen_time, opt_time) + +## -- WARMUP END + +# compton +bench_qed("ke->ke") +CSV.write(results_filename, df) +bench_qed("ke->kke") +CSV.write(results_filename, df) +bench_qed("ke->kkke") +CSV.write(results_filename, df) +bench_qed("ke->kkkke") +CSV.write(results_filename, df) +bench_qed("ke->kkkkke") +CSV.write(results_filename, df) +bench_qed("ke->kkkkkke") +CSV.write(results_filename, df) +bench_qed("ke->kkkkkkke") +CSV.write(results_filename, df) + +bench_abc("AB->AB") +CSV.write(results_filename, df) +bench_abc("AB->ABBB") +CSV.write(results_filename, df) +bench_abc("AB->ABBBBB") +CSV.write(results_filename, df) diff --git a/examples/qed_gen_bench.jl b/examples/qed_gen_bench.jl new file mode 100644 index 0000000..e97f42c --- /dev/null +++ b/examples/qed_gen_bench.jl @@ -0,0 +1,144 @@ +using MetagraphOptimization +using DataFrames +using CSV +using BenchmarkTools +using StatsBase + +results_filename = "qed_gen_results_$(Threads.nthreads()).csv" + +df = DataFrame( + process_name = String[], + cpu_threads = Int[], + graph_gen_samples = Int[], + graph_gen_mean = Float64[], + graph_gen_std = Float64[], + graph_gen_median = Float64[], + graph_nodes = Int[], + graph_data_nodes = Int[], + graph_u_nodes = Int[], + graph_v_nodes = Int[], + graph_s1_nodes = Int[], + graph_s2_nodes = Int[], + graph_edges = Int[], + graph_nodes_reduced = Int[], + graph_data_nodes_reduced = Int[], + graph_u_nodes_reduced = Int[], + graph_v_nodes_reduced = Int[], + graph_s1_nodes_reduced = Int[], + graph_s2_nodes_reduced = Int[], + graph_edges_reduced = Int[], + graph_mem = Float64[], + graph_mem_reduced = Float64[], + graph_elapsed_reduce = Float64[], +) + +function bench_process(process::AbstractString; warmup = false, optimize = true) + println("Benchmarking $process...") + model = QEDModel() + + proc = parse_process(process, model) + + gen_bench = @benchmark gen_graph($proc) gcsample = true seconds = 5 + + graph = gen_graph(proc) + + props = GraphProperties(graph) + node_dict = countmap(typeof.(graph.nodes)) + graph_size = Base.summarysize(graph) + + reduce_elapsed = -1.0 + node_dict_reduced = Dict() + graph_size_reduced = -1.0 + props_reduced = GraphProperties() + if optimize + reduce_elapsed = @elapsed optimize_to_fixpoint!(ReductionOptimizer(), graph) + + props_reduced = GraphProperties(graph) + node_dict_reduced = countmap(typeof.(graph.nodes)) + graph_size_reduced = Base.summarysize(graph) + end + + if warmup + return nothing + end + + push!( + df, + Dict( + :process_name => process, + :cpu_threads => Threads.nthreads(), + :graph_gen_samples => length(gen_bench.times), + :graph_gen_mean => mean(gen_bench.times), + :graph_gen_std => std(gen_bench.times), + :graph_gen_median => median(gen_bench.times), + :graph_nodes => props.noNodes, + :graph_data_nodes => get(node_dict, DataTaskNode{DataTask}, 0), + :graph_u_nodes => get(node_dict, ComputeTaskNode{ComputeTaskQED_U}, 0), + :graph_v_nodes => get(node_dict, ComputeTaskNode{ComputeTaskQED_V}, 0), + :graph_s1_nodes => get(node_dict, ComputeTaskNode{ComputeTaskQED_S1}, 0), + :graph_s2_nodes => get(node_dict, ComputeTaskNode{ComputeTaskQED_S2}, 0), + :graph_edges => props.noEdges, + :graph_nodes_reduced => props_reduced.noNodes, + :graph_data_nodes_reduced => get(node_dict_reduced, DataTaskNode{DataTask}, 0), + :graph_u_nodes_reduced => get(node_dict_reduced, ComputeTaskNode{ComputeTaskQED_U}, 0), + :graph_v_nodes_reduced => get(node_dict_reduced, ComputeTaskNode{ComputeTaskQED_V}, 0), + :graph_s1_nodes_reduced => get(node_dict_reduced, ComputeTaskNode{ComputeTaskQED_S1}, 0), + :graph_s2_nodes_reduced => get(node_dict_reduced, ComputeTaskNode{ComputeTaskQED_S2}, 0), + :graph_edges_reduced => props_reduced.noEdges, + :graph_mem => graph_size, + :graph_mem_reduced => graph_size_reduced, + :graph_elapsed_reduce => reduce_elapsed, + ), + ) + return nothing +end + +processes = [ + ("ke->ke", true), + ("ke->kke", true), + ("ke->kkke", true), + ("ke->kkkke", true), + ("ke->kkkkke", true), + ("ke->kkkkkke", true), + ("ke->kkkkkkke", true), + #("ke->kkkkkkkke", false), + #("ke->kkkkkkkkke", false), +] + +df = DataFrame( + process_name = String[], + cpu_threads = Int[], + graph_gen_samples = Int[], + graph_gen_mean = Float64[], + graph_gen_std = Float64[], + graph_gen_median = Float64[], + graph_nodes = Int[], + graph_data_nodes = Int[], + graph_u_nodes = Int[], + graph_v_nodes = Int[], + graph_s1_nodes = Int[], + graph_s2_nodes = Int[], + graph_edges = Int[], + graph_nodes_reduced = Int[], + graph_data_nodes_reduced = Int[], + graph_u_nodes_reduced = Int[], + graph_v_nodes_reduced = Int[], + graph_s1_nodes_reduced = Int[], + graph_s2_nodes_reduced = Int[], + graph_edges_reduced = Int[], + graph_mem = Float64[], + graph_mem_reduced = Float64[], + graph_elapsed_reduce = Float64[], +) + +# if they exist, read existing results and append new ones +if isfile(results_filename) + df = CSV.read(results_filename, DataFrame) +end + +bench_process("ke->kke", warmup = true) + +for (process, opt) in processes + bench_process(process, optimize = opt) + CSV.write(results_filename, df) +end diff --git a/examples/reduction.ipynb b/examples/reduction.ipynb deleted file mode 100644 index cfa8674..0000000 --- a/examples/reduction.ipynb +++ /dev/null @@ -1,542 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Threads: 32\n" - ] - } - ], - "source": [ - "#using Pkg\n", - "#Pkg.add(url=\"https://github.com/QEDjl-project/QEDprocesses.jl/\")\n", - "\n", - "using MetagraphOptimization\n", - "using CUDA\n", - "using UUIDs\n", - "using BenchmarkTools\n", - "\n", - "println(\"Threads: $(Threads.nthreads())\")" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "compute__5aa84716_9ba0_11ee_31df_554757739f76 (generic function with 1 method)" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# preparation of graph\n", - "machine = Machine([MetagraphOptimization.NumaNode(0, 1, MetagraphOptimization.default_strategy(MetagraphOptimization.NumaNode), -1.0, UUIDs.uuid1())], [-1.0;;])\n", - "model = QEDModel()\n", - "process = parse_process(\"ke->kkkkke\", model)\n", - "graph = gen_graph(process)\n", - "n_inputs = 10_000\n", - "inputs = [gen_process_input(process) for _ in 1:n_inputs]\n", - "cu_inputs = CuArray(inputs)\n", - "optimizer = ReductionOptimizer()\n", - "\n", - "get_compute_function(graph, process, machine) # run once for compilation" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "bench (generic function with 1 method)" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "function bench(func, inputs, cu_inputs)\n", - " compile_time = @elapsed func(inputs[1])\n", - "\n", - " single_thread = @elapsed func.(inputs)\n", - " multi_threaded = @elapsed Threads.@threads for i in eachindex(inputs)\n", - " func(inputs[i]) \n", - " end\n", - " \n", - " gpu_compile = 0 #@elapsed CUDA.@sync func.(cu_inputs[1:2])\n", - " gpu = 0 #@elapsed CUDA.@sync func.(cu_inputs)\n", - " return (cpu_compile_time = compile_time, gpu_compile_time = gpu_compile, cpu_single_thread_time = single_thread, cpu_multi_thread_time = multi_threaded, gpu_time = gpu)\n", - "end" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "# bench and produce data\n", - "using DataFrames\n", - "\n", - "STEPSIZE = 10\n", - "n = 0\n", - "\n", - "df = DataFrame(operations=Int[], graph_nodes=Int[], graph_edges=Int[], graph_ce=Float64[], graph_dt=Float64[], graph_ci=Float64[], gen_func_t=Float64[], cpu_compile_t=Float64[], cpu_st_t=Float64[], cpu_mt_t=Float64[], gpu_compile_t=Float64[], gpu_t=Float64[])\n", - "\n", - "while true\n", - " func_gen_time = @elapsed func = get_compute_function(graph, process, machine)\n", - " res = bench(func, inputs, cu_inputs)\n", - "\n", - " graph_properties = get_properties(graph)\n", - " push!(df, (\n", - " n,\n", - " graph_properties.noNodes,\n", - " graph_properties.noEdges,\n", - " graph_properties.computeEffort,\n", - " graph_properties.data,\n", - " graph_properties.computeIntensity,\n", - " func_gen_time,\n", - " res.cpu_compile_time,\n", - " res.cpu_single_thread_time,\n", - " res.cpu_multi_thread_time,\n", - " res.gpu_compile_time,\n", - " res.gpu_time\n", - " ))\n", - "\n", - " if fixpoint_reached(optimizer, graph)\n", - " break\n", - " end\n", - "\n", - " optimize!(optimizer, graph, STEPSIZE)\n", - " n += STEPSIZE\n", - "end\n", - ";" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "image/svg+xml": [ - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# plot data\n", - "using Plots\n", - "using StatsPlots\n", - "\n", - "img = @df df scatter(\n", - " :operations, \n", - " [:gen_func_t, :cpu_st_t, :cpu_mt_t], \n", - " label=[\"Function generation (s)\" \"Single threaded execution (s)\" \"$(Threads.nthreads())-threaded execution (s)\"], \n", - " title=\"$process using $optimizer ($(n_inputs) inputs)\",\n", - " linewidth=2,\n", - " xlabel=\"optimizer steps\",\n", - " ylabel=\"time (s)\",\n", - " yscale=:log10,\n", - " minorgrid=true,\n", - " size=(800, 600),\n", - " fmt=:pdf\n", - ")\n", - "\n", - "savefig(img, \"../images/$(String(process))_exec_$(n_inputs)_inputs.pdf\")\n", - "\n", - "img" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "image/svg+xml": [ - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "img = @df df scatter(\n", - " :operations,\n", - " [:graph_nodes, :graph_edges],\n", - " label=[\"Graph Nodes (#)\" \"Graph Edges (#)\"],\n", - " title=\"$process using $optimizer\",\n", - " linewidth=2,\n", - " xlabel=\"optimizer steps\",\n", - " ylims=(0.0, 1.05 * maximum(df.graph_edges)),\n", - " fmt=:pdf,\n", - " size=(800, 600)\n", - ")\n", - "\n", - "savefig(img, \"../images/$(String(process))_graph_properties.pdf\")\n", - "\n", - "img" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Julia 1.9.4 (32 Threads)", - "language": "julia", - "name": "julia-1.9" - }, - "language_info": { - "file_extension": ".jl", - "mimetype": "application/julia", - "name": "julia", - "version": "1.9.4" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/experiments/CUDA_container.def b/experiments/CUDA_container.def new file mode 100644 index 0000000..c12d99c --- /dev/null +++ b/experiments/CUDA_container.def @@ -0,0 +1,63 @@ +Bootstrap: docker +From: nvidia/cuda:12.3.1-devel-ubuntu20.04 + +%labels + Requires CUDA driver 470.57+. + +%environment + export LANG=C + +%runscript + nvidia-smi + ./run.sh + +%post + . /.singularity.d/env/10-docker*.sh + + apt-get update + apt-get install -y pciutils + DEBIAN_FRONTEND='noninteractive' apt-get -y -o Dpkg::Options::='--force-confdef' -o Dpkg::Options::='--force-confold' install build-essential cuda-compat-12-3 libibverbs-dev ibverbs-utils gcc wget git libcap2-bin + apt-get -y autoremove; apt-get -y clean + + cd /tmp + + # install slurm + : ${SLURM_VERSION:=17-02-11-1} + wget https://github.com/SchedMD/slurm/archive/slurm-${SLURM_VERSION}.tar.gz + tar -xf slurm-${SLURM_VERSION}.tar.gz + cd slurm-slurm-${SLURM_VERSION} + ./configure --prefix=/usr/ --sysconfdir=/etc/slurm --localstatedir=/var --disable-debug + make -C contribs/pmi2 -j$(nproc) install + cd .. + rm -rf slurm-* + + # install julia + cd ~ + wget https://julialang-s3.julialang.org/bin/linux/x64/1.9/julia-1.9.4-linux-x86_64.tar.gz + tar zxvf julia-1.9.4-linux-x86_64.tar.gz + mv julia-1.9.4/ /opt/julia-1.9.4 + #mkdir /usr/local/bin + ln -s /opt/julia-1.9.4/bin/julia /usr/local/bin/julia + + #Add nvidia driver paths to the environment variables + echo "\n #Nvidia driver paths \n" >> /environment + echo 'export PATH="/nvbin:$PATH"' >> /environment + echo 'export LD_LIBRARY_PATH="/nvlib:$LD_LIBRARY_PATH"' >> /environment + + #Add CUDA paths + echo "\n #Cuda paths \n" >> /environment + echo 'export CPATH="/usr/local/cuda/include:$CPATH"' >> /environment + echo 'export PATH="/usr/local/cuda/bin:$PATH"' >> /environment + echo 'export LD_LIBRARY_PATH="/usr/local/cuda/lib64:$LD_LIBRARY_PATH"' >> /environment + echo 'export CUDA_HOME="/usr/local/cuda"' >> /environment + + # install likwid + VERSION=5.3.0 + wget http://ftp.fau.de/pub/likwid/likwid-$VERSION.tar.gz + tar -xaf likwid-$VERSION.tar.gz + cd likwid-$VERSION + # accessdaemon doesn't work because of permissions + sed -i 's/ACCESSMODE = accessdaemon/ACCESSMODE = perf_event/g' config.mk + make -j4 + make -j4 install + echo 'export LD_LIBRARY_PATH="/usr/local/lib:$LD_LIBRARY_PATH"' >> /environment diff --git a/experiments/cluster/diagram_bench_hemera.sh b/experiments/cluster/diagram_bench_hemera.sh new file mode 100755 index 0000000..1aa8975 --- /dev/null +++ b/experiments/cluster/diagram_bench_hemera.sh @@ -0,0 +1,22 @@ +#!/bin/bash +#SBATCH --array=1-32 +#SBATCH --job-name=qed_bench +#SBATCH --partition=intel +#SBATCH --time=16:00:00 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --cpus-per-task=32 +#SBATCH --mem=16GB +#SBATCH --output=simulation-%A-%a.out +#SBATCH --error=simulation-%A-%a.err + +cd $HOME/repos/metagraph_optimization + +module load singularity +module load git + +printf "Current git commit hash: " > results/git.txt +git rev-parse HEAD >> results/git.txt +git status >> results/git.txt + +singularity exec experiments/CUDA_container.sif ./experiments/run_qed_exec.sh $SLURM_ARRAY_TASK_ID diff --git a/experiments/cluster/diagram_bench_hemera_a100.sh b/experiments/cluster/diagram_bench_hemera_a100.sh new file mode 100755 index 0000000..a5d6962 --- /dev/null +++ b/experiments/cluster/diagram_bench_hemera_a100.sh @@ -0,0 +1,24 @@ +#!/bin/bash +#SBATCH --job-name=qed_bench +#SBATCH --partition=casus_a100 +#SBATCH --account=casus +#SBATCH --time=8:00:00 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --cpus-per-task=32 +#SBATCH --gres=gpu:1 +#SBATCH --mem=256GB +#SBATCH --output=simulation-%A-%a.out +#SBATCH --error=simulation-%A-%a.err + +cd $HOME/repos/metagraph_optimization + +module load singularity +module load git +module load cuda/12.1 + +printf "Current git commit hash: " > results/git.txt +git rev-parse HEAD >> results/git.txt +git status >> results/git.txt + +singularity exec --nv experiments/CUDA_container.sif ./experiments/run_qed_exec.sh 32 diff --git a/experiments/cluster/full_node_hemera.sh b/experiments/cluster/full_node_hemera.sh new file mode 100755 index 0000000..981af97 --- /dev/null +++ b/experiments/cluster/full_node_hemera.sh @@ -0,0 +1,24 @@ +#!/bin/bash +#SBATCH --job-name=qed_bench +#SBATCH --partition=casus_a100 +#SBATCH --account=casus +#SBATCH --time=8:00:00 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --cpus-per-task=128 +#SBATCH --gres=gpu:4 +#SBATCH --mem=2048GB +#SBATCH --output=simulation-%A-%a.out +#SBATCH --error=simulation-%A-%a.err + +cd $HOME/repos/metagraph_optimization + +module load singularity +module load git +module load cuda/12.1 + +printf "Current git commit hash: " > results/git_reduce_bench_gpu.txt +git rev-parse HEAD >> results/git_reduce_bench_gpu.txt +git status >> results/git_reduce_bench_gpu.txt + +singularity exec --nv experiments/CUDA_container.sif ./experiments/full_node.sh diff --git a/experiments/cluster/gen_diagram_hemera.sh b/experiments/cluster/gen_diagram_hemera.sh new file mode 100755 index 0000000..6cfa19a --- /dev/null +++ b/experiments/cluster/gen_diagram_hemera.sh @@ -0,0 +1,22 @@ +#!/bin/bash +#SBATCH --array=1-8 +#SBATCH --job-name=qed_diag_gen +#SBATCH --partition=intel +#SBATCH --time=4:00:00 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --cpus-per-task=8 +#SBATCH --mem=64GB +#SBATCH --output=simulation-%A-%a.out +#SBATCH --error=simulation-%A-%a.err + +cd $HOME/repos/metagraph_optimization + +module load singularity +module load git + +printf "Current git commit hash: " > results/git.txt +git rev-parse HEAD >> results/git.txt +git status >> results/git.txt + +singularity exec experiments/CUDA_container.sif ./experiments/run_gen_diagram.sh $SLURM_ARRAY_TASK_ID diff --git a/experiments/cluster/reduce_bench_hemera.sh b/experiments/cluster/reduce_bench_hemera.sh new file mode 100755 index 0000000..6c2cc11 --- /dev/null +++ b/experiments/cluster/reduce_bench_hemera.sh @@ -0,0 +1,21 @@ +#!/bin/bash +#SBATCH --job-name=qed_bench +#SBATCH --partition=intel +#SBATCH --time=48:00:00 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --cpus-per-task=32 +#SBATCH --mem=24GB +#SBATCH --output=simulation-%A-%a.out +#SBATCH --error=simulation-%A-%a.err + +cd $HOME/repos/metagraph_optimization + +module load singularity +module load git + +printf "Current git commit hash: " > results/git_reduce_bench.txt +git rev-parse HEAD >> results/git_reduce_bench.txt +git status >> results/git_reduce_bench.txt + +singularity exec experiments/CUDA_container.sif ./experiments/run_reduce_bench.sh diff --git a/experiments/cluster/reduce_bench_hemera_gpu.sh b/experiments/cluster/reduce_bench_hemera_gpu.sh new file mode 100755 index 0000000..32e1f85 --- /dev/null +++ b/experiments/cluster/reduce_bench_hemera_gpu.sh @@ -0,0 +1,24 @@ +#!/bin/bash +#SBATCH --job-name=qed_bench +#SBATCH --partition=casus_a100 +#SBATCH --account=casus +#SBATCH --time=16:00:00 +#SBATCH --nodes=1 +#SBATCH --ntasks=1 +#SBATCH --cpus-per-task=32 +#SBATCH --gres=gpu:1 +#SBATCH --mem=256GB +#SBATCH --output=simulation-%A-%a.out +#SBATCH --error=simulation-%A-%a.err + +cd $HOME/repos/metagraph_optimization + +module load singularity +module load git +module load cuda/12.1 + +printf "Current git commit hash: " > results/git_reduce_bench_gpu.txt +git rev-parse HEAD >> results/git_reduce_bench_gpu.txt +git status >> results/git_reduce_bench_gpu.txt + +singularity exec --nv experiments/CUDA_container.sif ./experiments/run_reduce_bench_gpu.sh diff --git a/experiments/full_node.sh b/experiments/full_node.sh new file mode 100755 index 0000000..658defd --- /dev/null +++ b/experiments/full_node.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd ) +LOG_FILE="$SCRIPT_DIR/../julia_full_node.log" + +cd $SCRIPT_DIR/.. + +echo "Writing system info..." + +# collect some information of the used node and system +uname -a > results/system_full_node.txt +julia --version > results/julia_full_node.txt +lscpu > results/cpu_full_node.txt +nvidia-smi > results/cuda_gpu_full_node.txt +lsblk > results/storage_full_node.txt +lspci > results/pci_full_node.txt + +#echo "Initiating julia..." +#julia --threads=8 --project=./ -e 'using Pkg; Pkg.instantiate(); Pkg.add(url="https://github.com/QEDjl-project/QEDprocesses.jl/")' >> $LOG_FILE 2>&1 || exit 1 # need current dev version of QEDprocesses +#julia --threads=8 --project=./ -e 'using Pkg; Pkg.instantiate(); Pkg.add(url="https://github.com/AntonReinhard/QEDbase.jl/tree/fix_bs_multiplication")' >> $LOG_FILE 2>&1 || exit 1 # need a specific fix for abs*bs multiplication for gpu +#julia --threads=8 -e 'using Pkg; Pkg.add("CSV"); Pkg.add("DataFrames"); Pkg.add("CUDA"); Pkg.add("Random"); Pkg.add("BenchmarkTools"); Pkg.add("Dates")' >> $LOG_FILE 2>&1 || exit 1 # add requirements for the bench script +#julia --project -e 'using CUDA; CUDA.set_runtime_version!(VersionNumber("12.1"))' >> $LOG_FILE 2>&1 || echo "Failed to set CUDA version number" + +echo "Benchmarking Full Node 128 Threads + *GPUs*" +julia --project -O3 --threads=128 examples/full_node_bench.jl >> $LOG_FILE 2>&1 || echo "-- Something went wrong, check logs --" diff --git a/experiments/run_gen_diagram.sh b/experiments/run_gen_diagram.sh new file mode 100755 index 0000000..6d5fd83 --- /dev/null +++ b/experiments/run_gen_diagram.sh @@ -0,0 +1,27 @@ +#!/bin/bash + +# first arg = number of threads +i=$1 + +SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd ) +LOG_FILE="$SCRIPT_DIR/../julia.log" + +cd $SCRIPT_DIR/.. + +echo "Writing system info..." + +# collect some information of the used node and system +uname -a > results/system.txt +julia --version > results/julia.txt +lscpu > results/cpu.txt +lsblk > results/storage.txt +lspci > results/pci.txt + +echo "Initiating julia..." +julia --threads=8 --project=./ -e 'using Pkg; Pkg.instantiate(); Pkg.add(url="https://github.com/QEDjl-project/QEDprocesses.jl/")' >> $LOG_FILE 2>&1 || exit 1 # need current dev version of QEDprocesses +julia --threads=8 --project=./ -e 'using Pkg; Pkg.instantiate(); Pkg.add(url="https://github.com/AntonReinhard/QEDbase.jl/tree/fix_bs_multiplication")' >> $LOG_FILE 2>&1 || exit 1 # need a specific fix for abs*bs multiplication for gpu +julia --threads=8 -e 'using Pkg; Pkg.add("CSV"); Pkg.add("DataFrames"); Pkg.add("BenchmarkTools"); Pkg.add("StatsBase")' >> $LOG_FILE 2>&1 || exit 1 # add requirements for the bench script + +echo "Benchmarking with $i threads..." + +julia --project -O3 --threads=$i examples/qed_gen_bench.jl >> $LOG_FILE 2>&1 || echo "-- Something went wrong, check logs --" diff --git a/experiments/run_qed_exec.sh b/experiments/run_qed_exec.sh new file mode 100755 index 0000000..a84ef8b --- /dev/null +++ b/experiments/run_qed_exec.sh @@ -0,0 +1,31 @@ +#!/bin/bash + +# first arg = number of threads +i=$1 + +SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd ) +LOG_FILE="$SCRIPT_DIR/../julia_$i.log" + +cd $SCRIPT_DIR/.. + +echo "Writing system info..." + +# collect some information of the used node and system +uname -a > results/system_$i.txt +julia --version > results/julia_$i.txt +lscpu > results/cpu_$i.txt +nvidia-smi > results/cuda_gpu_$i.txt +lsblk > results/storage_$i.txt +lspci > results/pci_$i.txt + +echo "Initiating julia..." +#julia --threads=8 --project=./ -e 'using Pkg; Pkg.instantiate(); Pkg.add(url="https://github.com/QEDjl-project/QEDprocesses.jl/")' >> $LOG_FILE 2>&1 || exit 1 # need current dev version of QEDprocesses +#julia --threads=8 --project=./ -e 'using Pkg; Pkg.instantiate(); Pkg.add(url="https://github.com/AntonReinhard/QEDbase.jl/tree/fix_bs_multiplication")' >> $LOG_FILE 2>&1 || exit 1 # need a specific fix for abs*bs multiplication for gpu +#julia --threads=8 -e 'using Pkg; Pkg.add("CSV"); Pkg.add("DataFrames"); Pkg.add("LIKWID"); Pkg.add("CUDA"); Pkg.add("Random"); Pkg.add("BenchmarkTools"); Pkg.add("Dates")' >> $LOG_FILE 2>&1 || exit 1 # add requirements for the bench script +#julia --project -e 'using CUDA; CUDA.set_runtime_version!(VersionNumber("12.1"))' >> $LOG_FILE 2>&1 || echo "Failed to set CUDA version number" + +echo "Benchmarking $i Threads" +julia --project -O3 --threads=$i examples/qed_bench.jl >> $LOG_FILE 2>&1 || echo "-- Something went wrong, check logs --" + +echo "Benchmarking Tape variant $i Threads" +julia --project -O3 --threads=$i examples/qed_bench_tape.jl >> $LOG_FILE 2>&1 || echo "-- Something went wrong, check logs --" diff --git a/experiments/run_reduce_bench.sh b/experiments/run_reduce_bench.sh new file mode 100755 index 0000000..d17966d --- /dev/null +++ b/experiments/run_reduce_bench.sh @@ -0,0 +1,24 @@ +#!/bin/bash + +SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd ) +LOG_FILE="$SCRIPT_DIR/../julia_bench_reduce.log" + +cd $SCRIPT_DIR/.. + +echo "Writing system info..." + +# collect some information of the used node and system +uname -a > results/system_bench_reduce.txt +julia --version > results/julia_bench_reduce.txt +lscpu > results/cpu_bench_reduce.txt +nvidia-smi > results/cuda_gpu_bench_reduce.txt +lsblk > results/storage_bench_reduce.txt +lspci > results/pci_bench_reduce.txt + +#echo "Initiating julia..." +#julia --threads=8 --project=./ -e 'using Pkg; Pkg.instantiate(); Pkg.add(url="https://github.com/QEDjl-project/QEDprocesses.jl/")' >> $LOG_FILE 2>&1 || exit 1 # need current dev version of QEDprocesses +#julia --threads=8 --project=./ -e 'using Pkg; Pkg.instantiate(); Pkg.add(url="https://github.com/AntonReinhard/QEDbase.jl/tree/fix_bs_multiplication")' >> $LOG_FILE 2>&1 || exit 1 # need a specific fix for abs*bs multiplication for gpu +#julia --threads=8 -e 'using Pkg; Pkg.add("CSV"); Pkg.add("DataFrames"); Pkg.add("LIKWID"); Pkg.add("CUDA"); Pkg.add("Random"); Pkg.add("BenchmarkTools"); Pkg.add("Dates")' >> $LOG_FILE 2>&1 || exit 1 # add requirements for the bench script + +echo "Benchmarking Reduction 32 Threads" +julia --project -O3 --threads=32 examples/qed_bench_reduction_steps.jl >> $LOG_FILE 2>&1 || echo "-- Something went wrong, check logs --" diff --git a/experiments/run_reduce_bench_gpu.sh b/experiments/run_reduce_bench_gpu.sh new file mode 100755 index 0000000..ec9ec06 --- /dev/null +++ b/experiments/run_reduce_bench_gpu.sh @@ -0,0 +1,25 @@ +#!/bin/bash + +SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd ) +LOG_FILE="$SCRIPT_DIR/../julia_bench_reduce_gpu.log" + +cd $SCRIPT_DIR/.. + +echo "Writing system info..." + +# collect some information of the used node and system +uname -a > results/system_bench_reduce_gpu.txt +julia --version > results/julia_bench_reduce_gpu.txt +lscpu > results/cpu_bench_reduce_gpu.txt +nvidia-smi > results/cuda_gpu_bench_reduce_gpu.txt +lsblk > results/storage_bench_reduce_gpu.txt +lspci > results/pci_bench_reduce_gpu.txt + +#echo "Initiating julia..." +#julia --threads=8 --project=./ -e 'using Pkg; Pkg.instantiate(); Pkg.add(url="https://github.com/QEDjl-project/QEDprocesses.jl/")' >> $LOG_FILE 2>&1 || exit 1 # need current dev version of QEDprocesses +#julia --threads=8 --project=./ -e 'using Pkg; Pkg.instantiate(); Pkg.add(url="https://github.com/AntonReinhard/QEDbase.jl/tree/fix_bs_multiplication")' >> $LOG_FILE 2>&1 || exit 1 # need a specific fix for abs*bs multiplication for gpu +#julia --threads=8 -e 'using Pkg; Pkg.add("CSV"); Pkg.add("DataFrames"); Pkg.add("LIKWID"); Pkg.add("CUDA"); Pkg.add("Random"); Pkg.add("BenchmarkTools"); Pkg.add("Dates")' >> $LOG_FILE 2>&1 || exit 1 # add requirements for the bench script +#julia --project -e 'using CUDA; CUDA.set_runtime_version!(VersionNumber("12.1"))' >> $LOG_FILE 2>&1 || echo "Failed to set CUDA version number" + +echo "Benchmarking Reduction 32 Threads, *GPU*" +julia --project -O3 --threads=32 examples/qed_bench_reduction_steps_gpu.jl >> $LOG_FILE 2>&1 || echo "-- Something went wrong, check logs --" diff --git a/images/AB->ABBBBB_reduction_bench.pdf b/images/AB->ABBBBB_reduction_bench.pdf new file mode 100644 index 0000000..8f44e34 Binary files /dev/null and b/images/AB->ABBBBB_reduction_bench.pdf differ diff --git a/images/AB->ABBB_reduction_bench.pdf b/images/AB->ABBB_reduction_bench.pdf new file mode 100644 index 0000000..537db47 Binary files /dev/null and b/images/AB->ABBB_reduction_bench.pdf differ diff --git a/images/README.md b/images/README.md new file mode 100644 index 0000000..bd5b9f8 --- /dev/null +++ b/images/README.md @@ -0,0 +1,3 @@ +# Images + +In this folder we collect benchmark results in pdf form which may be useful in the future. diff --git a/images/compton_diagram_gen_comparison.pdf b/images/compton_diagram_gen_comparison.pdf new file mode 100644 index 0000000..a1de74c Binary files /dev/null and b/images/compton_diagram_gen_comparison.pdf differ diff --git a/images/compton_graph_size_reduced.pdf b/images/compton_graph_size_reduced.pdf new file mode 100644 index 0000000..3ecdf13 Binary files /dev/null and b/images/compton_graph_size_reduced.pdf differ diff --git a/images/compton_graph_size_unreduced.pdf b/images/compton_graph_size_unreduced.pdf new file mode 100644 index 0000000..a426cea Binary files /dev/null and b/images/compton_graph_size_unreduced.pdf differ diff --git a/images/compton_graph_size_versus.pdf b/images/compton_graph_size_versus.pdf new file mode 100644 index 0000000..a837294 Binary files /dev/null and b/images/compton_graph_size_versus.pdf differ diff --git a/images/cpu_vs_gpu_abc.pdf b/images/cpu_vs_gpu_abc.pdf new file mode 100644 index 0000000..e9c401b Binary files /dev/null and b/images/cpu_vs_gpu_abc.pdf differ diff --git a/images/cpu_vs_gpu_qed.pdf b/images/cpu_vs_gpu_qed.pdf new file mode 100644 index 0000000..adca145 Binary files /dev/null and b/images/cpu_vs_gpu_qed.pdf differ diff --git a/images/full_node/1bil_size/full_node_chunk_size_1k_rate.pdf b/images/full_node/1bil_size/full_node_chunk_size_1k_rate.pdf new file mode 100644 index 0000000..cf624fa Binary files /dev/null and b/images/full_node/1bil_size/full_node_chunk_size_1k_rate.pdf differ diff --git a/images/full_node/1bil_size/full_node_chunk_size_1k_ratio.pdf b/images/full_node/1bil_size/full_node_chunk_size_1k_ratio.pdf new file mode 100644 index 0000000..72b1c38 Binary files /dev/null and b/images/full_node/1bil_size/full_node_chunk_size_1k_ratio.pdf differ diff --git a/images/full_node/1bil_size/full_node_chunk_size_1k_time.pdf b/images/full_node/1bil_size/full_node_chunk_size_1k_time.pdf new file mode 100644 index 0000000..33ef067 Binary files /dev/null and b/images/full_node/1bil_size/full_node_chunk_size_1k_time.pdf differ diff --git a/images/full_node/1bil_size/full_node_chunk_size_2k_rate.pdf b/images/full_node/1bil_size/full_node_chunk_size_2k_rate.pdf new file mode 100644 index 0000000..1f37ef9 Binary files /dev/null and b/images/full_node/1bil_size/full_node_chunk_size_2k_rate.pdf differ diff --git a/images/full_node/1bil_size/full_node_chunk_size_2k_ratio.pdf b/images/full_node/1bil_size/full_node_chunk_size_2k_ratio.pdf new file mode 100644 index 0000000..42f06fd Binary files /dev/null and b/images/full_node/1bil_size/full_node_chunk_size_2k_ratio.pdf differ diff --git a/images/full_node/1bil_size/full_node_chunk_size_2k_time.pdf b/images/full_node/1bil_size/full_node_chunk_size_2k_time.pdf new file mode 100644 index 0000000..f006104 Binary files /dev/null and b/images/full_node/1bil_size/full_node_chunk_size_2k_time.pdf differ diff --git a/images/full_node/1bil_size/full_node_chunk_size_3k_rate.pdf b/images/full_node/1bil_size/full_node_chunk_size_3k_rate.pdf new file mode 100644 index 0000000..8a167b5 Binary files /dev/null and b/images/full_node/1bil_size/full_node_chunk_size_3k_rate.pdf differ diff --git a/images/full_node/1bil_size/full_node_chunk_size_3k_ratio.pdf b/images/full_node/1bil_size/full_node_chunk_size_3k_ratio.pdf new file mode 100644 index 0000000..447e195 Binary files /dev/null and b/images/full_node/1bil_size/full_node_chunk_size_3k_ratio.pdf differ diff --git a/images/full_node/1bil_size/full_node_chunk_size_3k_time.pdf b/images/full_node/1bil_size/full_node_chunk_size_3k_time.pdf new file mode 100644 index 0000000..64c6153 Binary files /dev/null and b/images/full_node/1bil_size/full_node_chunk_size_3k_time.pdf differ diff --git a/images/full_node/1bil_size/full_node_chunk_size_4k_rate.pdf b/images/full_node/1bil_size/full_node_chunk_size_4k_rate.pdf new file mode 100644 index 0000000..2736b7f Binary files /dev/null and b/images/full_node/1bil_size/full_node_chunk_size_4k_rate.pdf differ diff --git a/images/full_node/1bil_size/full_node_chunk_size_4k_ratio.pdf b/images/full_node/1bil_size/full_node_chunk_size_4k_ratio.pdf new file mode 100644 index 0000000..ae7aac2 Binary files /dev/null and b/images/full_node/1bil_size/full_node_chunk_size_4k_ratio.pdf differ diff --git a/images/full_node/1bil_size/full_node_chunk_size_4k_time.pdf b/images/full_node/1bil_size/full_node_chunk_size_4k_time.pdf new file mode 100644 index 0000000..4d89e37 Binary files /dev/null and b/images/full_node/1bil_size/full_node_chunk_size_4k_time.pdf differ diff --git a/images/full_node/1bil_size/full_node_chunk_size_5k_rate.pdf b/images/full_node/1bil_size/full_node_chunk_size_5k_rate.pdf new file mode 100644 index 0000000..de186b4 Binary files /dev/null and b/images/full_node/1bil_size/full_node_chunk_size_5k_rate.pdf differ diff --git a/images/full_node/1bil_size/full_node_chunk_size_5k_ratio.pdf b/images/full_node/1bil_size/full_node_chunk_size_5k_ratio.pdf new file mode 100644 index 0000000..3273737 Binary files /dev/null and b/images/full_node/1bil_size/full_node_chunk_size_5k_ratio.pdf differ diff --git a/images/full_node/1bil_size/full_node_chunk_size_5k_time.pdf b/images/full_node/1bil_size/full_node_chunk_size_5k_time.pdf new file mode 100644 index 0000000..0cd4c3b Binary files /dev/null and b/images/full_node/1bil_size/full_node_chunk_size_5k_time.pdf differ diff --git a/images/full_node/1bil_size/full_node_process_best_rate.pdf b/images/full_node/1bil_size/full_node_process_best_rate.pdf new file mode 100644 index 0000000..436be16 Binary files /dev/null and b/images/full_node/1bil_size/full_node_process_best_rate.pdf differ diff --git a/images/full_node/1bil_size/full_node_process_best_rate_plus_theory.pdf b/images/full_node/1bil_size/full_node_process_best_rate_plus_theory.pdf new file mode 100644 index 0000000..31e913b Binary files /dev/null and b/images/full_node/1bil_size/full_node_process_best_rate_plus_theory.pdf differ diff --git a/images/full_node/1bil_size/full_node_process_best_time.pdf b/images/full_node/1bil_size/full_node_process_best_time.pdf new file mode 100644 index 0000000..0f33efc Binary files /dev/null and b/images/full_node/1bil_size/full_node_process_best_time.pdf differ diff --git a/images/full_node/64mil_size/full_node_chunk_size_1k_rate.pdf b/images/full_node/64mil_size/full_node_chunk_size_1k_rate.pdf new file mode 100644 index 0000000..d38d509 Binary files /dev/null and b/images/full_node/64mil_size/full_node_chunk_size_1k_rate.pdf differ diff --git a/images/full_node/64mil_size/full_node_chunk_size_1k_ratio.pdf b/images/full_node/64mil_size/full_node_chunk_size_1k_ratio.pdf new file mode 100644 index 0000000..c050a63 Binary files /dev/null and b/images/full_node/64mil_size/full_node_chunk_size_1k_ratio.pdf differ diff --git a/images/full_node/64mil_size/full_node_chunk_size_1k_time.pdf b/images/full_node/64mil_size/full_node_chunk_size_1k_time.pdf new file mode 100644 index 0000000..c0134ab Binary files /dev/null and b/images/full_node/64mil_size/full_node_chunk_size_1k_time.pdf differ diff --git a/images/full_node/64mil_size/full_node_chunk_size_2k_rate.pdf b/images/full_node/64mil_size/full_node_chunk_size_2k_rate.pdf new file mode 100644 index 0000000..da9610e Binary files /dev/null and b/images/full_node/64mil_size/full_node_chunk_size_2k_rate.pdf differ diff --git a/images/full_node/64mil_size/full_node_chunk_size_2k_ratio.pdf b/images/full_node/64mil_size/full_node_chunk_size_2k_ratio.pdf new file mode 100644 index 0000000..1f3cc78 Binary files /dev/null and b/images/full_node/64mil_size/full_node_chunk_size_2k_ratio.pdf differ diff --git a/images/full_node/64mil_size/full_node_chunk_size_2k_time.pdf b/images/full_node/64mil_size/full_node_chunk_size_2k_time.pdf new file mode 100644 index 0000000..9c40cf9 Binary files /dev/null and b/images/full_node/64mil_size/full_node_chunk_size_2k_time.pdf differ diff --git a/images/full_node/64mil_size/full_node_chunk_size_3k_rate.pdf b/images/full_node/64mil_size/full_node_chunk_size_3k_rate.pdf new file mode 100644 index 0000000..db0f05f Binary files /dev/null and b/images/full_node/64mil_size/full_node_chunk_size_3k_rate.pdf differ diff --git a/images/full_node/64mil_size/full_node_chunk_size_3k_ratio.pdf b/images/full_node/64mil_size/full_node_chunk_size_3k_ratio.pdf new file mode 100644 index 0000000..f893627 Binary files /dev/null and b/images/full_node/64mil_size/full_node_chunk_size_3k_ratio.pdf differ diff --git a/images/full_node/64mil_size/full_node_chunk_size_3k_time.pdf b/images/full_node/64mil_size/full_node_chunk_size_3k_time.pdf new file mode 100644 index 0000000..7db8b1a Binary files /dev/null and b/images/full_node/64mil_size/full_node_chunk_size_3k_time.pdf differ diff --git a/images/full_node/64mil_size/full_node_chunk_size_4k_rate.pdf b/images/full_node/64mil_size/full_node_chunk_size_4k_rate.pdf new file mode 100644 index 0000000..078d7a6 Binary files /dev/null and b/images/full_node/64mil_size/full_node_chunk_size_4k_rate.pdf differ diff --git a/images/full_node/64mil_size/full_node_chunk_size_4k_ratio.pdf b/images/full_node/64mil_size/full_node_chunk_size_4k_ratio.pdf new file mode 100644 index 0000000..8c51d97 Binary files /dev/null and b/images/full_node/64mil_size/full_node_chunk_size_4k_ratio.pdf differ diff --git a/images/full_node/64mil_size/full_node_chunk_size_4k_time.pdf b/images/full_node/64mil_size/full_node_chunk_size_4k_time.pdf new file mode 100644 index 0000000..1ef186f Binary files /dev/null and b/images/full_node/64mil_size/full_node_chunk_size_4k_time.pdf differ diff --git a/images/full_node/64mil_size/full_node_chunk_size_5k_rate.pdf b/images/full_node/64mil_size/full_node_chunk_size_5k_rate.pdf new file mode 100644 index 0000000..f824bcf Binary files /dev/null and b/images/full_node/64mil_size/full_node_chunk_size_5k_rate.pdf differ diff --git a/images/full_node/64mil_size/full_node_chunk_size_5k_ratio.pdf b/images/full_node/64mil_size/full_node_chunk_size_5k_ratio.pdf new file mode 100644 index 0000000..f748614 Binary files /dev/null and b/images/full_node/64mil_size/full_node_chunk_size_5k_ratio.pdf differ diff --git a/images/full_node/64mil_size/full_node_chunk_size_5k_time.pdf b/images/full_node/64mil_size/full_node_chunk_size_5k_time.pdf new file mode 100644 index 0000000..9b9b4b2 Binary files /dev/null and b/images/full_node/64mil_size/full_node_chunk_size_5k_time.pdf differ diff --git a/images/full_node/64mil_size/full_node_process_best_rate.pdf b/images/full_node/64mil_size/full_node_process_best_rate.pdf new file mode 100644 index 0000000..d07bd87 Binary files /dev/null and b/images/full_node/64mil_size/full_node_process_best_rate.pdf differ diff --git a/images/full_node/64mil_size/full_node_process_best_rate_plus_theory.pdf b/images/full_node/64mil_size/full_node_process_best_rate_plus_theory.pdf new file mode 100644 index 0000000..840ba19 Binary files /dev/null and b/images/full_node/64mil_size/full_node_process_best_rate_plus_theory.pdf differ diff --git a/images/full_node/64mil_size/full_node_process_best_time.pdf b/images/full_node/64mil_size/full_node_process_best_time.pdf new file mode 100644 index 0000000..153dd09 Binary files /dev/null and b/images/full_node/64mil_size/full_node_process_best_time.pdf differ diff --git a/images/full_node/README.md b/images/full_node/README.md new file mode 100644 index 0000000..96c7aca --- /dev/null +++ b/images/full_node/README.md @@ -0,0 +1,3 @@ +# Full Node Benchmarks + +Done using `experiments/full_node.sh` on hemera, using 128 threads and 4 A100 GPUs. diff --git a/images/fuse_reduce_split_cdplot_greedy.pdf b/images/fuse_reduce_split_cdplot_greedy.pdf new file mode 100644 index 0000000..9cd3832 Binary files /dev/null and b/images/fuse_reduce_split_cdplot_greedy.pdf differ diff --git a/images/gen_memory.pdf b/images/gen_memory.pdf new file mode 100644 index 0000000..10d6b7a Binary files /dev/null and b/images/gen_memory.pdf differ diff --git a/images/gen_times.pdf b/images/gen_times.pdf new file mode 100644 index 0000000..9501e73 Binary files /dev/null and b/images/gen_times.pdf differ diff --git a/images/gpu_rate_NVIDIA A100-SXM4-80GB.pdf b/images/gpu_rate_NVIDIA A100-SXM4-80GB.pdf new file mode 100644 index 0000000..d76a9e6 Binary files /dev/null and b/images/gpu_rate_NVIDIA A100-SXM4-80GB.pdf differ diff --git a/images/gpu_times_NVIDIA A100-SXM4-80GB.pdf b/images/gpu_times_NVIDIA A100-SXM4-80GB.pdf new file mode 100644 index 0000000..c85a698 Binary files /dev/null and b/images/gpu_times_NVIDIA A100-SXM4-80GB.pdf differ diff --git a/images/ke->kke_reduction_bench.pdf b/images/ke->kke_reduction_bench.pdf new file mode 100644 index 0000000..5f426ec Binary files /dev/null and b/images/ke->kke_reduction_bench.pdf differ diff --git a/images/ke->kkke_reduction_bench_lin.pdf b/images/ke->kkke_reduction_bench_lin.pdf new file mode 100644 index 0000000..491ad7a Binary files /dev/null and b/images/ke->kkke_reduction_bench_lin.pdf differ diff --git a/images/ke->kkkke_reduction_bench.pdf b/images/ke->kkkke_reduction_bench.pdf new file mode 100644 index 0000000..2b9954b Binary files /dev/null and b/images/ke->kkkke_reduction_bench.pdf differ diff --git a/images/ke->kkkkke_reduction_bench.pdf b/images/ke->kkkkke_reduction_bench.pdf new file mode 100644 index 0000000..fcfa3e9 Binary files /dev/null and b/images/ke->kkkkke_reduction_bench.pdf differ diff --git a/images/optim_plots/README.md b/images/optim_plots/README.md new file mode 100644 index 0000000..b37c5c1 --- /dev/null +++ b/images/optim_plots/README.md @@ -0,0 +1,5 @@ +# Optimizer Plots + +Plots of FusionOptimizer, ReductionOptimizer, SplitOptimizer, RandomWalkOptimizer, and GreedyOptimizer, executed on a system with 32 threads and an A30 GPU. + +Benchmarked using `notebooks/optimizers.ipynb`. diff --git a/images/optim_plots/qed_k3_cdplot_fuse.pdf b/images/optim_plots/qed_k3_cdplot_fuse.pdf new file mode 100644 index 0000000..942cc6f Binary files /dev/null and b/images/optim_plots/qed_k3_cdplot_fuse.pdf differ diff --git a/images/optim_plots/qed_k3_cdplot_greedy.pdf b/images/optim_plots/qed_k3_cdplot_greedy.pdf new file mode 100644 index 0000000..0a2436e Binary files /dev/null and b/images/optim_plots/qed_k3_cdplot_greedy.pdf differ diff --git a/images/optim_plots/qed_k3_cdplot_random.pdf b/images/optim_plots/qed_k3_cdplot_random.pdf new file mode 100644 index 0000000..ff17523 Binary files /dev/null and b/images/optim_plots/qed_k3_cdplot_random.pdf differ diff --git a/images/optim_plots/qed_k3_cdplot_reduce.pdf b/images/optim_plots/qed_k3_cdplot_reduce.pdf new file mode 100644 index 0000000..d5f43c7 Binary files /dev/null and b/images/optim_plots/qed_k3_cdplot_reduce.pdf differ diff --git a/images/optim_plots/qed_k3_cdplot_split.pdf b/images/optim_plots/qed_k3_cdplot_split.pdf new file mode 100644 index 0000000..3477289 Binary files /dev/null and b/images/optim_plots/qed_k3_cdplot_split.pdf differ diff --git a/images/optim_plots/qed_k3_ce_dt_fuse.pdf b/images/optim_plots/qed_k3_ce_dt_fuse.pdf new file mode 100644 index 0000000..0414b70 Binary files /dev/null and b/images/optim_plots/qed_k3_ce_dt_fuse.pdf differ diff --git a/images/optim_plots/qed_k3_ce_dt_greedy.pdf b/images/optim_plots/qed_k3_ce_dt_greedy.pdf new file mode 100644 index 0000000..04c44dd Binary files /dev/null and b/images/optim_plots/qed_k3_ce_dt_greedy.pdf differ diff --git a/images/optim_plots/qed_k3_ce_dt_random.pdf b/images/optim_plots/qed_k3_ce_dt_random.pdf new file mode 100644 index 0000000..ae0a4ff Binary files /dev/null and b/images/optim_plots/qed_k3_ce_dt_random.pdf differ diff --git a/images/optim_plots/qed_k3_ce_dt_reduce.pdf b/images/optim_plots/qed_k3_ce_dt_reduce.pdf new file mode 100644 index 0000000..d9857a1 Binary files /dev/null and b/images/optim_plots/qed_k3_ce_dt_reduce.pdf differ diff --git a/images/optim_plots/qed_k3_ce_dt_split.pdf b/images/optim_plots/qed_k3_ce_dt_split.pdf new file mode 100644 index 0000000..5b0d0ca Binary files /dev/null and b/images/optim_plots/qed_k3_ce_dt_split.pdf differ diff --git a/images/optim_plots/qed_k3_execution_fuse.pdf b/images/optim_plots/qed_k3_execution_fuse.pdf new file mode 100644 index 0000000..ec1aa1c Binary files /dev/null and b/images/optim_plots/qed_k3_execution_fuse.pdf differ diff --git a/images/optim_plots/qed_k3_execution_greedy.pdf b/images/optim_plots/qed_k3_execution_greedy.pdf new file mode 100644 index 0000000..d1d55c9 Binary files /dev/null and b/images/optim_plots/qed_k3_execution_greedy.pdf differ diff --git a/images/optim_plots/qed_k3_execution_random.pdf b/images/optim_plots/qed_k3_execution_random.pdf new file mode 100644 index 0000000..e0582b1 Binary files /dev/null and b/images/optim_plots/qed_k3_execution_random.pdf differ diff --git a/images/optim_plots/qed_k3_execution_reduce.pdf b/images/optim_plots/qed_k3_execution_reduce.pdf new file mode 100644 index 0000000..4e4745f Binary files /dev/null and b/images/optim_plots/qed_k3_execution_reduce.pdf differ diff --git a/images/optim_plots/qed_k3_execution_split.pdf b/images/optim_plots/qed_k3_execution_split.pdf new file mode 100644 index 0000000..753f0b5 Binary files /dev/null and b/images/optim_plots/qed_k3_execution_split.pdf differ diff --git a/images/optim_plots/qed_k3_nodes_edges_fuse.pdf b/images/optim_plots/qed_k3_nodes_edges_fuse.pdf new file mode 100644 index 0000000..832a51c Binary files /dev/null and b/images/optim_plots/qed_k3_nodes_edges_fuse.pdf differ diff --git a/images/optim_plots/qed_k3_nodes_edges_greedy.pdf b/images/optim_plots/qed_k3_nodes_edges_greedy.pdf new file mode 100644 index 0000000..124cbd3 Binary files /dev/null and b/images/optim_plots/qed_k3_nodes_edges_greedy.pdf differ diff --git a/images/optim_plots/qed_k3_nodes_edges_random.pdf b/images/optim_plots/qed_k3_nodes_edges_random.pdf new file mode 100644 index 0000000..65e6993 Binary files /dev/null and b/images/optim_plots/qed_k3_nodes_edges_random.pdf differ diff --git a/images/optim_plots/qed_k3_nodes_edges_reduce.pdf b/images/optim_plots/qed_k3_nodes_edges_reduce.pdf new file mode 100644 index 0000000..b96a4a1 Binary files /dev/null and b/images/optim_plots/qed_k3_nodes_edges_reduce.pdf differ diff --git a/images/optim_plots/qed_k3_nodes_edges_split.pdf b/images/optim_plots/qed_k3_nodes_edges_split.pdf new file mode 100644 index 0000000..2fde4cc Binary files /dev/null and b/images/optim_plots/qed_k3_nodes_edges_split.pdf differ diff --git a/images/qed_ke-kke_exec_10000_inputs.pdf b/images/qed_ke-kke_exec_10000_inputs.pdf new file mode 100644 index 0000000..fb4658e Binary files /dev/null and b/images/qed_ke-kke_exec_10000_inputs.pdf differ diff --git a/images/qed_ke-kke_graph_properties.pdf b/images/qed_ke-kke_graph_properties.pdf index 83fecf2..de20dc9 100644 Binary files a/images/qed_ke-kke_graph_properties.pdf and b/images/qed_ke-kke_graph_properties.pdf differ diff --git a/images/qed_ke-kkke_exec_10000_inputs.pdf b/images/qed_ke-kkke_exec_10000_inputs.pdf new file mode 100644 index 0000000..516c27f Binary files /dev/null and b/images/qed_ke-kkke_exec_10000_inputs.pdf differ diff --git a/images/qed_ke-kkke_graph_properties.pdf b/images/qed_ke-kkke_graph_properties.pdf index fce3bff..eeeffe0 100644 Binary files a/images/qed_ke-kkke_graph_properties.pdf and b/images/qed_ke-kkke_graph_properties.pdf differ diff --git a/images/reduction_bench_relative.pdf b/images/reduction_bench_relative.pdf new file mode 100644 index 0000000..e6fa4a9 Binary files /dev/null and b/images/reduction_bench_relative.pdf differ diff --git a/images/reduction_bench_relative_cpu_3b_4k.pdf b/images/reduction_bench_relative_cpu_3b_4k.pdf new file mode 100644 index 0000000..9b4a80f Binary files /dev/null and b/images/reduction_bench_relative_cpu_3b_4k.pdf differ diff --git a/images/reduction_bench_relative_cpu_5b_4k.pdf b/images/reduction_bench_relative_cpu_5b_4k.pdf new file mode 100644 index 0000000..c8972cd Binary files /dev/null and b/images/reduction_bench_relative_cpu_5b_4k.pdf differ diff --git a/images/reduction_bench_relative_cpu_vs_gpu.pdf b/images/reduction_bench_relative_cpu_vs_gpu.pdf new file mode 100644 index 0000000..36a51b1 Binary files /dev/null and b/images/reduction_bench_relative_cpu_vs_gpu.pdf differ diff --git a/images/reduction_bench_relative_cpu_vs_gpu_3k.pdf b/images/reduction_bench_relative_cpu_vs_gpu_3k.pdf new file mode 100644 index 0000000..73a2436 Binary files /dev/null and b/images/reduction_bench_relative_cpu_vs_gpu_3k.pdf differ diff --git a/images/reduction_bench_relative_cpu_vs_gpu_4k.pdf b/images/reduction_bench_relative_cpu_vs_gpu_4k.pdf new file mode 100644 index 0000000..6b2b34a Binary files /dev/null and b/images/reduction_bench_relative_cpu_vs_gpu_4k.pdf differ diff --git a/images/reduction_bench_relative_gpu.pdf b/images/reduction_bench_relative_gpu.pdf new file mode 100644 index 0000000..d797e35 Binary files /dev/null and b/images/reduction_bench_relative_gpu.pdf differ diff --git a/images/reduction_bench_relative_gpu_3b_4k.pdf b/images/reduction_bench_relative_gpu_3b_4k.pdf new file mode 100644 index 0000000..44fb55d Binary files /dev/null and b/images/reduction_bench_relative_gpu_3b_4k.pdf differ diff --git a/images/reduction_bench_relative_gpu_5b_4k.pdf b/images/reduction_bench_relative_gpu_5b_4k.pdf new file mode 100644 index 0000000..3e688ec Binary files /dev/null and b/images/reduction_bench_relative_gpu_5b_4k.pdf differ diff --git a/notebooks/README.md b/notebooks/README.md new file mode 100644 index 0000000..15174f3 --- /dev/null +++ b/notebooks/README.md @@ -0,0 +1,3 @@ +# Notebooks + +In this folder is a collection of jupyter notebooks run using Julia kernels and showcasing some features or plotting some diagrams interactively. diff --git a/notebooks/abc_model_large.ipynb b/notebooks/abc_model_large.ipynb index 653a9b1..e98871c 100644 --- a/notebooks/abc_model_large.ipynb +++ b/notebooks/abc_model_large.ipynb @@ -413,15 +413,15 @@ ], "metadata": { "kernelspec": { - "display_name": "Julia 1.9.4", + "display_name": "Julia 1.10.2", "language": "julia", - "name": "julia-1.9" + "name": "julia-1.10" }, "language_info": { "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", - "version": "1.9.4" + "version": "1.10.2" } }, "nbformat": 4, diff --git a/notebooks/abc_model_showcase.ipynb b/notebooks/abc_model_showcase.ipynb index 865c4a3..09a4aac 100644 --- a/notebooks/abc_model_showcase.ipynb +++ b/notebooks/abc_model_showcase.ipynb @@ -391,15 +391,15 @@ ], "metadata": { "kernelspec": { - "display_name": "Julia 1.9.4", + "display_name": "Julia 1.10.2", "language": "julia", - "name": "julia-1.9" + "name": "julia-1.10" }, "language_info": { "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", - "version": "1.9.4" + "version": "1.10.2" } }, "nbformat": 4, diff --git a/notebooks/diagram_gen.ipynb b/notebooks/diagram_gen.ipynb index 290fc4b..f18c1ee 100644 --- a/notebooks/diagram_gen.ipynb +++ b/notebooks/diagram_gen.ipynb @@ -435,15 +435,15 @@ ], "metadata": { "kernelspec": { - "display_name": "Julia 1.9.4", + "display_name": "Julia 1.10.2", "language": "julia", - "name": "julia-1.9" + "name": "julia-1.10" }, "language_info": { "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", - "version": "1.9.4" + "version": "1.10.2" } }, "nbformat": 4, diff --git a/notebooks/large_compton.ipynb b/notebooks/large_compton.ipynb index f5dc873..a36c6c6 100644 --- a/notebooks/large_compton.ipynb +++ b/notebooks/large_compton.ipynb @@ -139,15 +139,15 @@ ], "metadata": { "kernelspec": { - "display_name": "Julia 1.9.4", + "display_name": "Julia 1.10.2", "language": "julia", - "name": "julia-1.9" + "name": "julia-1.10" }, "language_info": { "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", - "version": "1.9.4" + "version": "1.10.2" } }, "nbformat": 4, diff --git a/notebooks/num_diagrams.ipynb b/notebooks/num_diagrams.ipynb new file mode 100644 index 0000000..43fac67 --- /dev/null +++ b/notebooks/num_diagrams.ipynb @@ -0,0 +1,148 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "using Combinatorics" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "num_diagrams_small_form (generic function with 3 methods)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "function num_diagrams(m::Int, e::Int, u::Int = 0, t::Int = 0)\n", + " n = e + u + t\n", + " return Int(factorial(3n-3) / factorial(2n-1)) * binomial(m+3n-3, 3n-3) * factorial(m) * factorial(e) * factorial(u) * factorial(t)\n", + "end\n", + "\n", + "function num_diagrams_small_form(m::Int, e::Int, u::Int = 0, t::Int = 0)\n", + " n = e + u + t\n", + " return Int(factorial(m+3n-3) / factorial(2n-1)) * factorial(e) * factorial(u) * factorial(t)\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "8\n", + "8\n" + ] + } + ], + "source": [ + "# Trident:\n", + "println(num_diagrams(1, 2))\n", + "println(num_diagrams_small_form(1, 2))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2, 6, 24, 120, 720, 5040, 40320]\n", + "[2, 6, 24, 120, 720, 5040, 40320]\n" + ] + } + ], + "source": [ + "# n-Photon Compton:\n", + "println([num_diagrams(n, 1) for n in 2:8])\n", + "println([num_diagrams_small_form(n, 1) for n in 2:8])" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2, 36, 1728, 158400, 23587200, 5181926400]\n", + "[2, 36, 1728, 158400, 23587200, 5181926400]\n" + ] + } + ], + "source": [ + "# fermion scattering\n", + "println([num_diagrams(0, n) for n in 2:7])\n", + "println([num_diagrams_small_form(0, n) for n in 2:7])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "n=1, e=1, u=0, t=0 || m=0: 1 | m=1: 1 | m=2: 2 | m=3: 6 | m=4: 24 | m=5: 120\n", + "n=2, e=1, u=1, t=0 || m=0: 1 | m=1: 4 | m=2: 20 | m=3: 120 | m=4: 840 | m=5: 6720\n", + "n=2, e=2, u=0, t=0 || m=0: 2 | m=1: 8 | m=2: 40 | m=3: 240 | m=4: 1680 | m=5: 13440\n", + "n=3, e=1, u=1, t=1 || m=0: 6 | m=1: 42 | m=2: 336 | m=3: 3024 | m=4: 30240 | m=5: 332640\n", + "n=3, e=2, u=1, t=0 || m=0: 12 | m=1: 84 | m=2: 672 | m=3: 6048 | m=4: 60480 | m=5: 665280\n", + "n=3, e=3, u=0, t=0 || m=0: 36 | m=1: 252 | m=2: 2016 | m=3: 18144 | m=4: 181440 | m=5: 1995840\n", + "n=4, e=2, u=1, t=1 || m=0: 144 | m=1: 1440 | m=2: 15840 | m=3: 190080 | m=4: 2471040 | m=5: 34594560\n", + "n=4, e=2, u=2, t=0 || m=0: 288 | m=1: 2880 | m=2: 31680 | m=3: 380160 | m=4: 4942080 | m=5: 69189120\n", + "n=4, e=3, u=1, t=0 || m=0: 432 | m=1: 4320 | m=2: 47520 | m=3: 570240 | m=4: 7413120 | m=5: 103783680\n", + "n=4, e=4, u=0, t=0 || m=0: 1728 | m=1: 17280 | m=2: 190080 | m=3: 2280960 | m=4: 29652480 | m=5: 415134720\n" + ] + } + ], + "source": [ + "# tables\n", + "i = 0\n", + "nums = [[1, 0, 0], [1, 1, 0], [2, 0, 0], [1, 1, 1], [2, 1, 0], [3, 0, 0], [2, 1, 1], [2, 2, 0], [3, 1, 0], [4, 0, 0]]\n", + "for (e, u, t) in nums\n", + " i += 1\n", + " if (u + t + e == 0) continue end\n", + " println(\"n=$(e + u + t), e=$e, u=$u, t=$t || m=0: $(num_diagrams(0, e, u, t)) | m=1: $(num_diagrams(1, e, u, t)) | m=2: $(num_diagrams(2, e, u, t)) | m=3: $(num_diagrams(3, e, u, t)) | m=4: $(num_diagrams(4, e, u, t)) | m=5: $(num_diagrams(5, e, u, t))\")\n", + "end" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Julia 1.10.2", + "language": "julia", + "name": "julia-1.10" + }, + "language_info": { + "file_extension": ".jl", + "mimetype": "application/julia", + "name": "julia", + "version": "1.10.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/optimizers.ipynb b/notebooks/optimizers.ipynb new file mode 100644 index 0000000..1615494 --- /dev/null +++ b/notebooks/optimizers.ipynb @@ -0,0 +1,2087 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 81, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Threads: 32\n" + ] + } + ], + "source": [ + "#using Pkg\n", + "#Pkg.add(url=\"https://github.com/QEDjl-project/QEDprocesses.jl/\")\n", + "\n", + "using MetagraphOptimization\n", + "using CUDA\n", + "using UUIDs\n", + "using BenchmarkTools\n", + "\n", + "println(\"Threads: $(Threads.nthreads())\")" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "compute__f86f16c2_dcba_11ee_3d4b_6b88d96bf393 (generic function with 1 method)" + ] + }, + "execution_count": 98, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using Random\n", + "\n", + "# preparation of graph\n", + "machine = Machine([MetagraphOptimization.NumaNode(0, 1, MetagraphOptimization.default_strategy(MetagraphOptimization.NumaNode), -1.0, UUIDs.uuid1())], [-1.0;;])\n", + "model = QEDModel()\n", + "process = parse_process(\"ke->kkke\", model)\n", + "graph = gen_graph(process)\n", + "n_inputs = 2^20\n", + "inputs = [gen_process_input(process) for _ in 1:n_inputs]\n", + "cu_inputs = CuArray(inputs)\n", + "optimizer = RandomWalkOptimizer(MersenneTwister(0))# GreedyOptimizer(GlobalMetricEstimator())\n", + "\n", + "#done: split, reduce, fuse, greedy\n", + "\n", + "process_str_short = \"qed_k3\"\n", + "optim_str = \"Random Walk Optimization\"\n", + "optim_str_short=\"random\"\n", + "\n", + "get_compute_function(graph, process, machine) # run once for compilation" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "bench (generic function with 1 method)" + ] + }, + "execution_count": 99, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "function bench(func, kernel!, inputs, cu_inputs)\n", + " compile_time = @elapsed func(inputs[1])\n", + "\n", + " # b = @benchmark $func.($inputs) samples = 10 evals = 1\n", + " single_thread = 0. # median(b.times) / 1e9\n", + " st_std = 0. # std(b.times) / 1e9\n", + "\n", + " b = @benchmark begin \n", + " Threads.@threads for i in eachindex($inputs)\n", + " $func($inputs[i]) \n", + " end \n", + " end samples = 10 evals = 1\n", + " multi_threaded = median(b.times) / 1e9\n", + " mt_std = std(b.times) / 1e9\n", + " \n", + " n = length(cu_inputs)\n", + " ts = 32\n", + " bs = Int(n / ts)\n", + " cu_outputs = CuVector{ComplexF64}()\n", + " resize!(cu_outputs, n)\n", + " b = @benchmark begin\n", + " @cuda threads = $ts blocks = $bs always_inline=true $kernel!($cu_inputs, $cu_outputs, $n)\n", + " CUDA.device_synchronize()\n", + " end samples = 10 evals = 1\n", + " gpu_compile = 0\n", + " gpu = median(b.times) / 1e9\n", + " gpu_std = std(b.times) / 1e9\n", + "\n", + " return (cpu_compile_time = compile_time, gpu_compile_time = gpu_compile, cpu_single_thread_time = single_thread, cpu_st_std = st_std, cpu_multi_thread_time = multi_threaded, cpu_mt_std = mt_std, gpu_time = gpu, gpu_std = gpu_std)\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII\n", + "Done\n" + ] + } + ], + "source": [ + "# bench and produce data\n", + "using DataFrames\n", + "\n", + "STEPSIZE = 1\n", + "n = 0\n", + "\n", + "df = DataFrame(\n", + " operations=Int[], \n", + " graph_nodes=Int[], \n", + " graph_edges=Int[], \n", + " graph_ce=Float64[], \n", + " graph_dt=Float64[], \n", + " graph_ci=Float64[], \n", + " gen_func_t=Float64[], \n", + " cpu_compile_t=Float64[], \n", + " cpu_st_t=Float64[], \n", + " cpu_st_std=Float64[],\n", + " cpu_mt_t=Float64[], \n", + " cpu_mt_std=Float64[],\n", + " gpu_compile_t=Float64[], \n", + " gpu_t=Float64[],\n", + " gpu_std=Float64[]\n", + ")\n", + "\n", + "while true\n", + " func_gen_time = @elapsed func = get_compute_function(graph, process, machine)\n", + " kernel! = get_cuda_kernel(graph, process, machine)\n", + " res = bench(func, kernel!, inputs, cu_inputs)\n", + "\n", + " graph_properties = get_properties(graph)\n", + " push!(df, (\n", + " n,\n", + " graph_properties.noNodes,\n", + " graph_properties.noEdges,\n", + " graph_properties.computeEffort,\n", + " graph_properties.data,\n", + " graph_properties.computeIntensity,\n", + " func_gen_time,\n", + " res.cpu_compile_time,\n", + " res.cpu_single_thread_time,\n", + " res.cpu_st_std,\n", + " res.cpu_multi_thread_time,\n", + " res.cpu_mt_std,\n", + " res.gpu_compile_time,\n", + " res.gpu_time,\n", + " res.gpu_std\n", + " ))\n", + "\n", + " print(\"I\")\n", + "\n", + " if fixpoint_reached(optimizer, graph)\n", + " break\n", + " end\n", + "\n", + " if n >= 100\n", + " break\n", + " end\n", + "\n", + " optimize!(optimizer, graph, STEPSIZE)\n", + " n += STEPSIZE\n", + "end\n", + "println(\"\\nDone\")\n", + ";" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "beautify_title (generic function with 1 method)" + ] + }, + "execution_count": 101, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "using LaTeXStrings\n", + "\n", + "function beautify_title(str::AbstractString)\n", + " parts = split(str, \"'\")\n", + "\n", + " preprefix = parts[1]\n", + " infix = parts[2]\n", + " sufsuffix = parts[3]\n", + "\n", + " parts = split(infix, \"->\")\n", + "\n", + " prefix = parts[1]\n", + " suffix = parts[2]\n", + "\n", + " k_count = count(c -> c == 'k', suffix)\n", + " B_count = count(c -> c == 'B', suffix)\n", + "\n", + " if k_count == 1 || B_count == 1\n", + " new_suffix = suffix\n", + " elseif k_count >= 1\n", + " new_suffix = replace(suffix, r\"k+\" => \"k^$k_count\")\n", + " elseif B_count >= 1\n", + " new_suffix = replace(suffix, r\"B+\" => \"B^$B_count\")\n", + " end\n", + "\n", + " return preprefix * L\"%$prefix \\rightarrow %$new_suffix\" * sufsuffix\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "execution_count": 102, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# plot data\n", + "using Plots\n", + "using StatsPlots\n", + "\n", + "img = @df df scatter(\n", + " :operations, \n", + " [#=:cpu_st_t=# :cpu_mt_t :gpu_t],\n", + " label=[#=\"Single threaded execution (s)\"=# \"$(Threads.nthreads())-threaded CPU execution (s)\" \"GPU execution (Tesla A30) (s)\"],\n", + " yerror=[#=:cpu_st_std=# :cpu_mt_std :gpu_std],\n", + " title=\"$(beautify_title(string(process))) Using $(optim_str)\\nCalculate $(n_inputs) (\\$2^{20}\\$) Matrix Elements\",\n", + " linewidth=2,\n", + " xlabel=\"optimizer steps\",\n", + " ylabel=\"time (s)\",\n", + " yscale=:log10,\n", + " legend=:outerbottom,\n", + " legendcolumns=2,\n", + " legend_font_pointsize=10,\n", + " minorgrid=true,\n", + " size=(800, 600),\n", + " fmt=:pdf\n", + ")\n", + "\n", + "savefig(img, \"../images/$(process_str_short)_execution_$(optim_str_short).pdf\")\n", + "\n", + "img" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "execution_count": 103, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "img = @df df scatter(\n", + " :operations,\n", + " [:graph_nodes, :graph_edges],\n", + " label=[\"graph nodes (#)\" \"graph edges (#)\"],\n", + " title=\"$(beautify_title(string(process))) Using $(optim_str)\",\n", + " linewidth=2,\n", + " xlabel=\"optimizer steps\",\n", + " ylims=(0.0, 1.05 * maximum(df.graph_edges)),\n", + " legend=:outerbottom,\n", + " legendcolumns=2,\n", + " legend_font_pointsize=10,\n", + " fmt=:pdf,\n", + " size=(800, 600)\n", + ")\n", + "\n", + "savefig(img, \"../images/$(process_str_short)_nodes_edges_$(optim_str_short).pdf\")\n", + "\n", + "img" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "execution_count": 104, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "img = @df df scatter(\n", + " :operations,\n", + " [:graph_ce, :graph_dt],\n", + " label=[\"graph compute effort (FLOP)\" \"graph data transfer (B)\"],\n", + " title=\"$(beautify_title(string(process))) Using $(optim_str)\",\n", + " linewidth=2,\n", + " xlabel=\"optimizer steps\",\n", + " ylims=(0.0, 1.05 * maximum(df.graph_ce)),\n", + " legend=:outerbottom,\n", + " legendcolumns=2,\n", + " legend_font_pointsize=10,\n", + " fmt=:pdf,\n", + " size=(800, 600)\n", + ")\n", + "\n", + "savefig(img, \"../images/$(process_str_short)_ce_dt_$(optim_str_short).pdf\")\n", + "\n", + "img" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[33m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[33m\u001b[1mWarning: \u001b[22m\u001b[39mn° of legend_column=2 is larger than n° of series=1\n", + "\u001b[33m\u001b[1m└ \u001b[22m\u001b[39m\u001b[90m@ Plots ~/.julia/packages/Plots/sxUvK/src/backends/gr.jl:1235\u001b[39m\n" + ] + }, + { + "data": { + "image/png": "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", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "execution_count": 106, + "metadata": {}, + "output_type": "execute_result" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[33m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[33m\u001b[1mWarning: \u001b[22m\u001b[39mn° of legend_column=2 is larger than n° of series=1\n", + "\u001b[33m\u001b[1m└ \u001b[22m\u001b[39m\u001b[90m@ Plots ~/.julia/packages/Plots/sxUvK/src/backends/gr.jl:1235\u001b[39m\n", + "\u001b[33m\u001b[1m┌ \u001b[22m\u001b[39m\u001b[33m\u001b[1mWarning: \u001b[22m\u001b[39mn° of legend_column=2 is larger than n° of series=1\n", + "\u001b[33m\u001b[1m└ \u001b[22m\u001b[39m\u001b[90m@ Plots ~/.julia/packages/Plots/sxUvK/src/backends/gr.jl:1235\u001b[39m\n" + ] + } + ], + "source": [ + "img = @df df plot(\n", + " :graph_dt,\n", + " :graph_ce,\n", + " label=\"graph compute intensity\",\n", + " title=\"$(beautify_title(string(process))) Using $(optim_str)\",\n", + " line_z=:operations,\n", + " color=:viridis,\n", + " linewidth=2,\n", + " xlabel=\"data transfer (Byte)\",\n", + " ylabel=\"compute effort (FLOPS)\",\n", + " colorbar_title=\"applied operations (#)\",\n", + " colorbar_ticks=(0, maximum(df.operations)),\n", + " #ylims=(0.0, 1.05 * maximum(df.graph_ce)),\n", + " #xlims=(0.0, 1.05 * maximum(df.graph_dt)),\n", + " legend=:outerbottom,\n", + " legendcolumns=2,\n", + " legend_font_pointsize=10,\n", + " fmt=:pdf,\n", + " size=(800, 600)\n", + ")\n", + "\n", + "savefig(img, \"../images/$(process_str_short)_cdplot_$(optim_str_short).pdf\")\n", + "\n", + "img" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Julia 1.10.2", + "language": "julia", + "name": "julia-1.10" + }, + "language_info": { + "file_extension": ".jl", + "mimetype": "application/julia", + "name": "julia", + "version": "1.10.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/profiling.ipynb b/notebooks/profiling.ipynb index e0be63d..6095673 100644 --- a/notebooks/profiling.ipynb +++ b/notebooks/profiling.ipynb @@ -52,15 +52,15 @@ ], "metadata": { "kernelspec": { - "display_name": "Julia 1.9.4", + "display_name": "Julia 1.10.2", "language": "julia", - "name": "julia-1.9" + "name": "julia-1.10" }, "language_info": { "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", - "version": "1.9.4" + "version": "1.10.2" }, "orig_nbformat": 4 }, diff --git a/src/MetagraphOptimization.jl b/src/MetagraphOptimization.jl index 76172d9..f17c8b1 100644 --- a/src/MetagraphOptimization.jl +++ b/src/MetagraphOptimization.jl @@ -78,7 +78,7 @@ export gen_graph export execute export parse_dag, parse_process export gen_process_input -export get_compute_function +export get_compute_function, get_cuda_kernel export gen_tape, execute_tape # estimator @@ -86,7 +86,8 @@ export cost_type, graph_cost, operation_effect export GlobalMetricEstimator, CDCost # optimization -export AbstractOptimizer, GreedyOptimizer, ReductionOptimizer, RandomWalkOptimizer +export AbstractOptimizer, GreedyOptimizer, RandomWalkOptimizer +export ReductionOptimizer, SplitOptimizer, FusionOptimizer export optimize_step!, optimize! export fixpoint_reached, optimize_to_fixpoint! @@ -166,6 +167,8 @@ include("optimization/interface.jl") include("optimization/greedy.jl") include("optimization/random_walk.jl") include("optimization/reduce.jl") +include("optimization/fuse.jl") +include("optimization/split.jl") include("models/interface.jl") include("models/print.jl") diff --git a/src/code_gen/function.jl b/src/code_gen/function.jl index 8e21b3e..97df44e 100644 --- a/src/code_gen/function.jl +++ b/src/code_gen/function.jl @@ -21,6 +21,38 @@ function get_compute_function(graph::DAG, process::AbstractProcessDescription, m return func end +""" + get_cuda_kernel(graph::DAG, process::AbstractProcessDescription, machine::Machine) + +Return a function of signature `compute_(input::CuVector, output::CuVector, n::Int64)`, which will return the result of the DAG computation of the input on the given output variable. +""" +function get_cuda_kernel(graph::DAG, process::AbstractProcessDescription, machine::Machine) + tape = gen_tape(graph, process, machine) + + initCaches = Expr(:block, tape.initCachesCode...) + assignInputs = Expr(:block, expr_from_fc.(tape.inputAssignCode)...) + code = Expr(:block, expr_from_fc.(tape.computeCode)...) + + functionId = to_var_name(UUIDs.uuid1(rng[1])) + resSym = eval(gen_access_expr(entry_device(tape.machine), tape.outputSymbol)) + expr = Meta.parse("function compute_$(functionId)(input_vector, output_vector, n::Int64) + id = (blockIdx().x - 1) * blockDim().x + threadIdx().x + if (id > n) + return + end + @inline data_input = input_vector[id] + $(initCaches) + $(assignInputs) + $code + @inline output_vector[id] = $resSym + return nothing + end") + + func = eval(expr) + + return func +end + """ execute(graph::DAG, process::AbstractProcessDescription, machine::Machine, input::AbstractProcessInput) diff --git a/src/estimator/global_metric.jl b/src/estimator/global_metric.jl index 3e0a55e..c662ccb 100644 --- a/src/estimator/global_metric.jl +++ b/src/estimator/global_metric.jl @@ -1,4 +1,3 @@ - """ CDCost @@ -34,7 +33,7 @@ function isless(cost1::CDCost, cost2::CDCost)::Bool end function zero(type::Type{CDCost}) - return (data = 0.0, computeEffort = 00.0, computeIntensity = 0.0)::CDCost + return (data = 0.0, computeEffort = 0.0, computeIntensity = 0.0)::CDCost end function typemax(type::Type{CDCost}) diff --git a/src/graph/properties.jl b/src/graph/properties.jl index 394ddec..9515820 100644 --- a/src/graph/properties.jl +++ b/src/graph/properties.jl @@ -7,7 +7,8 @@ function get_properties(graph::DAG) # make sure the graph is fully generated apply_all!(graph) - if (graph.properties.computeEffort == 0.0) + # TODO: tests stop working without the if condition, which means there is probably a bug in the lazy evaluation and in the tests + if (graph.properties.computeEffort <= 0.0) graph.properties = GraphProperties(graph) end diff --git a/src/models/abc/compute.jl b/src/models/abc/compute.jl index b2984d2..1611a4b 100644 --- a/src/models/abc/compute.jl +++ b/src/models/abc/compute.jl @@ -84,9 +84,17 @@ Compute a sum over the vector. Use an algorithm that accounts for accumulated er Linearly many FLOP with growing data. """ function compute(::ComputeTaskABC_Sum, data...)::Float64 - return sum(data) + s = 0.0im + for d in data + s += d + end + return s end function compute(::ComputeTaskABC_Sum, data::AbstractArray)::Float64 - return sum(data) + s = 0.0im + for d in data + s += d + end + return s end diff --git a/src/models/qed/compute.jl b/src/models/qed/compute.jl index 726f9d1..b30994f 100644 --- a/src/models/qed/compute.jl +++ b/src/models/qed/compute.jl @@ -72,9 +72,9 @@ function compute( # inner edge is just a "scalar", data1 and data2 are bispinor/adjointbispinnor, need to keep correct order if typeof(data1.v) <: BiSpinor - return data2.v * inner * data1.v + return (data2.v)::AdjointBiSpinor * inner * (data1.v)::BiSpinor else - return data1.v * inner * data2.v + return (data1.v)::AdjointBiSpinor * inner * (data2.v)::BiSpinor end end @@ -115,10 +115,18 @@ Linearly many FLOP with growing data. """ function compute(::ComputeTaskQED_Sum, data...)::ComplexF64 # TODO: want to use sum_kbn here but it doesn't seem to support ComplexF64, do it element-wise? - return sum(data) + s = 0.0im + for d in data + s += d + end + return s end function compute(::ComputeTaskQED_Sum, data::AbstractArray)::ComplexF64 # TODO: want to use sum_kbn here but it doesn't seem to support ComplexF64, do it element-wise? - return sum(data) + s = 0.0im + for d in data + s += d + end + return s end diff --git a/src/models/qed/create.jl b/src/models/qed/create.jl index 899e76d..85ee3aa 100644 --- a/src/models/qed/create.jl +++ b/src/models/qed/create.jl @@ -114,12 +114,8 @@ function gen_graph(process_description::QEDProcessDescription) dataOutNodes[String(particle)] = data_out end - #dataOutBackup = copy(dataOutNodes) - + # TODO: this should be parallelizable somewhat easily for diagram in diagrams - # the intermediate (virtual) particles change across - #dataOutNodes = copy(dataOutBackup) - tie = diagram.tie[] # handle the vertices diff --git a/src/models/qed/diagrams.jl b/src/models/qed/diagrams.jl index 073fe4e..9477eb6 100644 --- a/src/models/qed/diagrams.jl +++ b/src/models/qed/diagrams.jl @@ -1,3 +1,4 @@ +using Combinatorics import Base.copy import Base.hash @@ -265,11 +266,12 @@ function add_vertex!(fd::FeynmanDiagram, vertex::FeynmanVertex) end if !can_apply_vertex(get_particles(fd), vertex) - #@assert false "Can't add vertex $vertex to diagram" + @assert false "Can't add vertex $vertex to diagram $(get_particles(fd))" end push!(fd.vertices, Set{FeynmanVertex}()) push!(fd.vertices[end], vertex) + fd.type_ids[vertex.out.particle] += 1 return nothing @@ -437,12 +439,196 @@ function remove_duplicates(compare_set::Set{FeynmanDiagram}) return result end +""" + is_compton(fd::FeynmanDiagram) + +Returns true iff the given feynman diagram is an (empty) diagram of a compton process like ke->k^ne +""" +function is_compton(fd::FeynmanDiagram) + return fd.type_ids[FermionStateful{Incoming, SpinUp}] == 1 && + fd.type_ids[FermionStateful{Outgoing, SpinUp}] == 1 && + fd.type_ids[AntiFermionStateful{Incoming, SpinUp}] == 0 && + fd.type_ids[AntiFermionStateful{Outgoing, SpinUp}] == 0 && + fd.type_ids[PhotonStateful{Incoming, PolX}] >= 1 && + fd.type_ids[PhotonStateful{Outgoing, PolX}] >= 1 +end + +""" + gen_compton_diagram_from_order(order::Vector{Int}, inFerm, outFerm, n::Int, m::Int) + +Helper function for [`gen_compton_diagrams`](@Ref). Generates a single diagram for the given order and n input and m output photons. +""" +function gen_compton_diagram_from_order(order::Vector{Int}, inFerm, outFerm, n::Int, m::Int) + photons = vcat( + [FeynmanParticle(PhotonStateful{Incoming, PolX}, i) for i in 1:n], + [FeynmanParticle(PhotonStateful{Outgoing, PolX}, i) for i in 1:m], + ) + + new_diagram = FeynmanDiagram( + [], + missing, + [inFerm, outFerm, photons...], + Dict{Type, Int64}( + FermionStateful{Incoming, SpinUp} => 1, + FermionStateful{Outgoing, SpinUp} => 1, + PhotonStateful{Incoming, PolX} => n, + PhotonStateful{Outgoing, PolX} => m, + ), + ) + + left_index = 1 + right_index = length(order) + + iterations = 1 + + while left_index <= right_index + # left side + v_left = FeynmanVertex( + FeynmanParticle(FermionStateful{Incoming, SpinUp}, iterations), + photons[order[left_index]], + FeynmanParticle(FermionStateful{Incoming, SpinUp}, iterations + 1), + ) + left_index += 1 + add_vertex!(new_diagram, v_left) + + if (left_index > right_index) + break + end + + # right side + v_right = FeynmanVertex( + FeynmanParticle(FermionStateful{Outgoing, SpinUp}, iterations), + photons[order[right_index]], + FeynmanParticle(FermionStateful{Outgoing, SpinUp}, iterations + 1), + ) + right_index -= 1 + add_vertex!(new_diagram, v_right) + + iterations += 1 + end + + @assert possible_tie(new_diagram) !== missing + add_tie!(new_diagram, possible_tie(new_diagram)) + return new_diagram +end + + +""" + gen_compton_diagram_from_order_one_side(order::Vector{Int}, inFerm, outFerm, n::Int, m::Int) + +Helper function for [`gen_compton_diagrams`](@Ref). Generates a single diagram for the given order and n input and m output photons. +""" +function gen_compton_diagram_from_order_one_side(order::Vector{Int}, inFerm, outFerm, n::Int, m::Int) + photons = vcat( + [FeynmanParticle(PhotonStateful{Incoming, PolX}, i) for i in 1:n], + [FeynmanParticle(PhotonStateful{Outgoing, PolX}, i) for i in 1:m], + ) + + new_diagram = FeynmanDiagram( + [], + missing, + [inFerm, outFerm, photons...], + Dict{Type, Int64}( + FermionStateful{Incoming, SpinUp} => 1, + FermionStateful{Outgoing, SpinUp} => 1, + PhotonStateful{Incoming, PolX} => n, + PhotonStateful{Outgoing, PolX} => m, + ), + ) + + left_index = 1 + right_index = length(order) + + iterations = 1 + + while left_index <= right_index + # left side + v_left = FeynmanVertex( + FeynmanParticle(FermionStateful{Incoming, SpinUp}, iterations), + photons[order[left_index]], + FeynmanParticle(FermionStateful{Incoming, SpinUp}, iterations + 1), + ) + left_index += 1 + add_vertex!(new_diagram, v_left) + + if (left_index > right_index) + break + end + + # only once on the right side + if (iterations == 1) + # right side + v_right = FeynmanVertex( + FeynmanParticle(FermionStateful{Outgoing, SpinUp}, iterations), + photons[order[right_index]], + FeynmanParticle(FermionStateful{Outgoing, SpinUp}, iterations + 1), + ) + right_index -= 1 + add_vertex!(new_diagram, v_right) + end + + iterations += 1 + end + + ps = get_particles(new_diagram) + @assert length(ps) == 2 + add_tie!(new_diagram, FeynmanTie(ps[1], ps[2])) + return new_diagram +end + + +""" + gen_compton_diagrams(n::Int, m::Int) + +Special case diagram generation for Compton processes, i.e., processes of the form k^ne->k^me +""" +function gen_compton_diagrams(n::Int, m::Int) + inFerm = FeynmanParticle(FermionStateful{Incoming, SpinUp}, 1) + outFerm = FeynmanParticle(FermionStateful{Outgoing, SpinUp}, 1) + + perms = [permutations([i for i in 1:(n + m)])...] + + diagrams = [Vector{FeynmanDiagram}() for i in 1:nthreads()] + @threads for order in perms + push!(diagrams[threadid()], gen_compton_diagram_from_order(order, inFerm, outFerm, n, m)) + end + + return vcat(diagrams...) +end + + +""" + gen_compton_diagrams_one_side(n::Int, m::Int) + +Special case diagram generation for Compton processes, i.e., processes of the form k^ne->k^me, but generating from one end, yielding larger diagrams +""" +function gen_compton_diagrams_one_side(n::Int, m::Int) + inFerm = FeynmanParticle(FermionStateful{Incoming, SpinUp}, 1) + outFerm = FeynmanParticle(FermionStateful{Outgoing, SpinUp}, 1) + + perms = [permutations([i for i in 1:(n + m)])...] + + diagrams = [Vector{FeynmanDiagram}() for i in 1:nthreads()] + @threads for order in perms + push!(diagrams[threadid()], gen_compton_diagram_from_order_one_side(order, inFerm, outFerm, n, m)) + end + + return vcat(diagrams...) +end + """ gen_diagrams(fd::FeynmanDiagram) From a given feynman diagram in its initial state, e.g. when created through the [`FeynmanDiagram(pd::ProcessDescription)`](@ref) constructor, generate and return all possible [`FeynmanDiagram`](@ref)s that describe that process. """ function gen_diagrams(fd::FeynmanDiagram) + if is_compton(fd) + return gen_compton_diagrams_one_side( + fd.type_ids[PhotonStateful{Incoming, PolX}], + fd.type_ids[PhotonStateful{Outgoing, PolX}], + ) + end + working = Set{FeynmanDiagram}() results = Set{FeynmanDiagram}() diff --git a/src/models/qed/particle.jl b/src/models/qed/particle.jl index d51fedd..152b7b2 100644 --- a/src/models/qed/particle.jl +++ b/src/models/qed/particle.jl @@ -313,7 +313,7 @@ Return the factor of a vertex in a QED feynman diagram. return -1im * e * gamma() end -@inline function QED_inner_edge(p::QEDParticle) +@inline function QED_inner_edge(p::QEDParticle)::DiracMatrix return propagator(particle(p), p.momentum) end diff --git a/src/models/qed/print.jl b/src/models/qed/print.jl index 7ba4160..c5cb3f5 100644 --- a/src/models/qed/print.jl +++ b/src/models/qed/print.jl @@ -42,10 +42,10 @@ Create a short string suitable as a filename or similar, describing the given pr julia> using MetagraphOptimization julia> String(parse_process("ke->ke", QEDModel())) -qed_ke-ke +"qed_ke-ke" julia> print(parse_process("kk->ep", QEDModel())) -qed_kk-ep +QED Process: 'kk->ep' ``` """ function String(process::QEDProcessDescription) diff --git a/src/models/qed/properties.jl b/src/models/qed/properties.jl index 1ea9e4c..b31b38a 100644 --- a/src/models/qed/properties.jl +++ b/src/models/qed/properties.jl @@ -1,32 +1,32 @@ -# TODO use correct numbers +# compute effort numbers were measured on a home pc system using likwid """ compute_effort(t::ComputeTaskQED_S1) Return the compute effort of an S1 task. """ -compute_effort(t::ComputeTaskQED_S1)::Float64 = 11.0 +compute_effort(t::ComputeTaskQED_S1)::Float64 = 475.0 """ compute_effort(t::ComputeTaskQED_S2) Return the compute effort of an S2 task. """ -compute_effort(t::ComputeTaskQED_S2)::Float64 = 12.0 +compute_effort(t::ComputeTaskQED_S2)::Float64 = 505.0 """ compute_effort(t::ComputeTaskQED_U) Return the compute effort of a U task. """ -compute_effort(t::ComputeTaskQED_U)::Float64 = 1.0 +compute_effort(t::ComputeTaskQED_U)::Float64 = (291.0 + 467.0 + 16.0 + 17.0) / 4.0 # The exact FLOPS count depends heavily on the type of particle, take an average value here """ compute_effort(t::ComputeTaskQED_V) Return the compute effort of a V task. """ -compute_effort(t::ComputeTaskQED_V)::Float64 = 6.0 +compute_effort(t::ComputeTaskQED_V)::Float64 = (1150.0 + 764.0 + 828.0) / 3.0 """ compute_effort(t::ComputeTaskQED_P) diff --git a/src/node/type.jl b/src/node/type.jl index 39283d0..2ba4258 100644 --- a/src/node/type.jl +++ b/src/node/type.jl @@ -3,7 +3,7 @@ using UUIDs using Base.Threads # TODO: reliably find out how many threads we're running with (nthreads() returns 1 when precompiling :/) -rng = [Random.MersenneTwister(0) for _ in 1:64] +rng = [Random.MersenneTwister(0) for _ in 1:128] """ Node diff --git a/src/operation/find.jl b/src/operation/find.jl index 141443b..8120355 100644 --- a/src/operation/find.jl +++ b/src/operation/find.jl @@ -197,8 +197,7 @@ function generate_operations(graph::DAG) # launch thread for node reduction insertion # remove duplicates - nr_task = @task nr_insertion!(graph.possibleOperations, generatedReductions) - schedule(nr_task) + nr_task = @spawn nr_insertion!(graph.possibleOperations, generatedReductions) # --- find possible node fusions --- @threads for node in nodeArray @@ -223,8 +222,7 @@ function generate_operations(graph::DAG) end # launch thread for node fusion insertion - nf_task = @task nf_insertion!(graph, graph.possibleOperations, generatedFusions) - schedule(nf_task) + nf_task = @spawn nf_insertion!(graph, graph.possibleOperations, generatedFusions) # find possible node splits @threads for node in nodeArray @@ -234,8 +232,7 @@ function generate_operations(graph::DAG) end # launch thread for node split insertion - ns_task = @task ns_insertion!(graph.possibleOperations, generatedSplits) - schedule(ns_task) + ns_task = @spawn ns_insertion!(graph.possibleOperations, generatedSplits) empty!(graph.dirtyNodes) diff --git a/src/optimization/fuse.jl b/src/optimization/fuse.jl new file mode 100644 index 0000000..a64b300 --- /dev/null +++ b/src/optimization/fuse.jl @@ -0,0 +1,36 @@ +""" + FusionOptimizer + +An optimizer that simply applies an available [`NodeFusion`](@ref) on each step. It implements [`optimize_to_fixpoint`](@ref). The fixpoint is reached when there are no more possible [`NodeFusion`](@ref)s in the graph. + +See also: [`SplitOptimizer`](@ref), [`ReductionOptimizer`](@ref) +""" +struct FusionOptimizer <: AbstractOptimizer end + +function optimize_step!(optimizer::FusionOptimizer, graph::DAG) + # generate all options + operations = get_operations(graph) + if fixpoint_reached(optimizer, graph) + return false + end + + push_operation!(graph, first(operations.nodeFusions)) + + return true +end + +function fixpoint_reached(optimizer::FusionOptimizer, graph::DAG) + operations = get_operations(graph) + return isempty(operations.nodeFusions) +end + +function optimize_to_fixpoint!(optimizer::FusionOptimizer, graph::DAG) + while !fixpoint_reached(optimizer, graph) + optimize_step!(optimizer, graph) + end + return nothing +end + +function String(::FusionOptimizer) + return "fusion_optimizer" +end diff --git a/src/optimization/greedy.jl b/src/optimization/greedy.jl index a777587..5b4fbfa 100644 --- a/src/optimization/greedy.jl +++ b/src/optimization/greedy.jl @@ -21,7 +21,7 @@ function optimize_step!(optimizer::GreedyOptimizer, graph::DAG) lowestCost = reduce( (acc, op) -> begin op_cost = operation_effect(optimizer.estimator, graph, op) - if op_cost < acc + if isless(op_cost, acc) result = op return op_cost end @@ -50,7 +50,7 @@ function fixpoint_reached(optimizer::GreedyOptimizer, graph::DAG) lowestCost = reduce( (acc, op) -> begin op_cost = operation_effect(optimizer.estimator, graph, op) - if op_cost < acc + if isless(op_cost, acc) return op_cost end return acc diff --git a/src/optimization/reduce.jl b/src/optimization/reduce.jl index c6414f5..1f3a28a 100644 --- a/src/optimization/reduce.jl +++ b/src/optimization/reduce.jl @@ -2,6 +2,8 @@ ReductionOptimizer An optimizer that simply applies an available [`NodeReduction`](@ref) on each step. It implements [`optimize_to_fixpoint`](@ref). The fixpoint is reached when there are no more possible [`NodeReduction`](@ref)s in the graph. + +See also: [`FusionOptimizer`](@ref), [`SplitOptimizer`](@ref) """ struct ReductionOptimizer <: AbstractOptimizer end diff --git a/src/optimization/split.jl b/src/optimization/split.jl new file mode 100644 index 0000000..0bcda87 --- /dev/null +++ b/src/optimization/split.jl @@ -0,0 +1,36 @@ +""" + SplitOptimizer + +An optimizer that simply applies an available [`NodeSplit`](@ref) on each step. It implements [`optimize_to_fixpoint`](@ref). The fixpoint is reached when there are no more possible [`NodeSplit`](@ref)s in the graph. + +See also: [`FusionOptimizer`](@ref), [`ReductionOptimizer`](@ref) +""" +struct SplitOptimizer <: AbstractOptimizer end + +function optimize_step!(optimizer::SplitOptimizer, graph::DAG) + # generate all options + operations = get_operations(graph) + if fixpoint_reached(optimizer, graph) + return false + end + + push_operation!(graph, first(operations.nodeSplits)) + + return true +end + +function fixpoint_reached(optimizer::SplitOptimizer, graph::DAG) + operations = get_operations(graph) + return isempty(operations.nodeSplits) +end + +function optimize_to_fixpoint!(optimizer::SplitOptimizer, graph::DAG) + while !fixpoint_reached(optimizer, graph) + optimize_step!(optimizer, graph) + end + return nothing +end + +function String(::SplitOptimizer) + return "split_optimizer" +end diff --git a/src/scheduler/greedy.jl b/src/scheduler/greedy.jl index 5c0b4cb..ae7ae92 100644 --- a/src/scheduler/greedy.jl +++ b/src/scheduler/greedy.jl @@ -18,7 +18,7 @@ function schedule_dag(::GreedyScheduler, graph::DAG, machine::Machine) sizehint!(schedule, length(graph.nodes)) # keep an accumulated cost of things scheduled to this device so far - deviceAccCost = PriorityQueue{AbstractDevice, Int}() + deviceAccCost = PriorityQueue{AbstractDevice, Float64}() for device in machine.devices enqueue!(deviceAccCost, device => 0) end diff --git a/src/task/compute.jl b/src/task/compute.jl index c1ed265..2c06613 100644 --- a/src/task/compute.jl +++ b/src/task/compute.jl @@ -39,7 +39,7 @@ function get_function_call(node::ComputeTaskNode) @assert length(children(node)) <= children(task(node)) "Node $(node) has too many children for its task: node has $(length(node.children)) versus task has $(children(task(node)))\nNode's children: $(getfield.(node.children, :children))" @assert !ismissing(node.device) "Trying to get expression for an unscheduled ComputeTaskNode\nNode: $(node)" - if (length(node.children) <= 50) + if (length(node.children) <= 800) #only use an SVector when there are few children return get_function_call( node.task, diff --git a/test/unit_tests_optimization.jl b/test/unit_tests_optimization.jl index 6a5cb36..f216a65 100644 --- a/test/unit_tests_optimization.jl +++ b/test/unit_tests_optimization.jl @@ -6,7 +6,8 @@ RNG = Random.default_rng() graph = parse_dag(joinpath(@__DIR__, "..", "input", "AB->ABBB.txt"), ABCModel()) # create the optimizers -FIXPOINT_OPTIMIZERS = [GreedyOptimizer(GlobalMetricEstimator()), ReductionOptimizer()] +FIXPOINT_OPTIMIZERS = + [GreedyOptimizer(GlobalMetricEstimator()), ReductionOptimizer(), SplitOptimizer(), FusionOptimizer()] NO_FIXPOINT_OPTIMIZERS = [RandomWalkOptimizer(RNG)] @testset "Optimizer $optimizer" for optimizer in vcat(NO_FIXPOINT_OPTIMIZERS, FIXPOINT_OPTIMIZERS) @@ -16,7 +17,7 @@ NO_FIXPOINT_OPTIMIZERS = [RandomWalkOptimizer(RNG)] @test !fixpoint_reached(optimizer, graph) @test operation_stack_length(graph) == 1 - @test optimize!(optimizer, graph, 10) + @test optimize!(optimizer, graph, 2) @test !fixpoint_reached(optimizer, graph)