Work in progress: Parallel Benchmark

.gitmodules

@@ -1,6 +1,6 @@
 [submodule "deps/SparseRooflineBenchmark"]
 	path = deps/SparseRooflineBenchmark
-	url = https://github.com/SparseRooflineBenchmark/SparseRooflineBenchmark
+	url = git@github.com:Paramuths/SparseRooflineBenchmark.git
 [submodule "deps/taco"]
 	path = deps/taco
 	url = https://github.com/tensor-compiler/taco

parallel/.gitignore

@@ -0,0 +1 @@
+Manifest.toml

parallel/Project.toml

@@ -0,0 +1,13 @@
+[deps]
+ArgParse = "c7e460c6-2fb9-53a9-8c5b-16f535851c63"
+Atomix = "a9b6321e-bd34-4604-b9c9-b65b8de01458"
+BenchmarkTools = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf"
+DataStructures = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
+Finch = "9177782c-1635-4eb9-9bfb-d9dfa25e6bce"
+IterativeSolvers = "42fd0dbc-a981-5370-80f2-aaf504508153"
+JSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6"
+LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
+MatrixDepot = "b51810bb-c9f3-55da-ae3c-350fc1fbce05"
+SuiteSparseGraphBLAS = "c2e53296-7b14-11e9-1210-bddfa8111e1d"
+TensorMarket = "8b7d4fe7-0b45-4d0d-9dd8-5cc9b23b4b77"
+ThreadPinning = "811555cd-349b-4f26-b7bc-1f208b848042"

parallel/spadd/.gitignore

@@ -0,0 +1,2 @@
+Manifest.toml
+slurm*

parallel/spadd/concat.jl

@@ -0,0 +1,66 @@
+using Finch
+using Base.Threads
+
+function concat(A::Tensor{DenseLevel{Int64,SparseListLevel{Int64,Vector{Int64},Vector{Int64},ElementLevel{0.0,Float64,Int64,Vector{Float64}}}}}, B::Tensor{DenseLevel{Int64,SparseListLevel{Int64,Vector{Int64},Vector{Int64},ElementLevel{0.0,Float64,Int64,Vector{Float64}}}}})
+    @inbounds @fastmath(begin
+        A_lvl = A.lvl # DenseLevel
+        A_lvl_2 = A_lvl.lvl # SparseListLevel
+        A_lvl_ptr = A_lvl_2.ptr # Vector{Int64}
+        A_lvl_idx = A_lvl_2.idx # Vector{Int64}
+        # A_lvl_3 = A_lvl_2.lvl # ElementLevel
+        A_lvl_2_val = A_lvl_2.lvl.val # Vector{Float64}
+
+        B_lvl = B.lvl # DenseLevel
+        B_lvl_2 = B_lvl.lvl # SparseListLevel
+        B_lvl_ptr = B_lvl_2.ptr # Vector{Int64}
+        B_lvl_idx = B_lvl_2.idx # Vector{Int64}
+        # B_lvl_3 = B_lvl_2.lvl # ElementLevel
+        B_lvl_2_val = B_lvl_2.lvl.val # Vector{Float64}
+
+        # val
+        C_lvl_2_val = vcat(A_lvl_2_val, B_lvl_2_val)
+        C_lvl_3 = Element{0.0,Float64,Int64}(C_lvl_2_val)
+        # shape
+        A_lvl_2.shape == B_lvl_2.shape || throw(DimensionMismatch("mismatched dimension limits ($(A_lvl_2.shape) != $(B_lvl_2.shape))"))
+        C_lvl_shape = A_lvl_2.shape
+        # pointer
+        B_lvl_ptr_shift = B_lvl_ptr[2:end] .+ (last(A_lvl_ptr) - 1)
+        C_lvl_ptr = vcat(A_lvl_ptr, B_lvl_ptr_shift)
+        # index
+        C_lvl_idx = vcat(A_lvl_idx, B_lvl_idx)
+
+        C_lvl_2 = SparseList{Int64}(C_lvl_3, C_lvl_shape, C_lvl_ptr, C_lvl_idx)
+        C_lvl = Dense{Int64}(C_lvl_2, A_lvl.shape + B_lvl.shape)
+
+        C = Tensor(C_lvl)
+        return C
+    end)
+end
+
+function concat_vec(V::Vector{Tensor{DenseLevel{Int64,SparseListLevel{Int64,Vector{Int64},Vector{Int64},ElementLevel{0.0,Float64,Int64,Vector{Float64}}}}}}, nonzero_offset::Vector{Int64}, columns::Vector{Int64})
+    @inbounds @fastmath(begin
+        # val
+        B_lvl_2_val = Vector{Float64}(undef, last(nonzero_offset))
+        # shape
+        B_lvl_shape = V[1].lvl.lvl.shape
+        # pointer
+        B_lvl_ptr = Vector{Int64}(undef, last(columns) + 1)
+        B_lvl_ptr[1] = 1
+        # idx
+        B_lvl_idx = Vector{Int64}(undef, last(nonzero_offset))
+
+        Threads.@threads for i in 1:length(V)
+            B_lvl_2_val[nonzero_offset[i]+1:nonzero_offset[i+1]] .= V[i].lvl.lvl.lvl.val
+            B_lvl_idx[nonzero_offset[i]+1:nonzero_offset[i+1]] .= V[i].lvl.lvl.idx
+            B_lvl_ptr[columns[i]+2:columns[i+1]+1] = V[i].lvl.lvl.ptr[2:end] .+ nonzero_offset[i]
+        end
+        B_lvl_3 = Element{0.0,Float64,Int64}(B_lvl_2_val)
+
+        B_lvl_2 = SparseList{Int64}(B_lvl_3, B_lvl_shape, B_lvl_ptr, B_lvl_idx)
+        B_lvl = Dense{Int64}(B_lvl_2, mapreduce(A -> A.lvl.shape, +, V))
+
+        B = Tensor(B_lvl)
+        return B
+    end)
+end
+

parallel/spadd/graph.py

@@ -0,0 +1,116 @@
+import json
+from collections import defaultdict
+
+import matplotlib.pyplot as plt
+
+GRAPH_FOLDER = "graph"
+SPEEDUP_FOLDER = "speedup"
+RUNTIME_FOLDER = "runtime"
+RESULTS_FOLDER = "results"
+
+NTHREADS = [i + 1 for i in range(12)]
+
+DEFAULT_METHOD = "serial_default_implementation"
+METHODS = [
+    DEFAULT_METHOD,
+    # "parallel_col_separate_sparselist_results",
+    "separated_memory_concatenate_results",
+]
+
+DATASETS = [
+    {"uniform": ["1000-0.1", "10000-0.1", "1000000-3000000"]},
+    {"FEMLAB": ["FEMLAB-poisson3Da", "FEMLAB-poisson3Db"]},
+]
+
+COLORS = ["gray", "cadetblue", "saddlebrown", "navy", "black"]
+
+
+def load_json():
+    combine_results = defaultdict(lambda: defaultdict(lambda: defaultdict(lambda: {})))
+    for n_thread in NTHREADS:
+        results_json = json.load(
+            open(f"{RESULTS_FOLDER}/spadd_{n_thread}_threads.json", "r")
+        )
+        for result in results_json:
+
+            matrix = (
+                result["matrix"].replace("/", "-")
+                if result["dataset"] != "uniform"
+                else f"{result['matrix']['size']}-{result['matrix']['sparsity']}"
+            )
+            combine_results[result["dataset"]][matrix][result["method"]][
+                result["n_threads"]
+            ] = result["time"]
+
+    return combine_results
+
+
+def plot_speedup_result(results, dataset, matrix, save_location):
+    plt.figure(figsize=(10, 6))
+    for method, color in zip(METHODS, COLORS):
+        plt.plot(
+            NTHREADS,
+            [
+                results[dataset][matrix][DEFAULT_METHOD][n_thread]
+                / results[dataset][matrix][method][n_thread]
+                for n_thread in NTHREADS
+            ],
+            label=method,
+            color=color,
+            marker="o",
+            linestyle="-",
+            linewidth=1,
+        )
+
+    plt.title(
+        f"SpAdd - Speedup for {dataset}: {matrix} (with respect to {DEFAULT_METHOD})"
+    )
+    # plt.yscale("log", base=10)
+    plt.xticks(NTHREADS)
+    plt.xlabel("Number of Threads")
+    plt.ylabel(f"Speedup")
+
+    plt.legend()
+    plt.savefig(save_location)
+
+
+def plot_runtime_result(results, dataset, matrix, save_location):
+    plt.figure(figsize=(10, 6))
+    for method, color in zip(METHODS, COLORS):
+        plt.plot(
+            NTHREADS,
+            [results[dataset][matrix][method][n_thread] for n_thread in NTHREADS],
+            label=method,
+            color=color,
+            marker="o",
+            linestyle="-",
+            linewidth=1,
+        )
+
+    plt.title(f"SpAdd - Runtime for {dataset}: {matrix}")
+    # plt.yscale("log", base=10)
+    plt.xticks(NTHREADS)
+    plt.xlabel("Number of Threads")
+    plt.ylabel(f"Runtime (in seconds)")
+
+    plt.legend()
+    plt.savefig(save_location)
+
+
+if __name__ == "__main__":
+    results = load_json()
+    for datasets in DATASETS:
+        for dataset, matrices in datasets.items():
+            for matrix in matrices:
+                plot_speedup_result(
+                    results,
+                    dataset,
+                    matrix,
+                    f"{GRAPH_FOLDER}/{SPEEDUP_FOLDER}/{dataset}-{matrix}.png",
+                )
+                plot_runtime_result(
+                    results,
+                    dataset,
+                    matrix,
+                    f"{GRAPH_FOLDER}/{RUNTIME_FOLDER}/{dataset}-{matrix}.png",
+                )

parallel/spadd/parallel_col_separate_sparselist_results.jl

@@ -0,0 +1,19 @@
+using Finch
+using BenchmarkTools
+
+
+function parallel_col_separate_sparselist_results_add(A, B)
+        _A = Tensor(Dense(SparseList(Element(0.0))), A)
+        _B = Tensor(Dense(SparseList(Element(0.0))), B)
+        time = @belapsed begin
+                (_A, _B) = $(_A, _B)
+                global _C = Tensor(Dense(Separate(SparseList(Element(0.0)))))
+                @finch mode = :fast begin
+                        _C .= 0
+                        for j = parallel(_), i = _
+                                _C[i, j] = _A[i, j] + _B[i, j]
+                        end
+                end
+        end
+        return (; time=time, C=_C)
+end

parallel/spadd/results/spadd_10_threads.json

@@ -0,0 +1,134 @@
+[
+    {
+        "time": 0.00759134,
+        "n_threads": 10,
+        "method": "serial_default_implementation",
+        "dataset": "FEMLAB",
+        "matrix": "FEMLAB/poisson3Da"
+    },
+    {
+        "time": 0.048477826,
+        "n_threads": 10,
+        "method": "parallel_col_separate_sparselist_results",
+        "dataset": "FEMLAB",
+        "matrix": "FEMLAB/poisson3Da"
+    },
+    {
+        "time": 0.003060656,
+        "n_threads": 10,
+        "method": "separated_memory_concatenate_results",
+        "dataset": "FEMLAB",
+        "matrix": "FEMLAB/poisson3Da"
+    },
+    {
+        "time": 0.140822392,
+        "n_threads": 10,
+        "method": "serial_default_implementation",
+        "dataset": "FEMLAB",
+        "matrix": "FEMLAB/poisson3Db"
+    },
+    {
+        "time": 0.343739416,
+        "n_threads": 10,
+        "method": "parallel_col_separate_sparselist_results",
+        "dataset": "FEMLAB",
+        "matrix": "FEMLAB/poisson3Db"
+    },
+    {
+        "time": 0.025895345,
+        "n_threads": 10,
+        "method": "separated_memory_concatenate_results",
+        "dataset": "FEMLAB",
+        "matrix": "FEMLAB/poisson3Db"
+    },
+    {
+        "time": 0.002042569,
+        "n_threads": 10,
+        "method": "serial_default_implementation",
+        "dataset": "uniform",
+        "matrix": {
+            "size": 1000,
+            "sparsity": 0.1
+        }
+    },
+    {
+        "time": 0.004510134,
+        "n_threads": 10,
+        "method": "parallel_col_separate_sparselist_results",
+        "dataset": "uniform",
+        "matrix": {
+            "size": 1000,
+            "sparsity": 0.1
+        }
+    },
+    {
+        "time": 0.000682558,
+        "n_threads": 10,
+        "method": "separated_memory_concatenate_results",
+        "dataset": "uniform",
+        "matrix": {
+            "size": 1000,
+            "sparsity": 0.1
+        }
+    },
+    {
+        "time": 0.671362515,
+        "n_threads": 10,
+        "method": "serial_default_implementation",
+        "dataset": "uniform",
+        "matrix": {
+            "size": 10000,
+            "sparsity": 0.1
+        }
+    },
+    {
+        "time": 0.122503556,
+        "n_threads": 10,
+        "method": "parallel_col_separate_sparselist_results",
+        "dataset": "uniform",
+        "matrix": {
+            "size": 10000,
+            "sparsity": 0.1
+        }
+    },
+    {
+        "time": 0.059856956,
+        "n_threads": 10,
+        "method": "separated_memory_concatenate_results",
+        "dataset": "uniform",
+        "matrix": {
+            "size": 10000,
+            "sparsity": 0.1
+        }
+    },
+    {
+        "time": 0.142538191,
+        "n_threads": 10,
+        "method": "serial_default_implementation",
+        "dataset": "uniform",
+        "matrix": {
+            "size": 1000000,
+            "sparsity": 3000000
+        }
+    },
+    {
+        "time": 3.792686368,
+        "n_threads": 10,
+        "method": "parallel_col_separate_sparselist_results",
+        "dataset": "uniform",
+        "matrix": {
+            "size": 1000000,
+            "sparsity": 3000000
+        }
+    },
+    {
+        "time": 0.036291917,
+        "n_threads": 10,
+        "method": "separated_memory_concatenate_results",
+        "dataset": "uniform",
+        "matrix": {
+            "size": 1000000,
+            "sparsity": 3000000
+        }
+    }
+]