Lamagraph · Danil-Zaripov · May 4, 2026 · Mar 2, 2026 · Mar 2, 2026 · Mar 3, 2026
diff --git a/.gitignore b/.gitignore
@@ -1 +1,14 @@
+experiments_bfs/results/
+experiments_bfs/data/
+
+experiments_tc/results/
+experiments_tc/data/
+
+experiments_sssp/results/
+experiments_sssp/data/
+matrices/
+
+
 inpla/
+
+*.mtx
diff --git a/README.md b/README.md
@@ -2,6 +2,54 @@
 
 QuadTree linear algebra implementation in Inpla.
 
+# How to run experiments
+
+* Make threaded patched Inpla from `experiments` branch:
+```sh
+git clone https://github.com/Lamagraph/inpla.git -b experiments
+
+# Compile single-threaded version first (bug in vanilla Inpla):
+
+make -C inpla && make -C inpla clean && make -C inpla thread
+```
+
+* Use `ulimit -s unlimited` for unlimited stack
+
+* Run `./scripts/run_experiments.sh $PATH_TO_INPLA $MAX_THREADS $NUMBER_OF_RUNS $(bfs|tc|sssp)` to run all experiments in `./experiments_$(bfs|tc|sssp)/` directory and collect the results OR run the experiments yourself: `./inpla/inpla -f ./experiments_bfs/bcspwr10.in -t 4 -Xms 22 -Xmt 0 > ./my_4threaded_result.txt`
+
+* Using all the memory necessary for running the experiment is preferred as it may increase performance. Use `-Xmt 0` to disable geometric memory consumption. Use `-Xms 22` or greater to use more memory from the start. Not doing that will drag down running speed significantly. Make sure not to overallocate. Do note that memory consumption is proportional to the number of threads used.
+
+* After `./scripts/run_experiments.sh` you can `./scripts/results_to_data.fsx $(bfs|tc|sssp)` to extract data on algorithm time and conversion time ready to be plotted
+
+* Download mtx matrices from SuiteSparse matrix collection and convert them to experiments using `./scripts/mtx_to_experiment.fsx $PATH_TO_MTX_MATRIX $(bfs|tc|sssp)`
+
+# How to preprocess graphs
+
+Structured matrices should better fit to quad-trees.
+
+You can use `./scripts/simple_mtx_reordering.py` to reorder matrices stored in `mtx` files.
+
+```bash
+python reorder_mtx.py input.mtx output.mtx --method rcm
+```
+
+For visual control of reordering you can use `./scripts/draw_mtx_sparsity.py`
+
+```bash
+python spy_mtx.py original.mtx original_spy.png --title "Original Matrix"
+```
+
+## Examples of reordering
+
+| Original | Reordered |
+| :--- | :--- |
+| webbase-1M.mtx |
+| ![Original webbase-1M](reordering_figures/original_webbase.png) | ![Reordered webbase-1M](reordering_figures/reordered_webbase.png) |
+| coAuthorsCiteseer.mtx |
+| ![Original coAuthorsCiteseer](reordering_figures/original_coAuthors.png) | ![Reordered coAuthorsCiteseer](reordering_figures/reordered_coAuthors.png) |
+| arc130.mtx |
+| ![Original arc130](reordering_figures/original_arc_130.png) | ![Reordered arc130](reordering_figures/reordered_arc_130.png) |
+
 # How to run golden tests
 
 Ensure dotnet is installed.

diff --git a/experiments_bfs/3elt_dual.in b/experiments_bfs/3elt_dual.in
diff --git a/experiments_bfs/G57.in b/experiments_bfs/G57.in
diff --git a/experiments_bfs/bcspwr10.in b/experiments_bfs/bcspwr10.in
diff --git a/experiments_bfs/cti.in b/experiments_bfs/cti.in
diff --git a/experiments_sssp/big_positive.in b/experiments_sssp/big_positive.in
diff --git a/experiments_sssp/psmigr_1.in b/experiments_sssp/psmigr_1.in
diff --git a/experiments_tc/1138_bus.in b/experiments_tc/1138_bus.in
diff --git a/experiments_tc/3elt_dual.in b/experiments_tc/3elt_dual.in
diff --git a/experiments_tc/G57.in b/experiments_tc/G57.in
diff --git a/experiments_tc/bcspwr10.in b/experiments_tc/bcspwr10.in
diff --git a/reordering_figures/original_arc_130.png b/reordering_figures/original_arc_130.png
diff --git a/reordering_figures/original_coAuthors.png b/reordering_figures/original_coAuthors.png
diff --git a/reordering_figures/original_webbase.png b/reordering_figures/original_webbase.png
diff --git a/reordering_figures/reordered_arc_130.png b/reordering_figures/reordered_arc_130.png
diff --git a/reordering_figures/reordered_coAuthors.png b/reordering_figures/reordered_coAuthors.png
diff --git a/reordering_figures/reordered_webbase.png b/reordering_figures/reordered_webbase.png
diff --git a/scripts/common_get_experiment.fsx b/scripts/common_get_experiment.fsx
@@ -0,0 +1,272 @@
+let getBigCoo (linewords: string array array) =
+    linewords
+    |> Array.map (fun x -> int x.[0] - 1, int x.[1] - 1)
+    |> Array.map (fun (i, j) -> sprintf "(%d, %d, 1)" i j)
+    |> String.concat ", "
+    |> sprintf "[%s]"
+
+let getBigCooDuplicate (linewords: string array array) =
+    linewords
+    |> Array.map (fun x -> int x.[0] - 1, int x.[1] - 1)
+    |> Array.map (fun (i, j) -> sprintf "(%d, %d, 1), (%d, %d, 1)" i j j i)
+    |> String.concat ", "
+    |> sprintf "[%s]"
+
+let getBigCooValues (linewords: string array array) =
+    linewords
+    |> Array.map (fun x -> int x.[0] - 1, int x.[1] - 1, int x.[2])
+    |> Array.map (fun (i, j, v) -> sprintf "(%d, %d, %d)" i j v)
+    |> String.concat ", "
+    |> sprintf "[%s]"
+
+let getBigCooDuplicateValues (linewords: string array array) =
+    linewords
+    |> Array.map (fun x -> int x.[0] - 1, int x.[1] - 1, int x.[2])
+    |> Array.map (fun (i, j, v) -> sprintf "(%d, %d, %d), (%d, %d, %d)" i j v j i v)
+    |> String.concat ", "
+    |> sprintf "[%s]"
+
+type BinSearchTree<'value> =
+    | Leaf of 'value
+    | Node of BinSearchTree<'value> * 'value * BinSearchTree<'value>
+
+let powersOfTwo =
+    [ 1UL
+      2UL
+      4UL
+      8UL
+      16UL
+      32UL
+      64UL
+
+      128UL
+
+      256UL
+      512UL
+      1024UL
+      2048UL
+      4096UL
+      8192UL
+      16384UL
+
+      32768UL
+
+      65536UL
+      131072UL
+      262144UL
+      524288UL
+      1048576UL
+      2097152UL
+      4194304UL
+
+      8388608UL
+
+      16777216UL
+      33554432UL
+      67108864UL
+      134217728UL
+      268435456UL
+      536870912UL
+      1073741824UL
+
+      2147483648UL
+
+      4294967296UL
+      8589934592UL
+      17179869184UL
+      34359738368UL
+      68719476736UL
+      137438953472UL
+      274877906944UL
+
+      549755813888UL
+
+      1099511627776UL
+      2199023255552UL
+      4398046511104UL
+      8796093022208UL
+      17592186044416UL
+      35184372088832UL
+      70368744177664UL
+
+      140737488355328UL
+
+      281474976710656UL
+      562949953421312UL
+      1125899906842624UL
+      2251799813685248UL
+      4503599627370496UL
+      9007199254740992UL
+      18014398509481984UL
+
+      36028797018963970UL
+
+      72057594037927940UL
+      144115188075855870UL
+      288230376151711740UL
+      576460752303423500UL
+      1152921504606847000UL
+      2305843009213694000UL
+      4611686018427388000UL
+
+      9223372036854776000UL ]
+
+let treeOfPowersOfTwo =
+    BinSearchTree.Node(
+        BinSearchTree.Node(
+            BinSearchTree.Node(
+                BinSearchTree.Node(BinSearchTree.Leaf(1UL), 2UL, BinSearchTree.Leaf(4UL)),
+                8UL,
+                BinSearchTree.Node(BinSearchTree.Leaf(16UL), 32UL, BinSearchTree.Leaf(64UL))
+            ),
+            128UL,
+            BinSearchTree.Node(
+                BinSearchTree.Node(BinSearchTree.Leaf(256UL), 512UL, BinSearchTree.Leaf(1024UL)),
+                2048UL,
+                BinSearchTree.Node(BinSearchTree.Leaf(4096UL), 8192UL, BinSearchTree.Leaf(16384UL))
+            )
+        ),
+        32768UL,
+        BinSearchTree.Node(
+            BinSearchTree.Node(
+                BinSearchTree.Node(BinSearchTree.Leaf(65536UL), 131072UL, BinSearchTree.Leaf(262144UL)),
+                524288UL,
+                BinSearchTree.Node(BinSearchTree.Leaf(1048576UL), 2097152UL, BinSearchTree.Leaf(4194304UL))
+            ),
+            8388608UL,
+            BinSearchTree.Node(
+                BinSearchTree.Node(BinSearchTree.Leaf(16777216UL), 33554432UL, BinSearchTree.Leaf(67108864UL)),
+                134217728UL,
+                BinSearchTree.Node(BinSearchTree.Leaf(268435456UL), 536870912UL, BinSearchTree.Leaf(1073741824UL))
+            )
+        )
+    )
+
+let getNearestUpperPowerOfTwo (x: uint64) =
+    let MAX = 9223372036854776000UL
+
+    let rec find tree rightBound =
+        match tree with
+        | BinSearchTree.Node(left, v, right) ->
+            if x = v then v
+            elif x < v then find left v
+            else find right rightBound
+        | BinSearchTree.Leaf(v) -> if x <= v then v else rightBound
+
+    if x = MAX then
+        MAX
+    elif x < MAX then
+        find treeOfPowersOfTwo 9223372036854776000UL
+    else
+        failwithf "Argument is too large. Must be not greater then %A" MAX
+
+let getExperimentBfs nrows coo =
+    let ssize = int <| getNearestUpperPowerOfTwo (uint64 nrows)
+
+    sprintf
+        @"use ""./src/bfs.in"";
+
+coo ~ %s;
+
+const SSIZE=%d;
+const LENGTH=%d;
+SMFromCoordinateList(graph) ~ (LENGTH, LENGTH, SSIZE, coo);
+vcoo ~ [(0, 1)];
+SVFromCoordinateList(startVertices) ~ (LENGTH, SSIZE, vcoo);
+bfs_level(r) ~ (graph, startVertices);
+// To see the result: r; free r;
+
+exit;
+"
+        coo
+        ssize
+        nrows
+
+let getExperimentTc nrows coo =
+    let ssize = int <| getNearestUpperPowerOfTwo (uint64 nrows)
+
+    sprintf
+        @"use ""./src/triangle_count.in"";
+
+coo ~ %s;
+
+const SSIZE=%d;
+const LENGTH=%d;
+SMFromCoordinateList(graph) ~ (LENGTH, LENGTH, SSIZE, coo);
+triangle_count(r) ~ (graph);
+// To see the result: r; free r;
+
+exit;
+"
+        coo
+        ssize
+        nrows
+
+let getExperimentSSSP nrows coo =
+    let ssize = int <| getNearestUpperPowerOfTwo (uint64 nrows)
+
+    sprintf
+        @"use ""./src/sssp.in"";
+
+coo ~ %s;
+
+const SSIZE=%d;
+const LENGTH=%d;
+const STARTING_VERTEX=0;
+SMFromCoordinateList(graph) ~ (LENGTH, LENGTH, SSIZE, coo);
+sssp(r) ~ (graph, STARTING_VERTEX);
+// To see the result: r; free r;
+
+exit;
+"
+        coo
+        ssize
+        nrows
+
+type Algorithm =
+    | BFS
+    | TC
+    | SSSP
+
+let getExperiment alg nrows coo =
+    match alg with
+    | BFS -> getExperimentBfs nrows coo
+    | TC -> getExperimentTc nrows coo
+    | SSSP -> getExperimentSSSP nrows coo
+
+let usage =
+    $"Usage: {fsi.CommandLineArgs[0]} path/to/matrix.mtx (bfs|tc|sssp) ((true|false): OPTIONAL get values on the edges. Default: true for sssp, false otherwise)"
+
+let getEdgeValues (args: string array) =
+    if args.Length < 4 then
+        None
+    else if args.[3] = "true" then
+        printfn "Getting the values on the edges"
+        Some true
+    else
+        printfn "Not getting the values on the edges"
+        Some false
+
+let chooseValueCooFunc alg args =
+    let arg = getEdgeValues args
+
+    match arg with
+    | None -> alg = SSSP
+    | Some v -> v
+
+
+let getAlgorithm (str: string) =
+    match str.ToLower() with
+    | "bfs" -> BFS
+    | "tc" -> TC
+    | "sssp" -> SSSP
+    | _ -> failwith usage
+
+let experimentsPath algorithm =
+    match algorithm with
+    | BFS -> "./experiments_bfs/"
+    | TC -> "./experiments_tc/"
+    | SSSP -> "./experiments_sssp/"
+
+
+let inplaExtension = ".in"