Improve gen_access_expr with dispatch

Reviewed-on: Rubydragon/MetagraphOptimization.jl#8

.JuliaFormatter.toml

@@ -1,5 +1,5 @@
 indent = 4
-margin = 80
+margin = 120
 always_for_in = true
 for_in_replacement = "in"
 whitespace_typedefs = true

.gitattributes

@@ -1,2 +1,2 @@
-examples/AB->ABBBBBBB.txt filter=lfs diff=lfs merge=lfs -text
-examples/AB->ABBBBBBBBB.txt filter=lfs diff=lfs merge=lfs -text
+input/AB->ABBBBBBBBB.txt filter=lfs diff=lfs merge=lfs -text
+input/AB->ABBBBBBB.txt filter=lfs diff=lfs merge=lfs -text

.gitea/workflows/julia-package-ci.yml

@@ -1,34 +1,114 @@
-name: Test
+name: MetagraphOptimization_CI
 
 on: [push]
 
+env:
+  # keep the depot directly in the repository for the cache
+  JULIA_DEPOT_PATH: './.julia'
+
 jobs:
-  test:
+  prepare:
     runs-on: arch-latest
 
     steps:
-      #- name: Get git-lfs
-      #  run: apt-get update && apt-get install git-lfs
-
       - name: Checkout repository
         uses: actions/checkout@v3
         with:
           fetch-depth: 0
 
-      #- name: Checkout LFS objects
-      #  run: git lfs checkout
-
       - name: Setup Julia environment
         uses: https://github.com/julia-actions/setup-julia@v1.9.2
         with:
           version: '1.9.2'
 
+      # needed for the file hashing, should be removed when ${{ hashFiles('**/Project.toml') }} is supported in gitea
+      - name: Setup go environment
+        uses: actions/setup-go@v3
+        with:
+          go-version: '1.20'
+
+      - name: Hash files
+        uses: https://gitea.com/actions/go-hashfiles@v0.0.1
+        id: get-hash
+        with: 
+          patterns: |-
+            **/Project.toml
+
+      - name: Restore Cache
+        uses: actions/cache/restore@v3
+        id: cache-restore
+        with:
+          path: |
+            .julia/artifacts
+            .julia/packages
+            .julia/registries
+          key: julia-${{ steps.get-hash.outputs.hash }}
+
+      - name: Check cache hit
+        if: steps.cache-restore.outputs.cache-hit == 'true'
+        run: exit 0
+
       - name: Install dependencies
-        run: julia --project=./ -e 'import Pkg; Pkg.instantiate()'
+        run: |
+          julia --project=./        -e 'import Pkg; Pkg.instantiate(); Pkg.precompile()'
+          julia --project=examples/ -e 'import Pkg; Pkg.develop(Pkg.PackageSpec(path=pwd())); Pkg.instantiate(); Pkg.precompile()'
+          julia --project=docs/     -e 'import Pkg; Pkg.develop(Pkg.PackageSpec(path=pwd())); Pkg.instantiate(); Pkg.precompile()'
+
+      - name: Cache Julia packages
+        uses: actions/cache/save@v3
+        with:
+          path: |
+            .julia/artifacts
+            .julia/packages
+            .julia/registries
+          key: julia-${{ steps.get-hash.outputs.hash }}
+
+  test:
+    needs: prepare
+    runs-on: arch-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Setup Julia environment
+        uses: https://github.com/julia-actions/setup-julia@v1.9.2
+        with:
+          version: '1.9.2'
+
+      # needed for the file hashing, should be removed when ${{ hashFiles('**/Project.toml') }} is supported in gitea
+      - name: Setup go environment
+        uses: actions/setup-go@v3
+        with:
+          go-version: '1.20'
+
+      - name: Hash files
+        uses: https://gitea.com/actions/go-hashfiles@v0.0.1
+        id: get-hash
+        with: 
+          patterns: |-
+            **/Project.toml  
+
+      - name: Restore cached Julia packages
+        uses: actions/cache/restore@v3
+        with:
+          path: |
+            .julia/artifacts
+            .julia/packages
+            .julia/registries
+          key: julia-${{ steps.get-hash.outputs.hash }}
+
+      - name: Install dependencies
+        run: |
+          julia --project=./        -e 'import Pkg; Pkg.instantiate(); Pkg.precompile()'
+          julia --project=examples/ -e 'import Pkg; Pkg.develop(Pkg.PackageSpec(path=pwd())); Pkg.instantiate(); Pkg.precompile()'
+          julia --project=docs/     -e 'import Pkg; Pkg.develop(Pkg.PackageSpec(path=pwd())); Pkg.instantiate(); Pkg.precompile()'
 
       - name: Format check
         run: |
-          julia --project=./ -e 'using JuliaFormatter; format(".", verbose=true)'
+          julia --project=./ -e 'using JuliaFormatter; format(".", verbose=true, ignore=[".julia/*"])'
           julia --project=./ -e '
           out = Cmd(`git diff --name-only`) |> read |> String
           if out == ""
@@ -43,4 +123,63 @@ jobs:
         run: julia --project=./ -t 4 -e 'import Pkg; Pkg.test()' -O0
 
       - name: Run examples
-        run: julia --project=examples/ -t 4 -e 'import Pkg; Pkg.develop(Pkg.PackageSpec(path=pwd())); Pkg.instantiate(); include("examples/import_bench.jl")' -O3
+        run: julia --project=examples/ -t 4 -e 'include("examples/import_bench.jl")' -O3
+
+  docs:
+    needs: prepare
+    runs-on: arch-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Setup Julia environment
+        uses: https://github.com/julia-actions/setup-julia@v1.9.2
+        with:
+          version: '1.9.2'
+
+      # needed for the file hashing, should be removed when ${{ hashFiles('**/Project.toml') }} is supported in gitea
+      - name: Setup go environment
+        uses: actions/setup-go@v3
+        with:
+          go-version: '1.20'
+
+      - name: Hash files
+        uses: https://gitea.com/actions/go-hashfiles@v0.0.1
+        id: get-hash
+        with: 
+          patterns: |-
+            **/Project.toml  
+
+      - name: Restore cached Julia packages
+        uses: actions/cache/restore@v3
+        with:
+          path: |
+            .julia/artifacts
+            .julia/packages
+            .julia/registries
+          key: julia-${{ steps.get-hash.outputs.hash }}
+
+      - name: Install dependencies
+        run: |
+          julia --project=./        -e 'import Pkg; Pkg.instantiate(); Pkg.precompile()'
+          julia --project=examples/ -e 'import Pkg; Pkg.develop(Pkg.PackageSpec(path=pwd())); Pkg.instantiate(); Pkg.precompile()'
+          julia --project=docs/     -e 'import Pkg; Pkg.develop(Pkg.PackageSpec(path=pwd())); Pkg.instantiate(); Pkg.precompile()'
+
+      - name: Build docs
+        run: julia --project=docs/ docs/make.jl
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: web-doc
+          path: docs/build/
+
+      #- name: Webhook Trigger
+      #  uses: https://github.com/zzzze/webhook-trigger@master
+      #  continue-on-error: true
+      #  with:
+      #    data: "{\"event\":\"action_completed\", \"download_url\":\"deckardcain.local:8099/something\"}"
+      #    webhook_url: ${{ secrets.WEBHOOK_URL }}

.gitignore

@@ -26,3 +26,5 @@ Manifest.toml
 
 # vscode workspace directory
 .vscode
+.julia
+**/.ipynb_checkpoints/

Project.toml

@@ -4,10 +4,16 @@ authors = ["Anton Reinhard <anton.reinhard@proton.me>"]
 version = "0.1.0"
 
 [deps]
+AccurateArithmetic = "22286c92-06ac-501d-9306-4abd417d9753"
+CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba"
 DataStructures = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
+ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210"
 JuliaFormatter = "98e50ef6-434e-11e9-1051-2b60c6c9e899"
-Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7"
+KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c"
+NumaAllocators = "21436f30-1b4a-4f08-87af-e26101bb5379"
+QEDbase = "10e22c08-3ccb-4172-bfcf-7d7aa3d04d93"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
+Roots = "f2b01f46-fcfa-551c-844a-d8ac1e96c665"
 UUIDs = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
 
 [extras]

README.md

@@ -42,7 +42,7 @@ Problems:
 - Lots of testing required because mistakes will propagate and multiply.
 
 ## Other TODOs
-- Reduce memory footprint of the graph, are the UUIDs too large? 
+- Reduce memory footprint of the graph
 - Memory layout of Nodes? They should lie linearly in memory, right now probably on heap?
 - Add scaling functions
 
@@ -53,7 +53,7 @@ For graphs AB->AB^n:
 - Number of ComputeTaskS2 should always be (n+1)!
 - Number of ComputeTaskU should always be (n+3)
 
-Times are from my home machine: AMD Ryzen 7900X3D, 64GB DDR5 RAM @ 6000MHz
+Times are from my home machine: AMD Ryzen 7900X3D, 64GB DDR5 RAM @ 6000MHz (not necessarily up to date, check Jupyter Notebooks in `notebooks/` instead)
 
 ```
 $ julia --project examples/import_bench.jl

docs/Project.toml

@@ -0,0 +1,4 @@
+[deps]
+Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"
+DocumenterTools = "35a29f4d-8980-5a13-9543-d66fff28ecb8"
+MetagraphOptimization = "3e869610-d48d-4942-ba70-c1b702a33ca4"

docs/make.jl

@@ -0,0 +1,34 @@
+using Documenter
+using MetagraphOptimization
+
+makedocs(
+    #format = Documenter.LaTeX(platform=""),
+
+    root = "docs",
+    source = "src",
+    build = "build",
+    warnonly = true,
+    clean = true,
+    doctest = true,
+    modules = Module[MetagraphOptimization],
+    #repo = "https://code.woubery.com/Rubydragon/MetagraphOptimization.jl/src/branch/{commit}{path}#L{line}",
+    remotes = nothing,
+    sitename = "MetagraphOptimization.jl",
+    pages = [
+        "index.md",
+        "Manual" => "manual.md",
+        "Library" => [
+            "Public" => "lib/public.md",
+            "Graph" => "lib/internals/graph.md",
+            "Node" => "lib/internals/node.md",
+            "Task" => "lib/internals/task.md",
+            "Operation" => "lib/internals/operation.md",
+            "Models" => "lib/internals/models.md",
+            "Diff" => "lib/internals/diff.md",
+            "Utility" => "lib/internals/utility.md",
+            "Code Generation" => "lib/internals/code_gen.md",
+            "Devices" => "lib/internals/devices.md",
+        ],
+        "Contribution" => "contribution.md",
+    ],
+)

docs/src/contribution.md

@@ -0,0 +1,3 @@
+# Contribution
+
+This is currently in development for a diploma thesis and is therefore private and impossible to contribute to.

docs/src/flowchart.drawio

@@ -0,0 +1,75 @@
+<mxfile host="Electron" modified="2023-09-17T13:34:45.840Z" agent="Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) draw.io/21.6.1 Chrome/114.0.5735.134 Electron/25.6.0 Safari/537.36" etag="e0c8qLevhaP_q_R2fyC9" version="21.6.1" type="device">
+  <diagram name="Page-1" id="Vy0cA1nkMPfy-3cC5ahA">
+    <mxGraphModel dx="1185" dy="707" grid="1" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="500" pageHeight="900" math="0" shadow="0">
+      <root>
+        <mxCell id="0" />
+        <mxCell id="1" parent="0" />
+        <mxCell id="yG8qeggDCLqQ8GwY7ugi-5" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;shadow=1;" edge="1" parent="1" source="yG8qeggDCLqQ8GwY7ugi-1" target="yG8qeggDCLqQ8GwY7ugi-2">
+          <mxGeometry relative="1" as="geometry" />
+        </mxCell>
+        <mxCell id="yG8qeggDCLqQ8GwY7ugi-1" value="Process Generator Script" style="rounded=1;whiteSpace=wrap;html=1;shadow=1;" vertex="1" parent="1">
+          <mxGeometry x="180" y="120" width="120" height="60" as="geometry" />
+        </mxCell>
+        <mxCell id="yG8qeggDCLqQ8GwY7ugi-11" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;shadow=1;" edge="1" parent="1" source="yG8qeggDCLqQ8GwY7ugi-2" target="yG8qeggDCLqQ8GwY7ugi-3">
+          <mxGeometry relative="1" as="geometry" />
+        </mxCell>
+        <mxCell id="yG8qeggDCLqQ8GwY7ugi-2" value="Process Parser" style="rounded=1;whiteSpace=wrap;html=1;shadow=1;" vertex="1" parent="1">
+          <mxGeometry x="180" y="220" width="120" height="60" as="geometry" />
+        </mxCell>
+        <mxCell id="yG8qeggDCLqQ8GwY7ugi-8" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=1;exitY=0.25;exitDx=0;exitDy=0;entryX=0;entryY=0.25;entryDx=0;entryDy=0;shadow=1;" edge="1" parent="1" source="yG8qeggDCLqQ8GwY7ugi-3" target="yG8qeggDCLqQ8GwY7ugi-6">
+          <mxGeometry relative="1" as="geometry" />
+        </mxCell>
+        <mxCell id="yG8qeggDCLqQ8GwY7ugi-14" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;shadow=1;" edge="1" parent="1" source="yG8qeggDCLqQ8GwY7ugi-3" target="yG8qeggDCLqQ8GwY7ugi-12">
+          <mxGeometry relative="1" as="geometry" />
+        </mxCell>
+        <mxCell id="yG8qeggDCLqQ8GwY7ugi-3" value="Optimizer" style="rounded=1;whiteSpace=wrap;html=1;shadow=1;" vertex="1" parent="1">
+          <mxGeometry x="180" y="320" width="120" height="60" as="geometry" />
+        </mxCell>
+        <mxCell id="yG8qeggDCLqQ8GwY7ugi-9" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;entryX=1;entryY=0.75;entryDx=0;entryDy=0;exitX=0;exitY=0.75;exitDx=0;exitDy=0;shadow=1;" edge="1" parent="1" source="yG8qeggDCLqQ8GwY7ugi-6" target="yG8qeggDCLqQ8GwY7ugi-3">
+          <mxGeometry relative="1" as="geometry" />
+        </mxCell>
+        <mxCell id="yG8qeggDCLqQ8GwY7ugi-6" value="Fast Cost Estimator&lt;br&gt;(Global Metrics)" style="rounded=1;whiteSpace=wrap;html=1;shadow=1;" vertex="1" parent="1">
+          <mxGeometry x="340" y="320" width="120" height="60" as="geometry" />
+        </mxCell>
+        <mxCell id="yG8qeggDCLqQ8GwY7ugi-15" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;shadow=1;" edge="1" parent="1" source="yG8qeggDCLqQ8GwY7ugi-12" target="yG8qeggDCLqQ8GwY7ugi-13">
+          <mxGeometry relative="1" as="geometry">
+            <Array as="points">
+              <mxPoint x="80" y="450" />
+            </Array>
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="yG8qeggDCLqQ8GwY7ugi-12" value="Scheduler" style="rounded=1;whiteSpace=wrap;html=1;shadow=1;" vertex="1" parent="1">
+          <mxGeometry x="180" y="420" width="120" height="60" as="geometry" />
+        </mxCell>
+        <mxCell id="yG8qeggDCLqQ8GwY7ugi-16" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;entryX=0;entryY=0.5;entryDx=0;entryDy=0;shadow=1;" edge="1" parent="1" source="yG8qeggDCLqQ8GwY7ugi-13" target="yG8qeggDCLqQ8GwY7ugi-3">
+          <mxGeometry relative="1" as="geometry">
+            <mxPoint x="120" y="380" as="targetPoint" />
+            <Array as="points">
+              <mxPoint x="80" y="350" />
+            </Array>
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="yG8qeggDCLqQ8GwY7ugi-19" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=0.5;exitY=1;exitDx=0;exitDy=0;shadow=1;" edge="1" parent="1" source="yG8qeggDCLqQ8GwY7ugi-12" target="yG8qeggDCLqQ8GwY7ugi-18">
+          <mxGeometry relative="1" as="geometry">
+            <Array as="points">
+              <mxPoint x="240" y="500" />
+              <mxPoint x="240" y="500" />
+            </Array>
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="yG8qeggDCLqQ8GwY7ugi-13" value="Accurate Cost Estimator&lt;br&gt;(Machine Specific)" style="rounded=1;whiteSpace=wrap;html=1;shadow=1;" vertex="1" parent="1">
+          <mxGeometry x="20" y="370" width="120" height="60" as="geometry" />
+        </mxCell>
+        <mxCell id="yG8qeggDCLqQ8GwY7ugi-21" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;shadow=1;" edge="1" parent="1" source="yG8qeggDCLqQ8GwY7ugi-18" target="yG8qeggDCLqQ8GwY7ugi-20">
+          <mxGeometry relative="1" as="geometry" />
+        </mxCell>
+        <mxCell id="yG8qeggDCLqQ8GwY7ugi-18" value="Code Generator" style="rounded=1;whiteSpace=wrap;html=1;shadow=1;" vertex="1" parent="1">
+          <mxGeometry x="180" y="520" width="120" height="60" as="geometry" />
+        </mxCell>
+        <mxCell id="yG8qeggDCLqQ8GwY7ugi-20" value="Executor" style="rounded=1;whiteSpace=wrap;html=1;shadow=1;" vertex="1" parent="1">
+          <mxGeometry x="180" y="620" width="120" height="60" as="geometry" />
+        </mxCell>
+      </root>
+    </mxGraphModel>
+  </diagram>
+</mxfile>

docs/src/index.md

@@ -0,0 +1,26 @@
+# MetagraphOptimization.jl
+
+*A domain-specific DAG-optimizer*
+
+## Package Features
+- Read a DAG from a file
+- Analyze its properties
+- Mute the graph using the operations NodeFusion, NodeReduction and NodeSplit
+
+## Coming Soon:
+- Add Code Generation from finished DAG
+- Add optimization algorithms and strategies
+
+## Library Outline
+
+```@contents
+Pages = [
+    "lib/public.md",
+    "lib/internals.md"
+]
+```
+
+### [Index](@id main-index)
+```@index
+Pages = ["lib/public.md"]
+```

docs/src/lib/internals/code_gen.md

@@ -0,0 +1,8 @@
+# Code Generation
+
+## Main
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["code_gen/main.jl"]
+Order = [:function]
+```

docs/src/lib/internals/devices.md

@@ -0,0 +1,59 @@
+# Devices
+
+## Interface
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["devices/interface.jl"]
+Order = [:type, :constant, :function]
+```
+
+## Detect
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["devices/detect.jl"]
+Order = [:function]
+```
+
+## Measure
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["devices/measure.jl"]
+Order = [:function]
+```
+
+## Implementations
+
+### General
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["devices/impl.jl"]
+Order = [:type, :function]
+```
+
+### NUMA
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["devices/numa/impl.jl"]
+Order = [:type, :function]
+```
+
+### CUDA
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["devices/cuda/impl.jl"]
+Order = [:type, :function]
+```
+
+### ROCm
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["devices/rocm/impl.jl"]
+Order = [:type, :function]
+```
+
+### oneAPI
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["devices/oneapi/impl.jl"]
+Order = [:type, :function]
+```

docs/src/lib/internals/diff.md

@@ -0,0 +1,22 @@
+# Diff
+
+## Type
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["diff/type.jl"]
+Order   = [:type]
+```
+
+## Properties
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["diff/properties.jl"]
+Order   = [:function]
+```
+
+## Printing
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["diff/print.jl"]
+Order   = [:function]
+```

docs/src/lib/internals/graph.md

@@ -0,0 +1,50 @@
+# Graph
+
+## Type
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["graph/type.jl"]
+Order   = [:type]
+```
+
+## Interface
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["graph/interface.jl"]
+Order   = [:function]
+```
+
+## Compare
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["graph/compare.jl"]
+Order   = [:function]
+```
+
+## Mute
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["graph/mute.jl"]
+Order   = [:function]
+```
+
+## Print
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["graph/print.jl"]
+Order   = [:function]
+```
+
+## Properties
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["graph/properties.jl"]
+Order   = [:function]
+```
+
+## Validate
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["graph/validate.jl"]
+Order   = [:function]
+```

docs/src/lib/internals/models.md

@@ -0,0 +1,72 @@
+# Models
+
+## Interface
+
+The interface that has to be implemented for a model to be usable is defined in `src/models/interface.jl`.
+
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["models/interface.jl"]
+Order = [:type, :constant, :function]
+```
+
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["models/print.jl"]
+Order = [:function]
+```
+
+## ABC-Model
+
+### Types
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["models/abc/types.jl"]
+Order   = [:type, :constant]
+```
+
+### Particle
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["models/abc/particle.jl"]
+Order   = [:type, :constant, :function]
+```
+
+### Parse
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["models/abc/parse.jl"]
+Order   = [:function]
+```
+
+### Properties
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["models/abc/properties.jl"]
+Order   = [:function]
+```
+
+### Create
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["models/abc/create.jl"]
+Order = [:function]
+```
+
+### Compute
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["models/abc/compute.jl"]
+Order = [:function]
+```
+
+### Print
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["models/abc/print.jl"]
+Order = [:function]
+```
+
+## QED-Model
+
+*To be added*

docs/src/lib/internals/node.md

@@ -0,0 +1,43 @@
+# Node
+
+## Type
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["node/type.jl"]
+Order   = [:type]
+```
+
+## Create
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["node/create.jl"]
+Order   = [:function]
+```
+
+## Compare
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["node/compare.jl"]
+Order   = [:function]
+```
+
+## Properties
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["node/properties.jl"]
+Order   = [:function]
+```
+
+## Print
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["node/print.jl"]
+Order   = [:function]
+```
+
+## Validate
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["node/validate.jl"]
+Order   = [:function]
+```

docs/src/lib/internals/operation.md

@@ -0,0 +1,57 @@
+# Operation
+
+## Types
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["operation/type.jl"]
+Order   = [:type]
+```
+
+## Find
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["operation/find.jl"]
+Order   = [:function]
+```
+
+## Apply
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["operation/apply.jl"]
+Order   = [:function]
+```
+
+## Get
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["operation/get.jl"]
+Order   = [:function]
+```
+
+## Clean
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["operation/clean.jl"]
+Order   = [:function]
+```
+
+## Utility
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["operation/utility.jl"]
+Order   = [:function]
+```
+
+## Print
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["operation/print.jl"]
+Order   = [:function]
+```
+
+## Validate
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["operation/validate.jl"]
+Order   = [:function]
+```

docs/src/lib/internals/properties.md

@@ -0,0 +1,22 @@
+# Properties
+
+## Type
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["properties/type.jl"]
+Order   = [:type]
+```
+
+## Create
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["properties/create.jl"]
+Order   = [:function]
+```
+
+## Utility
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["properties/utility.jl"]
+Order   = [:function]
+```

docs/src/lib/internals/scheduler.md

@@ -0,0 +1,15 @@
+# Scheduler
+
+## Interface
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["scheduler/interface.jl"]
+Order   = [:type, :function]
+```
+
+## Greedy
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["scheduler/greedy.jl"]
+Order   = [:type, :function]
+```

docs/src/lib/internals/task.md

@@ -0,0 +1,43 @@
+# Task
+
+## Type
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["task/type.jl"]
+Order   = [:type]
+```
+
+## Create
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["task/create.jl"]
+Order   = [:function]
+```
+
+## Compare
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["task/compare.jl"]
+Order   = [:function]
+```
+
+## Compute
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["task/compute.jl"]
+Order   = [:function]
+```
+
+## Properties
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["task/properties.jl"]
+Order   = [:function]
+```
+
+## Print
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages = ["task/print.jl"]
+Order   = [:function]
+```

docs/src/lib/internals/utility.md

@@ -0,0 +1,17 @@
+# Utility
+
+## Helper Functions
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages   = ["./utility.jl"]
+Order   = [:type, :function]
+```
+
+## Trie Helper
+This is a simple implementation of a [Trie Data Structure](https://en.wikipedia.org/wiki/Trie) to greatly improve the performance of the Node Reduction search.
+
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages   = ["trie.jl"]
+Order   = [:type, :function]
+```

docs/src/lib/public.md

@@ -0,0 +1,24 @@
+# Public Documentation
+
+Documentation for `MetagraphOptimization.jl`'s public interface.
+
+See the Internals section of the manual for documentation of everything else.
+
+```@autodocs
+Modules = [MetagraphOptimization]
+Pages   = ["MetagraphOptimization.jl"]
+Order   = [:module]
+```
+
+## Contents
+
+```@contents
+Pages = ["public.md"]
+Depth = 2
+```
+
+## Index
+
+```@index
+Pages = ["public.md"]
+```

docs/src/manual.md

@@ -0,0 +1,7 @@
+# Manual
+
+## Jupyter Notebooks
+
+In the `notebooks` directory are notebooks containing some examples of the usage of this repository.
+
+- `abc_model_showcase`: A simple showcase of the intended usage of the ABC Model implementation.

examples/Project.toml

@@ -1,7 +1,3 @@
 [deps]
 BenchmarkTools = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf"
 MetagraphOptimization = "3e869610-d48d-4942-ba70-c1b702a33ca4"
-PProf = "e4faabce-9ead-11e9-39d9-4379958e3056"
-Plots = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
-ProfileView = "c46f51b8-102a-5cf2-8d2c-8597cb0e0da7"
-Revise = "295af30f-e4ad-537b-8983-00126c2a3abe"

examples/import_bench.jl

@@ -13,16 +13,15 @@ function bench_txt(filepath::String, bench::Bool = true)
         return
     end
 
+    model = ABCModel()
+
     println(name, ":")
-    g = parse_abc(filepath)
+    g = parse_dag(filepath, model)
     print(g)
-    println(
-        "  Graph size in memory: ",
-        bytes_to_human_readable(MetagraphOptimization.mem(g)),
-    )
+    println("  Graph size in memory: ", bytes_to_human_readable(MetagraphOptimization.mem(g)))
 
     if (bench)
-        @btime parse_abc($filepath)
+        @btime parse_dag($filepath, $model)
     end
 
     println("  Get Operations: ")

examples/plot_chain.jl

@@ -12,7 +12,7 @@ function gen_plot(filepath)
         return
     end
 
-    g = parse_abc(filepath)
+    g = parse_dag(filepath, ABCModel())
 
     Random.seed!(1)
 
@@ -41,30 +41,17 @@ function gen_plot(filepath)
             i = i - 1
         end
 
-        props = graph_properties(g)
+        props = get_properties(g)
         push!(x, props.data)
-        push!(y, props.compute_effort)
+        push!(y, props.computeEffort)
     end
 
     println("\rDone.")
 
-    plot(
-        [x[1], x[2]],
-        [y[1], y[2]],
-        linestyle = :solid,
-        linewidth = 1,
-        color = :red,
-        legend = false,
-    )
+    plot([x[1], x[2]], [y[1], y[2]], linestyle = :solid, linewidth = 1, color = :red, legend = false)
     # Create lines connecting the reference point to each data point
     for i in 3:length(x)
-        plot!(
-            [x[i - 1], x[i]],
-            [y[i - 1], y[i]],
-            linestyle = :solid,
-            linewidth = 1,
-            color = :red,
-        )
+        plot!([x[i - 1], x[i]], [y[i - 1], y[i]], linestyle = :solid, linewidth = 1, color = :red)
     end
 
     return gui()

examples/plot_star.jl

@@ -12,7 +12,7 @@ function gen_plot(filepath)
         return
     end
 
-    g = parse_abc(filepath)
+    g = parse_dag(filepath, ABCModel())
 
     Random.seed!(1)
 
@@ -44,9 +44,9 @@ function gen_plot(filepath)
 
 
 
-    props = graph_properties(g)
+    props = get_properties(g)
     x0 = props.data
-    y0 = props.compute_effort
+    y0 = props.computeEffort
 
     x = Vector{Float64}()
     y = Vector{Float64}()
@@ -55,70 +55,36 @@ function gen_plot(filepath)
     opt = get_operations(g)
     for op in opt.nodeFusions
         push_operation!(g, op)
-        props = graph_properties(g)
+        props = get_properties(g)
         push!(x, props.data)
-        push!(y, props.compute_effort)
+        push!(y, props.computeEffort)
         pop_operation!(g)
 
-        push!(
-            names,
-            "NF: (" *
-            string(props.data) *
-            ", " *
-            string(props.compute_effort) *
-            ")",
-        )
+        push!(names, "NF: (" * string(props.data) * ", " * string(props.computeEffort) * ")")
     end
     for op in opt.nodeReductions
         push_operation!(g, op)
-        props = graph_properties(g)
+        props = get_properties(g)
         push!(x, props.data)
-        push!(y, props.compute_effort)
+        push!(y, props.computeEffort)
         pop_operation!(g)
 
-        push!(
-            names,
-            "NR: (" *
-            string(props.data) *
-            ", " *
-            string(props.compute_effort) *
-            ")",
-        )
+        push!(names, "NR: (" * string(props.data) * ", " * string(props.computeEffort) * ")")
     end
     for op in opt.nodeSplits
         push_operation!(g, op)
-        props = graph_properties(g)
+        props = get_properties(g)
         push!(x, props.data)
-        push!(y, props.compute_effort)
+        push!(y, props.computeEffort)
         pop_operation!(g)
 
-        push!(
-            names,
-            "NS: (" *
-            string(props.data) *
-            ", " *
-            string(props.compute_effort) *
-            ")",
-        )
+        push!(names, "NS: (" * string(props.data) * ", " * string(props.computeEffort) * ")")
     end
 
-    plot(
-        [x0, x[1]],
-        [y0, y[1]],
-        linestyle = :solid,
-        linewidth = 1,
-        color = :red,
-        legend = false,
-    )
+    plot([x0, x[1]], [y0, y[1]], linestyle = :solid, linewidth = 1, color = :red, legend = false)
     # Create lines connecting the reference point to each data point
     for i in 2:length(x)
-        plot!(
-            [x0, x[i]],
-            [y0, y[i]],
-            linestyle = :solid,
-            linewidth = 1,
-            color = :red,
-        )
+        plot!([x0, x[i]], [y0, y[i]], linestyle = :solid, linewidth = 1, color = :red)
     end
     #scatter!(x, y, label=names)
 

examples/profiling_utilities.jl

@@ -1,9 +1,9 @@
 
-function test_random_walk(g::DAG, n::Int64)
-    # the purpose here is to do "random" operations and reverse them again and validate that the graph stays the same and doesn't diverge
+function random_walk!(g::DAG, n::Int64)
+    # the purpose here is to do "random" operations on the graph to simulate an optimizer
     reset_graph!(g)
 
-    properties = graph_properties(g)
+    properties = get_properties(g)
 
     for i in 1:n
         # choose push or pop
@@ -32,5 +32,28 @@ function test_random_walk(g::DAG, n::Int64)
         end
     end
 
-    return reset_graph!(g)
+    return nothing
+end
+
+function reduce_all!(g::DAG)
+    reset_graph!(g)
+
+    opt = get_operations(g)
+    while (!isempty(opt.nodeReductions))
+        push_operation!(g, pop!(opt.nodeReductions))
+
+        if (isempty(opt.nodeReductions))
+            opt = get_operations(g)
+        end
+    end
+    return nothing
+end
+
+function reduce_one!(g::DAG)
+    opt = get_operations(g)
+    if !isempty(opt.nodeReductions)
+        push_operation!(g, pop!(opt.nodeReductions))
+    end
+    opt = get_operations(g)
+    return nothing
 end

notebooks/abc_model_large.ipynb

@@ -0,0 +1,678 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "using MetagraphOptimization"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Graph:\n",
+      "  Nodes: Total: 438436, ComputeTaskP: 10, ComputeTaskU: 10, \n",
+      "         ComputeTaskV: 109600, ComputeTaskSum: 1, ComputeTaskS2: 40320, \n",
+      "         ComputeTaskS1: 69272, DataTask: 219223\n",
+      "  Edges: 628665\n",
+      "  Total Compute Effort: 1.903443e6\n",
+      "  Total Data Transfer: 1.8040896e7\n",
+      "  Total Compute Intensity: 0.10550712115407128\n"
+     ]
+    }
+   ],
+   "source": [
+    "model = ABCModel()\n",
+    "process_str = \"AB->ABBBBBBB\"\n",
+    "process = parse_process(process_str, model)\n",
+    "graph = parse_dag(\"../input/$process_str.txt\", model)\n",
+    "print(graph)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "351.606942 seconds (1.13 G allocations: 25.949 GiB, 1.33% gc time, 0.72% compilation time)\n",
+      "Graph:\n",
+      "  Nodes: Total: 277188, ComputeTaskP: 10, ComputeTaskU: 10, \n",
+      "         ComputeTaskV: 69288, ComputeTaskSum: 1, ComputeTaskS2: 40320, \n",
+      "         ComputeTaskS1: 28960, DataTask: 138599\n",
+      "  Edges: 427105\n",
+      "  Total Compute Effort: 1.218139e6\n",
+      "  Total Data Transfer: 1.2235968e7\n",
+      "  Total Compute Intensity: 0.0995539543745129\n"
+     ]
+    }
+   ],
+   "source": [
+    "include(\"../examples/profiling_utilities.jl\")\n",
+    "@time reduce_all!(graph)\n",
+    "print(graph)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Found 1 NUMA nodes\n",
+      "CUDA is non-functional\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Get machine and set dictionary caching strategy\n",
+    "machine = get_machine_info()\n",
+    "MetagraphOptimization.set_cache_strategy(machine.devices[1], MetagraphOptimization.Dictionary())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2315.896312 seconds (87.18 M allocations: 132.726 GiB, 0.11% gc time, 0.04% compilation time)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "compute__8fd7c454_6214_11ee_3616_0f2435e477fe (generic function with 1 method)"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "@time compute_AB_AB7 = get_compute_function(graph, process, machine)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  1.910169 seconds (4.34 M allocations: 278.284 MiB, 6.25% gc time, 99.23% compilation time)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "1000-element Vector{ABCProcessInput}:\n",
+       " Input for ABC Process: 'AB->ABBBBBBB':\n",
+       "  2 Incoming particles:\n",
+       "    A: [8.411745173347825, 0.0, 0.0, 8.352092962924948]\n",
+       "    B: [8.411745173347825, 0.0, 0.0, -8.352092962924948]\n",
+       "  8 Outgoing Particles:\n",
+       "    A: [-2.003428483168789, 1.2386385417950023, -0.8321671195319228, 0.8871291535745444]\n",
+       "    B: [-2.444326994820653, 1.1775023368116424, -0.9536682034633904, 1.6366855721594777]\n",
+       "    B: [-4.289211829680359, -3.7216649121036443, 1.128125248220305, 1.50793959634144]\n",
+       "    B: [-1.2727607454602508, 0.07512513775641204, 0.6370236198332677, -0.45659285653208986]\n",
+       "    B: [-1.8777156401619268, -1.042329795325101, -0.5508846238377632, -1.0657817573524957]\n",
+       "    B: [-1.1322368113474306, 0.0498922458527246, -0.2963537951915457, -0.4377732162313449]\n",
+       "    B: [-1.4340705015357569, 0.7798902829682378, 0.144450581630926, -0.6538068364381232]\n",
+       "    B: [-2.369739340520482, 1.4429461622447262, 0.7234742923401235, -1.4177996555214083]\n",
+       "\n",
+       " Input for ABC Process: 'AB->ABBBBBBB':\n",
+       "  2 Incoming particles:\n",
+       "    A: [8.262146117199348, 0.0, 0.0, 8.201405883258813]\n",
+       "    B: [8.262146117199348, 0.0, 0.0, -8.201405883258813]\n",
+       "  8 Outgoing Particles:\n",
+       "    A: [-2.022253637967156, 0.040616190652067494, 1.5789161216660899, -0.7712872241073523]\n",
+       "    B: [-1.085155894223277, -0.4013306445746292, 0.044561160964560184, -0.12046298778597243]\n",
+       "    B: [-2.3099664718736963, -0.6028883246226666, 0.7721426580907682, 1.8374619682515352]\n",
+       "    B: [-3.8528592267292674, -1.1057919702708323, -3.154341441424319, -1.6345881470237529]\n",
+       "    B: [-1.445065980497648, -0.3803292238069696, -0.9038074225417192, 0.3559459403736899]\n",
+       "    B: [-1.637993216461692, 0.18276067729419151, -0.6165325663294264, 1.1267244146927589]\n",
+       "    B: [-3.0791604558286254, 1.8666082398498536, 2.1149851082876507, -0.7237684597886623]\n",
+       "    B: [-1.091837350817336, 0.4003550554789843, 0.16407638128639515, -0.0700255046122441]\n",
+       "\n",
+       " Input for ABC Process: 'AB->ABBBBBBB':\n",
+       "  2 Incoming particles:\n",
+       "    A: [9.522164300929319, 0.0, 0.0, 9.4695096480173]\n",
+       "    B: [9.522164300929319, 0.0, 0.0, -9.4695096480173]\n",
+       "  8 Outgoing Particles:\n",
+       "    A: [-2.2614545815907876, 0.09596466269330481, -1.680314037563078, -1.1320390202111377]\n",
+       "    B: [-2.5164555101345942, 2.0544568173259474, 0.7608284478099104, 0.7299969816600982]\n",
+       "    B: [-3.527555187469315, 3.1461533872404055, -0.4998113855480195, 1.1382236350884531]\n",
+       "    B: [-1.5843416170605953, -0.649775322646379, 0.6368565466386346, -0.8260412390634552]\n",
+       "    B: [-1.0715042390215452, 0.33101538188959895, -0.19275377509309963, -0.037364868271978664]\n",
+       "    B: [-1.8269658913133924, -1.2104472444295427, -0.7036857693244948, 0.6143681099517287]\n",
+       "    B: [-1.7510547915269752, 0.35168054121444203, 0.408535633181173, -1.3325210378384098]\n",
+       "    B: [-4.504996783741433, -4.119048223287777, 1.270344339898973, 0.8453774386847008]\n",
+       "\n",
+       " Input for ABC Process: 'AB->ABBBBBBB':\n",
+       "  2 Incoming particles:\n",
+       "    A: [7.225275339000687, 0.0, 0.0, 7.1557392157883655]\n",
+       "    B: [7.225275339000687, 0.0, 0.0, -7.1557392157883655]\n",
+       "  8 Outgoing Particles:\n",
+       "    A: [-1.5721586195862234, -0.6346644373772993, 0.7957285133297657, -0.6600756851617959]\n",
+       "    B: [-1.0093393293662618, -0.11321130994303012, 0.07324286826550051, -0.024177745030521003]\n",
+       "    B: [-2.7355755394886443, 0.2329840388558535, -2.4939308642531, -0.4576033371958622]\n",
+       "    B: [-1.618399027736879, -0.47727357006920945, 1.0132042772011558, -0.6040218911217943]\n",
+       "    B: [-1.7201610947708947, 0.01110230391313025, 0.8839000043421623, -1.0851505486038107]\n",
+       "    B: [-1.792300907703241, 0.8101193095744785, -0.625916307414256, 1.0790171565463333]\n",
+       "    B: [-1.5563810656498285, -1.1865287585293671, 0.12019738267353275, -0.004910793671790455]\n",
+       "    B: [-2.4462350936994026, 1.3574724235754438, 0.2335741258552372, 1.7569228442392408]\n",
+       "\n",
+       " Input for ABC Process: 'AB->ABBBBBBB':\n",
+       "  2 Incoming particles:\n",
+       "    A: [7.94532861335446, 0.0, 0.0, 7.882147345374172]\n",
+       "    B: [7.94532861335446, 0.0, 0.0, -7.882147345374172]\n",
+       "  8 Outgoing Particles:\n",
+       "    A: [-2.118671714766621, -0.6322452591326608, -1.2236882164873555, -1.2615953852509143]\n",
+       "    B: [-2.560753710001491, -1.7412395645571277, -1.5891033163317627, 0.01717533495153369]\n",
+       "    B: [-1.5550581087132076, -0.639122838128628, -0.9624327134008909, 0.2888788525193626]\n",
+       "    B: [-2.181477133464949, 0.4918918998013713, 1.8559068969600523, -0.2692479016749415]\n",
+       "    B: [-1.2628370388798702, -0.4013500667990802, 0.24813196852393224, 0.6100049482124643]\n",
+       "    B: [-1.901139724448186, 1.3625293914322611, -0.8176066997802711, 0.2989401174693193]\n",
+       "    B: [-2.2302691928842697, -0.1867565668705846, 1.9609184768063308, 0.3066290670808993]\n",
+       "    B: [-2.0804506035503256, 1.7462930042544484, 0.5278736037099664, 0.009214966692276028]\n",
+       "\n",
+       " Input for ABC Process: 'AB->ABBBBBBB':\n",
+       "  2 Incoming particles:\n",
+       "    A: [5.597768901835826, 0.0, 0.0, 5.507723366179557]\n",
+       "    B: [5.597768901835826, 0.0, 0.0, -5.507723366179557]\n",
+       "  8 Outgoing Particles:\n",
+       "    A: [-1.0009073340208385, 0.03522831505376105, -0.010844681575969111, -0.021374049609080487]\n",
+       "    B: [-1.3943823799403026, -0.886019044587247, 0.21582726795187737, -0.3356948979730148]\n",
+       "    B: [-1.0593061926863385, 0.3261714964515558, -0.10930051701751846, -0.06160488410736567]\n",
+       "    B: [-1.0190344437384602, 0.02512063114228613, 0.04379726771854621, -0.18942531709556668]\n",
+       "    B: [-1.0919277601624486, -0.39612686480944176, 0.07078221355247243, -0.17429750036714983]\n",
+       "    B: [-1.8292258091360047, 1.1565638126055895, 0.329244535677723, 0.9486966026643375]\n",
+       "    B: [-1.7379569022732355, 0.6562121276078657, 0.7749535141539342, -0.9946491284065995]\n",
+       "    B: [-2.0627969817140217, -0.9171504734643696, -1.3144596004610647, 0.8283491748944392]\n",
+       "\n",
+       " Input for ABC Process: 'AB->ABBBBBBB':\n",
+       "  2 Incoming particles:\n",
+       "    A: [6.860362769879496, 0.0, 0.0, 6.787089017712134]\n",
+       "    B: [6.860362769879496, 0.0, 0.0, -6.787089017712134]\n",
+       "  8 Outgoing Particles:\n",
+       "    A: [-2.1483538194490985, 1.8204047500578164, 0.1342978924269131, -0.532461036694855]\n",
+       "    B: [-1.2136825716769264, 0.12932805245115084, -0.43609629710270903, -0.5158678699965871]\n",
+       "    B: [-3.3642987422516573, -1.7653207470663739, 0.533955101409256, 2.630026736893018]\n",
+       "    B: [-1.053677321951765, 0.11000921943972916, 0.04739423847128557, -0.30965732123337875]\n",
+       "    B: [-1.2932387925896982, -0.6843810329952256, 0.045636429012288295, -0.4494513240410521]\n",
+       "    B: [-1.1237194151971648, -0.45140047643622017, 0.19994785657222267, -0.13785422959193222]\n",
+       "    B: [-1.7619597212239484, 1.3299261857304887, 0.561749934748497, 0.1422512233127988]\n",
+       "    B: [-1.7617951554187332, -0.488565951181366, -1.0868851555377534, -0.8269861786480115]\n",
+       "\n",
+       " Input for ABC Process: 'AB->ABBBBBBB':\n",
+       "  2 Incoming particles:\n",
+       "    A: [9.57507915889135, 0.0, 0.0, 9.522717096450755]\n",
+       "    B: [9.57507915889135, 0.0, 0.0, -9.522717096450755]\n",
+       "  8 Outgoing Particles:\n",
+       "    A: [-3.4305207411483516, 2.6682294806816835, -1.883054168339437, -0.3211401453721668]\n",
+       "    B: [-2.185574270107571, 1.4558232366821502, 1.2235951792097912, 0.40016050668089054]\n",
+       "    B: [-3.0259648593433583, -0.9184166853584697, -0.10930222461665634, -2.7020412923806107]\n",
+       "    B: [-3.246659025038245, -2.493839704051011, -1.0189869044243565, 1.5110340975546257]\n",
+       "    B: [-1.4247322676315595, 0.05954103854817788, 0.9940897925990366, -0.19519831815252583]\n",
+       "    B: [-1.4889906300188005, 0.5912092032645169, -0.19371449043911573, -0.9110650198822441]\n",
+       "    B: [-1.1268952499657272, 0.36236812621338876, -0.3636229828302436, 0.07975319340034331]\n",
+       "    B: [-3.220821274529085, -1.7249146959804351, 1.350995798840981, 2.1384969781516885]\n",
+       "\n",
+       " Input for ABC Process: 'AB->ABBBBBBB':\n",
+       "  2 Incoming particles:\n",
+       "    A: [8.472852690841874, 0.0, 0.0, 8.413633740584764]\n",
+       "    B: [8.472852690841874, 0.0, 0.0, -8.413633740584764]\n",
+       "  8 Outgoing Particles:\n",
+       "    A: [-1.1530011327357317, 0.34211475449117323, -0.45923141786607913, -0.03841369149190832]\n",
+       "    B: [-2.62915067223017, 1.042431210232047, 0.6288618003426715, -2.1048285595963105]\n",
+       "    B: [-1.1265473249385953, -0.4344882737979479, -0.1553035746380426, 0.2370856700921221]\n",
+       "    B: [-1.4826889242092416, -0.5889894099544346, -0.45026884678673923, -0.8054290077639529]\n",
+       "    B: [-4.118520088756618, -2.101194203160593, -3.0008966741533745, 1.5943054265577095]\n",
+       "    B: [-3.9992129109551517, 1.0607252636964415, 3.6847882851419875, 0.539352496783755]\n",
+       "    B: [-1.3172538577755006, 0.4084669000294691, -0.6351790575407871, 0.4060296568803221]\n",
+       "    B: [-1.1193304700827373, 0.2709337584638445, 0.3872294855003629, 0.17189800853826395]\n",
+       "\n",
+       " Input for ABC Process: 'AB->ABBBBBBB':\n",
+       "  2 Incoming particles:\n",
+       "    A: [5.913538688235051, 0.0, 0.0, 5.828373685450576]\n",
+       "    B: [5.913538688235051, 0.0, 0.0, -5.828373685450576]\n",
+       "  8 Outgoing Particles:\n",
+       "    A: [-1.6813734506828508, -1.1942921586618185, -0.384476919421686, 0.5028522833318558]\n",
+       "    B: [-1.412586238014363, 0.010275442474480664, 0.8780055986304257, -0.4737092609218783]\n",
+       "    B: [-1.5338446207986793, 1.1234162145644635, 0.1670274754582306, -0.25043392751132176]\n",
+       "    B: [-1.4260274101869397, 0.9023875675844153, -0.4646063309051003, -0.058239245843783906]\n",
+       "    B: [-1.1055189977833793, -0.3699146930280028, 0.2809292901965394, -0.08008812803177658]\n",
+       "    B: [-1.1926016738662872, 0.4242726765633766, 0.34415633034138016, -0.3519202590308968]\n",
+       "    B: [-1.4188061371181722, 0.47356120240959365, 0.33662773751584696, 0.8218469496393668]\n",
+       "    B: [-2.0563188480194308, -1.3697062519065082, -1.1576631818156364, -0.1103084116315648]\n",
+       "\n",
+       " Input for ABC Process: 'AB->ABBBBBBB':\n",
+       "  2 Incoming particles:\n",
+       "    A: [6.062750568659298, 0.0, 0.0, 5.979711068085032]\n",
+       "    B: [6.062750568659298, 0.0, 0.0, -5.979711068085032]\n",
+       "  8 Outgoing Particles:\n",
+       "    A: [-1.1157392140073992, -0.0424317149721654, 0.4662958482482185, -0.16013033799016252]\n",
+       "    B: [-2.395340693850968, -1.171776361305547, -1.746409249879336, 0.5609384374776449]\n",
+       "    B: [-1.0289722654275464, 0.23139962589771268, 0.07055331234631396, 0.01613586906426155]\n",
+       "    B: [-1.212565238145815, -0.6377842504248107, 0.04163119753237706, 0.24862129848767983]\n",
+       "    B: [-1.8156755638105053, -0.3987185167288875, 1.2510245302740972, 0.7567290942527487]\n",
+       "    B: [-2.003891077687212, 1.2159250459117166, 0.38048599808923245, -1.1799729400359336]\n",
+       "    B: [-1.4663599649673638, 0.593985649692284, -0.7733488095969958, -0.44645740391848543]\n",
+       "    B: [-1.086957119421786, 0.20940052192969777, 0.3097671729860923, 0.20413598266224653]\n",
+       "\n",
+       " Input for ABC Process: 'AB->ABBBBBBB':\n",
+       "  2 Incoming particles:\n",
+       "    A: [7.088363151833832, 0.0, 0.0, 7.017470496715726]\n",
+       "    B: [7.088363151833832, 0.0, 0.0, -7.017470496715726]\n",
+       "  8 Outgoing Particles:\n",
+       "    A: [-3.1474601133746627, 0.14412280671945385, 2.7364508363525357, 1.1821889028802701]\n",
+       "    B: [-1.256451004773104, 0.1153142495225348, -0.7455659837621855, -0.09748392231091944]\n",
+       "    B: [-1.4964417911663928, -0.0996845872039782, -0.8492275192498467, 0.7128910421459969]\n",
+       "    B: [-3.2499484244824526, -0.8927423628721523, -1.0242747556675866, -2.777775559729678]\n",
+       "    B: [-1.0489067674373789, -0.31603136975662793, 0.016268502528308637, -0.008057042333727152]\n",
+       "    B: [-1.6957667777105587, 1.0857339287179024, 0.6252297389508089, 0.5530773670555896]\n",
+       "    B: [-1.243679438145053, 0.06348629097723194, -0.7145975145476898, 0.17904867473682565]\n",
+       "    B: [-1.0380719865780628, -0.10019895610436466, -0.044283304604344965, 0.2561105375556422]\n",
+       "\n",
+       " Input for ABC Process: 'AB->ABBBBBBB':\n",
+       "  2 Incoming particles:\n",
+       "    A: [9.842517855137334, 0.0, 0.0, 9.791586068084028]\n",
+       "    B: [9.842517855137334, 0.0, 0.0, -9.791586068084028]\n",
+       "  8 Outgoing Particles:\n",
+       "    A: [-1.0081083393933719, 0.09315850477843095, -0.05390640772287413, 0.06854207575149836]\n",
+       "    B: [-1.2533776879399583, -0.09567218890986252, -0.022562148977002077, -0.749195175056841]\n",
+       "    B: [-4.199102452438099, 3.1204551726062775, 2.23725963921713, 1.3747327844190023]\n",
+       "    B: [-5.1018332572388285, -4.999892707918183, 0.09407944148737099, -0.14465321518774693]\n",
+       "    B: [-3.7582268429742243, 2.1814891293707577, -1.5410280493623207, -2.4475715991095703]\n",
+       "    B: [-1.1792132348986593, 0.6125282131702711, -0.12369433042852651, -0.007263198361168502]\n",
+       "    B: [-1.3600169327450258, -0.07835376476887727, -0.6694537001487819, 0.6287594836317273]\n",
+       "    B: [-1.8251569626465018, -0.8337123583288142, 0.07930555593500455, 1.2766488439130985]\n",
+       "\n",
+       " ⋮\n",
+       " Input for ABC Process: 'AB->ABBBBBBB':\n",
+       "  2 Incoming particles:\n",
+       "    A: [9.861596443743153, 0.0, 0.0, 9.810763702141012]\n",
+       "    B: [9.861596443743153, 0.0, 0.0, -9.810763702141012]\n",
+       "  8 Outgoing Particles:\n",
+       "    A: [-1.8179384769334697, 0.9572508915748105, -0.9794338269553214, 0.6551949443563104]\n",
+       "    B: [-2.1028582035167607, -0.7676665378472812, 0.6218562087985972, -1.5639678917247444]\n",
+       "    B: [-3.1263866679666865, 2.3808322573838474, -1.6099851834448586, 0.7168535896041835]\n",
+       "    B: [-5.177179415841987, -1.3605325795287053, 4.805481256903438, -0.9270855911989424]\n",
+       "    B: [-1.2605754590213083, -0.023284320526100116, -0.14250915308265208, 0.7537900699744495]\n",
+       "    B: [-2.712925004518324, -1.4343063146086636, -1.452340398698398, 1.4810249296764189]\n",
+       "    B: [-2.3798188172675734, 0.6412170781802653, -1.487389994435021, -1.4283029321979925]\n",
+       "    B: [-1.1455108424201939, -0.39351047462817185, 0.24432109091421514, 0.3124928815103169]\n",
+       "\n",
+       " Input for ABC Process: 'AB->ABBBBBBB':\n",
+       "  2 Incoming particles:\n",
+       "    A: [5.611571819338176, 0.0, 0.0, 5.521751378284825]\n",
+       "    B: [5.611571819338176, 0.0, 0.0, -5.521751378284825]\n",
+       "  8 Outgoing Particles:\n",
+       "    A: [-1.0759150984150232, -0.3903007964405737, 0.045679777762273936, -0.05632002484775736]\n",
+       "    B: [-1.021003529021616, -0.07269336486556076, 0.11388411952175649, 0.15554513267817288]\n",
+       "    B: [-1.6939705353811365, -0.1440535362616654, -0.25084793375093056, -1.3363607550219565]\n",
+       "    B: [-1.185801144621379, -0.31618880274591826, 0.5459120200606805, -0.09016131075324207]\n",
+       "    B: [-1.197431131926246, 0.16472462054297168, -0.17198607315407527, -0.6141074056988615]\n",
+       "    B: [-1.0089442324730478, -0.12314856400749492, -0.027052115631495212, -0.04550910308256443]\n",
+       "    B: [-2.703474424566498, 0.16902217864171518, -0.14049660772763695, 2.502092358533033]\n",
+       "    B: [-1.3366035422714058, 0.7126382651365266, -0.11509318708057305, -0.5151788918068239]\n",
+       "\n",
+       " Input for ABC Process: 'AB->ABBBBBBB':\n",
+       "  2 Incoming particles:\n",
+       "    A: [8.775111706253933, 0.0, 0.0, 8.717946171962454]\n",
+       "    B: [8.775111706253933, 0.0, 0.0, -8.717946171962454]\n",
+       "  8 Outgoing Particles:\n",
+       "    A: [-2.2750151423103953, 1.8467170131598, 0.8729070809034145, 0.05799482008261441]\n",
+       "    B: [-1.5756212156561644, 1.0377655822554295, 0.3001332912880399, 0.5617337616455574]\n",
+       "    B: [-1.6945981163898138, -0.5153714693329569, 0.050834292767083435, 1.2662823142365867]\n",
+       "    B: [-2.630307241578496, -0.5126707368632603, 1.3344949978186418, -1.9684532002212756]\n",
+       "    B: [-3.0848917600353407, -2.827901193400985, -0.46541663267058264, -0.5503811129833626]\n",
+       "    B: [-2.812675339815945, 2.346626876124383, -1.1757879806725677, 0.14834923648401968]\n",
+       "    B: [-1.695817659938434, -0.3817827622891304, -0.19598317768122073, 1.3006267920675472]\n",
+       "    B: [-1.7812969367832734, -0.9933833096532803, -0.7211818717528079, -0.8161526113116866]\n",
+       "\n",
+       " Input for ABC Process: 'AB->ABBBBBBB':\n",
+       "  2 Incoming particles:\n",
+       "    A: [6.832501783927461, 0.0, 0.0, 6.758925996589395]\n",
+       "    B: [6.832501783927461, 0.0, 0.0, -6.758925996589395]\n",
+       "  8 Outgoing Particles:\n",
+       "    A: [-1.0114752465345387, -0.11558780230223581, -0.03776248532804595, -0.09108034372406744]\n",
+       "    B: [-1.031154612454516, -0.04425244057817861, -0.0789748074180023, -0.23470095032271823]\n",
+       "    B: [-2.2555952063288855, 1.7491237654517413, -0.4233804231771479, -0.9214254203222908]\n",
+       "    B: [-2.089561973736715, 0.9235335217807571, 1.3477207222453012, -0.8348676128969853]\n",
+       "    B: [-1.3199981586264844, -0.6902187266500668, -0.06216816149242132, -0.5119847340063199]\n",
+       "    B: [-1.0105028642371863, -0.09317036739551621, -0.041275823376393385, -0.1035935696630954]\n",
+       "    B: [-1.2426376312622325, -0.48126859609618416, 0.05225488689293943, -0.5565952280036419]\n",
+       "    B: [-3.704077874674367, -1.2481593542103167, -0.7564139083462295, 3.254247858939119]\n",
+       "\n",
+       " Input for ABC Process: 'AB->ABBBBBBB':\n",
+       "  2 Incoming particles:\n",
+       "    A: [8.775903429741401, 0.0, 0.0, 8.718743086485969]\n",
+       "    B: [8.775903429741401, 0.0, 0.0, -8.718743086485969]\n",
+       "  8 Outgoing Particles:\n",
+       "    A: [-1.7137666526922533, 1.1358800766324049, 0.08268488211087159, 0.7999598750311686]\n",
+       "    B: [-1.1669696745288112, -0.04351472671445914, 0.5992401461010018, 0.028912577361687116]\n",
+       "    B: [-3.5481649603318184, 0.4490928742123019, 1.0371640968528058, -3.21124287656006]\n",
+       "    B: [-1.276578701414564, -0.08287623449031867, -0.6317118623642547, -0.47299559576203803]\n",
+       "    B: [-4.955351547203613, -2.6459981607514886, 0.5026315754882429, 4.037519558961317]\n",
+       "    B: [-2.3130557250521284, 1.4242375193555785, -1.5228161303749386, 0.05296516521446809]\n",
+       "    B: [-1.4353464814836179, 0.25997106791735547, -0.029309860840599063, -0.9958792586507745]\n",
+       "    B: [-1.1425731167759967, -0.4967924161613736, -0.03788284697312998, -0.23923944559576807]\n",
+       "\n",
+       " Input for ABC Process: 'AB->ABBBBBBB':\n",
+       "  2 Incoming particles:\n",
+       "    A: [8.907102929629284, 0.0, 0.0, 8.850789942090511]\n",
+       "    B: [8.907102929629284, 0.0, 0.0, -8.850789942090511]\n",
+       "  8 Outgoing Particles:\n",
+       "    A: [-2.946046511363992, -0.9439001466724447, 2.1873638734369836, 1.4155146927582347]\n",
+       "    B: [-3.7848309582649415, -2.22832689875391, -0.18756115269295068, -2.885190709282662]\n",
+       "    B: [-1.0159875652570234, 0.04172671107403079, -0.15271016054388648, 0.08467125371989566]\n",
+       "    B: [-2.0867601165869685, -1.8155383548303043, -0.021995043965926685, -0.24063350631004576]\n",
+       "    B: [-4.34790862339958, 3.6266859724946396, -1.8990793068549607, 1.0700261868843775]\n",
+       "    B: [-1.1578951917200673, 0.35622580432348594, 0.23734793715600985, 0.3968506117802061]\n",
+       "    B: [-1.4421363377447174, 1.0156020669389267, -0.20020339434090184, -0.0907097523285523]\n",
+       "    B: [-1.0326405549212787, -0.052475154574424254, 0.03683724780563263, 0.24947122277854633]\n",
+       "\n",
+       " Input for ABC Process: 'AB->ABBBBBBB':\n",
+       "  2 Incoming particles:\n",
+       "    A: [6.294285658794556, 0.0, 0.0, 6.214340830249562]\n",
+       "    B: [6.294285658794556, 0.0, 0.0, -6.214340830249562]\n",
+       "  8 Outgoing Particles:\n",
+       "    A: [-1.06844272609547, -0.2848922847204133, 0.15179083391454987, -0.19330232226393051]\n",
+       "    B: [-2.114647837734541, -1.6956804594706658, -0.38950327120442063, 0.6668511518515798]\n",
+       "    B: [-1.494217345848325, 0.7529614584695401, -0.5432224448027106, -0.6088053006963738]\n",
+       "    B: [-1.3783311635115514, 0.9215501628423943, 0.0395584401371469, -0.2213079833313275]\n",
+       "    B: [-1.7816982863175768, 0.5393674002906785, 0.38766524831377364, 1.316528482874748]\n",
+       "    B: [-1.659172767477475, 0.17135237894801714, -1.2297516401309854, -0.45956886117628726]\n",
+       "    B: [-1.55277617510909, -0.23319042207457166, 1.041131562383322, 0.522284545863997]\n",
+       "    B: [-1.5392850154950812, -0.17146823428497893, 0.5423312713893238, -1.022679713122405]\n",
+       "\n",
+       " Input for ABC Process: 'AB->ABBBBBBB':\n",
+       "  2 Incoming particles:\n",
+       "    A: [6.965556009635571, 0.0, 0.0, 6.8934005050751415]\n",
+       "    B: [6.965556009635571, 0.0, 0.0, -6.8934005050751415]\n",
+       "  8 Outgoing Particles:\n",
+       "    A: [-1.0775179795487104, -0.05690318568456522, -0.2919638065794134, 0.269377354945329]\n",
+       "    B: [-3.216279237662679, -2.600571207682032, 0.23217633942174215, 1.5898351096286563]\n",
+       "    B: [-1.9852997763312183, 1.2696870590322706, -0.6412445999499571, -0.9581833525279955]\n",
+       "    B: [-1.9885313318262752, 0.8019078287339996, 1.2060162608136897, 0.9255946577864792]\n",
+       "    B: [-1.4288503016026572, 0.2805632486843285, 0.07929023042776773, -0.9780646743628009]\n",
+       "    B: [-1.3652585458391595, -0.12810083240879516, 0.7809145290728301, -0.4875382774777694]\n",
+       "    B: [-1.8158888731893035, 0.7439741257624499, -1.2924797037897653, -0.2710186621991885]\n",
+       "    B: [-1.0534859732711408, -0.3105570364376559, -0.07270924941689365, -0.0900021557927108]\n",
+       "\n",
+       " Input for ABC Process: 'AB->ABBBBBBB':\n",
+       "  2 Incoming particles:\n",
+       "    A: [6.43062328219917, 0.0, 0.0, 6.352394493225528]\n",
+       "    B: [6.43062328219917, 0.0, 0.0, -6.352394493225528]\n",
+       "  8 Outgoing Particles:\n",
+       "    A: [-2.125364788369443, -1.214725294501684, 0.4075454777366224, 1.369497946736289]\n",
+       "    B: [-1.1032249572940587, -0.2977536437640783, 0.35819035202044425, 0.012155070594697458]\n",
+       "    B: [-2.225917349319406, 1.3039585629995813, -0.8668848261688078, 1.2259326287114942]\n",
+       "    B: [-2.717025897056506, -0.9721840017189309, 0.6274004665152297, -2.2457641565164295]\n",
+       "    B: [-1.000557419196324, 0.013685057618434337, 0.015873673340379625, 0.025997976872664537]\n",
+       "    B: [-1.1652637249339481, 0.20750251779397902, -0.05219673300317853, -0.5586212982154317]\n",
+       "    B: [-1.4667402310584912, 0.9160649085291783, -0.533306342231441, -0.16654228923208916]\n",
+       "    B: [-1.057152197170161, 0.043451893043520345, 0.0433779317907512, 0.3373441210488047]\n",
+       "\n",
+       " Input for ABC Process: 'AB->ABBBBBBB':\n",
+       "  2 Incoming particles:\n",
+       "    A: [8.156196486154876, 0.0, 0.0, 8.094661272762755]\n",
+       "    B: [8.156196486154876, 0.0, 0.0, -8.094661272762755]\n",
+       "  8 Outgoing Particles:\n",
+       "    A: [-1.4617318374080812, 0.10404421660552193, -0.19476289320497314, -1.0430254938944576]\n",
+       "    B: [-2.745518719911882, 2.0283487429720055, -0.01415841484271091, -1.556751090431481]\n",
+       "    B: [-1.193795120882441, -0.223211890483827, 0.20666745479885903, 0.5767250694363129]\n",
+       "    B: [-1.0771186742980503, 0.29121400254582763, -0.18584437613704033, 0.20209134345899718]\n",
+       "    B: [-2.9756813564276348, 0.7747616688600099, 0.31071107817153876, 2.6754219325851647]\n",
+       "    B: [-1.8605025819101852, -0.3441559100391822, 0.5570133470539003, 1.4257498722017754]\n",
+       "    B: [-3.3546424693401353, -1.4228183303706836, -0.7768040014609222, -2.7614832317390525]\n",
+       "    B: [-1.6434022121313414, -1.2081825000896715, 0.0971778056213486, 0.48127159838273986]\n",
+       "\n",
+       " Input for ABC Process: 'AB->ABBBBBBB':\n",
+       "  2 Incoming particles:\n",
+       "    A: [9.631814348202784, 0.0, 0.0, 9.579762399884718]\n",
+       "    B: [9.631814348202784, 0.0, 0.0, -9.579762399884718]\n",
+       "  8 Outgoing Particles:\n",
+       "    A: [-2.4271747113709625, -0.9216752449526319, 0.35006248470601437, 1.9796838331313595]\n",
+       "    B: [-1.926574191117535, -0.6155920425308834, -0.36855158619622796, 1.4821957628346814]\n",
+       "    B: [-2.809711053334662, 0.053095841327541846, -2.415282611989454, -1.0286238083410733]\n",
+       "    B: [-2.069340346061984, 0.0706218659128716, 1.6880494984307581, 0.6539655271821153]\n",
+       "    B: [-1.600891859223819, 0.522182956459051, 1.0136801062226364, -0.5124766796267364]\n",
+       "    B: [-2.3653602811566903, 0.7359929823506941, 2.003935313635875, 0.19361520696286152]\n",
+       "    B: [-4.134587420071929, 0.11270979705086029, -1.0448676862999513, -3.871738776569513]\n",
+       "    B: [-1.9299888340679847, 0.04266384438249662, -1.2270255185096508, 1.1033789344263045]\n",
+       "\n",
+       " Input for ABC Process: 'AB->ABBBBBBB':\n",
+       "  2 Incoming particles:\n",
+       "    A: [7.383091586636561, 0.0, 0.0, 7.31505580133628]\n",
+       "    B: [7.383091586636561, 0.0, 0.0, -7.31505580133628]\n",
+       "  8 Outgoing Particles:\n",
+       "    A: [-1.0026822379766207, 0.02425303574920085, -0.0683120173174935, 0.010813366763733786]\n",
+       "    B: [-3.2851307251831745, -2.830568076855887, -0.9156122597784988, 0.9703723169846757]\n",
+       "    B: [-2.028220232462834, 1.6810294384373135, 0.4923274291375999, -0.21314558638988076]\n",
+       "    B: [-1.5191535227395792, -0.17123543395193966, -1.1293131485074372, -0.05619309939470401]\n",
+       "    B: [-1.1059696544762567, 0.2375361941082015, -0.40208228112542477, -0.07124094550113935]\n",
+       "    B: [-1.371740281577803, -0.2278482692103191, -0.6986437390927988, -0.5845113276468179]\n",
+       "    B: [-1.2867512190171768, 0.6015837296464805, -0.16735271525316733, -0.5155761675681034]\n",
+       "    B: [-3.166535299839676, 0.6852493820769491, 2.888988731937221, 0.4594814427522358]\n"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "@time inputs = [gen_process_input(process) for _ in 1:1000]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Internal error: stack overflow in type inference of materialize(Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(MetagraphOptimization.compute__8fd7c454_6214_11ee_3616_0f2435e477fe), Tuple{Array{MetagraphOptimization.ABCProcessInput, 1}}}).\n",
+      "This might be caused by recursion over very long tuples or argument lists.\n"
+     ]
+    },
+    {
+     "ename": "LoadError",
+     "evalue": "StackOverflowError:",
+     "output_type": "error",
+     "traceback": [
+      "StackOverflowError:",
+      "",
+      "Stacktrace:",
+      "    [1] get",
+      "      @ ./iddict.jl:102 [inlined]",
+      "    [2] in",
+      "      @ ./iddict.jl:189 [inlined]",
+      "    [3] haskey",
+      "      @ ./abstractdict.jl:17 [inlined]",
+      "    [4] findall(sig::Type, table::Core.Compiler.CachedMethodTable{Core.Compiler.InternalMethodTable}; limit::Int64)",
+      "      @ Core.Compiler ./compiler/methodtable.jl:120",
+      "    [5] findall",
+      "      @ ./compiler/methodtable.jl:114 [inlined]",
+      "    [6] find_matching_methods(argtypes::Vector{Any}, atype::Any, method_table::Core.Compiler.CachedMethodTable{Core.Compiler.InternalMethodTable}, union_split::Int64, max_methods::Int64)",
+      "      @ Core.Compiler ./compiler/abstractinterpretation.jl:336",
+      "    [7] abstract_call_gf_by_type(interp::Core.Compiler.NativeInterpreter, f::Any, arginfo::Core.Compiler.ArgInfo, si::Core.Compiler.StmtInfo, atype::Any, sv::Core.Compiler.InferenceState, max_methods::Int64)",
+      "      @ Core.Compiler ./compiler/abstractinterpretation.jl:80",
+      "    [8] abstract_call_known(interp::Core.Compiler.NativeInterpreter, f::Any, arginfo::Core.Compiler.ArgInfo, si::Core.Compiler.StmtInfo, sv::Core.Compiler.InferenceState, max_methods::Int64)",
+      "      @ Core.Compiler ./compiler/abstractinterpretation.jl:1949",
+      "    [9] abstract_call(interp::Core.Compiler.NativeInterpreter, arginfo::Core.Compiler.ArgInfo, si::Core.Compiler.StmtInfo, sv::Core.Compiler.InferenceState, max_methods::Int64)",
+      "      @ Core.Compiler ./compiler/abstractinterpretation.jl:2020",
+      "   [10] abstract_apply(interp::Core.Compiler.NativeInterpreter, argtypes::Vector{Any}, si::Core.Compiler.StmtInfo, sv::Core.Compiler.InferenceState, max_methods::Int64)",
+      "      @ Core.Compiler ./compiler/abstractinterpretation.jl:1566",
+      "   [11] abstract_call_known(interp::Core.Compiler.NativeInterpreter, f::Any, arginfo::Core.Compiler.ArgInfo, si::Core.Compiler.StmtInfo, sv::Core.Compiler.InferenceState, max_methods::Int64)",
+      "      @ Core.Compiler ./compiler/abstractinterpretation.jl:1855",
+      "   [12] abstract_call(interp::Core.Compiler.NativeInterpreter, arginfo::Core.Compiler.ArgInfo, si::Core.Compiler.StmtInfo, sv::Core.Compiler.InferenceState, max_methods::Nothing)",
+      "      @ Core.Compiler ./compiler/abstractinterpretation.jl:2020",
+      "   [13] abstract_call(interp::Core.Compiler.NativeInterpreter, arginfo::Core.Compiler.ArgInfo, si::Core.Compiler.StmtInfo, sv::Core.Compiler.InferenceState)",
+      "      @ Core.Compiler ./compiler/abstractinterpretation.jl:1999",
+      "   [14] abstract_eval_statement_expr(interp::Core.Compiler.NativeInterpreter, e::Expr, vtypes::Vector{Core.Compiler.VarState}, sv::Core.Compiler.InferenceState, mi::Nothing)",
+      "      @ Core.Compiler ./compiler/abstractinterpretation.jl:2183",
+      "   [15] abstract_eval_statement(interp::Core.Compiler.NativeInterpreter, e::Any, vtypes::Vector{Core.Compiler.VarState}, sv::Core.Compiler.InferenceState)",
+      "      @ Core.Compiler ./compiler/abstractinterpretation.jl:2396",
+      "   [16] abstract_eval_basic_statement(interp::Core.Compiler.NativeInterpreter, stmt::Any, pc_vartable::Vector{Core.Compiler.VarState}, frame::Core.Compiler.InferenceState)",
+      "      @ Core.Compiler ./compiler/abstractinterpretation.jl:2682",
+      "   [17] typeinf_local(interp::Core.Compiler.NativeInterpreter, frame::Core.Compiler.InferenceState)",
+      "      @ Core.Compiler ./compiler/abstractinterpretation.jl:2867",
+      "   [18] typeinf_nocycle(interp::Core.Compiler.NativeInterpreter, frame::Core.Compiler.InferenceState)",
+      "      @ Core.Compiler ./compiler/abstractinterpretation.jl:2955",
+      "   [19] _typeinf(interp::Core.Compiler.NativeInterpreter, frame::Core.Compiler.InferenceState)",
+      "      @ Core.Compiler ./compiler/typeinfer.jl:246",
+      "   [20] typeinf(interp::Core.Compiler.NativeInterpreter, frame::Core.Compiler.InferenceState)",
+      "      @ Core.Compiler ./compiler/typeinfer.jl:216",
+      "   [21] typeinf_edge(interp::Core.Compiler.NativeInterpreter, method::Method, atype::Any, sparams::Core.SimpleVector, caller::Core.Compiler.InferenceState)",
+      "      @ Core.Compiler ./compiler/typeinfer.jl:932",
+      "   [22] abstract_call_method(interp::Core.Compiler.NativeInterpreter, method::Method, sig::Any, sparams::Core.SimpleVector, hardlimit::Bool, si::Core.Compiler.StmtInfo, sv::Core.Compiler.InferenceState)",
+      "      @ Core.Compiler ./compiler/abstractinterpretation.jl:611",
+      "   [23] abstract_call_gf_by_type(interp::Core.Compiler.NativeInterpreter, f::Any, arginfo::Core.Compiler.ArgInfo, si::Core.Compiler.StmtInfo, atype::Any, sv::Core.Compiler.InferenceState, max_methods::Int64)",
+      "      @ Core.Compiler ./compiler/abstractinterpretation.jl:152",
+      "--- the last 16 lines are repeated 413 more times ---",
+      " [6632] abstract_call_known(interp::Core.Compiler.NativeInterpreter, f::Any, arginfo::Core.Compiler.ArgInfo, si::Core.Compiler.StmtInfo, sv::Core.Compiler.InferenceState, max_methods::Int64)",
+      "      @ Core.Compiler ./compiler/abstractinterpretation.jl:1949",
+      " [6633] abstract_call(interp::Core.Compiler.NativeInterpreter, arginfo::Core.Compiler.ArgInfo, si::Core.Compiler.StmtInfo, sv::Core.Compiler.InferenceState, max_methods::Int64)",
+      "      @ Core.Compiler ./compiler/abstractinterpretation.jl:2020",
+      " [6634] abstract_apply(interp::Core.Compiler.NativeInterpreter, argtypes::Vector{Any}, si::Core.Compiler.StmtInfo, sv::Core.Compiler.InferenceState, max_methods::Int64)",
+      "      @ Core.Compiler ./compiler/abstractinterpretation.jl:1566",
+      " [6635] abstract_call_known(interp::Core.Compiler.NativeInterpreter, f::Any, arginfo::Core.Compiler.ArgInfo, si::Core.Compiler.StmtInfo, sv::Core.Compiler.InferenceState, max_methods::Int64)",
+      "      @ Core.Compiler ./compiler/abstractinterpretation.jl:1855",
+      " [6636] abstract_call(interp::Core.Compiler.NativeInterpreter, arginfo::Core.Compiler.ArgInfo, si::Core.Compiler.StmtInfo, sv::Core.Compiler.InferenceState, max_methods::Nothing)",
+      "      @ Core.Compiler ./compiler/abstractinterpretation.jl:2020",
+      " [6637] abstract_call(interp::Core.Compiler.NativeInterpreter, arginfo::Core.Compiler.ArgInfo, si::Core.Compiler.StmtInfo, sv::Core.Compiler.InferenceState)",
+      "      @ Core.Compiler ./compiler/abstractinterpretation.jl:1999",
+      " [6638] abstract_eval_statement_expr(interp::Core.Compiler.NativeInterpreter, e::Expr, vtypes::Vector{Core.Compiler.VarState}, sv::Core.Compiler.InferenceState, mi::Nothing)",
+      "      @ Core.Compiler ./compiler/abstractinterpretation.jl:2183",
+      " [6639] abstract_eval_statement(interp::Core.Compiler.NativeInterpreter, e::Any, vtypes::Vector{Core.Compiler.VarState}, sv::Core.Compiler.InferenceState)",
+      "      @ Core.Compiler ./compiler/abstractinterpretation.jl:2396",
+      " [6640] abstract_eval_basic_statement(interp::Core.Compiler.NativeInterpreter, stmt::Any, pc_vartable::Vector{Core.Compiler.VarState}, frame::Core.Compiler.InferenceState)",
+      "      @ Core.Compiler ./compiler/abstractinterpretation.jl:2658",
+      " [6641] typeinf_local(interp::Core.Compiler.NativeInterpreter, frame::Core.Compiler.InferenceState)",
+      "      @ Core.Compiler ./compiler/abstractinterpretation.jl:2867",
+      " [6642] typeinf_nocycle(interp::Core.Compiler.NativeInterpreter, frame::Core.Compiler.InferenceState)",
+      "      @ Core.Compiler ./compiler/abstractinterpretation.jl:2955",
+      " [6643] _typeinf(interp::Core.Compiler.NativeInterpreter, frame::Core.Compiler.InferenceState)",
+      "      @ Core.Compiler ./compiler/typeinfer.jl:246",
+      " [6644] typeinf(interp::Core.Compiler.NativeInterpreter, frame::Core.Compiler.InferenceState)",
+      "      @ Core.Compiler ./compiler/typeinfer.jl:216",
+      " [6645] typeinf_edge(interp::Core.Compiler.NativeInterpreter, method::Method, atype::Any, sparams::Core.SimpleVector, caller::Core.Compiler.InferenceState)",
+      "      @ Core.Compiler ./compiler/typeinfer.jl:932",
+      " [6646] abstract_call_method(interp::Core.Compiler.NativeInterpreter, method::Method, sig::Any, sparams::Core.SimpleVector, hardlimit::Bool, si::Core.Compiler.StmtInfo, sv::Core.Compiler.InferenceState)",
+      "      @ Core.Compiler ./compiler/abstractinterpretation.jl:611",
+      " [6647] abstract_call_gf_by_type(interp::Core.Compiler.NativeInterpreter, f::Any, arginfo::Core.Compiler.ArgInfo, si::Core.Compiler.StmtInfo, atype::Any, sv::Core.Compiler.InferenceState, max_methods::Int64)",
+      "      @ Core.Compiler ./compiler/abstractinterpretation.jl:152",
+      " [6648] abstract_call_known(interp::Core.Compiler.NativeInterpreter, f::Any, arginfo::Core.Compiler.ArgInfo, si::Core.Compiler.StmtInfo, sv::Core.Compiler.InferenceState, max_methods::Int64)",
+      "      @ Core.Compiler ./compiler/abstractinterpretation.jl:1949",
+      " [6649] abstract_call(interp::Core.Compiler.NativeInterpreter, arginfo::Core.Compiler.ArgInfo, si::Core.Compiler.StmtInfo, sv::Core.Compiler.InferenceState, max_methods::Nothing)",
+      "      @ Core.Compiler ./compiler/abstractinterpretation.jl:2020",
+      " [6650] abstract_call(interp::Core.Compiler.NativeInterpreter, arginfo::Core.Compiler.ArgInfo, si::Core.Compiler.StmtInfo, sv::Core.Compiler.InferenceState)",
+      "      @ Core.Compiler ./compiler/abstractinterpretation.jl:1999",
+      " [6651] abstract_eval_statement_expr(interp::Core.Compiler.NativeInterpreter, e::Expr, vtypes::Vector{Core.Compiler.VarState}, sv::Core.Compiler.InferenceState, mi::Nothing)",
+      "      @ Core.Compiler ./compiler/abstractinterpretation.jl:2183",
+      " [6652] abstract_eval_statement(interp::Core.Compiler.NativeInterpreter, e::Any, vtypes::Vector{Core.Compiler.VarState}, sv::Core.Compiler.InferenceState)",
+      "      @ Core.Compiler ./compiler/abstractinterpretation.jl:2396",
+      " [6653] abstract_eval_basic_statement(interp::Core.Compiler.NativeInterpreter, stmt::Any, pc_vartable::Vector{Core.Compiler.VarState}, frame::Core.Compiler.InferenceState)",
+      "      @ Core.Compiler ./compiler/abstractinterpretation.jl:2682",
+      " [6654] typeinf_local(interp::Core.Compiler.NativeInterpreter, frame::Core.Compiler.InferenceState)",
+      "      @ Core.Compiler ./compiler/abstractinterpretation.jl:2867",
+      " [6655] typeinf_nocycle(interp::Core.Compiler.NativeInterpreter, frame::Core.Compiler.InferenceState)",
+      "      @ Core.Compiler ./compiler/abstractinterpretation.jl:2955",
+      " [6656] _typeinf(interp::Core.Compiler.NativeInterpreter, frame::Core.Compiler.InferenceState)",
+      "      @ Core.Compiler ./compiler/typeinfer.jl:246",
+      " [6657] typeinf(interp::Core.Compiler.NativeInterpreter, frame::Core.Compiler.InferenceState)",
+      "      @ Core.Compiler ./compiler/typeinfer.jl:216",
+      " [6658] typeinf",
+      "      @ ./compiler/typeinfer.jl:12 [inlined]",
+      " [6659] typeinf_type(interp::Core.Compiler.NativeInterpreter, method::Method, atype::Any, sparams::Core.SimpleVector)",
+      "      @ Core.Compiler ./compiler/typeinfer.jl:1079",
+      " [6660] return_type(interp::Core.Compiler.NativeInterpreter, t::DataType)",
+      "      @ Core.Compiler ./compiler/typeinfer.jl:1140",
+      " [6661] return_type(f::Any, t::DataType)",
+      "      @ Core.Compiler ./compiler/typeinfer.jl:1112",
+      " [6662] combine_eltypes(f::Function, args::Tuple{Vector{ABCProcessInput}})",
+      "      @ Base.Broadcast ./broadcast.jl:730",
+      " [6663] copy(bc::Base.Broadcast.Broadcasted{Style}) where Style",
+      "      @ Base.Broadcast ./broadcast.jl:895",
+      " [6664] materialize(bc::Base.Broadcast.Broadcasted)",
+      "      @ Base.Broadcast ./broadcast.jl:873",
+      " [6665] var\"##core#293\"()",
+      "      @ Main ~/.julia/packages/BenchmarkTools/0owsb/src/execution.jl:489",
+      " [6666] var\"##sample#294\"(::Tuple{}, __params::BenchmarkTools.Parameters)",
+      "      @ Main ~/.julia/packages/BenchmarkTools/0owsb/src/execution.jl:495",
+      " [6667] _run(b::BenchmarkTools.Benchmark, p::BenchmarkTools.Parameters; verbose::Bool, pad::String, kwargs::Base.Pairs{Symbol, Integer, NTuple{4, Symbol}, NamedTuple{(:samples, :evals, :gctrial, :gcsample), Tuple{Int64, Int64, Bool, Bool}}})",
+      "      @ BenchmarkTools ~/.julia/packages/BenchmarkTools/0owsb/src/execution.jl:99",
+      " [6668] #invokelatest#2",
+      "      @ ./essentials.jl:821 [inlined]",
+      " [6669] invokelatest",
+      "      @ ./essentials.jl:816 [inlined]",
+      " [6670] #run_result#45",
+      "      @ ~/.julia/packages/BenchmarkTools/0owsb/src/execution.jl:34 [inlined]",
+      " [6671] run_result",
+      "      @ ~/.julia/packages/BenchmarkTools/0owsb/src/execution.jl:34 [inlined]",
+      " [6672] run(b::BenchmarkTools.Benchmark, p::BenchmarkTools.Parameters; progressid::Nothing, nleaves::Float64, ndone::Float64, kwargs::Base.Pairs{Symbol, Integer, NTuple{5, Symbol}, NamedTuple{(:verbose, :samples, :evals, :gctrial, :gcsample), Tuple{Bool, Int64, Int64, Bool, Bool}}})",
+      "      @ BenchmarkTools ~/.julia/packages/BenchmarkTools/0owsb/src/execution.jl:117",
+      " [6673] run (repeats 2 times)",
+      "      @ ~/.julia/packages/BenchmarkTools/0owsb/src/execution.jl:117 [inlined]",
+      " [6674] #warmup#54",
+      "      @ ~/.julia/packages/BenchmarkTools/0owsb/src/execution.jl:169 [inlined]",
+      " [6675] warmup(item::BenchmarkTools.Benchmark)",
+      "      @ BenchmarkTools ~/.julia/packages/BenchmarkTools/0owsb/src/execution.jl:168"
+     ]
+    }
+   ],
+   "source": [
+    "using BenchmarkTools\n",
+    "@benchmark compute_AB_AB7.(inputs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Julia 1.9.3",
+   "language": "julia",
+   "name": "julia-1.9"
+  },
+  "language_info": {
+   "file_extension": ".jl",
+   "mimetype": "application/julia",
+   "name": "julia",
+   "version": "1.9.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

notebooks/abc_model_showcase.ipynb

@@ -0,0 +1,409 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "20768e45-df62-4638-ba33-b0ccf239f1aa",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "using Revise\n",
+    "using MetagraphOptimization\n",
+    "using BenchmarkTools"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "ff5f4a49",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Found 1 NUMA nodes\n",
+      "CUDA is non-functional\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Machine(MetagraphOptimization.AbstractDevice[MetagraphOptimization.NumaNode(0x0000, 0x0001, MetagraphOptimization.LocalVariables(), -1.0, UUID(\"a89974f6-6212-11ee-0866-0f591a3b69ea\"))], [-1.0;;])"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Get our machine's info\n",
+    "machine = get_machine_info()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "9df482a4-ca44-44c5-9ea7-7a2977d529be",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "ABCModel()"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Create a model identifier\n",
+    "model = ABCModel()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "30b16872-07f7-4d47-8ff8-8c3a849c9d4e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "ABC Process: 'AB->ABBB'"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Create a process in our model\n",
+    "process_str = \"AB->ABBB\"\n",
+    "process = parse_process(process_str, model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "043bd9e2-f89a-4362-885a-8c89d4cdd76f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Total: 280, ComputeTaskP"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Graph:\n",
+       "  Nodes: \n",
+       "  Edges: 385\n",
+       "  Total Compute Effort: 1075.0\n",
+       "  Total Data Transfer: 10944.0\n",
+       "  Total Compute Intensity: 0.09822733918128655\n"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      ": 6, ComputeTaskU: 6, \n",
+      "         ComputeTaskV: 64, ComputeTaskSum: 1, ComputeTaskS2: 24, \n",
+      "         ComputeTaskS1: 36, DataTask: 143"
+     ]
+    }
+   ],
+   "source": [
+    "# Read the graph (of the same process) from a file\n",
+    "graph = parse_dag(\"../input/$process_str.txt\", model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "02f01ad3-fd10-48d5-a0e0-c03dc83c80a4",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Input for ABC Process: 'AB->ABBB':\n",
+       "  2 Incoming particles:\n",
+       "    A: [5.77986599979293, 0.0, 0.0, 5.692701553354288]\n",
+       "    B: [5.77986599979293, 0.0, 0.0, -5.692701553354288]\n",
+       "  4 Outgoing Particles:\n",
+       "    A: [-3.8835293143673746, -1.4292027910861678, 2.8576090179942106, 1.968057422378813]\n",
+       "    B: [-1.1554024905063585, -0.1464656500147254, -0.2082400426692148, 0.5197487980391896]\n",
+       "    B: [-2.849749730594798, -1.0177034035100576, -2.464951858896686, -0.09677625137882176]\n",
+       "    B: [-3.6710504641173287, 2.5933718446109513, -0.1844171164283155, -2.391029969039186]\n"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Generate some random input data for our process\n",
+    "input_data = gen_process_input(process)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "083fb1be-ce2a-47f9-afb9-60a6fdfaed0b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "compute__af4450a2_6212_11ee_2601_cde7cf2aedc1 (generic function with 1 method)"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Get the function computing the result of the process from a ProcessInput\n",
+    "AB_AB3_compute = get_compute_function(graph, process, machine)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "a40c9500-8f79-4f04-b3c5-59b72a6b7ba9",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "-1.8924431710735022e-13"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Actually compute a result using the generated function and the input data\n",
+    "result = AB_AB3_compute(input_data)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "80c70010",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "include(\"../examples/profiling_utilities.jl\")\n",
+    "\n",
+    "# We can also mute the graph by applying some operations to it\n",
+    "reduce_all!(graph)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "5b192b44",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# The result should be the same as before (we can use execute to save having to generate the function ourselves)\n",
+    "@assert result ≈ execute(graph, process, machine, input_data)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "9b2f4a3f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1000-element Vector{Float64}:\n",
+       " -2.1491995259940396e-11\n",
+       " -1.04995646459455e-11\n",
+       "  5.821760691187782e-15\n",
+       " -6.556969485683705e-14\n",
+       " -1.3588086164373753e-14\n",
+       " -1.8789662441593694e-13\n",
+       " -2.131973301835892e-13\n",
+       " -5.3359759072004825e-12\n",
+       " -9.053914191490223e-13\n",
+       " -5.61107901706923e-13\n",
+       " -5.063492275603428e-11\n",
+       "  2.9168508985811397e-15\n",
+       " -1.6420151378194157e-13\n",
+       "  ⋮\n",
+       "  1.0931677247833436e-13\n",
+       " -7.704755306462797e-16\n",
+       " -1.8385907037491397e-12\n",
+       " -6.036215596560059e-14\n",
+       " -9.98872401400362e-12\n",
+       "  3.4861755637292935e-13\n",
+       " -1.1051119822969222e-10\n",
+       " -2.496572513216201e-12\n",
+       " -3.8682427847201926e-11\n",
+       "  7.904149696653438e-15\n",
+       " -7.606811743178716e-11\n",
+       " -5.100594937480292e-13"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Now we can generate a function and use it on lots of inputs\n",
+    "inputs = [gen_process_input(process) for _ in 1:1000]\n",
+    "AB_AB3_reduced_compute = get_compute_function(graph, process, machine)\n",
+    "\n",
+    "results = AB_AB3_reduced_compute.(inputs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "d43e4ff0",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "BenchmarkTools.Trial: 879 samples with 1 evaluation.\n",
+       " Range \u001b[90m(\u001b[39m\u001b[36m\u001b[1mmin\u001b[22m\u001b[39m … \u001b[35mmax\u001b[39m\u001b[90m):  \u001b[39m\u001b[36m\u001b[1m4.567 ms\u001b[22m\u001b[39m … \u001b[35m14.334 ms\u001b[39m  \u001b[90m┊\u001b[39m GC \u001b[90m(\u001b[39mmin … max\u001b[90m): \u001b[39m0.00% … 54.51%\n",
+       " Time  \u001b[90m(\u001b[39m\u001b[34m\u001b[1mmedian\u001b[22m\u001b[39m\u001b[90m):     \u001b[39m\u001b[34m\u001b[1m4.998 ms              \u001b[22m\u001b[39m\u001b[90m┊\u001b[39m GC \u001b[90m(\u001b[39mmedian\u001b[90m):    \u001b[39m0.00%\n",
+       " Time  \u001b[90m(\u001b[39m\u001b[32m\u001b[1mmean\u001b[22m\u001b[39m ± \u001b[32mσ\u001b[39m\u001b[90m):   \u001b[39m\u001b[32m\u001b[1m5.686 ms\u001b[22m\u001b[39m ± \u001b[32m 1.414 ms\u001b[39m  \u001b[90m┊\u001b[39m GC \u001b[90m(\u001b[39mmean ± σ\u001b[90m):  \u001b[39m9.09% ± 14.49%\n",
+       "\n",
+       "  \u001b[39m \u001b[39m \u001b[39m▃\u001b[39m▇\u001b[39m█\u001b[34m▅\u001b[39m\u001b[39m▄\u001b[39m▁\u001b[39m \u001b[39m▁\u001b[39m \u001b[39m \u001b[32m \u001b[39m\u001b[39m \u001b[39m▁\u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m▁\u001b[39m▁\u001b[39m \u001b[39m▁\u001b[39m▁\u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \n",
+       "  \u001b[39m▆\u001b[39m█\u001b[39m█\u001b[39m█\u001b[39m█\u001b[34m█\u001b[39m\u001b[39m█\u001b[39m█\u001b[39m▇\u001b[39m█\u001b[39m▇\u001b[39m▇\u001b[32m█\u001b[39m\u001b[39m▆\u001b[39m█\u001b[39m█\u001b[39m▆\u001b[39m▆\u001b[39m▇\u001b[39m▅\u001b[39m▅\u001b[39m▄\u001b[39m▁\u001b[39m▄\u001b[39m▅\u001b[39m▅\u001b[39m▆\u001b[39m▅\u001b[39m▅\u001b[39m▄\u001b[39m▁\u001b[39m▄\u001b[39m▄\u001b[39m▁\u001b[39m▅\u001b[39m▄\u001b[39m▄\u001b[39m▆\u001b[39m▇\u001b[39m█\u001b[39m█\u001b[39m█\u001b[39m█\u001b[39m█\u001b[39m█\u001b[39m▄\u001b[39m▅\u001b[39m▆\u001b[39m▅\u001b[39m▅\u001b[39m▅\u001b[39m▁\u001b[39m▅\u001b[39m▄\u001b[39m▄\u001b[39m▅\u001b[39m▁\u001b[39m▄\u001b[39m \u001b[39m▇\n",
+       "  4.57 ms\u001b[90m      \u001b[39m\u001b[90mHistogram: \u001b[39m\u001b[90m\u001b[1mlog(\u001b[22m\u001b[39m\u001b[90mfrequency\u001b[39m\u001b[90m\u001b[1m)\u001b[22m\u001b[39m\u001b[90m by time\u001b[39m       10 ms \u001b[0m\u001b[1m<\u001b[22m\n",
+       "\n",
+       " Memory estimate\u001b[90m: \u001b[39m\u001b[33m6.17 MiB\u001b[39m, allocs estimate\u001b[90m: \u001b[39m\u001b[33m143006\u001b[39m."
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "@benchmark results = AB_AB3_compute.($inputs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "e18d9546",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "BenchmarkTools.Trial: 1089 samples with 1 evaluation.\n",
+       " Range \u001b[90m(\u001b[39m\u001b[36m\u001b[1mmin\u001b[22m\u001b[39m … \u001b[35mmax\u001b[39m\u001b[90m):  \u001b[39m\u001b[36m\u001b[1m3.637 ms\u001b[22m\u001b[39m … \u001b[35m10.921 ms\u001b[39m  \u001b[90m┊\u001b[39m GC \u001b[90m(\u001b[39mmin … max\u001b[90m): \u001b[39m 0.00% … 59.52%\n",
+       " Time  \u001b[90m(\u001b[39m\u001b[34m\u001b[1mmedian\u001b[22m\u001b[39m\u001b[90m):     \u001b[39m\u001b[34m\u001b[1m4.098 ms              \u001b[22m\u001b[39m\u001b[90m┊\u001b[39m GC \u001b[90m(\u001b[39mmedian\u001b[90m):    \u001b[39m 0.00%\n",
+       " Time  \u001b[90m(\u001b[39m\u001b[32m\u001b[1mmean\u001b[22m\u001b[39m ± \u001b[32mσ\u001b[39m\u001b[90m):   \u001b[39m\u001b[32m\u001b[1m4.587 ms\u001b[22m\u001b[39m ± \u001b[32m 1.334 ms\u001b[39m  \u001b[90m┊\u001b[39m GC \u001b[90m(\u001b[39mmean ± σ\u001b[90m):  \u001b[39m10.21% ± 15.77%\n",
+       "\n",
+       "  \u001b[39m \u001b[39m▂\u001b[39m▆\u001b[39m▆\u001b[39m▇\u001b[34m█\u001b[39m\u001b[39m▆\u001b[39m▂\u001b[39m \u001b[39m \u001b[39m \u001b[32m \u001b[39m\u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m▁\u001b[39m▁\u001b[39m \u001b[39m▁\u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \n",
+       "  \u001b[39m▆\u001b[39m█\u001b[39m█\u001b[39m█\u001b[39m█\u001b[34m█\u001b[39m\u001b[39m█\u001b[39m█\u001b[39m▇\u001b[39m█\u001b[39m▇\u001b[32m▆\u001b[39m\u001b[39m▅\u001b[39m▇\u001b[39m▅\u001b[39m▅\u001b[39m▅\u001b[39m▄\u001b[39m▆\u001b[39m▄\u001b[39m▅\u001b[39m▅\u001b[39m▅\u001b[39m▅\u001b[39m▆\u001b[39m▄\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▁\u001b[39m▄\u001b[39m▆\u001b[39m▆\u001b[39m▆\u001b[39m█\u001b[39m█\u001b[39m▇\u001b[39m█\u001b[39m█\u001b[39m▆\u001b[39m▆\u001b[39m▆\u001b[39m█\u001b[39m█\u001b[39m▇\u001b[39m▆\u001b[39m▄\u001b[39m▄\u001b[39m \u001b[39m█\n",
+       "  3.64 ms\u001b[90m      \u001b[39m\u001b[90mHistogram: \u001b[39m\u001b[90m\u001b[1mlog(\u001b[22m\u001b[39m\u001b[90mfrequency\u001b[39m\u001b[90m\u001b[1m)\u001b[22m\u001b[39m\u001b[90m by time\u001b[39m     8.78 ms \u001b[0m\u001b[1m<\u001b[22m\n",
+       "\n",
+       " Memory estimate\u001b[90m: \u001b[39m\u001b[33m5.26 MiB\u001b[39m, allocs estimate\u001b[90m: \u001b[39m\u001b[33m123006\u001b[39m."
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "@benchmark results = AB_AB3_reduced_compute.($inputs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "13efed12-3547-400b-a7a2-5dfae9a973a2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Set a different caching strategy\n",
+    "MetagraphOptimization.set_cache_strategy(machine.devices[1], MetagraphOptimization.Dictionary())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "ef62716b-a219-4f6e-9150-f984d3734839",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "BenchmarkTools.Trial: 331 samples with 1 evaluation.\n",
+       " Range \u001b[90m(\u001b[39m\u001b[36m\u001b[1mmin\u001b[22m\u001b[39m … \u001b[35mmax\u001b[39m\u001b[90m):  \u001b[39m\u001b[36m\u001b[1m12.148 ms\u001b[22m\u001b[39m … \u001b[35m24.164 ms\u001b[39m  \u001b[90m┊\u001b[39m GC \u001b[90m(\u001b[39mmin … max\u001b[90m): \u001b[39m 0.00% … 13.35%\n",
+       " Time  \u001b[90m(\u001b[39m\u001b[34m\u001b[1mmedian\u001b[22m\u001b[39m\u001b[90m):     \u001b[39m\u001b[34m\u001b[1m15.412 ms              \u001b[22m\u001b[39m\u001b[90m┊\u001b[39m GC \u001b[90m(\u001b[39mmedian\u001b[90m):    \u001b[39m17.47%\n",
+       " Time  \u001b[90m(\u001b[39m\u001b[32m\u001b[1mmean\u001b[22m\u001b[39m ± \u001b[32mσ\u001b[39m\u001b[90m):   \u001b[39m\u001b[32m\u001b[1m15.117 ms\u001b[22m\u001b[39m ± \u001b[32m 2.194 ms\u001b[39m  \u001b[90m┊\u001b[39m GC \u001b[90m(\u001b[39mmean ± σ\u001b[90m):  \u001b[39m12.31% ±  8.95%\n",
+       "\n",
+       "  \u001b[39m \u001b[39m▄\u001b[39m█\u001b[39m▄\u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[32m▄\u001b[39m\u001b[39m▄\u001b[34m▂\u001b[39m\u001b[39m \u001b[39m▂\u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \u001b[39m \n",
+       "  \u001b[39m▅\u001b[39m█\u001b[39m█\u001b[39m█\u001b[39m▅\u001b[39m▃\u001b[39m▃\u001b[39m▂\u001b[39m▃\u001b[39m▂\u001b[39m▅\u001b[39m▂\u001b[39m▃\u001b[39m▁\u001b[39m▂\u001b[39m▂\u001b[39m▂\u001b[39m▃\u001b[39m▂\u001b[39m▃\u001b[32m█\u001b[39m\u001b[39m█\u001b[34m█\u001b[39m\u001b[39m▇\u001b[39m█\u001b[39m▄\u001b[39m▆\u001b[39m▄\u001b[39m▆\u001b[39m▄\u001b[39m▄\u001b[39m▆\u001b[39m▅\u001b[39m▄\u001b[39m▃\u001b[39m▄\u001b[39m▂\u001b[39m▂\u001b[39m▃\u001b[39m▃\u001b[39m▄\u001b[39m▃\u001b[39m▂\u001b[39m▂\u001b[39m▁\u001b[39m▂\u001b[39m▂\u001b[39m▃\u001b[39m▂\u001b[39m▂\u001b[39m▁\u001b[39m▂\u001b[39m▁\u001b[39m▃\u001b[39m▃\u001b[39m▂\u001b[39m▂\u001b[39m▁\u001b[39m▂\u001b[39m \u001b[39m▃\n",
+       "  12.1 ms\u001b[90m         Histogram: frequency by time\u001b[39m          21 ms \u001b[0m\u001b[1m<\u001b[22m\n",
+       "\n",
+       " Memory estimate\u001b[90m: \u001b[39m\u001b[33m27.46 MiB\u001b[39m, allocs estimate\u001b[90m: \u001b[39m\u001b[33m118013\u001b[39m."
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# ... and bench again\n",
+    "AB_AB3_reduced_dict_compute = get_compute_function(graph, process, machine)\n",
+    "@benchmark results = AB_AB3_reduced_dict_compute.($inputs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5461ffd4-6a0e-4f1f-b1f1-3a2854a8ae88",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Julia 1.9.3",
+   "language": "julia",
+   "name": "julia-1.9"
+  },
+  "language_info": {
+   "file_extension": ".jl",
+   "mimetype": "application/julia",
+   "name": "julia",
+   "version": "1.9.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

notebooks/profiling.ipynb

@@ -0,0 +1,70 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "using Revise; using MetagraphOptimization; using BenchmarkTools; using ProfileView\n",
+    "using Base.Threads\n",
+    "nthreads()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = ABCModel()\n",
+    "process_str = \"AB->ABBBBB\"\n",
+    "process = parse_process(process_str, model)\n",
+    "graph = parse_dag(\"../input/$process_str.txt\", model)\n",
+    "print(graph)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "include(\"../examples/profiling_utilities.jl\")\n",
+    "@ProfileView.profview reduce_all!(graph)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "@ProfileView.profview comp_func = get_compute_function(graph, process)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Julia 1.9.3",
+   "language": "julia",
+   "name": "julia-1.9"
+  },
+  "language_info": {
+   "file_extension": ".jl",
+   "mimetype": "application/julia",
+   "name": "julia",
+   "version": "1.9.3"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

scripts/bench_threads.fish

@@ -6,20 +6,20 @@ julia --project=./examples -t 4 -e 'import Pkg; Pkg.instantiate()'
 
 #for i in $(seq $minthreads $maxthreads)
 #   printf "(AB->AB, $i) "
-#   julia --project=./examples -t $i -O3 -e 'using MetagraphOptimization; using BenchmarkTools; @btime get_operations(graph) setup=(graph = parse_abc("input/AB->AB.txt"))'
+#   julia --project=./examples -t $i -O3 -e 'using MetagraphOptimization; using BenchmarkTools; @btime get_operations(graph) setup=(graph = parse_dag("input/AB->AB.txt"), ABCModel())'
 #end
 
 #for i in $(seq $minthreads $maxthreads)
 #   printf "(AB->ABBB, $i) "
-#   julia --project=./examples -t $i -O3 -e 'using MetagraphOptimization; using BenchmarkTools; @btime get_operations(graph) setup=(graph = parse_abc("input/AB->ABBB.txt"))'
+#   julia --project=./examples -t $i -O3 -e 'using MetagraphOptimization; using BenchmarkTools; @btime get_operations(graph) setup=(graph = parse_dag("input/AB->ABBB.txt"), ABCModel())'
 #end
 
 #for i in $(seq $minthreads $maxthreads)
 #   printf "(AB->ABBBBB, $i) "
-#   julia --project=./examples -t $i -O3 -e 'using MetagraphOptimization; using BenchmarkTools; @btime get_operations(graph) setup=(graph = parse_abc("input/AB->ABBBBB.txt"))'
+#   julia --project=./examples -t $i -O3 -e 'using MetagraphOptimization; using BenchmarkTools; @btime get_operations(graph) setup=(graph = parse_dag("input/AB->ABBBBB.txt"), ABCModel())'
 #end
 
 for i in $(seq $minthreads $maxthreads)
    printf "(AB->ABBBBBBB, $i) "
-   julia --project=./examples -t $i -O3 -e 'using MetagraphOptimization; using BenchmarkTools; @btime get_operations(graph) setup=(graph = parse_abc("input/AB->ABBBBBBB.txt"))'
+   julia --project=./examples -t $i -O3 -e 'using MetagraphOptimization; using BenchmarkTools; @btime get_operations(graph) setup=(graph = parse_dag("input/AB->ABBBBBBB.txt"), ABCModel())'
 end

src/MetagraphOptimization.jl

@@ -1,35 +1,64 @@
+"""
+    MetagraphOptimization
+
+A module containing tools to work on DAGs.
+"""
 module MetagraphOptimization
 
-export Node, Edge, ComputeTaskNode, DataTaskNode, DAG
-export AbstractTask,
-    AbstractComputeTask, AbstractDataTask, DataTask, FusedComputeTask
-export make_node,
-    make_edge,
-    insert_node,
-    insert_edge,
-    is_entry_node,
-    is_exit_node,
-    parents,
-    children,
-    compute,
-    graph_properties,
-    get_exit_node,
-    is_valid
-export NodeFusion,
-    NodeReduction,
-    NodeSplit,
-    push_operation!,
-    pop_operation!,
-    can_pop,
-    reset_graph!,
-    get_operations
-export parse_abc,
-    ComputeTaskP,
-    ComputeTaskS1,
-    ComputeTaskS2,
-    ComputeTaskV,
-    ComputeTaskU,
-    ComputeTaskSum
+export DAG
+export Node
+export Edge
+export ComputeTaskNode
+export DataTaskNode
+export AbstractTask
+export AbstractComputeTask
+export AbstractDataTask
+export DataTask
+export FusedComputeTask
+export PossibleOperations
+export GraphProperties
+
+export make_node
+export make_edge
+export insert_node
+export insert_edge
+export is_entry_node
+export is_exit_node
+export parents
+export children
+export compute
+export get_properties
+export get_exit_node
+export is_valid, is_scheduled
+
+export Operation
+export AppliedOperation
+export NodeFusion
+export NodeReduction
+export NodeSplit
+export push_operation!
+export pop_operation!
+export can_pop
+export reset_graph!
+export get_operations
+
+export ComputeTaskP
+export ComputeTaskS1
+export ComputeTaskS2
+export ComputeTaskV
+export ComputeTaskU
+export ComputeTaskSum
+
+export execute
+export parse_dag, parse_process
+export gen_process_input
+export get_compute_function
+export ParticleValue
+export ParticleA, ParticleB, ParticleC
+export ABCProcessDescription, ABCProcessInput, ABCModel
+
+export Machine
+export get_machine_info
 
 export ==, in, show, isempty, delete!, length
 
@@ -38,6 +67,8 @@ export bytes_to_human_readable
 import Base.length
 import Base.show
 import Base.==
+import Base.+
+import Base.-
 import Base.in
 import Base.copy
 import Base.isempty
@@ -46,9 +77,11 @@ import Base.insert!
 import Base.collect
 
 
+include("devices/interface.jl")
 include("task/type.jl")
 include("node/type.jl")
 include("diff/type.jl")
+include("properties/type.jl")
 include("operation/type.jl")
 include("graph/type.jl")
 
@@ -79,12 +112,40 @@ include("operation/get.jl")
 include("operation/print.jl")
 include("operation/validate.jl")
 
+include("properties/create.jl")
+include("properties/utility.jl")
+
+include("task/create.jl")
 include("task/compare.jl")
+include("task/compute.jl")
 include("task/print.jl")
 include("task/properties.jl")
 
+include("models/interface.jl")
+include("models/print.jl")
+
 include("models/abc/types.jl")
+include("models/abc/particle.jl")
+include("models/abc/compute.jl")
+include("models/abc/create.jl")
 include("models/abc/properties.jl")
 include("models/abc/parse.jl")
+include("models/abc/print.jl")
+
+include("devices/measure.jl")
+include("devices/detect.jl")
+include("devices/impl.jl")
+
+include("devices/numa/impl.jl")
+include("devices/cuda/impl.jl")
+# can currently not use AMDGPU because of incompatability with the newest rocm drivers
+# include("devices/rocm/impl.jl")
+# oneapi seems also broken for now
+# include("devices/oneapi/impl.jl")
+
+include("scheduler/interface.jl")
+include("scheduler/greedy.jl")
+
+include("code_gen/main.jl")
 
 end # module MetagraphOptimization

src/code_gen/main.jl

@@ -0,0 +1,157 @@
+"""
+    gen_code(graph::DAG)
+
+Generate the code for a given graph. The return value is a named tuple of:
+
+- `code::Expr`: The julia expression containing the code for the whole graph.
+- `inputSymbols::Dict{String, Vector{Symbol}}`: A dictionary of symbols mapping the names of the input nodes of the graph to the symbols their inputs should be provided on.
+- `outputSymbol::Symbol`: The symbol of the final calculated value
+
+See also: [`execute`](@ref)
+"""
+function gen_code(graph::DAG, machine::Machine)
+    sched = schedule_dag(GreedyScheduler(), graph, machine)
+
+    codeAcc = Vector{Expr}()
+    sizehint!(codeAcc, length(graph.nodes))
+
+    for node in sched
+        # TODO: this is kind of ugly, should init nodes be scheduled differently from the rest?
+        if (node isa DataTaskNode && length(node.children) == 0)
+            push!(codeAcc, get_init_expression(node, entry_device(machine)))
+            continue
+        end
+        push!(codeAcc, get_expression(node))
+    end
+
+    # get inSymbols
+    inputSyms = Dict{String, Vector{Symbol}}()
+    for node in get_entry_nodes(graph)
+        if !haskey(inputSyms, node.name)
+            inputSyms[node.name] = Vector{Symbol}()
+        end
+
+        push!(inputSyms[node.name], Symbol("$(to_var_name(node.id))_in"))
+    end
+
+    # get outSymbol
+    outSym = Symbol(to_var_name(get_exit_node(graph).id))
+
+    return (code = Expr(:block, codeAcc...), inputSymbols = inputSyms, outputSymbol = outSym)
+end
+
+function gen_cache_init_code(machine::Machine)
+    initializeCaches = Vector{Expr}()
+
+    for device in machine.devices
+        push!(initializeCaches, gen_cache_init_code(device))
+    end
+
+    return Expr(:block, initializeCaches...)
+end
+
+function gen_input_assignment_code(
+    inputSymbols::Dict{String, Vector{Symbol}},
+    processDescription::AbstractProcessDescription,
+    machine::Machine,
+    processInputSymbol::Symbol = :input,
+)
+    @assert length(inputSymbols) >=
+            sum(values(in_particles(processDescription))) + sum(values(out_particles(processDescription))) "Number of input Symbols is smaller than the number of particles in the process description"
+
+    assignInputs = Vector{Expr}()
+    for (name, symbols) in inputSymbols
+        type = type_from_name(name)
+        index = parse(Int, name[2:end])
+
+        p = nothing
+
+        if (index > in_particles(processDescription)[type])
+            index -= in_particles(processDescription)[type]
+            @assert index <= out_particles(processDescription)[type] "Too few particles of type $type in input particles for this process"
+
+            p = "filter(x -> typeof(x) <: $type, out_particles($(processInputSymbol)))[$(index)]"
+        else
+            p = "filter(x -> typeof(x) <: $type, in_particles($(processInputSymbol)))[$(index)]"
+        end
+
+        for symbol in symbols
+            # TODO: how to get the "default" cpu device?
+            device = entry_device(machine)
+            evalExpr = eval(gen_access_expr(device, symbol))
+            push!(assignInputs, Meta.parse("$(evalExpr) = ParticleValue($p, 1.0)"))
+        end
+    end
+
+    return Expr(:block, assignInputs...)
+end
+
+"""
+    get_compute_function(graph::DAG, process::AbstractProcessDescription, machine::Machine)
+
+Return a function of signature `compute_<id>(input::AbstractProcessInput)`, which will return the result of the DAG computation on the given input.
+"""
+function get_compute_function(graph::DAG, process::AbstractProcessDescription, machine::Machine)
+    (code, inputSymbols, outputSymbol) = gen_code(graph, machine)
+
+    initCaches = gen_cache_init_code(machine)
+    assignInputs = gen_input_assignment_code(inputSymbols, process, machine, :input)
+
+    functionId = to_var_name(UUIDs.uuid1(rng[1]))
+    resSym = eval(gen_access_expr(entry_device(machine), outputSymbol))
+    expr = Meta.parse(
+        "function compute_$(functionId)(input::AbstractProcessInput) $initCaches; $assignInputs; $code; return $resSym; end",
+    )
+    func = eval(expr)
+
+    return func
+end
+
+"""
+    execute(graph::DAG, process::AbstractProcessDescription, machine::Machine, input::AbstractProcessInput)
+
+Execute the code of the given `graph` on the given input particles.
+
+This is essentially shorthand for
+    ```julia
+    compute_graph = get_compute_function(graph, process)
+    result = compute_graph(particles)
+    ```
+
+See also: [`parse_dag`](@ref), [`parse_process`](@ref), [`gen_process_input`](@ref)
+"""
+function execute(graph::DAG, process::AbstractProcessDescription, machine::Machine, input::AbstractProcessInput)
+    (code, inputSymbols, outputSymbol) = gen_code(graph, machine)
+
+    initCaches = gen_cache_init_code(machine)
+    assignInputs = gen_input_assignment_code(inputSymbols, process, machine, :input)
+
+
+    functionId = to_var_name(UUIDs.uuid1(rng[1]))
+    resSym = eval(gen_access_expr(entry_device(machine), outputSymbol))
+    expr = Meta.parse(
+        "function compute_$(functionId)(input::AbstractProcessInput) $initCaches; $assignInputs; $code; return $resSym; end",
+    )
+    func = eval(expr)
+
+    result = 0
+    try
+        result = @eval $func($input)
+    catch e
+        println("Error while evaluating: $e")
+
+        # if we find a uuid in the exception we can color it in so it's easier to spot
+        uuidRegex = r"[0-9a-f]{8}_[0-9a-f]{4}_[0-9a-f]{4}_[0-9a-f]{4}_[0-9a-f]{12}"
+        m = match(uuidRegex, string(e))
+
+        functionStr = string(expr)
+        if (isa(m, RegexMatch))
+            functionStr = replace(functionStr, m.match => "\033[31m$(m.match)\033[0m")
+        end
+
+        println("Function:\n$functionStr")
+        @assert false
+    end
+
+    return result
+end

src/devices/cuda/impl.jl

@@ -0,0 +1,53 @@
+using CUDA
+
+"""
+    CUDAGPU <: AbstractGPU
+
+Representation of a specific CUDA GPU that code can run on. Implements the [`AbstractDevice`](@ref) interface.
+"""
+mutable struct CUDAGPU <: AbstractGPU
+    device::Any # TODO: what's the cuda device type?
+    cacheStrategy::CacheStrategy
+    FLOPS::Float64
+end
+
+push!(DEVICE_TYPES, CUDAGPU)
+
+CACHE_STRATEGIES[CUDAGPU] = [LocalVariables()]
+
+default_strategy(::Type{T}) where {T <: CUDAGPU} = LocalVariables()
+
+function measure_device!(device::CUDAGPU; verbose::Bool)
+    if verbose
+        println("Measuring CUDA GPU $(device.device)")
+    end
+
+    # TODO implement
+    return nothing
+end
+
+"""
+    get_devices(deviceType::Type{T}; verbose::Bool) where {T <: CUDAGPU}
+
+Return a Vector of [`CUDAGPU`](@ref)s available on the current machine. If `verbose` is true, print some additional information.
+"""
+function get_devices(deviceType::Type{T}; verbose::Bool = false) where {T <: CUDAGPU}
+    devices = Vector{AbstractDevice}()
+
+    if !CUDA.functional()
+        if verbose
+            println("CUDA is non-functional")
+        end
+        return devices
+    end
+
+    CUDADevices = CUDA.devices()
+    if verbose
+        println("Found $(length(CUDADevices)) CUDA devices")
+    end
+    for device in CUDADevices
+        push!(devices, CUDAGPU(device, default_strategy(CUDAGPU), -1))
+    end
+
+    return devices
+end

src/devices/detect.jl

@@ -0,0 +1,23 @@
+
+"""
+    get_machine_info(verbose::Bool)
+
+Return the [`Machine`](@ref) currently running on. The parameter `verbose` defaults to true when interactive.
+"""
+function get_machine_info(; verbose::Bool = Base.is_interactive)
+    devices = Vector{AbstractDevice}()
+
+    for device in device_types()
+        devs = get_devices(device, verbose = verbose)
+        for dev in devs
+            push!(devices, dev)
+        end
+    end
+
+    noDevices = length(devices)
+    @assert noDevices > 0 "No devices were found, but at least one NUMA node should always be available!"
+
+    transferRates = Matrix{Float64}(undef, noDevices, noDevices)
+    fill!(transferRates, -1)
+    return Machine(devices, transferRates)
+end

src/devices/impl.jl

@@ -0,0 +1,52 @@
+"""
+    device_types()
+
+Return a vector of available and implemented device types.
+
+See also: [`DEVICE_TYPES`](@ref)
+"""
+function device_types()
+    return DEVICE_TYPES
+end
+
+"""
+    entry_device(machine::Machine)
+
+Return the "entry" device, i.e., the device that starts CPU threads and GPU kernels, and takes input values and returns the output value.
+"""
+function entry_device(machine::Machine)
+    return machine.devices[1]
+end
+
+"""
+    strategies(t::Type{T}) where {T <: AbstractDevice}
+
+Return a vector of available [`CacheStrategy`](@ref)s for the given [`AbstractDevice`](@ref).
+The caching strategies are used in code generation.
+"""
+function strategies(t::Type{T}) where {T <: AbstractDevice}
+    if !haskey(CACHE_STRATEGIES, t)
+        error("Trying to get strategies for $T, but it has no strategies defined!")
+    end
+
+    return CACHE_STRATEGIES[t]
+end
+
+"""
+    cache_strategy(device::AbstractDevice)
+
+Returns the cache strategy set for this device.
+"""
+function cache_strategy(device::AbstractDevice)
+    return device.cacheStrategy
+end
+
+"""
+    set_cache_strategy(device::AbstractDevice, cacheStrategy::CacheStrategy)
+
+Sets the device's cache strategy. After this call, [`cache_strategy`](@ref) should return `cacheStrategy` on the given device.
+"""
+function set_cache_strategy(device::AbstractDevice, cacheStrategy::CacheStrategy)
+    device.cacheStrategy = cacheStrategy
+    return nothing
+end

src/devices/interface.jl

@@ -0,0 +1,108 @@
+"""
+    AbstractDevice
+
+Abstract base type for every device, like GPUs, CPUs or any other compute devices.
+Every implementation needs to implement various functions and needs a member `cacheStrategy`.
+"""
+abstract type AbstractDevice end
+
+abstract type AbstractCPU <: AbstractDevice end
+
+abstract type AbstractGPU <: AbstractDevice end
+
+"""
+    Machine
+
+A representation of a machine to execute on. Contains information about its architecture (CPUs, GPUs, maybe more). This representation can be used to make a more accurate cost prediction of a [`DAG`](@ref) state.
+
+See also: [`Scheduler`](@ref)
+"""
+struct Machine
+    devices::Vector{AbstractDevice}
+
+    transferRates::Matrix{Float64}
+end
+
+"""
+    CacheStrategy
+
+Abstract base type for caching strategies.
+
+See also: [`strategies`](@ref)
+"""
+abstract type CacheStrategy end
+
+"""
+    LocalVariables <: CacheStrategy
+
+A caching strategy relying solely on local variables for every input and output.
+
+Implements the [`CacheStrategy`](@ref) interface.
+"""
+struct LocalVariables <: CacheStrategy end
+
+"""
+    Dictionary <: CacheStrategy
+
+A caching strategy relying on a dictionary of Symbols to store every input and output.
+
+Implements the [`CacheStrategy`](@ref) interface.
+"""
+struct Dictionary <: CacheStrategy end
+
+"""
+    DEVICE_TYPES::Vector{Type}
+
+Global vector of available and implemented device types. Each implementation of a [`AbstractDevice`](@ref) should add its concrete type to this vector.
+
+See also: [`device_types`](@ref), [`get_devices`](@ref)
+"""
+DEVICE_TYPES = Vector{Type}()
+
+"""
+    CACHE_STRATEGIES::Dict{Type{AbstractDevice}, Symbol}
+
+Global dictionary of available caching strategies per device. Each implementation of [`AbstractDevice`](@ref) should add its available strategies to the dictionary.
+
+See also: [`strategies`](@ref)
+"""
+CACHE_STRATEGIES = Dict{Type, Vector{CacheStrategy}}()
+
+"""
+    default_strategy(deviceType::Type{T}) where {T <: AbstractDevice}
+
+Interface function that must be implemented for every subtype of [`AbstractDevice`](@ref). Returns the default [`CacheStrategy`](@ref) to use on the given device type.
+See also: [`cache_strategy`](@ref), [`set_cache_strategy`](@ref)
+"""
+function default_strategy end
+
+"""
+    get_devices(t::Type{T}; verbose::Bool) where {T <: AbstractDevice}
+
+Interface function that must be implemented for every subtype of [`AbstractDevice`](@ref). Returns a `Vector{Type}` of the devices for the given [`AbstractDevice`](@ref) Type available on the current machine.
+"""
+function get_devices end
+
+"""
+    measure_device!(device::AbstractDevice; verbose::Bool)
+
+Interface function that must be implemented for every subtype of [`AbstractDevice`](@ref). Measures the compute speed of the given device and writes into it.
+"""
+function measure_device! end
+
+"""
+    gen_cache_init_code(device::AbstractDevice)
+
+Interface function that must be implemented for every subtype of [`AbstractDevice`](@ref) and at least one [`CacheStrategy`](@ref). Returns an `Expr` initializing this device's variable cache.
+    
+The strategy is a symbol
+"""
+function gen_cache_init_code end
+
+"""
+    gen_access_expr(device::AbstractDevice, symbol::Symbol)
+
+Interface function that must be implemented for every subtype of [`AbstractDevice`](@ref) and at least one [`CacheStrategy`](@ref).
+Return an `Expr` or `QuoteNode` accessing the variable identified by [`symbol`].
+"""
+function gen_access_expr end

src/devices/measure.jl

@@ -0,0 +1,22 @@
+"""
+    measure_devices(machine::Machine; verbose::Bool)
+
+Measure FLOPS, RAM, cache sizes and what other properties can be extracted for the devices in the given machine.
+"""
+function measure_devices!(machine::Machine; verbose::Bool = Base.is_interactive())
+    for device in machine.devices
+        measure_device!(device; verbose = verbose)
+    end
+
+    return nothing
+end
+
+"""
+    measure_transfer_rates(machine::Machine; verbose::Bool)
+
+Measure the transfer rates between devices in the machine.
+"""
+function measure_transfer_rates!(machine::Machine; verbose::Bool = Base.is_interactive())
+    # TODO implement
+    return nothing
+end

src/devices/numa/impl.jl

@@ -0,0 +1,96 @@
+using NumaAllocators
+
+"""
+    NumaNode <: AbstractCPU
+
+Representation of a specific CPU that code can run on. Implements the [`AbstractDevice`](@ref) interface.
+"""
+mutable struct NumaNode <: AbstractCPU
+    numaId::UInt16
+    threads::UInt16
+    cacheStrategy::CacheStrategy
+    FLOPS::Float64
+    id::UUID
+end
+
+push!(DEVICE_TYPES, NumaNode)
+
+CACHE_STRATEGIES[NumaNode] = [LocalVariables()]
+
+default_strategy(::Type{T}) where {T <: NumaNode} = LocalVariables()
+
+function measure_device!(device::NumaNode; verbose::Bool)
+    if verbose
+        println("Measuring Numa Node $(device.numaId)")
+    end
+
+    # TODO implement
+    return nothing
+end
+
+"""
+    get_devices(deviceType::Type{T}; verbose::Bool) where {T <: NumaNode}
+
+Return a Vector of [`NumaNode`](@ref)s available on the current machine. If `verbose` is true, print some additional information.
+"""
+function get_devices(deviceType::Type{T}; verbose::Bool = false) where {T <: NumaNode}
+    devices = Vector{AbstractDevice}()
+    noNumaNodes = highest_numa_node()
+
+    if (verbose)
+        println("Found $(noNumaNodes + 1) NUMA nodes")
+    end
+    for i in 0:noNumaNodes
+        push!(devices, NumaNode(i, 1, default_strategy(NumaNode), -1, UUIDs.uuid1(rng[1])))
+    end
+
+    return devices
+end
+
+"""
+    gen_cache_init_code(device::NumaNode)
+
+Generate code for initializing the [`LocalVariables`](@ref) strategy on a [`NumaNode`](@ref).
+"""
+function gen_cache_init_code(device::NumaNode)
+    if typeof(device.cacheStrategy) <: LocalVariables
+        # don't need to initialize anything
+        return Expr(:block)
+    elseif typeof(device.cacheStrategy) <: Dictionary
+        return Meta.parse("cache_$(to_var_name(device.id)) = Dict{Symbol, Any}()")
+        # TODO: sizehint?
+    end
+
+    return error("Unimplemented cache strategy \"$(device.cacheStrategy)\" for device \"$(device)\"")
+end
+
+"""
+    gen_access_expr(device::NumaNode, symbol::Symbol)
+
+Generate code to access the variable designated by `symbol` on a [`NumaNode`](@ref), using the [`CacheStrategy`](@ref) set in the device.
+"""
+function gen_access_expr(device::NumaNode, symbol::Symbol)
+    return _gen_access_expr(device, device.cacheStrategy, symbol)
+end
+
+"""
+    _gen_access_expr(device::NumaNode, ::LocalVariables, symbol::Symbol)
+
+Internal function for dispatch, used in [`gen_access_expr`](@ref).
+"""
+function _gen_access_expr(device::NumaNode, ::LocalVariables, symbol::Symbol)
+    s = Symbol("data_$symbol")
+    quoteNode = Meta.parse(":($s)")
+    return quoteNode
+end
+
+"""
+    _gen_access_expr(device::NumaNode, ::Dictionary, symbol::Symbol)
+
+Internal function for dispatch, used in [`gen_access_expr`](@ref).
+"""
+function _gen_access_expr(device::NumaNode, ::Dictionary, symbol::Symbol)
+    accessStr = ":(cache_$(to_var_name(device.id))[:$symbol])"
+    quoteNode = Meta.parse(accessStr)
+    return quoteNode
+end

src/devices/oneapi/impl.jl

@@ -0,0 +1,53 @@
+using oneAPI
+
+"""
+    oneAPIGPU <: AbstractGPU
+
+Representation of a specific Intel GPU that code can run on. Implements the [`AbstractDevice`](@ref) interface.
+"""
+mutable struct oneAPIGPU <: AbstractGPU
+    device::Any
+    cacheStrategy::CacheStrategy
+    FLOPS::Float64
+end
+
+push!(DEVICE_TYPES, oneAPIGPU)
+
+CACHE_STRATEGIES[oneAPIGPU] = [LocalVariables()]
+
+default_strategy(::Type{T}) where {T <: oneAPIGPU} = LocalVariables()
+
+function measure_device!(device::oneAPIGPU; verbose::Bool)
+    if verbose
+        println("Measuring oneAPI GPU $(device.device)")
+    end
+
+    # TODO implement
+    return nothing
+end
+
+"""
+    get_devices(deviceType::Type{T}; verbose::Bool = false) where {T <: oneAPIGPU}
+
+Return a Vector of [`oneAPIGPU`](@ref)s available on the current machine. If `verbose` is true, print some additional information.
+"""
+function get_devices(deviceType::Type{T}; verbose::Bool = false) where {T <: oneAPIGPU}
+    devices = Vector{AbstractDevice}()
+
+    if !oneAPI.functional()
+        if verbose
+            println("oneAPI is non-functional")
+        end
+        return devices
+    end
+
+    oneAPIDevices = oneAPI.devices()
+    if verbose
+        println("Found $(length(oneAPIDevices)) oneAPI devices")
+    end
+    for device in oneAPIDevices
+        push!(devices, oneAPIGPU(device, default_strategy(oneAPIGPU), -1))
+    end
+
+    return devices
+end

src/devices/rocm/impl.jl

@@ -0,0 +1,53 @@
+using AMDGPU
+
+"""
+    ROCmGPU <: AbstractGPU
+
+Representation of a specific AMD GPU that code can run on. Implements the [`AbstractDevice`](@ref) interface.
+"""
+mutable struct ROCmGPU <: AbstractGPU
+    device::Any
+    cacheStrategy::CacheStrategy
+    FLOPS::Float64
+end
+
+push!(DEVICE_TYPES, ROCmGPU)
+
+CACHE_STRATEGIES[ROCmGPU] = [LocalVariables()]
+
+default_strategy(::Type{T}) where {T <: ROCmGPU} = LocalVariables()
+
+function measure_device!(device::ROCmGPU; verbose::Bool)
+    if verbose
+        println("Measuring ROCm GPU $(device.device)")
+    end
+
+    # TODO implement
+    return nothing
+end
+
+"""
+    get_devices(deviceType::Type{T}; verbose::Bool = false) where {T <: ROCmGPU}
+
+Return a Vector of [`ROCmGPU`](@ref)s available on the current machine. If `verbose` is true, print some additional information.
+"""
+function get_devices(deviceType::Type{T}; verbose::Bool = false) where {T <: ROCmGPU}
+    devices = Vector{AbstractDevice}()
+
+    if !AMDGPU.functional()
+        if verbose
+            println("AMDGPU is non-functional")
+        end
+        return devices
+    end
+
+    AMDDevices = AMDGPU.devices()
+    if verbose
+        println("Found $(length(AMDDevices)) AMD devices")
+    end
+    for device in AMDDevices
+        push!(devices, ROCmGPU(device, default_strategy(ROCmGPU), -1))
+    end
+
+    return devices
+end

src/diff/print.jl

@@ -1,6 +1,11 @@
+"""
+    show(io::IO, diff::Diff)
+
+Pretty-print a [`Diff`](@ref). Called via print, println and co.
+"""
 function show(io::IO, diff::Diff)
     print(io, "Nodes: ")
     print(io, length(diff.addedNodes) + length(diff.removedNodes))
-    print(io, " Edges: ")
+    print(io, ", Edges: ")
     return print(io, length(diff.addedEdges) + length(diff.removedEdges))
 end

src/diff/properties.jl

@@ -1,4 +1,9 @@
-# return a namedtuple of the lengths of the added/removed nodes/edges
+"""
+    length(diff::Diff)
+    
+Return a named tuple of the lengths of the added/removed nodes/edges.
+The fields are `.addedNodes`, `.addedEdges`, `.removedNodes` and `.removedEdges`.
+"""
 function length(diff::Diff)
     return (
         addedNodes = length(diff.addedNodes),

src/diff/type.jl

@@ -1,6 +1,11 @@
+"""
+    Diff
+
+A named tuple representing a difference of added and removed nodes and edges on a [`DAG`](@ref).
+"""
 const Diff = NamedTuple{
-    (:addedNodes, :removedNodes, :addedEdges, :removedEdges),
-    Tuple{Vector{Node}, Vector{Node}, Vector{Edge}, Vector{Edge}},
+    (:addedNodes, :removedNodes, :addedEdges, :removedEdges, :updatedChildren),
+    Tuple{Vector{Node}, Vector{Node}, Vector{Edge}, Vector{Edge}, Vector{Tuple{Node, AbstractTask}}},
 }
 
 function Diff()
@@ -9,5 +14,8 @@ function Diff()
         removedNodes = Vector{Node}(),
         addedEdges = Vector{Edge}(),
         removedEdges = Vector{Edge}(),
+
+        # children were updated in the task, updatedChildren[x][2] is the task before the update
+        updatedChildren = Vector{Tuple{Node, AbstractTask}}(),
     )::Diff
 end

src/graph/compare.jl

@@ -1,7 +1,30 @@
+"""
+    in(node::Node, graph::DAG)
 
+Check whether the node is part of the graph.
+"""
 in(node::Node, graph::DAG) = node in graph.nodes
-in(edge::Edge, graph::DAG) = edge in graph.edges
 
+"""
+    in(edge::Edge, graph::DAG)
+
+Check whether the edge is part of the graph.
+"""
+function in(edge::Edge, graph::DAG)
+    n1 = edge.edge[1]
+    n2 = edge.edge[2]
+    if !(n1 in graph) || !(n2 in graph)
+        return false
+    end
+
+    return n1 in n2.children
+end
+
+"""
+    ==(n1::Node, n2::Node, g::DAG)
+
+Check equality of two nodes in a graph.
+"""
 function ==(n1::Node, n2::Node, g::DAG)
     if typeof(n1) != typeof(n2)
         return false

src/graph/interface.jl

@@ -1,6 +1,10 @@
-# user interface on the DAG
+"""
+    push_operation!(graph::DAG, operation::Operation)
 
-# applies a new operation to the end of the graph
+Apply a new operation to the graph.
+
+See also: [`DAG`](@ref), [`pop_operation!`](@ref)
+"""
 function push_operation!(graph::DAG, operation::Operation)
     # 1.: Add the operation to the DAG
     push!(graph.operationsToApply, operation)
@@ -8,7 +12,13 @@ function push_operation!(graph::DAG, operation::Operation)
     return nothing
 end
 
-# reverts the latest applied operation, essentially like a ctrl+z for
+"""
+    pop_operation!(graph::DAG)
+
+Revert the latest applied operation on the graph.
+
+See also: [`DAG`](@ref), [`push_operation!`](@ref)
+"""
 function pop_operation!(graph::DAG)
     # 1.: Remove the operation from the appliedChain of the DAG
     if !isempty(graph.operationsToApply)
@@ -23,10 +33,18 @@ function pop_operation!(graph::DAG)
     return nothing
 end
 
-can_pop(graph::DAG) =
-    !isempty(graph.operationsToApply) || !isempty(graph.appliedOperations)
+"""
+    can_pop(graph::DAG)
 
-# reset the graph to its initial state with no operations applied
+Return `true` if [`pop_operation!`](@ref) is possible, `false` otherwise.
+"""
+can_pop(graph::DAG) = !isempty(graph.operationsToApply) || !isempty(graph.appliedOperations)
+
+"""
+    reset_graph!(graph::DAG)
+
+Reset the graph to its initial state with no operations applied.
+"""
 function reset_graph!(graph::DAG)
     while (can_pop(graph))
         pop_operation!(graph)

src/graph/mute.jl

@@ -3,12 +3,19 @@
 # 2: keep track of what was changed for the diff (if track == true)
 # 3: invalidate operation caches
 
-function insert_node!(
-    graph::DAG,
-    node::Node,
-    track = true,
-    invalidate_cache = true,
-)
+"""
+    insert_node!(graph::DAG, node::Node; track = true, invalidate_cache = true)
+
+Insert the node into the graph.
+
+## Keyword Arguments
+`track::Bool`: Whether to add the changes to the [`DAG`](@ref)'s [`Diff`](@ref). Should be set `false` in parsing or graph creation functions for performance.
+
+`invalidate_cache::Bool`: Whether to invalidate caches associated with the changes. Should also be turned off for graph creation or parsing.
+
+See also: [`remove_node!`](@ref), [`insert_edge!`](@ref), [`remove_edge!`](@ref)
+"""
+function insert_node!(graph::DAG, node::Node; track = true, invalidate_cache = true)
     # 1: mute
     push!(graph.nodes, node)
 
@@ -26,14 +33,20 @@ function insert_node!(
     return node
 end
 
-function insert_edge!(
-    graph::DAG,
-    node1::Node,
-    node2::Node,
-    track = true,
-    invalidate_cache = true,
-)
-    # @assert (node2 ∉ node1.parents) && (node1 ∉ node2.children) "Edge to insert already exists"
+"""
+    insert_edge!(graph::DAG, node1::Node, node2::Node; track = true, invalidate_cache = true)
+
+Insert the edge between node1 (child) and node2 (parent) into the graph.
+
+## Keyword Arguments
+`track::Bool`: Whether to add the changes to the [`DAG`](@ref)'s [`Diff`](@ref). Should be set `false` in parsing or graph creation functions for performance.
+
+`invalidate_cache::Bool`: Whether to invalidate caches associated with the changes. Should also be turned off for graph creation or parsing.
+
+See also: [`insert_node!`](@ref), [`remove_node!`](@ref), [`remove_edge!`](@ref)
+"""
+function insert_edge!(graph::DAG, node1::Node, node2::Node; track = true, invalidate_cache = true)
+    @assert (node2 ∉ node1.parents) && (node1 ∉ node2.children) "Edge to insert already exists"
 
     # 1: mute
     # edge points from child to parent
@@ -59,13 +72,20 @@ function insert_edge!(
     return nothing
 end
 
-function remove_node!(
-    graph::DAG,
-    node::Node,
-    track = true,
-    invalidate_cache = true,
-)
-    # @assert node in graph.nodes "Trying to remove a node that's not in the graph"
+"""
+    remove_node!(graph::DAG, node::Node; track = true, invalidate_cache = true)
+
+Remove the node from the graph.
+
+## Keyword Arguments
+`track::Bool`: Whether to add the changes to the [`DAG`](@ref)'s [`Diff`](@ref). Should be set `false` in parsing or graph creation functions for performance.
+
+`invalidate_cache::Bool`: Whether to invalidate caches associated with the changes. Should also be turned off for graph creation or parsing.
+
+See also: [`insert_node!`](@ref), [`insert_edge!`](@ref), [`remove_edge!`](@ref)
+"""
+function remove_node!(graph::DAG, node::Node; track = true, invalidate_cache = true)
+    @assert node in graph.nodes "Trying to remove a node that's not in the graph"
 
     # 1: mute
     delete!(graph.nodes, node)
@@ -86,28 +106,36 @@ function remove_node!(
     return nothing
 end
 
-function remove_edge!(
-    graph::DAG,
-    node1::Node,
-    node2::Node,
-    track = true,
-    invalidate_cache = true,
-)
+"""
+    remove_edge!(graph::DAG, node1::Node, node2::Node; track = true, invalidate_cache = true)
+
+Remove the edge between node1 (child) and node2 (parent) into the graph.
+
+## Keyword Arguments
+`track::Bool`: Whether to add the changes to the [`DAG`](@ref)'s [`Diff`](@ref). Should be set `false` in parsing or graph creation functions for performance.
+
+`invalidate_cache::Bool`: Whether to invalidate caches associated with the changes. Should also be turned off for graph creation or parsing.
+
+See also: [`insert_node!`](@ref), [`remove_node!`](@ref), [`insert_edge!`](@ref)
+"""
+function remove_edge!(graph::DAG, node1::Node, node2::Node; track = true, invalidate_cache = true)
     # 1: mute
     pre_length1 = length(node1.parents)
     pre_length2 = length(node2.children)
+
+    #TODO: filter is very slow
     filter!(x -> x != node2, node1.parents)
     filter!(x -> x != node1, node2.children)
 
-    #=@assert begin
-       removed = pre_length1 - length(node1.parents)
-       removed <= 1
-    end "removed more than one node from node1's parents"=#
+    @assert begin
+        removed = pre_length1 - length(node1.parents)
+        removed <= 1
+    end "removed more than one node from node1's parents"
 
-    #=@assert begin
-       removed = pre_length2 - length(node2.children)
-       removed <= 1
-    end "removed more than one node from node2's children"=#
+    @assert begin
+        removed = pre_length2 - length(node2.children)
+        removed <= 1
+    end "removed more than one node from node2's children"
 
     # 2: keep track
     if (track)
@@ -131,16 +159,89 @@ function remove_edge!(
     return nothing
 end
 
-# return the graph "difference" since last time this function was called
+function replace_children!(task::FusedComputeTask, before, after)
+    replacedIn1 = length(findall(x -> x == before, task.t1_inputs))
+    replacedIn2 = length(findall(x -> x == before, task.t2_inputs))
+
+    @assert replacedIn1 >= 1 || replacedIn2 >= 1 "Nothing to replace while replacing $before with $after in $(task.t1_inputs...) and $(task.t2_inputs...)"
+
+    replace!(task.t1_inputs, before => after)
+    replace!(task.t2_inputs, before => after)
+
+    # recursively descend down the tree, but only in the tasks where we're replacing things
+    if replacedIn1 > 0
+        replace_children!(task.first_task, before, after)
+    end
+    if replacedIn2 > 0
+        replace_children!(task.second_task, before, after)
+    end
+
+    return nothing
+end
+
+function replace_children!(task::AbstractTask, before, after)
+    return nothing
+end
+
+function update_child!(graph::DAG, n::Node, child_before::Symbol, child_after::Symbol; track = true)
+    # only need to update fused compute tasks
+    if !(typeof(n.task) <: FusedComputeTask)
+        return nothing
+    end
+
+    taskBefore = copy(n.task)
+
+    if !((child_before in n.task.t1_inputs) || (child_before in n.task.t2_inputs))
+        println("------------------ Nothing to replace!! ------------------")
+        child_ids = Vector{String}()
+        for child in n.children
+            push!(child_ids, "$(child.id)")
+        end
+        println("From $(child_before) to $(child_after) in $n with children $(child_ids)")
+        @assert false
+    end
+
+    replace_children!(n.task, child_before, child_after)
+
+    if !((child_after in n.task.t1_inputs) || (child_after in n.task.t2_inputs))
+        println("------------------ Did not replace anything!! ------------------")
+        child_ids = Vector{String}()
+        for child in n.children
+            push!(child_ids, "$(child.id)")
+        end
+        println("From $(child_before) to $(child_after) in $n with children $(child_ids)")
+        @assert false
+    end
+
+    # keep track
+    if (track)
+        push!(graph.diff.updatedChildren, (n, taskBefore))
+    end
+end
+
+"""
+    get_snapshot_diff(graph::DAG)
+
+Return the graph's [`Diff`](@ref) since last time this function was called.
+
+See also: [`revert_diff!`](@ref), [`AppliedOperation`](@ref) and [`revert_operation!`](@ref)
+"""
 function get_snapshot_diff(graph::DAG)
     return swapfield!(graph, :diff, Diff())
 end
 
-# function to invalidate the operation caches for a given NodeFusion
+"""
+    invalidate_caches!(graph::DAG, operation::NodeFusion)
+
+Invalidate the operation caches for a given [`NodeFusion`](@ref).
+
+This deletes the operation from the graph's possible operations and from the involved nodes' own operation caches.
+"""
 function invalidate_caches!(graph::DAG, operation::NodeFusion)
     delete!(graph.possibleOperations, operation)
 
     # delete the operation from all caches of nodes involved in the operation
+    # TODO: filter is very slow
     filter!(!=(operation), operation.input[1].nodeFusions)
     filter!(!=(operation), operation.input[3].nodeFusions)
 
@@ -149,7 +250,13 @@ function invalidate_caches!(graph::DAG, operation::NodeFusion)
     return nothing
 end
 
-# function to invalidate the operation caches for a given NodeReduction
+"""
+    invalidate_caches!(graph::DAG, operation::NodeReduction)
+
+Invalidate the operation caches for a given [`NodeReduction`](@ref).
+
+This deletes the operation from the graph's possible operations and from the involved nodes' own operation caches.
+"""
 function invalidate_caches!(graph::DAG, operation::NodeReduction)
     delete!(graph.possibleOperations, operation)
 
@@ -160,7 +267,13 @@ function invalidate_caches!(graph::DAG, operation::NodeReduction)
     return nothing
 end
 
-# function to invalidate the operation caches for a given NodeSplit
+"""
+    invalidate_caches!(graph::DAG, operation::NodeSplit)
+
+Invalidate the operation caches for a given [`NodeSplit`](@ref).
+
+This deletes the operation from the graph's possible operations and from the involved nodes' own operation caches.
+"""
 function invalidate_caches!(graph::DAG, operation::NodeSplit)
     delete!(graph.possibleOperations, operation)
 
@@ -171,7 +284,11 @@ function invalidate_caches!(graph::DAG, operation::NodeSplit)
     return nothing
 end
 
-# function to invalidate the operation caches of a ComputeTaskNode
+"""
+    invalidate_operation_caches!(graph::DAG, node::ComputeTaskNode)
+
+Invalidate the operation caches of the given node through calls to the respective [`invalidate_caches!`](@ref) functions.
+"""
 function invalidate_operation_caches!(graph::DAG, node::ComputeTaskNode)
     if !ismissing(node.nodeReduction)
         invalidate_caches!(graph, node.nodeReduction)
@@ -185,7 +302,11 @@ function invalidate_operation_caches!(graph::DAG, node::ComputeTaskNode)
     return nothing
 end
 
-# function to invalidate the operation caches of a DataTaskNode
+"""
+    invalidate_operation_caches!(graph::DAG, node::DataTaskNode)
+
+Invalidate the operation caches of the given node through calls to the respective [`invalidate_caches!`](@ref) functions.
+"""
 function invalidate_operation_caches!(graph::DAG, node::DataTaskNode)
     if !ismissing(node.nodeReduction)
         invalidate_caches!(graph, node.nodeReduction)

src/graph/print.jl

@@ -1,4 +1,9 @@
-function show_nodes(io, graph::DAG)
+"""
+    show_nodes(io::IO, graph::DAG)
+
+Print a graph's nodes. Should only be used for small graphs as it prints every node in a list.
+"""
+function show_nodes(io::IO, graph::DAG)
     print(io, "[")
     first = true
     for n in graph.nodes
@@ -12,7 +17,13 @@ function show_nodes(io, graph::DAG)
     return print(io, "]")
 end
 
+"""
+    show(io::IO, graph::DAG)
+
+Print the given graph to io. If there are too many nodes it will print only a summary of them.
+"""
 function show(io::IO, graph::DAG)
+    apply_all!(graph)
     println(io, "Graph:")
     print(io, "  Nodes: ")
 
@@ -48,12 +59,8 @@ function show(io::IO, graph::DAG)
     end
     println(io)
     println(io, "  Edges: ", noEdges)
-    properties = graph_properties(graph)
-    println(io, "  Total Compute Effort: ", properties.compute_effort)
+    properties = get_properties(graph)
+    println(io, "  Total Compute Effort: ", properties.computeEffort)
     println(io, "  Total Data Transfer: ", properties.data)
-    return println(
-        io,
-        "  Total Compute Intensity: ",
-        properties.compute_intensity,
-    )
+    return println(io, "  Total Compute Intensity: ", properties.computeIntensity)
 end

src/graph/properties.jl

@@ -1,28 +1,24 @@
-function graph_properties(graph::DAG)
+"""
+    get_properties(graph::DAG)
+
+Return the graph's [`GraphProperties`](@ref).
+"""
+function get_properties(graph::DAG)
     # make sure the graph is fully generated
     apply_all!(graph)
 
-    d = 0
-    ce = 0
-    ed = 0
-    for node in graph.nodes
-        d += data(node.task) * length(node.parents)
-        ce += compute_effort(node.task)
-        ed += length(node.parents)
+    if (graph.properties.computeEffort == 0.0)
+        graph.properties = GraphProperties(graph)
     end
 
-    ci = ce / d
-
-    result = (
-        data = d,
-        compute_effort = ce,
-        compute_intensity = ci,
-        nodes = length(graph.nodes),
-        edges = ed,
-    )
-    return result
+    return graph.properties
 end
 
+"""
+    get_exit_node(graph::DAG)
+
+Return the graph's exit node. This assumes the graph only has a single exit node. If the graph has multiple exit nodes, the one encountered first will be returned.
+"""
 function get_exit_node(graph::DAG)
     for node in graph.nodes
         if (is_exit_node(node))
@@ -31,3 +27,19 @@ function get_exit_node(graph::DAG)
     end
     @assert false "The given graph has no exit node! It is either empty or not acyclic!"
 end
+
+"""
+    get_entry_nodes(graph::DAG)
+
+Return a vector of the graph's entry nodes.
+"""
+function get_entry_nodes(graph::DAG)
+    apply_all!(graph)
+    result = Vector{Node}()
+    for node in graph.nodes
+        if (is_entry_node(node))
+            push!(result, node)
+        end
+    end
+    return result
+end

src/graph/type.jl

@@ -1,21 +1,28 @@
 using DataStructures
 
+"""
+    PossibleOperations
+
+A struct storing all possible operations on a [`DAG`](@ref).
+To get the [`PossibleOperations`](@ref) on a [`DAG`](@ref), use [`get_operations`](@ref).
+"""
 mutable struct PossibleOperations
     nodeFusions::Set{NodeFusion}
     nodeReductions::Set{NodeReduction}
     nodeSplits::Set{NodeSplit}
 end
 
-function PossibleOperations()
-    return PossibleOperations(
-        Set{NodeFusion}(),
-        Set{NodeReduction}(),
-        Set{NodeSplit}(),
-    )
-end
+""" 
+    DAG
 
-# The actual state of the DAG is the initial state given by the set of nodes 
-# but with all the operations in appliedChain applied in order
+The representation of the graph as a set of [`Node`](@ref)s.
+
+A DAG can be loaded using the appropriate parse_dag function, e.g. [`parse_dag`](@ref).
+
+[`Operation`](@ref)s can be applied on it using [`push_operation!`](@ref) and reverted using [`pop_operation!`](@ref) like a stack.
+To get the set of possible operations, use [`get_operations`](@ref).
+The members of the object should not be manually accessed, instead always use the provided interface functions.
+"""
 mutable struct DAG
     nodes::Set{Node}
 
@@ -34,8 +41,25 @@ mutable struct DAG
     # "snapshot" system: keep track of added/removed nodes/edges since last snapshot
     # these are muted in insert_node! etc.
     diff::Diff
+
+    # the cached properties of the DAG
+    properties::GraphProperties
 end
 
+"""
+    PossibleOperations()
+
+Construct and return an empty [`PossibleOperations`](@ref) object.
+"""
+function PossibleOperations()
+    return PossibleOperations(Set{NodeFusion}(), Set{NodeReduction}(), Set{NodeSplit}())
+end
+
+"""
+    DAG()
+
+Construct and return an empty [`DAG`](@ref).
+"""
 function DAG()
     return DAG(
         Set{Node}(),
@@ -44,5 +68,6 @@ function DAG()
         PossibleOperations(),
         Set{Node}(),
         Diff(),
+        GraphProperties(),
     )
 end

src/graph/validate.jl

@@ -1,4 +1,8 @@
-# check whether the given graph is connected
+"""
+    is_connected(graph::DAG)
+
+Return whether the given graph is connected.
+"""
 function is_connected(graph::DAG)
     nodeQueue = Deque{Node}()
     push!(nodeQueue, get_exit_node(graph))
@@ -16,6 +20,11 @@ function is_connected(graph::DAG)
     return length(seenNodes) == length(graph.nodes)
 end
 
+"""
+    is_valid(graph::DAG)
+
+Validate the entire graph using asserts. Intended for testing with `@assert is_valid(graph)`.
+"""
 function is_valid(graph::DAG)
     for node in graph.nodes
         @assert is_valid(graph, node)
@@ -50,3 +59,19 @@ function is_valid(graph::DAG)
 
     return true
 end
+
+"""
+    is_scheduled(graph::DAG)
+
+Validate that the entire graph has been scheduled, i.e., every [`ComputeTaskNode`](@ref) has its `.device` set.
+"""
+function is_scheduled(graph::DAG)
+    for node in graph.nodes
+        if (node isa DataTaskNode)
+            continue
+        end
+        @assert !ismissing(node.device)
+    end
+
+    return true
+end

src/models/abc/compute.jl

@@ -0,0 +1,154 @@
+using AccurateArithmetic
+
+"""
+    compute(::ComputeTaskP, data::ParticleValue)
+
+Return the particle and value as is. 
+
+0 FLOP.
+"""
+function compute(::ComputeTaskP, data::ParticleValue)
+    return data
+end
+
+"""
+    compute(::ComputeTaskU, data::ParticleValue)
+
+Compute an outer edge. Return the particle value with the same particle and the value multiplied by an outer_edge factor.
+
+1 FLOP.
+"""
+function compute(::ComputeTaskU, data::ParticleValue)
+    return ParticleValue(data.p, data.v * outer_edge(data.p))
+end
+
+"""
+    compute(::ComputeTaskV, data1::ParticleValue, data2::ParticleValue)
+
+Compute a vertex. Preserve momentum and particle types (AB->C etc.) to create resulting particle, multiply values together and times a vertex factor.
+
+6 FLOP.
+"""
+function compute(::ComputeTaskV, data1::ParticleValue, data2::ParticleValue)
+    p3 = preserve_momentum(data1.p, data2.p)
+    dataOut = ParticleValue(p3, data1.v * vertex() * data2.v)
+    return dataOut
+end
+
+"""
+    compute(::ComputeTaskS2, data1::ParticleValue, data2::ParticleValue)
+
+Compute a final inner edge (2 input particles, no output particle).
+
+For valid inputs, both input particles should have the same momenta at this point.
+
+12 FLOP.
+"""
+function compute(::ComputeTaskS2, data1::ParticleValue, data2::ParticleValue)
+    #=
+    @assert isapprox(abs(data1.p.momentum.E), abs(data2.p.momentum.E), rtol = 0.001, atol = sqrt(eps())) "E: $(data1.p.momentum.E) vs. $(data2.p.momentum.E)"
+    @assert isapprox(data1.p.momentum.px, -data2.p.momentum.px, rtol = 0.001, atol = sqrt(eps())) "px: $(data1.p.momentum.px) vs. $(data2.p.momentum.px)"
+    @assert isapprox(data1.p.momentum.py, -data2.p.momentum.py, rtol = 0.001, atol = sqrt(eps())) "py: $(data1.p.momentum.py) vs. $(data2.p.momentum.py)"
+    @assert isapprox(data1.p.momentum.pz, -data2.p.momentum.pz, rtol = 0.001, atol = sqrt(eps())) "pz: $(data1.p.momentum.pz) vs. $(data2.p.momentum.pz)"
+    =#
+    return data1.v * inner_edge(data1.p) * data2.v
+end
+
+"""
+    compute(::ComputeTaskS1, data::ParticleValue)
+
+Compute inner edge (1 input particle, 1 output particle).
+
+11 FLOP.
+"""
+function compute(::ComputeTaskS1, data::ParticleValue)
+    return ParticleValue(data.p, data.v * inner_edge(data.p))
+end
+
+"""
+    compute(::ComputeTaskSum, data::Vector{Float64})
+
+Compute a sum over the vector. Use an algorithm that accounts for accumulated errors in long sums with potentially large differences in magnitude of the summands.
+
+Linearly many FLOP with growing data.
+"""
+function compute(::ComputeTaskSum, data::Vector{Float64})
+    return sum_kbn(data)
+end
+
+"""
+    get_expression(::ComputeTaskP, device::AbstractDevice, inExprs::Vector{Expr}, outExpr::Expr)
+
+Generate and return code evaluating [`ComputeTaskP`](@ref) on `inSyms`, providing the output on `outSym`.
+"""
+function get_expression(::ComputeTaskP, device::AbstractDevice, inExprs::Vector, outExpr)
+    in = [eval(inExprs[1])]
+    out = eval(outExpr)
+
+    return Meta.parse("$out = compute(ComputeTaskP(), $(in[1]))")
+end
+
+"""
+    get_expression(::ComputeTaskU, device::AbstractDevice, inExprs::Vector{Expr}, outExpr::Expr)
+
+Generate code evaluating [`ComputeTaskU`](@ref) on `inSyms`, providing the output on `outSym`.
+`inSyms` should be of type [`ParticleValue`](@ref), `outSym` will be of type [`ParticleValue`](@ref).
+"""
+function get_expression(::ComputeTaskU, device::AbstractDevice, inExprs::Vector, outExpr)
+    in = [eval(inExprs[1])]
+    out = eval(outExpr)
+
+    return Meta.parse("$out = compute(ComputeTaskU(), $(in[1]))")
+end
+
+"""
+    get_expression(::ComputeTaskV, device::AbstractDevice, inExprs::Vector{Expr}, outExpr::Expr)
+
+Generate code evaluating [`ComputeTaskV`](@ref) on `inSyms`, providing the output on `outSym`.
+`inSym[1]` and `inSym[2]` should be of type [`ParticleValue`](@ref), `outSym` will be of type [`ParticleValue`](@ref).
+"""
+function get_expression(::ComputeTaskV, device::AbstractDevice, inExprs::Vector, outExpr)
+    in = [eval(inExprs[1]), eval(inExprs[2])]
+    out = eval(outExpr)
+
+    return Meta.parse("$out = compute(ComputeTaskV(), $(in[1]), $(in[2]))")
+end
+
+"""
+    get_expression(::ComputeTaskS2, device::AbstractDevice, inExprs::Vector{Expr}, outExpr::Expr)
+
+Generate code evaluating [`ComputeTaskS2`](@ref) on `inSyms`, providing the output on `outSym`.
+`inSyms[1]` and `inSyms[2]` should be of type [`ParticleValue`](@ref), `outSym` will be of type `Float64`.
+"""
+function get_expression(::ComputeTaskS2, device::AbstractDevice, inExprs::Vector, outExpr)
+    in = [eval(inExprs[1]), eval(inExprs[2])]
+    out = eval(outExpr)
+
+    return Meta.parse("$out = compute(ComputeTaskS2(), $(in[1]), $(in[2]))")
+end
+
+"""
+    get_expression(::ComputeTaskS1, device::AbstractDevice, inExprs::Vector{Expr}, outExpr::Expr)
+
+Generate code evaluating [`ComputeTaskS1`](@ref) on `inSyms`, providing the output on `outSym`.
+`inSyms` should be of type [`ParticleValue`](@ref), `outSym` will be of type [`ParticleValue`](@ref).
+"""
+function get_expression(::ComputeTaskS1, device::AbstractDevice, inExprs::Vector, outExpr)
+    in = [eval(inExprs[1])]
+    out = eval(outExpr)
+
+    return Meta.parse("$out = compute(ComputeTaskS1(), $(in[1]))")
+end
+
+"""
+    get_expression(::ComputeTaskSum, device::AbstractDevice, inExprs::Vector{Expr}, outExpr::Expr)
+
+Generate code evaluating [`ComputeTaskSum`](@ref) on `inSyms`, providing the output on `outSym`.
+`inSyms` should be of type [`Float64`], `outSym` will be of type [`Float64`].
+"""
+function get_expression(::ComputeTaskSum, device::AbstractDevice, inExprs::Vector, outExpr)
+    in = eval.(inExprs)
+    out = eval(outExpr)
+
+    return Meta.parse("$out = compute(ComputeTaskSum(), [$(unroll_symbol_vector(in))])")
+end

src/models/abc/create.jl

@@ -0,0 +1,198 @@
+using QEDbase
+using Random
+using Roots
+using ForwardDiff
+
+ComputeTaskSum() = ComputeTaskSum(0)
+
+"""
+    gen_process_input(processDescription::ABCProcessDescription)
+
+Return a ProcessInput of randomly generated [`ABCParticle`](@ref)s from a [`ABCProcessDescription`](@ref). The process description can be created manually or parsed from a string using [`parse_process`](@ref).
+
+Note: This uses RAMBO to create a valid process with conservation of momentum and energy.
+"""
+function gen_process_input(processDescription::ABCProcessDescription)
+    inParticleTypes = keys(processDescription.inParticles)
+    outParticleTypes = keys(processDescription.outParticles)
+
+    massSum = 0
+    inputMasses = Vector{Float64}()
+    for (particle, n) in processDescription.inParticles
+        for _ in 1:n
+            massSum += mass(particle)
+            push!(inputMasses, mass(particle))
+        end
+    end
+    outputMasses = Vector{Float64}()
+    for (particle, n) in processDescription.outParticles
+        for _ in 1:n
+            massSum += mass(particle)
+            push!(outputMasses, mass(particle))
+        end
+    end
+
+    # add some extra random mass to allow for some momentum
+    massSum += rand(rng[threadid()]) * (length(inputMasses) + length(outputMasses))
+
+
+    inputParticles = Vector{ABCParticle}()
+    initialMomenta = generate_initial_moms(massSum, inputMasses)
+    index = 1
+    for (particle, n) in processDescription.inParticles
+        for _ in 1:n
+            mom = initialMomenta[index]
+            push!(inputParticles, particle(mom))
+            index += 1
+        end
+    end
+
+    outputParticles = Vector{ABCParticle}()
+    final_momenta = generate_physical_massive_moms(rng[threadid()], massSum, outputMasses)
+    index = 1
+    for (particle, n) in processDescription.outParticles
+        for _ in 1:n
+            mom = final_momenta[index]
+            push!(outputParticles, particle(SFourMomentum(-mom.E, mom.px, mom.py, mom.pz)))
+            index += 1
+        end
+    end
+
+    processInput = ABCProcessInput(processDescription, inputParticles, outputParticles)
+
+    return return processInput
+end
+
+####################
+# CODE FROM HERE BORROWED FROM SOURCE: https://codebase.helmholtz.cloud/qedsandbox/QEDphasespaces.jl/
+# use qedphasespaces directly once released
+#
+# quick and dirty implementation of the RAMBO algorithm
+#
+# reference: 
+# * https://cds.cern.ch/record/164736/files/198601282.pdf
+# * https://www.sciencedirect.com/science/article/pii/0010465586901190
+####################
+
+function generate_initial_moms(ss, masses)
+    E1 = (ss^2 + masses[1]^2 - masses[2]^2) / (2 * ss)
+    E2 = (ss^2 + masses[2]^2 - masses[1]^2) / (2 * ss)
+
+    rho1 = sqrt(E1^2 - masses[1]^2)
+    rho2 = sqrt(E2^2 - masses[2]^2)
+
+    return [SFourMomentum(E1, 0, 0, rho1), SFourMomentum(E2, 0, 0, -rho2)]
+end
+
+
+Random.rand(rng::AbstractRNG, ::Random.SamplerType{SFourMomentum}) = SFourMomentum(rand(rng, 4))
+Random.rand(rng::AbstractRNG, ::Random.SamplerType{NTuple{N, Float64}}) where {N} = Tuple(rand(rng, N))
+
+
+function _transform_uni_to_mom(u1, u2, u3, u4)
+    cth = 2 * u1 - 1
+    sth = sqrt(1 - cth^2)
+    phi = 2 * pi * u2
+    q0 = -log(u3 * u4)
+    qx = q0 * sth * cos(phi)
+    qy = q0 * sth * sin(phi)
+    qz = q0 * cth
+
+    return SFourMomentum(q0, qx, qy, qz)
+end
+
+function _transform_uni_to_mom!(uni_mom, dest)
+    u1, u2, u3, u4 = Tuple(uni_mom)
+    cth = 2 * u1 - 1
+    sth = sqrt(1 - cth^2)
+    phi = 2 * pi * u2
+    q0 = -log(u3 * u4)
+    qx = q0 * sth * cos(phi)
+    qy = q0 * sth * sin(phi)
+    qz = q0 * cth
+
+    return dest = SFourMomentum(q0, qx, qy, qz)
+end
+
+_transform_uni_to_mom(u1234::Tuple) = _transform_uni_to_mom(u1234...)
+_transform_uni_to_mom(u1234::SFourMomentum) = _transform_uni_to_mom(Tuple(u1234))
+
+function generate_massless_moms(rng, n::Int)
+    a = Vector{SFourMomentum}(undef, n)
+    rand!(rng, a)
+    return map(_transform_uni_to_mom, a)
+end
+
+function generate_physical_massless_moms(rng, ss, n)
+    r_moms = generate_massless_moms(rng, n)
+    Q = sum(r_moms)
+    M = sqrt(Q * Q)
+    fac = -1 / M
+    Qx = getX(Q)
+    Qy = getY(Q)
+    Qz = getZ(Q)
+    bx = fac * Qx
+    by = fac * Qy
+    bz = fac * Qz
+    gamma = getT(Q) / M
+    a = 1 / (1 + gamma)
+    x = ss / M
+
+    i = 1
+    while i <= n
+        mom = r_moms[i]
+        mom0 = getT(mom)
+        mom1 = getX(mom)
+        mom2 = getY(mom)
+        mom3 = getZ(mom)
+
+        bq = bx * mom1 + by * mom2 + bz * mom3
+
+        p0 = x * (gamma * mom0 + bq)
+        px = x * (mom1 + bx * mom0 + a * bq * bx)
+        py = x * (mom2 + by * mom0 + a * bq * by)
+        pz = x * (mom3 + bz * mom0 + a * bq * bz)
+
+        r_moms[i] = SFourMomentum(p0, px, py, pz)
+        i += 1
+    end
+    return r_moms
+end
+
+function _to_be_solved(xi, masses, p0s, ss)
+    sum = 0.0
+    for (i, E) in enumerate(p0s)
+        sum += sqrt(masses[i]^2 + xi^2 * E^2)
+    end
+    return sum - ss
+end
+
+function _build_massive_momenta(xi, masses, massless_moms)
+    vec = SFourMomentum[]
+    i = 1
+    while i <= length(massless_moms)
+        massless_mom = massless_moms[i]
+        k0 = sqrt(getT(massless_mom)^2 * xi^2 + masses[i]^2)
+
+        kx = xi * getX(massless_mom)
+        ky = xi * getY(massless_mom)
+        kz = xi * getZ(massless_mom)
+
+        push!(vec, SFourMomentum(k0, kx, ky, kz))
+
+        i += 1
+    end
+    return vec
+end
+
+first_derivative(func) = x -> ForwardDiff.derivative(func, float(x))
+
+
+function generate_physical_massive_moms(rng, ss, masses; x0 = 0.1)
+    n = length(masses)
+    massless_moms = generate_physical_massless_moms(rng, ss, n)
+    energies = getT.(massless_moms)
+    f = x -> _to_be_solved(x, masses, energies, ss)
+    xi = find_zero((f, first_derivative(f)), x0, Roots.Newton())
+    return _build_massive_momenta(xi, masses, massless_moms)
+end

src/models/abc/parse.jl

@@ -1,11 +1,17 @@
-using Printf
-
 # functions for importing DAGs from a file
 regex_a = r"^[A-C]\d+$"                     # Regex for the initial particles
 regex_c = r"^[A-C]\(([^']*),([^']*)\)$"     # Regex for the combinations of 2 particles
 regex_m = r"^M\(([^']*),([^']*),([^']*)\)$" # Regex for the combinations of 3 particles
 regex_plus = r"^\+$"                        # Regex for the sum
 
+const PARTICLE_VALUE_SIZE::Int = 48
+const FLOAT_SIZE::Int = 8
+
+"""
+    parse_nodes(input::AbstractString)
+
+Parse the given string into a vector of strings containing each node.
+"""
 function parse_nodes(input::AbstractString)
     regex = r"'([^']*)'"
     matches = eachmatch(regex, input)
@@ -13,6 +19,11 @@ function parse_nodes(input::AbstractString)
     return output
 end
 
+"""
+    parse_edges(input::AbstractString)
+
+Parse the given string into a vector of strings containing each edge. Currently unused since the entire graph can be read from just the node names.
+"""
 function parse_edges(input::AbstractString)
     regex = r"\('([^']*)', '([^']*)'\)"
     matches = eachmatch(regex, input)
@@ -20,8 +31,14 @@ function parse_edges(input::AbstractString)
     return output
 end
 
-# reads an abc-model process from the given file
-function parse_abc(filename::String, verbose::Bool = false)
+"""
+    parse_dag(filename::String, model::ABCModel; verbose::Bool = false)
+
+Read an abc-model process from the given file. If `verbose` is set to true, print some progress information to stdout.
+
+Returns a valid [`DAG`](@ref).
+"""
+function parse_dag(filename::AbstractString, model::ABCModel, verbose::Bool = false)
     file = open(filename, "r")
 
     if (verbose)
@@ -46,9 +63,9 @@ function parse_abc(filename::String, verbose::Bool = false)
     end
     sizehint!(graph.nodes, estimate_no_nodes)
 
-    sum_node = insert_node!(graph, make_node(ComputeTaskSum()), false, false)
-    global_data_out = insert_node!(graph, make_node(DataTask(10)), false, false)
-    insert_edge!(graph, sum_node, global_data_out, false, false)
+    sum_node = insert_node!(graph, make_node(ComputeTaskSum(0)), track = false, invalidate_cache = false)
+    global_data_out = insert_node!(graph, make_node(DataTask(FLOAT_SIZE)), track = false, invalidate_cache = false)
+    insert_edge!(graph, sum_node, global_data_out, track = false, invalidate_cache = false)
 
     # remember the data out nodes for connection
     dataOutNodes = Dict()
@@ -63,25 +80,29 @@ function parse_abc(filename::String, verbose::Bool = false)
         noNodes += 1
         if (noNodes % 100 == 0)
             if (verbose)
-                @printf "\rReading Nodes... %.2f%%" (
-                    100.0 * noNodes / nodesToRead
-                )
+                percent = string(round(100.0 * noNodes / nodesToRead, digits = 2), "%")
+                print("\rReading Nodes... $percent")
             end
         end
         if occursin(regex_a, node)
             # add nodes and edges for the state reading to u(P(Particle))
-            data_in = insert_node!(graph, make_node(DataTask(4)), false, false) # read particle data node
-            compute_P =
-                insert_node!(graph, make_node(ComputeTaskP()), false, false) # compute P node
-            data_Pu = insert_node!(graph, make_node(DataTask(6)), false, false) # transfer data from P to u
-            compute_u =
-                insert_node!(graph, make_node(ComputeTaskU()), false, false) # compute U node
-            data_out = insert_node!(graph, make_node(DataTask(3)), false, false) # transfer data out from u
+            data_in = insert_node!(
+                graph,
+                make_node(DataTask(PARTICLE_VALUE_SIZE), string(node)),
+                track = false,
+                invalidate_cache = false,
+            ) # read particle data node
+            compute_P = insert_node!(graph, make_node(ComputeTaskP()), track = false, invalidate_cache = false) # compute P node
+            data_Pu =
+                insert_node!(graph, make_node(DataTask(PARTICLE_VALUE_SIZE)), track = false, invalidate_cache = false) # transfer data from P to u (one ParticleValue object)
+            compute_u = insert_node!(graph, make_node(ComputeTaskU()), track = false, invalidate_cache = false) # compute U node
+            data_out =
+                insert_node!(graph, make_node(DataTask(PARTICLE_VALUE_SIZE)), track = false, invalidate_cache = false) # transfer data out from u (one ParticleValue object)
 
-            insert_edge!(graph, data_in, compute_P, false, false)
-            insert_edge!(graph, compute_P, data_Pu, false, false)
-            insert_edge!(graph, data_Pu, compute_u, false, false)
-            insert_edge!(graph, compute_u, data_out, false, false)
+            insert_edge!(graph, data_in, compute_P, track = false, invalidate_cache = false)
+            insert_edge!(graph, compute_P, data_Pu, track = false, invalidate_cache = false)
+            insert_edge!(graph, data_Pu, compute_u, track = false, invalidate_cache = false)
+            insert_edge!(graph, compute_u, data_out, track = false, invalidate_cache = false)
 
             # remember the data_out node for future edges
             dataOutNodes[node] = data_out
@@ -91,50 +112,48 @@ function parse_abc(filename::String, verbose::Bool = false)
             in1 = capt.captures[1]
             in2 = capt.captures[2]
 
-            compute_v =
-                insert_node!(graph, make_node(ComputeTaskV()), false, false)
-            data_out = insert_node!(graph, make_node(DataTask(5)), false, false)
+            compute_v = insert_node!(graph, make_node(ComputeTaskV()), track = false, invalidate_cache = false)
+            data_out =
+                insert_node!(graph, make_node(DataTask(PARTICLE_VALUE_SIZE)), track = false, invalidate_cache = false)
 
             if (occursin(regex_c, in1))
                 # put an S node after this input
-                compute_S = insert_node!(
+                compute_S = insert_node!(graph, make_node(ComputeTaskS1()), track = false, invalidate_cache = false)
+                data_S_v = insert_node!(
                     graph,
-                    make_node(ComputeTaskS1()),
-                    false,
-                    false,
+                    make_node(DataTask(PARTICLE_VALUE_SIZE)),
+                    track = false,
+                    invalidate_cache = false,
                 )
-                data_S_v =
-                    insert_node!(graph, make_node(DataTask(5)), false, false)
 
-                insert_edge!(graph, dataOutNodes[in1], compute_S, false, false)
-                insert_edge!(graph, compute_S, data_S_v, false, false)
+                insert_edge!(graph, dataOutNodes[in1], compute_S, track = false, invalidate_cache = false)
+                insert_edge!(graph, compute_S, data_S_v, track = false, invalidate_cache = false)
 
-                insert_edge!(graph, data_S_v, compute_v, false, false)
+                insert_edge!(graph, data_S_v, compute_v, track = false, invalidate_cache = false)
             else
-                insert_edge!(graph, dataOutNodes[in1], compute_v, false, false)
+                insert_edge!(graph, dataOutNodes[in1], compute_v, track = false, invalidate_cache = false)
             end
 
             if (occursin(regex_c, in2))
                 # i think the current generator only puts the combined particles in the first space, so this case might never be entered
                 # put an S node after this input
-                compute_S = insert_node!(
+                compute_S = insert_node!(graph, make_node(ComputeTaskS1()), track = false, invalidate_cache = false)
+                data_S_v = insert_node!(
                     graph,
-                    make_node(ComputeTaskS1()),
-                    false,
-                    false,
+                    make_node(DataTask(PARTICLE_VALUE_SIZE)),
+                    track = false,
+                    invalidate_cache = false,
                 )
-                data_S_v =
-                    insert_node!(graph, make_node(DataTask(5)), false, false)
 
-                insert_edge!(graph, dataOutNodes[in2], compute_S, false, false)
-                insert_edge!(graph, compute_S, data_S_v, false, false)
+                insert_edge!(graph, dataOutNodes[in2], compute_S, track = false, invalidate_cache = false)
+                insert_edge!(graph, compute_S, data_S_v, track = false, invalidate_cache = false)
 
-                insert_edge!(graph, data_S_v, compute_v, false, false)
+                insert_edge!(graph, data_S_v, compute_v, track = false, invalidate_cache = false)
             else
-                insert_edge!(graph, dataOutNodes[in2], compute_v, false, false)
+                insert_edge!(graph, dataOutNodes[in2], compute_v, track = false, invalidate_cache = false)
             end
 
-            insert_edge!(graph, compute_v, data_out, false, false)
+            insert_edge!(graph, compute_v, data_out, track = false, invalidate_cache = false)
             dataOutNodes[node] = data_out
 
         elseif occursin(regex_m, node)
@@ -145,40 +164,85 @@ function parse_abc(filename::String, verbose::Bool = false)
             in3 = capt.captures[3]
 
             # in2 + in3 with a v
-            compute_v =
-                insert_node!(graph, make_node(ComputeTaskV()), false, false)
-            data_v = insert_node!(graph, make_node(DataTask(5)), false, false)
+            compute_v = insert_node!(graph, make_node(ComputeTaskV()), track = false, invalidate_cache = false)
+            data_v =
+                insert_node!(graph, make_node(DataTask(PARTICLE_VALUE_SIZE)), track = false, invalidate_cache = false)
 
-            insert_edge!(graph, dataOutNodes[in2], compute_v, false, false)
-            insert_edge!(graph, dataOutNodes[in3], compute_v, false, false)
-            insert_edge!(graph, compute_v, data_v, false, false)
+            insert_edge!(graph, dataOutNodes[in2], compute_v, track = false, invalidate_cache = false)
+            insert_edge!(graph, dataOutNodes[in3], compute_v, track = false, invalidate_cache = false)
+            insert_edge!(graph, compute_v, data_v, track = false, invalidate_cache = false)
 
             # combine with the v of the combined other input
-            compute_S2 =
-                insert_node!(graph, make_node(ComputeTaskS2()), false, false)
-            data_out =
-                insert_node!(graph, make_node(DataTask(10)), false, false)
+            compute_S2 = insert_node!(graph, make_node(ComputeTaskS2()), track = false, invalidate_cache = false)
+            data_out = insert_node!(graph, make_node(DataTask(FLOAT_SIZE)), track = false, invalidate_cache = false) # output of a S2 task is only a float
 
-            insert_edge!(graph, data_v, compute_S2, false, false)
-            insert_edge!(graph, dataOutNodes[in1], compute_S2, false, false)
-            insert_edge!(graph, compute_S2, data_out, false, false)
+            insert_edge!(graph, data_v, compute_S2, track = false, invalidate_cache = false)
+            insert_edge!(graph, dataOutNodes[in1], compute_S2, track = false, invalidate_cache = false)
+            insert_edge!(graph, compute_S2, data_out, track = false, invalidate_cache = false)
 
-            insert_edge!(graph, data_out, sum_node, false, false)
+            insert_edge!(graph, data_out, sum_node, track = false, invalidate_cache = false)
+            add_child!(sum_node.task)
         elseif occursin(regex_plus, node)
             if (verbose)
                 println("\rReading Nodes Complete    ")
                 println("Added ", length(graph.nodes), " nodes")
             end
         else
-            @assert false (
-                "Unknown node '$node' while reading from file $filename"
-            )
+            @assert false ("Unknown node '$node' while reading from file $filename")
         end
     end
 
     #put all nodes into dirty nodes set
     graph.dirtyNodes = copy(graph.nodes)
 
+    if (verbose)
+        println("Generating the graph's properties")
+    end
+    graph.properties = GraphProperties(graph)
+
+    if (verbose)
+        println("Done")
+    end
+
     # don't actually need to read the edges
     return graph
 end
+
+"""
+    parse_process(string::AbstractString, model::ABCModel)
+
+Parse a string representation of a process, such as "AB->ABBB" into the corresponding [`ABCProcessDescription`](@ref).
+"""
+function parse_process(str::AbstractString, model::ABCModel)
+    inParticles = Dict{Type, Int}()
+    outParticles = Dict{Type, Int}()
+
+    if !(contains(str, "->"))
+        throw("Did not find -> while parsing process \"$str\"")
+    end
+
+    (inStr, outStr) = split(str, "->")
+
+    if (isempty(inStr) || isempty(outStr))
+        throw("Process (\"$str\") input or output part is empty!")
+    end
+
+    for t in types(model)
+        inCount = count(x -> x == String(t)[1], inStr)
+        outCount = count(x -> x == String(t)[1], outStr)
+        if inCount != 0
+            inParticles[t] = inCount
+        end
+        if outCount != 0
+            outParticles[t] = outCount
+        end
+    end
+
+    if length(inStr) != sum(values(inParticles))
+        throw("Encountered unknown characters in the input part of process \"$str\"")
+    elseif length(outStr) != sum(values(outParticles))
+        throw("Encountered unknown characters in the output part of process \"$str\"")
+    end
+
+    return ABCProcessDescription(inParticles, outParticles)
+end

src/models/abc/particle.jl

@@ -0,0 +1,209 @@
+using QEDbase
+
+"""
+    ABCModel <: AbstractPhysicsModel
+
+Singleton definition for identification of the ABC-Model.
+"""
+struct ABCModel <: AbstractPhysicsModel end
+
+"""
+    ABCParticle
+
+Base type for all particles in the [`ABCModel`](@ref).
+"""
+abstract type ABCParticle <: AbstractParticle end
+
+"""
+    ParticleA <: ABCParticle
+
+An 'A' particle in the ABC Model.
+"""
+struct ParticleA <: ABCParticle
+    momentum::SFourMomentum
+end
+
+"""
+    ParticleB <: ABCParticle
+
+A 'B' particle in the ABC Model.
+"""
+struct ParticleB <: ABCParticle
+    momentum::SFourMomentum
+end
+
+"""
+    ParticleC <: ABCParticle
+
+A 'C' particle in the ABC Model.
+"""
+struct ParticleC <: ABCParticle
+    momentum::SFourMomentum
+end
+
+"""
+    ABCProcessDescription <: AbstractProcessDescription
+
+A description of a process in the ABC-Model. Contains the input and output particles.
+
+See also: [`in_particles`](@ref), [`out_particles`](@ref), [`parse_process`](@ref)
+"""
+struct ABCProcessDescription <: AbstractProcessDescription
+    inParticles::Dict{Type, Int}
+    outParticles::Dict{Type, Int}
+end
+
+"""
+    ABCProcessInput <: AbstractProcessInput
+
+Input for a ABC Process. Contains the [`ABCProcessDescription`](@ref) of the process it is an input for, and the values of the in and out particles.
+
+See also: [`gen_process_input`](@ref)
+"""
+struct ABCProcessInput <: AbstractProcessInput
+    process::ABCProcessDescription
+    inParticles::Vector{ABCParticle}
+    outParticles::Vector{ABCParticle}
+end
+
+"""
+    PARTICLE_MASSES
+
+A constant dictionary containing the masses of the different [`ABCParticle`](@ref)s.
+"""
+const PARTICLE_MASSES = Dict{Type, Float64}(ParticleA => 1.0, ParticleB => 1.0, ParticleC => 0.0)
+
+"""
+    mass(t::Type{T}) where {T <: ABCParticle}
+    
+Return the mass (at rest) of the given particle type.
+"""
+mass(t::Type{T}) where {T <: ABCParticle} = PARTICLE_MASSES[t]
+
+"""
+    interaction_result(t1::Type{T1}, t2::Type{T2}) where {T1 <: ABCParticle, T2 <: ABCParticle}
+
+For 2 given (non-equal) particle types, return the third of ABC.
+"""
+function interaction_result(t1::Type{T1}, t2::Type{T2}) where {T1 <: ABCParticle, T2 <: ABCParticle}
+    @assert t1 != t2
+    if t1 != Type{ParticleA} && t2 != Type{ParticleA}
+        return ParticleA
+    elseif t1 != Type{ParticleB} && t2 != Type{ParticleB}
+        return ParticleB
+    else
+        return ParticleC
+    end
+end
+
+"""
+    types(::ABCModel)
+
+Return a Vector of the possible types of particle in the [`ABCModel`](@ref).
+"""
+function types(::ABCModel)
+    return [ParticleA, ParticleB, ParticleC]
+end
+
+"""
+    square(p::ABCParticle)
+
+Return the square of the particle's momentum as a `Float` value.
+
+Takes 7 effective FLOP.
+"""
+function square(p::ABCParticle)
+    return getMass2(p.momentum)
+end
+
+"""
+    inner_edge(p::ABCParticle)
+
+Return the factor of the inner edge with the given (virtual) particle.
+
+Takes 10 effective FLOP. (3 here + 7 in square(p))
+"""
+function inner_edge(p::ABCParticle)
+    return 1.0 / (square(p) - mass(typeof(p)) * mass(typeof(p)))
+end
+
+"""
+    outer_edge(p::ABCParticle)
+
+Return the factor of the outer edge with the given (real) particle.
+
+Takes 0 effective FLOP.
+"""
+function outer_edge(p::ABCParticle)
+    return 1.0
+end
+
+"""
+    vertex()
+
+Return the factor of a vertex.
+
+Takes 0 effective FLOP since it's constant.
+"""
+function vertex()
+    i = 1.0
+    lambda = 1.0 / 137.0
+    return i * lambda
+end
+
+"""
+    preserve_momentum(p1::ABCParticle, p2::ABCParticle)
+
+Calculate and return a new particle from two given interacting ones at a vertex.
+
+Takes 4 effective FLOP.
+"""
+function preserve_momentum(p1::ABCParticle, p2::ABCParticle)
+    t3 = interaction_result(typeof(p1), typeof(p2))
+    p3 = t3(p1.momentum + p2.momentum)
+
+    return p3
+end
+
+"""
+    type_from_name(name::String)
+
+For a name of a particle, return the particle's [`Type`].
+"""
+function type_from_name(name::String)
+    if startswith(name, "A")
+        return ParticleA
+    elseif startswith(name, "B")
+        return ParticleB
+    elseif startswith(name, "C")
+        return ParticleC
+    else
+        throw("Invalid name for a particle in the ABC model")
+    end
+end
+
+function String(::Type{ParticleA})
+    return "A"
+end
+function String(::Type{ParticleB})
+    return "B"
+end
+function String(::Type{ParticleC})
+    return "C"
+end
+
+function in_particles(process::ABCProcessDescription)
+    return process.inParticles
+end
+
+function in_particles(input::ABCProcessInput)
+    return input.inParticles
+end
+
+function out_particles(process::ABCProcessDescription)
+    return process.outParticles
+end
+
+function out_particles(input::ABCProcessInput)
+    return input.outParticles
+end

src/models/abc/print.jl

@@ -0,0 +1,58 @@
+
+"""
+    show(io::IO, process::ABCProcessDescription)
+
+Pretty print an [`ABCProcessDescription`](@ref) (no newlines).
+
+```jldoctest
+julia> using MetagraphOptimization
+
+julia> print(parse_process("AB->ABBB", ABCModel()))
+ABC Process: 'AB->ABBB'
+```
+"""
+function show(io::IO, process::ABCProcessDescription)
+    # types() gives the types in order (ABC) instead of random like keys() would
+    print(io, "ABC Process: \'")
+    for type in types(ABCModel())
+        for _ in 1:get(process.inParticles, type, 0)
+            print(io, String(type))
+        end
+    end
+    print(io, "->")
+    for type in types(ABCModel())
+        for _ in 1:get(process.outParticles, type, 0)
+            print(io, String(type))
+        end
+    end
+    print(io, "'")
+    return nothing
+end
+
+"""
+    show(io::IO, processInput::ABCProcessInput)
+
+Pretty print an [`ABCProcessInput`](@ref) (with newlines).
+"""
+function show(io::IO, processInput::ABCProcessInput)
+    println(io, "Input for $(processInput.process):")
+    println(io, "  $(length(processInput.inParticles)) Incoming particles:")
+    for particle in processInput.inParticles
+        println(io, "    $particle")
+    end
+    println(io, "  $(length(processInput.outParticles)) Outgoing Particles:")
+    for particle in processInput.outParticles
+        println(io, "    $particle")
+    end
+    return nothing
+end
+
+"""
+    show(io::IO, particle::T) where {T <: ABCParticle}
+
+Pretty print an [`ABCParticle`](@ref) (no newlines).
+"""
+function show(io::IO, particle::T) where {T <: ABCParticle}
+    print(io, "$(String(typeof(particle))): $(particle.momentum)")
+    return nothing
+end

src/models/abc/properties.jl

@@ -1,21 +1,166 @@
-# define compute_efforts tasks computation
-# put some "random" numbers here for now
-compute_effort(t::ComputeTaskS1) = 10
-compute_effort(t::ComputeTaskS2) = 10
-compute_effort(t::ComputeTaskU) = 6
-compute_effort(t::ComputeTaskV) = 20
-compute_effort(t::ComputeTaskP) = 15
+"""
+    compute_effort(t::ComputeTaskS1)
+
+Return the compute effort of an S1 task.
+"""
+compute_effort(t::ComputeTaskS1) = 11
+
+"""
+    compute_effort(t::ComputeTaskS2)
+
+Return the compute effort of an S2 task.
+"""
+compute_effort(t::ComputeTaskS2) = 12
+
+"""
+    compute_effort(t::ComputeTaskU)
+
+Return the compute effort of a U task.
+"""
+compute_effort(t::ComputeTaskU) = 1
+
+"""
+    compute_effort(t::ComputeTaskV)
+
+Return the compute effort of a V task.
+"""
+compute_effort(t::ComputeTaskV) = 6
+
+"""
+    compute_effort(t::ComputeTaskP)
+
+Return the compute effort of a P task.
+"""
+compute_effort(t::ComputeTaskP) = 0
+
+"""
+    compute_effort(t::ComputeTaskSum)
+
+Return the compute effort of a Sum task. 
+
+Note: This is a constant compute effort, even though sum scales with the number of its inputs. Since there is only ever a single sum node in a graph generated from the ABC-Model,
+this doesn't matter.
+"""
 compute_effort(t::ComputeTaskSum) = 1
 
+"""
+    show(io::IO, t::DataTask)
+
+Print the data task to io.
+"""
 function show(io::IO, t::DataTask)
     return print(io, "Data", t.data)
 end
 
-show(io::IO, t::ComputeTaskS1) = print("ComputeS1")
-show(io::IO, t::ComputeTaskS2) = print("ComputeS2")
-show(io::IO, t::ComputeTaskP) = print("ComputeP")
-show(io::IO, t::ComputeTaskU) = print("ComputeU")
-show(io::IO, t::ComputeTaskV) = print("ComputeV")
-show(io::IO, t::ComputeTaskSum) = print("ComputeSum")
+"""
+    show(io::IO, t::ComputeTaskS1)
 
+Print the S1 task to io.
+"""
+show(io::IO, t::ComputeTaskS1) = print(io, "ComputeS1")
+
+"""
+    show(io::IO, t::ComputeTaskS2)
+
+Print the S2 task to io.
+"""
+show(io::IO, t::ComputeTaskS2) = print(io, "ComputeS2")
+
+"""
+    show(io::IO, t::ComputeTaskP)
+
+Print the P task to io.
+"""
+show(io::IO, t::ComputeTaskP) = print(io, "ComputeP")
+
+"""
+    show(io::IO, t::ComputeTaskU)
+
+Print the U task to io.
+"""
+show(io::IO, t::ComputeTaskU) = print(io, "ComputeU")
+
+"""
+    show(io::IO, t::ComputeTaskV)
+
+Print the V task to io.
+"""
+show(io::IO, t::ComputeTaskV) = print(io, "ComputeV")
+
+"""
+    show(io::IO, t::ComputeTaskSum)
+
+Print the sum task to io.
+"""
+show(io::IO, t::ComputeTaskSum) = print(io, "ComputeSum")
+
+"""
+    copy(t::DataTask)
+
+Copy the data task and return it.
+"""
 copy(t::DataTask) = DataTask(t.data)
+
+"""
+    children(::DataTask)
+
+Return the number of children of a data task (always 1).
+"""
+children(::DataTask) = 1
+
+"""
+    children(::ComputeTaskS1)
+
+Return the number of children of a ComputeTaskS1 (always 1).
+"""
+children(::ComputeTaskS1) = 1
+
+"""
+    children(::ComputeTaskS2)
+
+Return the number of children of a ComputeTaskS2 (always 2).
+"""
+children(::ComputeTaskS2) = 2
+
+"""
+    children(::ComputeTaskP)
+
+Return the number of children of a ComputeTaskP (always 1).
+"""
+children(::ComputeTaskP) = 1
+
+"""
+    children(::ComputeTaskU)
+
+Return the number of children of a ComputeTaskU (always 1).
+"""
+children(::ComputeTaskU) = 1
+
+"""
+    children(::ComputeTaskV)
+
+Return the number of children of a ComputeTaskV (always 2).
+"""
+children(::ComputeTaskV) = 2
+
+
+"""
+    children(::ComputeTaskSum)
+
+Return the number of children of a ComputeTaskSum.
+"""
+children(t::ComputeTaskSum) = t.children_number
+
+"""
+    children(t::FusedComputeTask)
+
+Return the number of children of a FusedComputeTask.
+"""
+function children(t::FusedComputeTask)
+    return length(union(Set(t.t1_inputs), Set(t.t2_inputs)))
+end
+
+function add_child!(t::ComputeTaskSum)
+    t.children_number += 1
+    return nothing
+end

src/models/abc/types.jl

@@ -1,31 +1,59 @@
+"""
+    DataTask <: AbstractDataTask
+
+Task representing a specific data transfer in the ABC Model.
+"""
 struct DataTask <: AbstractDataTask
     data::UInt64
 end
 
-# S task with 1 child
+"""
+    ComputeTaskS1 <: AbstractComputeTask
+
+S task with a single child.
+"""
 struct ComputeTaskS1 <: AbstractComputeTask end
 
-# S task with 2 children
+"""
+    ComputeTaskS2 <: AbstractComputeTask
+
+S task with two children.
+"""
 struct ComputeTaskS2 <: AbstractComputeTask end
 
-# P task with 0 children
+"""
+    ComputeTaskP <: AbstractComputeTask
+
+P task with no children.
+"""
 struct ComputeTaskP <: AbstractComputeTask end
 
-# v task with 2 children
+"""
+    ComputeTaskV <: AbstractComputeTask
+
+v task with two children.
+"""
 struct ComputeTaskV <: AbstractComputeTask end
 
-# u task with 1 child
+"""
+    ComputeTaskU <: AbstractComputeTask
+
+u task with a single child.
+"""
 struct ComputeTaskU <: AbstractComputeTask end
 
-# task that sums all its inputs, n children
-struct ComputeTaskSum <: AbstractComputeTask end
+"""
+    ComputeTaskSum <: AbstractComputeTask
 
-ABC_TASKS = [
-    DataTask,
-    ComputeTaskS1,
-    ComputeTaskS2,
-    ComputeTaskP,
-    ComputeTaskV,
-    ComputeTaskU,
-    ComputeTaskSum,
-]
+Task that sums all its inputs, n children.
+"""
+mutable struct ComputeTaskSum <: AbstractComputeTask
+    children_number::Int
+end
+
+"""
+    ABC_TASKS
+
+Constant vector of all tasks of the ABC-Model.
+"""
+ABC_TASKS = [DataTask, ComputeTaskS1, ComputeTaskS2, ComputeTaskP, ComputeTaskV, ComputeTaskU, ComputeTaskSum]

src/models/interface.jl

@@ -0,0 +1,109 @@
+
+"""
+    AbstractPhysicsModel
+
+Base type for a model, e.g. ABC-Model or QED. This is used to dispatch many functions.
+"""
+abstract type AbstractPhysicsModel end
+
+"""
+    AbstractParticle
+
+Base type for particles belonging to a certain [`AbstractPhysicsModel`](@ref).
+"""
+abstract type AbstractParticle end
+
+"""
+    ParticleValue{ParticleType <: AbstractParticle}
+
+A struct describing a particle during a calculation of a Feynman Diagram, together with the value that's being calculated.
+
+`sizeof(ParticleValue())` = 48 Byte
+"""
+struct ParticleValue{ParticleType <: AbstractParticle}
+    p::ParticleType
+    v::Float64
+end
+
+"""
+    AbstractProcessDescription
+
+Base type for process descriptions. An object of this type of a corresponding [`AbstractPhysicsModel`](@ref) should uniquely identify a process in that model.
+
+See also: [`parse_process`](@ref)
+"""
+abstract type AbstractProcessDescription end
+
+"""
+    AbstractProcessInput
+
+Base type for process inputs. An object of this type contains the input values (e.g. momenta) of the particles in a process.
+
+See also: [`gen_process_input`](@ref)
+"""
+abstract type AbstractProcessInput end
+
+"""
+    mass(t::Type{T}) where {T <: AbstractParticle}
+
+Interface function that must be implemented for every subtype of [`AbstractParticle`](@ref), returning the particles mass at rest.
+"""
+function mass end
+
+"""
+    interaction_result(t1::Type{T1}, t2::Type{T2}) where {T1 <: AbstractParticle, T2 <: AbstractParticle}
+
+Interface function that must be implemented for every subtype of [`AbstractParticle`](@ref), returning the result particle type when the two given particles interact.
+"""
+function interaction_result end
+
+"""
+    types(::AbstractPhysicsModel)
+
+Interface function that must be implemented for every subtype of [`AbstractPhysicsModel`](@ref), returning a `Vector` of the available particle types in the model.
+"""
+function types end
+
+"""
+    in_particles(::AbstractProcessDescription)
+
+Interface function that must be implemented for every subtype of [`AbstractProcessDescription`](@ref).
+Returns a `<: Dict{Type{AbstractParticle}, Int}` object, representing the number of incoming particles for the process per particle type.
+
+
+    in_particles(::AbstractProcessInput)
+
+Interface function that must be implemented for every subtype of [`AbstractProcessInput`](@ref).
+Returns a `<: Vector{AbstractParticle}` object with the values of all incoming particles for the corresponding `ProcessDescription`.
+"""
+function in_particles end
+
+"""
+    out_particles(::AbstractProcessDescription)
+
+Interface function that must be implemented for every subtype of [`AbstractProcessDescription`](@ref).
+Returns a `<: Dict{Type{AbstractParticle}, Int}` object, representing the number of outgoing particles for the process per particle type.
+
+
+    out_particles(::AbstractProcessInput)
+
+Interface function that must be implemented for every subtype of [`AbstractProcessInput`](@ref).
+Returns a `<: Vector{AbstractParticle}` object with the values of all outgoing particles for the corresponding `ProcessDescription`.
+"""
+function out_particles end
+
+"""
+    parse_process(::AbstractString, ::AbstractPhysicsModel)
+
+Interface function that must be implemented for every subtype of [`AbstractPhysicsModel`](@ref).
+Returns a `ProcessDescription` object.
+"""
+function parse_process end
+
+"""
+    gen_process_input(::AbstractProcessDescription)
+
+Interface function that must be implemented for every specific [`AbstractProcessDescription`](@ref).
+Returns a randomly generated and valid corresponding `ProcessInput`.
+"""
+function gen_process_input end

src/models/print.jl

@@ -0,0 +1,10 @@
+
+"""
+    show(io::IO, particleValue::ParticleValue)
+
+Pretty print a [`ParticleValue`](@ref), no newlines.
+"""
+function show(io::IO, particleValue::ParticleValue)
+    print(io, "($(particleValue.p), value: $(particleValue.v))")
+    return nothing
+end

src/node/compare.jl

@@ -1,15 +1,35 @@
+"""
+    ==(e1::Edge, e2::Edge)
+
+Equality comparison between two edges.
+"""
 function ==(e1::Edge, e2::Edge)
     return e1.edge[1] == e2.edge[1] && e1.edge[2] == e2.edge[2]
 end
 
+"""
+    ==(n1::Node, n2::Node)
+
+Fallback equality comparison between two nodes. For equal node types, the more specific versions of this function will be called.
+"""
 function ==(n1::Node, n2::Node)
     return false
 end
 
+"""
+    ==(n1::ComputeTaskNode, n2::ComputeTaskNode)
+
+Equality comparison between two [`ComputeTaskNode`](@ref)s.
+"""
 function ==(n1::ComputeTaskNode, n2::ComputeTaskNode)
     return n1.id == n2.id
 end
 
+"""
+    ==(n1::DataTaskNode, n2::DataTaskNode)
+
+Equality comparison between two [`DataTaskNode`](@ref)s.
+"""
 function ==(n1::DataTaskNode, n2::DataTaskNode)
     return n1.id == n2.id
 end

src/node/create.jl

@@ -1,23 +1,71 @@
+
+DataTaskNode(t::AbstractDataTask, name = "") =
+    DataTaskNode(t, Vector{Node}(), Vector{Node}(), UUIDs.uuid1(rng[threadid()]), missing, missing, missing, name)
+ComputeTaskNode(t::AbstractComputeTask) = ComputeTaskNode(
+    t,                              # task
+    Vector{Node}(),                 # parents
+    Vector{Node}(),                 # children
+    UUIDs.uuid1(rng[threadid()]),   # id
+    missing,                        # node reduction
+    missing,                        # node split
+    Vector{NodeFusion}(),           # node fusions
+    missing,                        # device
+)
+
+copy(m::Missing) = missing
+copy(n::ComputeTaskNode) = ComputeTaskNode(copy(n.task))
+copy(n::DataTaskNode) = DataTaskNode(copy(n.task), n.name)
+
+"""
+    make_node(t::AbstractTask)
+
+Fallback implementation of `make_node` for an [`AbstractTask`](@ref), throwing an error.
+"""
 function make_node(t::AbstractTask)
     return error("Cannot make a node from this task type")
 end
 
-function make_node(t::AbstractDataTask)
-    return DataTaskNode(t)
+"""
+    make_node(t::AbstractDataTask)
+
+Construct and return a new [`DataTaskNode`](@ref) with the given task.
+"""
+function make_node(t::AbstractDataTask, name::String = "")
+    return DataTaskNode(t, name)
 end
 
+"""
+    make_node(t::AbstractComputeTask)
+
+Construct and return a new [`ComputeTaskNode`](@ref) with the given task.
+"""
 function make_node(t::AbstractComputeTask)
     return ComputeTaskNode(t)
 end
 
+"""
+    make_edge(n1::Node, n2::Node)
+
+Fallback implementation of `make_edge` throwing an error. If you got this error it likely means you tried to construct an edge between two nodes of the same type.
+"""
 function make_edge(n1::Node, n2::Node)
     return error("Can only create edges from compute to data node or reverse")
 end
 
+"""
+    make_edge(n1::ComputeTaskNode, n2::DataTaskNode)
+
+Construct and return a new [`Edge`](@ref) pointing from `n1` (child) to `n2` (parent).
+"""
 function make_edge(n1::ComputeTaskNode, n2::DataTaskNode)
     return Edge((n1, n2))
 end
 
+"""
+    make_edge(n1::DataTaskNode, n2::ComputeTaskNode)
+
+Construct and return a new [`Edge`](@ref) pointing from `n1` (child) to `n2` (parent).
+"""
 function make_edge(n1::DataTaskNode, n2::ComputeTaskNode)
     return Edge((n1, n2))
 end

src/node/print.jl

@@ -1,7 +1,27 @@
+"""
+    show(io::IO, n::Node)
+
+Print a short string representation of the node to io.
+"""
 function show(io::IO, n::Node)
     return print(io, "Node(", n.task, ")")
 end
 
+"""
+    show(io::IO, e::Edge)
+
+Print a short string representation of the edge to io.
+"""
 function show(io::IO, e::Edge)
     return print(io, "Edge(", e.edge[1], ", ", e.edge[2], ")")
 end
+
+"""
+    to_var_name(id::UUID)
+
+Return the uuid as a string usable as a variable name in code generation.
+"""
+function to_var_name(id::UUID)
+    str = "_" * replace(string(id), "-" => "_")
+    return str
+end

src/node/properties.jl

@@ -1,17 +1,58 @@
+"""
+    is_entry_node(node::Node)
+
+Return whether this node is an entry node in its graph, i.e., it has no children.
+"""
 is_entry_node(node::Node) = length(node.children) == 0
+
+"""
+    is_exit_node(node::Node)
+
+Return whether this node is an exit node of its graph, i.e., it has no parents.
+"""
 is_exit_node(node::Node) = length(node.parents) == 0
 
-# children = prerequisite nodes, nodes that need to execute before the task, edges point into this task
+"""
+    data(edge::Edge)
+
+Return the data transfered by this edge, i.e., 0 if the child is a [`ComputeTaskNode`](@ref), otherwise the child's `data()`.
+"""
+function data(edge::Edge)
+    if typeof(edge.edge[1]) <: DataTaskNode
+        return data(edge.edge[1].task)
+    end
+    return 0.0
+end
+
+"""
+    children(node::Node)
+
+Return a copy of the node's children so it can safely be muted without changing the node in the graph.
+
+A node's children are its prerequisite nodes, nodes that need to execute before the task of this node.
+"""
 function children(node::Node)
     return copy(node.children)
 end
 
-# parents = subsequent nodes, nodes that need this node to execute, edges point from this task
+"""
+    parents(node::Node)
+
+Return a copy of the node's parents so it can safely be muted without changing the node in the graph.
+
+A node's parents are its subsequent nodes, nodes that need this node to execute.
+"""
 function parents(node::Node)
     return copy(node.parents)
 end
 
-# siblings = all children of any parents, no duplicates, includes the node itself
+"""
+    siblings(node::Node)
+
+Return a vector of all siblings of this node. 
+
+A node's siblings are all children of any of its parents. The result contains no duplicates and includes the node itself.
+"""
 function siblings(node::Node)
     result = Set{Node}()
     push!(result, node)
@@ -22,7 +63,16 @@ function siblings(node::Node)
     return result
 end
 
-# partners = all parents of any children, no duplicates, includes the node itself
+"""
+    partners(node::Node)
+
+Return a vector of all partners of this node. 
+
+A node's partners are all parents of any of its children. The result contains no duplicates and includes the node itself.
+
+Note: This is very slow when there are multiple children with many parents. 
+This is less of a problem in [`siblings(node::Node)`](@ref) because (depending on the model) there are no nodes with a large number of children, or only a single one.
+"""
 function partners(node::Node)
     result = Set{Node}()
     push!(result, node)
@@ -33,8 +83,11 @@ function partners(node::Node)
     return result
 end
 
-# alternative version to partners(Node), avoiding allocation of a new set
-# works on the given set and returns nothing
+"""
+    partners(node::Node, set::Set{Node})
+
+Alternative version to [`partners(node::Node)`](@ref), avoiding allocation of a new set. Works on the given set and returns `nothing`.
+"""
 function partners(node::Node, set::Set{Node})
     push!(set, node)
     for child in node.children
@@ -43,10 +96,20 @@ function partners(node::Node, set::Set{Node})
     return nothing
 end
 
-function is_parent(potential_parent, node)
+"""
+    is_parent(potential_parent::Node, node::Node)
+
+Return whether the `potential_parent` is a parent of `node`.
+"""
+function is_parent(potential_parent::Node, node::Node)
     return potential_parent in node.parents
 end
 
-function is_child(potential_child, node)
+"""
+    is_child(potential_child::Node, node::Node)
+
+Return whether the `potential_child` is a child of `node`.
+"""
+function is_child(potential_child::Node, node::Node)
     return potential_child in node.children
 end

src/node/type.jl

@@ -5,12 +5,34 @@ 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:32]
 
+"""
+    Node
+
+The abstract base type of every node.
+
+See [`DataTaskNode`](@ref), [`ComputeTaskNode`](@ref) and [`make_node`](@ref).
+"""
 abstract type Node end
 
 # declare this type here because it's needed
 # the specific operations are declared in graph.jl
 abstract type Operation end
 
+"""
+    DataTaskNode <: Node
+    
+Any node that transfers data and does no computation.
+
+# Fields
+`.task`:            The node's data task type. Usually [`DataTask`](@ref).\\
+`.parents`:         A vector of the node's parents (i.e. nodes that depend on this one).\\
+`.children`:        A vector of the node's children (i.e. nodes that this one depends on).\\
+`.id`:              The node's id. Improves the speed of comparisons and is used as a unique identifier.\\
+`.nodeReduction`:   Either this node's [`NodeReduction`](@ref) or `missing`, if none. There can only be at most one.\\
+`.nodeSplit`:       Either this node's [`NodeSplit`](@ref) or `missing`, if none. There can only be at most one.\\
+`.nodeFusion`:      Either this node's [`NodeFusion`](@ref) or `missing`, if none. There can only be at most one for DataTaskNodes.\\
+`.name`:            The name of this node for entry nodes into the graph ([`is_entry_node`](@ref)) to reliably assign the inputs to the correct nodes when executing.\\
+"""
 mutable struct DataTaskNode <: Node
     task::AbstractDataTask
 
@@ -31,9 +53,26 @@ mutable struct DataTaskNode <: Node
 
     # the node fusion involving this node, if it exists
     nodeFusion::Union{Operation, Missing}
+
+    # for input nodes we need a name for the node to distinguish between them
+    name::String
 end
 
-# same as DataTaskNode
+"""
+    ComputeTaskNode <: Node
+    
+Any node that computes a result from inputs using an [`AbstractComputeTask`](@ref).
+
+# Fields
+`.task`:            The node's compute task type. A concrete subtype of [`AbstractComputeTask`](@ref).\\
+`.parents`:         A vector of the node's parents (i.e. nodes that depend on this one).\\
+`.children`:        A vector of the node's children (i.e. nodes that this one depends on).\\
+`.id`:              The node's id. Improves the speed of comparisons and is used as a unique identifier.\\
+`.nodeReduction`:   Either this node's [`NodeReduction`](@ref) or `missing`, if none. There can only be at most one.\\
+`.nodeSplit`:       Either this node's [`NodeSplit`](@ref) or `missing`, if none. There can only be at most one.\\
+`.nodeFusions`:     A vector of this node's [`NodeFusion`](@ref)s. For a `ComputeTaskNode` there can be any number of these, unlike the [`DataTaskNode`](@ref)s.\\
+`.device`:          The Device this node has been scheduled on by a [`Scheduler`](@ref).
+"""
 mutable struct ComputeTaskNode <: Node
     task::AbstractComputeTask
     parents::Vector{Node}
@@ -45,51 +84,21 @@ mutable struct ComputeTaskNode <: Node
 
     # for ComputeTasks there can be multiple fusions, unlike the DataTasks
     nodeFusions::Vector{Operation}
+
+    # the device this node is assigned to execute on
+    device::Union{AbstractDevice, Missing}
 end
 
-DataTaskNode(t::AbstractDataTask) = DataTaskNode(
-    t,
-    Vector{Node}(),
-    Vector{Node}(),
-    UUIDs.uuid1(rng[threadid()]),
-    missing,
-    missing,
-    missing,
-)
-ComputeTaskNode(t::AbstractComputeTask) = ComputeTaskNode(
-    t,
-    Vector{Node}(),
-    Vector{Node}(),
-    UUIDs.uuid1(rng[threadid()]),
-    missing,
-    missing,
-    Vector{NodeFusion}(),
-)
+"""
+    Edge
 
+Type of an edge in the graph. Edges can only exist between a [`DataTaskNode`](@ref) and a [`ComputeTaskNode`](@ref) or vice versa, not between two of the same type of node.
+
+An edge always points from child to parent: `child = e.edge[1]` and `parent = e.edge[2]`.
+
+The child is the prerequisite node of the parent.
+"""
 struct Edge
     # edge points from child to parent
-    edge::Union{
-        Tuple{DataTaskNode, ComputeTaskNode},
-        Tuple{ComputeTaskNode, DataTaskNode},
-    }
+    edge::Union{Tuple{DataTaskNode, ComputeTaskNode}, Tuple{ComputeTaskNode, DataTaskNode}}
 end
-
-copy(m::Missing) = missing
-copy(n::ComputeTaskNode) = ComputeTaskNode(
-    copy(n.task),
-    copy(n.parents),
-    copy(n.children),
-    UUIDs.uuid1(rng[threadid()]),
-    copy(n.nodeReduction),
-    copy(n.nodeSplit),
-    copy(n.nodeFusions),
-)
-copy(n::DataTaskNode) = DataTaskNode(
-    copy(n.task),
-    copy(n.parents),
-    copy(n.children),
-    UUIDs.uuid1(rng[threadid()]),
-    copy(n.nodeReduction),
-    copy(n.nodeSplit),
-    copy(n.nodeFusion),
-)

src/node/validate.jl

@@ -1,3 +1,12 @@
+"""
+    is_valid_node(graph::DAG, node::Node)
+
+Verify that a given node is valid in the graph. Call like `@test is_valid_node(g, n)`. Uses `@assert` to fail if something is invalid but also provide an error message.
+
+This function is very performance intensive and should only be used when testing or debugging.
+
+See also this function's specific versions for the concrete Node types [`is_valid(graph::DAG, node::ComputeTaskNode)`](@ref) and [`is_valid(graph::DAG, node::DataTaskNode)`](@ref).
+"""
 function is_valid_node(graph::DAG, node::Node)
     @assert node in graph "Node is not part of the given graph!"
 
@@ -13,31 +22,55 @@ function is_valid_node(graph::DAG, node::Node)
         @assert node in child.parents "Node is not a parent of its child!"
     end
 
-    if !ismissing(node.nodeReduction)
+    #=if !ismissing(node.nodeReduction)
         @assert is_valid(graph, node.nodeReduction)
     end
     if !ismissing(node.nodeSplit)
         @assert is_valid(graph, node.nodeSplit)
+    end=#
+
+    if !(typeof(node.task) <: FusedComputeTask)
+        # the remaining checks are only necessary for fused compute tasks
+        return true
     end
+
+    # every child must be in some input of the task
+    for child in node.children
+        str = Symbol(to_var_name(child.id))
+        @assert (str in node.task.t1_inputs) || (str in node.task.t2_inputs) "$str was not in any of the tasks' inputs\nt1_inputs: $(node.task.t1_inputs)\nt2_inputs: $(node.task.t2_inputs)"
+    end
+
     return true
 end
 
-# call with @assert
+"""
+    is_valid(graph::DAG, node::ComputeTaskNode)
+
+Verify that the given compute node is valid in the graph. Call with `@assert` or `@test` when testing or debugging.
+
+This also calls [`is_valid_node(graph::DAG, node::Node)`](@ref).
+"""
 function is_valid(graph::DAG, node::ComputeTaskNode)
     @assert is_valid_node(graph, node)
 
-    for nf in node.nodeFusions
+    #=for nf in node.nodeFusions
         @assert is_valid(graph, nf)
-    end
+    end=#
     return true
 end
 
-# call with @assert
+"""
+    is_valid(graph::DAG, node::DataTaskNode)
+
+Verify that the given compute node is valid in the graph. Call with `@assert` or `@test` when testing or debugging.
+
+This also calls [`is_valid_node(graph::DAG, node::Node)`](@ref).
+"""
 function is_valid(graph::DAG, node::DataTaskNode)
     @assert is_valid_node(graph, node)
 
-    if !ismissing(node.nodeFusion)
+    #=if !ismissing(node.nodeFusion)
         @assert is_valid(graph, node.nodeFusion)
-    end
+    end=#
     return true
 end

src/operation/apply.jl

@@ -1,6 +1,8 @@
-# functions that apply graph operations
+"""
+    apply_all!(graph::DAG)
 
-# applies all unapplied operations in the DAG
+Apply all unapplied operations in the DAG. Is automatically called in all functions that require the latest state of the [`DAG`](@ref).
+"""
 function apply_all!(graph::DAG)
     while !isempty(graph.operationsToApply)
         # get next operation to apply from front of the deque
@@ -15,86 +17,158 @@ function apply_all!(graph::DAG)
     return nothing
 end
 
+"""
+    apply_operation!(graph::DAG, operation::Operation)
+
+Fallback implementation of apply_operation! for unimplemented operation types, throwing an error.
+"""
 function apply_operation!(graph::DAG, operation::Operation)
     return error("Unknown operation type!")
 end
 
+"""
+    apply_operation!(graph::DAG, operation::NodeFusion)
+
+Apply the given [`NodeFusion`](@ref) to the graph. Generic wrapper around [`node_fusion!`](@ref).
+
+Return an [`AppliedNodeFusion`](@ref) object generated from the graph's [`Diff`](@ref).
+"""
 function apply_operation!(graph::DAG, operation::NodeFusion)
-    diff = node_fusion!(
-        graph,
-        operation.input[1],
-        operation.input[2],
-        operation.input[3],
-    )
+    diff = node_fusion!(graph, operation.input[1], operation.input[2], operation.input[3])
+
+    graph.properties += GraphProperties(diff)
+
     return AppliedNodeFusion(operation, diff)
 end
 
+"""
+    apply_operation!(graph::DAG, operation::NodeReduction)
+
+Apply the given [`NodeReduction`](@ref) to the graph. Generic wrapper around [`node_reduction!`](@ref).
+
+Return an [`AppliedNodeReduction`](@ref) object generated from the graph's [`Diff`](@ref).
+"""
 function apply_operation!(graph::DAG, operation::NodeReduction)
     diff = node_reduction!(graph, operation.input)
+
+    graph.properties += GraphProperties(diff)
+
     return AppliedNodeReduction(operation, diff)
 end
 
+"""
+    apply_operation!(graph::DAG, operation::NodeSplit)
+
+Apply the given [`NodeSplit`](@ref) to the graph. Generic wrapper around [`node_split!`](@ref).
+
+Return an [`AppliedNodeSplit`](@ref) object generated from the graph's [`Diff`](@ref).
+"""
 function apply_operation!(graph::DAG, operation::NodeSplit)
     diff = node_split!(graph, operation.input)
+
+    graph.properties += GraphProperties(diff)
+
     return AppliedNodeSplit(operation, diff)
 end
 
+"""
+    revert_operation!(graph::DAG, operation::AppliedOperation)
 
+Fallback implementation of operation reversion for unimplemented operation types, throwing an error.
+"""
 function revert_operation!(graph::DAG, operation::AppliedOperation)
     return error("Unknown operation type!")
 end
 
+"""
+    revert_operation!(graph::DAG, operation::AppliedNodeFusion)
+
+Revert the applied node fusion on the graph. Return the original [`NodeFusion`](@ref) operation.
+"""
 function revert_operation!(graph::DAG, operation::AppliedNodeFusion)
     revert_diff!(graph, operation.diff)
     return operation.operation
 end
 
+"""
+    revert_operation!(graph::DAG, operation::AppliedNodeReduction)
+
+Revert the applied node fusion on the graph. Return the original [`NodeReduction`](@ref) operation.
+"""
 function revert_operation!(graph::DAG, operation::AppliedNodeReduction)
     revert_diff!(graph, operation.diff)
     return operation.operation
 end
 
+"""
+    revert_operation!(graph::DAG, operation::AppliedNodeSplit)
+
+Revert the applied node fusion on the graph. Return the original [`NodeSplit`](@ref) operation.
+"""
 function revert_operation!(graph::DAG, operation::AppliedNodeSplit)
     revert_diff!(graph, operation.diff)
     return operation.operation
 end
 
+"""
+    revert_diff!(graph::DAG, diff::Diff)
 
+Revert the given diff on the graph. Used to revert the individual [`AppliedOperation`](@ref)s with [`revert_operation!`](@ref).
+"""
 function revert_diff!(graph::DAG, diff::Diff)
     # add removed nodes, remove added nodes, same for edges
     # note the order
     for edge in diff.addedEdges
-        remove_edge!(graph, edge.edge[1], edge.edge[2], false)
+        remove_edge!(graph, edge.edge[1], edge.edge[2], track = false)
     end
     for node in diff.addedNodes
-        remove_node!(graph, node, false)
+        remove_node!(graph, node, track = false)
     end
 
     for node in diff.removedNodes
-        insert_node!(graph, node, false)
+        insert_node!(graph, node, track = false)
     end
     for edge in diff.removedEdges
-        insert_edge!(graph, edge.edge[1], edge.edge[2], false)
+        insert_edge!(graph, edge.edge[1], edge.edge[2], track = false)
     end
+
+    for (node, task) in diff.updatedChildren
+        # node must be fused compute task at this point
+        @assert typeof(node.task) <: FusedComputeTask
+
+        node.task = task
+    end
+
+    graph.properties -= GraphProperties(diff)
+
+    return nothing
 end
 
-# Fuse nodes n1 -> n2 -> n3 together into one node, return the applied difference to the graph
-function node_fusion!(
-    graph::DAG,
-    n1::ComputeTaskNode,
-    n2::DataTaskNode,
-    n3::ComputeTaskNode,
-)
-    # @assert is_valid_node_fusion_input(graph, n1, n2, n3)
+"""
+    node_fusion!(graph::DAG, n1::ComputeTaskNode, n2::DataTaskNode, n3::ComputeTaskNode)
+
+Fuse nodes n1 -> n2 -> n3 together into one node, return the applied difference to the graph.
+
+For details see [`NodeFusion`](@ref).
+"""
+function node_fusion!(graph::DAG, n1::ComputeTaskNode, n2::DataTaskNode, n3::ComputeTaskNode)
+    @assert is_valid_node_fusion_input(graph, n1, n2, n3)
 
     # clear snapshot
     get_snapshot_diff(graph)
 
-
     # save children and parents
-    n1_children = children(n1)
-    n3_parents = parents(n3)
-    n3_children = children(n3)
+    n1Children = children(n1)
+    n3Parents = parents(n3)
+
+    n1Task = copy(n1.task)
+    n3Task = copy(n3.task)
+
+    # assemble the input node vectors of n1 and n3 to save into the FusedComputeTask
+    n1Inputs = Vector{Symbol}()
+    for child in n1Children
+        push!(n1Inputs, Symbol(to_var_name(child.id)))
+    end
 
     # remove the edges and nodes that will be replaced by the fused node
     remove_edge!(graph, n1, n2)
@@ -103,58 +177,71 @@ function node_fusion!(
     remove_node!(graph, n2)
 
     # get n3's children now so it automatically excludes n2
-    n3_children = children(n3)
+    n3Children = children(n3)
+
+    n3Inputs = Vector{Symbol}()
+    for child in n3Children
+        push!(n3Inputs, Symbol(to_var_name(child.id)))
+    end
+
     remove_node!(graph, n3)
 
     # create new node with the fused compute task
-    new_node =
-        ComputeTaskNode(FusedComputeTask{typeof(n1.task), typeof(n3.task)}())
-    insert_node!(graph, new_node)
+    newNode = ComputeTaskNode(FusedComputeTask(n1Task, n3Task, n1Inputs, Symbol(to_var_name(n2.id)), n3Inputs))
+    insert_node!(graph, newNode)
 
-    # use a set for combined children of n1 and n3 to not get duplicates
-    n1and3_children = Set{Node}()
-
-    # remove edges from n1 children to n1
-    for child in n1_children
+    for child in n1Children
         remove_edge!(graph, child, n1)
-        push!(n1and3_children, child)
+        insert_edge!(graph, child, newNode)
     end
 
-    # remove edges from n3 children to n3
-    for child in n3_children
+    for child in n3Children
         remove_edge!(graph, child, n3)
-        push!(n1and3_children, child)
+        if !(child in n1Children)
+            insert_edge!(graph, child, newNode)
+        end
     end
 
-    for child in n1and3_children
-        insert_edge!(graph, child, new_node)
-    end
-
-    # "repoint" parents of n3 from new node
-    for parent in n3_parents
+    for parent in n3Parents
         remove_edge!(graph, n3, parent)
-        insert_edge!(graph, new_node, parent)
+        insert_edge!(graph, newNode, parent)
+
+        # important! update the parent node's child names in case they are fused compute tasks
+        # needed for compute generation so the fused compute task can correctly match inputs to its component tasks
+        update_child!(graph, parent, Symbol(to_var_name(n3.id)), Symbol(to_var_name(newNode.id)))
     end
 
     return get_snapshot_diff(graph)
 end
 
+"""
+    node_reduction!(graph::DAG, nodes::Vector{Node})
+
+Reduce the given nodes together into one node, return the applied difference to the graph.
+
+For details see [`NodeReduction`](@ref).
+"""
 function node_reduction!(graph::DAG, nodes::Vector{Node})
-    # @assert is_valid_node_reduction_input(graph, nodes)
+    @assert is_valid_node_reduction_input(graph, nodes)
 
     # clear snapshot
     get_snapshot_diff(graph)
 
     n1 = nodes[1]
-    n1_children = children(n1)
+    n1Children = children(n1)
 
-    n1_parents = Set(n1.parents)
-    new_parents = Set{Node}()
+    n1Parents = Set(n1.parents)
+
+    # set of the new parents of n1
+    newParents = Set{Node}()
+
+    # names of the previous children that n1 now replaces per parent
+    newParentsChildNames = Dict{Node, Symbol}()
 
     # remove all of the nodes' parents and children and the nodes themselves (except for first node)
     for i in 2:length(nodes)
         n = nodes[i]
-        for child in n1_children
+        for child in n1Children
             remove_edge!(graph, child, n)
         end
 
@@ -162,47 +249,63 @@ function node_reduction!(graph::DAG, nodes::Vector{Node})
             remove_edge!(graph, n, parent)
 
             # collect all parents
-            push!(new_parents, parent)
+            push!(newParents, parent)
+            newParentsChildNames[parent] = Symbol(to_var_name(n.id))
         end
 
         remove_node!(graph, n)
     end
 
-    setdiff!(new_parents, n1_parents)
-
-    for parent in new_parents
+    for parent in newParents
         # now add parents of all input nodes to n1 without duplicates
-        insert_edge!(graph, n1, parent)
+        if !(parent in n1Parents)
+            # don't double insert edges
+            insert_edge!(graph, n1, parent)
+        end
+
+        # this has to be done for all parents, even the ones of n1 because they can be duplicate
+        prevChild = newParentsChildNames[parent]
+        update_child!(graph, parent, prevChild, Symbol(to_var_name(n1.id)))
     end
 
     return get_snapshot_diff(graph)
 end
 
+"""
+    node_split!(graph::DAG, n1::Node)
+
+Split the given node into one node per parent, return the applied difference to the graph.
+
+For details see [`NodeSplit`](@ref).
+"""
 function node_split!(graph::DAG, n1::Node)
-    # @assert is_valid_node_split_input(graph, n1)
+    @assert is_valid_node_split_input(graph, n1)
 
     # clear snapshot
     get_snapshot_diff(graph)
 
-    n1_parents = parents(n1)
-    n1_children = children(n1)
+    n1Parents = parents(n1)
+    n1Children = children(n1)
 
-    for parent in n1_parents
+    for parent in n1Parents
         remove_edge!(graph, n1, parent)
     end
-    for child in n1_children
+    for child in n1Children
         remove_edge!(graph, child, n1)
     end
     remove_node!(graph, n1)
 
-    for parent in n1_parents
-        n_copy = copy(n1)
-        insert_node!(graph, n_copy)
-        insert_edge!(graph, n_copy, parent)
+    for parent in n1Parents
+        nCopy = copy(n1)
 
-        for child in n1_children
-            insert_edge!(graph, child, n_copy)
+        insert_node!(graph, nCopy)
+        insert_edge!(graph, nCopy, parent)
+
+        for child in n1Children
+            insert_edge!(graph, child, nCopy)
         end
+
+        update_child!(graph, parent, Symbol(to_var_name(n1.id)), Symbol(to_var_name(nCopy.id)))
     end
 
     return get_snapshot_diff(graph)

src/operation/clean.jl

@@ -1,9 +1,14 @@
-# functions for "cleaning" nodes, i.e. regenerating the possible operations for a node
+# These are functions for "cleaning" nodes, i.e. regenerating the possible operations for a node
 
-# function to find node fusions involving the given node if it's a data node
-# pushes the found fusion everywhere it needs to be and returns nothing
+"""
+    find_fusions!(graph::DAG, node::DataTaskNode)
+
+Find node fusions involving the given data node. The function pushes the found [`NodeFusion`](@ref) (if any) everywhere it needs to be and returns nothing.
+
+Does nothing if the node already has a node fusion set. Since it's a data node, only one node fusion can be possible with it.
+"""
 function find_fusions!(graph::DAG, node::DataTaskNode)
-    # if there is already a fusion here, skip
+    # if there is already a fusion here, skip to avoid duplicates
     if !ismissing(node.nodeFusion)
         return nothing
     end
@@ -32,7 +37,11 @@ function find_fusions!(graph::DAG, node::DataTaskNode)
     return nothing
 end
 
+"""
+    find_fusions!(graph::DAG, node::ComputeTaskNode)
 
+Find node fusions involving the given compute node. The function pushes the found [`NodeFusion`](@ref)s (if any) everywhere they need to be and returns nothing.
+"""
 function find_fusions!(graph::DAG, node::ComputeTaskNode)
     # just find fusions in neighbouring DataTaskNodes
     for child in node.children
@@ -46,6 +55,11 @@ function find_fusions!(graph::DAG, node::ComputeTaskNode)
     return nothing
 end
 
+"""
+    find_reductions!(graph::DAG, node::Node)
+
+Find node reductions involving the given node. The function pushes the found [`NodeReduction`](@ref) (if any) everywhere it needs to be and returns nothing.
+"""
 function find_reductions!(graph::DAG, node::Node)
     # there can only be one reduction per node, avoid adding duplicates
     if !ismissing(node.nodeReduction)
@@ -57,14 +71,8 @@ function find_reductions!(graph::DAG, node::Node)
     partners_ = partners(node)
     delete!(partners_, node)
     for partner in partners_
-        if partner ∉ graph.nodes
-            error("Partner is not part of the graph")
-        end
-
+        @assert partner in graph.nodes
         if can_reduce(node, partner)
-            if Set(node.children) != Set(partner.children)
-                error("Not equal children")
-            end
             if reductionVector === nothing
                 # only when there's at least one reduction partner, insert the vector
                 reductionVector = Vector{Node}()
@@ -91,6 +99,11 @@ function find_reductions!(graph::DAG, node::Node)
     return nothing
 end
 
+"""
+    find_splits!(graph::DAG, node::Node)
+
+Find the node split of the given node. The function pushes the found [`NodeSplit`](@ref) (if any) everywhere it needs to be and returns nothing.
+"""
 function find_splits!(graph::DAG, node::Node)
     if !ismissing(node.nodeSplit)
         return nothing
@@ -105,11 +118,17 @@ function find_splits!(graph::DAG, node::Node)
     return nothing
 end
 
-# "clean" the operations on a dirty node
+"""
+    clean_node!(graph::DAG, node::Node)
+
+Sort this node's parent and child sets, then find fusions, reductions and splits involving it. Needs to be called after the node was changed in some way.
+"""
 function clean_node!(graph::DAG, node::Node)
     sort_node!(node)
 
     find_fusions!(graph, node)
     find_reductions!(graph, node)
-    return find_splits!(graph, node)
+    find_splits!(graph, node)
+
+    return nothing
 end

src/operation/find.jl

@@ -2,10 +2,12 @@
 
 using Base.Threads
 
-function insert_operation!(
-    nf::NodeFusion,
-    locks::Dict{ComputeTaskNode, SpinLock},
-)
+"""
+    insert_operation!(nf::NodeFusion, locks::Dict{ComputeTaskNode, SpinLock})
+
+Insert the given node fusion into its input nodes' operation caches. For the compute nodes, locking via the given `locks` is employed to have safe multi-threading. For a large set of nodes, contention on the locks should be very small.
+"""
+function insert_operation!(nf::NodeFusion, locks::Dict{ComputeTaskNode, SpinLock})
     n1 = nf.input[1]
     n2 = nf.input[2]
     n3 = nf.input[3]
@@ -20,6 +22,11 @@ function insert_operation!(
     return nothing
 end
 
+"""
+    insert_operation!(nf::NodeReduction)
+
+Insert the given node reduction into its input nodes' operation caches. This is thread-safe.
+"""
 function insert_operation!(nr::NodeReduction)
     for n in nr.input
         n.nodeReduction = nr
@@ -27,15 +34,22 @@ function insert_operation!(nr::NodeReduction)
     return nothing
 end
 
+"""
+    insert_operation!(nf::NodeSplit)
+
+Insert the given node split into its input node's operation cache. This is thread-safe.
+"""
 function insert_operation!(ns::NodeSplit)
     ns.input.nodeSplit = ns
     return nothing
 end
 
-function nr_insertion!(
-    operations::PossibleOperations,
-    nodeReductions::Vector{Vector{NodeReduction}},
-)
+"""
+    nr_insertion!(operations::PossibleOperations, nodeReductions::Vector{Vector{NodeReduction}})
+
+Insert the node reductions into the graph and the nodes' caches. Employs multithreading for speedup.
+"""
+function nr_insertion!(operations::PossibleOperations, nodeReductions::Vector{Vector{NodeReduction}})
     total_len = 0
     for vec in nodeReductions
         total_len += length(vec)
@@ -58,11 +72,12 @@ function nr_insertion!(
     return nothing
 end
 
-function nf_insertion!(
-    graph::DAG,
-    operations::PossibleOperations,
-    nodeFusions::Vector{Vector{NodeFusion}},
-)
+"""
+    nf_insertion!(graph::DAG, operations::PossibleOperations, nodeFusions::Vector{Vector{NodeFusion}})
+
+Insert the node fusions into the graph and the nodes' caches. Employs multithreading for speedup.
+"""
+function nf_insertion!(graph::DAG, operations::PossibleOperations, nodeFusions::Vector{Vector{NodeFusion}})
     total_len = 0
     for vec in nodeFusions
         total_len += length(vec)
@@ -92,10 +107,12 @@ function nf_insertion!(
     return nothing
 end
 
-function ns_insertion!(
-    operations::PossibleOperations,
-    nodeSplits::Vector{Vector{NodeSplit}},
-)
+"""
+    ns_insertion!(operations::PossibleOperations, nodeSplits::Vector{Vector{NodeSplits}})
+
+Insert the node splits into the graph and the nodes' caches. Employs multithreading for speedup.
+"""
+function ns_insertion!(operations::PossibleOperations, nodeSplits::Vector{Vector{NodeSplit}})
     total_len = 0
     for vec in nodeSplits
         total_len += length(vec)
@@ -118,8 +135,14 @@ function ns_insertion!(
     return nothing
 end
 
-# function to generate all possible operations on the graph
-function generate_options(graph::DAG)
+"""
+    generate_operations(graph::DAG)
+
+Generate all possible operations on the graph. Used initially when the graph is freshly assembled or parsed. Uses multithreading for speedup.
+
+Safely inserts all the found operations into the graph and its nodes.
+"""
+function generate_operations(graph::DAG)
     generatedFusions = [Vector{NodeFusion}() for _ in 1:nthreads()]
     generatedReductions = [Vector{NodeReduction}() for _ in 1:nthreads()]
     generatedSplits = [Vector{NodeSplit}() for _ in 1:nthreads()]
@@ -195,16 +218,12 @@ function generate_options(graph::DAG)
                 continue
             end
 
-            push!(
-                generatedFusions[threadid()],
-                NodeFusion((child_node, node, parent_node)),
-            )
+            push!(generatedFusions[threadid()], NodeFusion((child_node, node, parent_node)))
         end
     end
 
     # launch thread for node fusion insertion
-    nf_task =
-        @task nf_insertion!(graph, graph.possibleOperations, generatedFusions)
+    nf_task = @task nf_insertion!(graph, graph.possibleOperations, generatedFusions)
     schedule(nf_task)
 
     # find possible node splits

src/operation/get.jl

@@ -2,11 +2,16 @@
 
 using Base.Threads
 
+"""
+    get_operations(graph::DAG)
+
+Return the [`PossibleOperations`](@ref) of the graph at the current state.
+"""
 function get_operations(graph::DAG)
     apply_all!(graph)
 
     if isempty(graph.possibleOperations)
-        generate_options(graph)
+        generate_operations(graph)
     end
 
     for node in graph.dirtyNodes

src/operation/print.jl

@@ -1,3 +1,8 @@
+"""
+    show(io::IO, ops::PossibleOperations)
+
+Print a string representation of the set of possible operations to io.
+"""
 function show(io::IO, ops::PossibleOperations)
     print(io, length(ops.nodeFusions))
     println(io, " Node Fusions: ")
@@ -16,6 +21,11 @@ function show(io::IO, ops::PossibleOperations)
     end
 end
 
+"""
+    show(io::IO, op::NodeReduction)
+
+Print a string representation of the node reduction to io.
+"""
 function show(io::IO, op::NodeReduction)
     print(io, "NR: ")
     print(io, length(op.input))
@@ -23,11 +33,21 @@ function show(io::IO, op::NodeReduction)
     return print(io, op.input[1].task)
 end
 
+"""
+    show(io::IO, op::NodeSplit)
+
+Print a string representation of the node split to io.
+"""
 function show(io::IO, op::NodeSplit)
     print(io, "NS: ")
     return print(io, op.input.task)
 end
 
+"""
+    show(io::IO, op::NodeFusion)
+
+Print a string representation of the node fusion to io.
+"""
 function show(io::IO, op::NodeFusion)
     print(io, "NF: ")
     print(io, op.input[1].task)

src/operation/type.jl

@@ -1,33 +1,116 @@
-# An abstract base class for operations
-# an operation can be applied to a DAG
+"""
+    Operation
+
+An abstract base class for operations. An operation can be applied to a [`DAG`](@ref), changing its nodes and edges.
+
+Possible operations on a [`DAG`](@ref) can be retrieved using [`get_operations`](@ref).
+
+See also: [`push_operation!`](@ref), [`pop_operation!`](@ref)
+"""
 abstract type Operation end
 
-# An abstract base class for already applied operations
-# an applied operation can be reversed iff it is the last applied operation on the DAG
+"""
+    AppliedOperation
+
+An abstract base class for already applied operations.
+An applied operation can be reversed iff it is the last applied operation on the DAG.
+Every applied operation stores a [`Diff`](@ref) from when it was initially applied to be able to revert the operation.
+
+See also: [`revert_operation!`](@ref).
+"""
 abstract type AppliedOperation end
 
+"""
+    NodeFusion <: Operation
+
+The NodeFusion operation. Represents the fusing of a chain of compute node -> data node -> compute node.
+
+After the node fusion is applied, the graph has 2 fewer nodes and edges, and a new [`FusedComputeTask`](@ref) with the two input compute nodes as parts.
+
+# Requirements for successful application
+
+A chain of (n1, n2, n3) can be fused if:
+- All nodes are in the graph.
+- (n1, n2) is an edge in the graph.
+- (n2, n3) is an edge in the graph.
+- n2 has exactly one parent (n3) and exactly one child (n1).
+- n1 has exactly one parent (n2).
+
+[`is_valid_node_fusion_input`](@ref) can be used to `@assert` these requirements.
+
+See also: [`can_fuse`](@ref)
+"""
 struct NodeFusion <: Operation
     input::Tuple{ComputeTaskNode, DataTaskNode, ComputeTaskNode}
 end
 
+"""
+    AppliedNodeFusion <: AppliedOperation
+
+The applied version of the [`NodeFusion`](@ref).
+"""
 struct AppliedNodeFusion <: AppliedOperation
     operation::NodeFusion
     diff::Diff
 end
 
+"""
+    NodeReduction <: Operation
+
+The NodeReduction operation. Represents the reduction of two or more nodes with one another.
+Only one of the input nodes is kept, while all others are deleted and their parents are accumulated in the kept node's parents instead.
+
+After the node reduction is applied, the graph has `length(nr.input) - 1` fewer nodes.
+
+# Requirements for successful application
+
+A vector of nodes can be reduced if:
+- All nodes are in the graph.
+- All nodes have the same task type.
+- All nodes have the same set of children.
+
+[`is_valid_node_reduction_input`](@ref) can be used to `@assert` these requirements.
+
+See also: [`can_reduce`](@ref)
+"""
 struct NodeReduction <: Operation
     input::Vector{Node}
 end
 
+"""
+    AppliedNodeReduction <: AppliedOperation
+
+The applied version of the [`NodeReduction`](@ref).
+"""
 struct AppliedNodeReduction <: AppliedOperation
     operation::NodeReduction
     diff::Diff
 end
 
+"""
+    NodeSplit <: Operation
+
+The NodeSplit operation. Represents the split of its input node into one node for each of its parents. It is the reverse operation to the [`NodeReduction`](@ref).
+
+# Requirements for successful application
+
+A node can be split if:
+- It is in the graph.
+- It has at least 2 parents.
+
+[`is_valid_node_split_input`](@ref) can be used to `@assert` these requirements.
+
+See also: [`can_split`](@ref)
+"""
 struct NodeSplit <: Operation
     input::Node
 end
 
+"""
+    AppliedNodeSplit <: AppliedOperation
+
+The applied version of the [`NodeSplit`](@ref).
+"""
 struct AppliedNodeSplit <: AppliedOperation
     operation::NodeSplit
     diff::Diff

src/operation/utility.jl

@@ -1,10 +1,17 @@
+"""
+    isempty(operations::PossibleOperations)
 
+Return whether `operations` is empty, i.e. all of its fields are empty.
+"""
 function isempty(operations::PossibleOperations)
-    return isempty(operations.nodeFusions) &&
-           isempty(operations.nodeReductions) &&
-           isempty(operations.nodeSplits)
+    return isempty(operations.nodeFusions) && isempty(operations.nodeReductions) && isempty(operations.nodeSplits)
 end
 
+"""
+    length(operations::PossibleOperations)
+
+Return a named tuple with the number of each of the operation types as a named tuple. The fields are named the same as the [`PossibleOperations`](@ref)'.
+"""
 function length(operations::PossibleOperations)
     return (
         nodeFusions = length(operations.nodeFusions),
@@ -13,37 +20,59 @@ function length(operations::PossibleOperations)
     )
 end
 
+"""
+    delete!(operations::PossibleOperations, op::NodeFusion)
+
+Delete the given node fusion from the possible operations.
+"""
 function delete!(operations::PossibleOperations, op::NodeFusion)
     delete!(operations.nodeFusions, op)
     return operations
 end
 
+"""
+    delete!(operations::PossibleOperations, op::NodeReduction)
+
+Delete the given node reduction from the possible operations.
+"""
 function delete!(operations::PossibleOperations, op::NodeReduction)
     delete!(operations.nodeReductions, op)
     return operations
 end
 
+"""
+    delete!(operations::PossibleOperations, op::NodeSplit)
+
+Delete the given node split from the possible operations.
+"""
 function delete!(operations::PossibleOperations, op::NodeSplit)
     delete!(operations.nodeSplits, op)
     return operations
 end
 
+"""
+    can_fuse(n1::ComputeTaskNode, n2::DataTaskNode, n3::ComputeTaskNode)
 
+Return whether the given nodes can be fused. See [`NodeFusion`](@ref) for the requirements.
+"""
 function can_fuse(n1::ComputeTaskNode, n2::DataTaskNode, n3::ComputeTaskNode)
     if !is_child(n1, n2) || !is_child(n2, n3)
         # the checks are redundant but maybe a good sanity check
         return false
     end
 
-    if length(n2.parents) != 1 ||
-       length(n2.children) != 1 ||
-       length(n1.parents) != 1
+    if length(n2.parents) != 1 || length(n2.children) != 1 || length(n1.parents) != 1
         return false
     end
 
     return true
 end
 
+"""
+    can_reduce(n1::Node, n2::Node)
+
+Return whether the given two nodes can be reduced. See [`NodeReduction`](@ref) for the requirements.
+"""
 function can_reduce(n1::Node, n2::Node)
     if (n1.task != n2.task)
         return false
@@ -86,26 +115,49 @@ function can_reduce(n1::Node, n2::Node)
     return Set(n1.children) == Set(n2.children)
 end
 
+"""
+    can_split(n1::Node)
+
+Return whether the given node can be split. See [`NodeSplit`](@ref) for the requirements.
+"""
 function can_split(n::Node)
     return length(parents(n)) > 1
 end
 
+"""
+    ==(op1::Operation, op2::Operation)
+
+Fallback implementation of operation equality. Return false. Actual comparisons are done by the overloads of same type operation comparisons.
+"""
 function ==(op1::Operation, op2::Operation)
     return false
 end
 
+"""
+    ==(op1::NodeFusion, op2::NodeFusion)
+
+Equality comparison between two node fusions. Two node fusions are considered equal if they have the same inputs.
+"""
 function ==(op1::NodeFusion, op2::NodeFusion)
     # there can only be one node fusion on a given data task, so if the data task is the same, the fusion is the same
     return op1.input[2] == op2.input[2]
 end
 
+"""
+    ==(op1::NodeReduction, op2::NodeReduction)
+
+Equality comparison between two node reductions. Two node reductions are considered equal when they have the same inputs.
+"""
 function ==(op1::NodeReduction, op2::NodeReduction)
     # node reductions are equal exactly if their first input is the same
     return op1.input[1].id == op2.input[1].id
 end
 
+"""
+    ==(op1::NodeSplit, op2::NodeSplit)
+
+Equality comparison between two node splits. Two node splits are considered equal if they have the same input node.
+"""
 function ==(op1::NodeSplit, op2::NodeSplit)
     return op1.input == op2.input
 end
-
-copy(id::UUID) = UUID(id.value)

src/operation/validate.jl

@@ -2,24 +2,19 @@
 # should be called with @assert
 # the functions throw their own errors though, to still have helpful error messages
 
-function is_valid_node_fusion_input(
-    graph::DAG,
-    n1::ComputeTaskNode,
-    n2::DataTaskNode,
-    n3::ComputeTaskNode,
-)
+"""
+    is_valid_node_fusion_input(graph::DAG, n1::ComputeTaskNode, n2::DataTaskNode, n3::ComputeTaskNode)
+
+Assert for a gven node fusion input whether the nodes can be fused. For the requirements of a node fusion see [`NodeFusion`](@ref).
+
+Intended for use with `@assert` or `@test`.
+"""
+function is_valid_node_fusion_input(graph::DAG, n1::ComputeTaskNode, n2::DataTaskNode, n3::ComputeTaskNode)
     if !(n1 in graph) || !(n2 in graph) || !(n3 in graph)
-        throw(
-            AssertionError(
-                "[Node Fusion] The given nodes are not part of the given graph",
-            ),
-        )
+        throw(AssertionError("[Node Fusion] The given nodes are not part of the given graph"))
     end
 
-    if !is_child(n1, n2) ||
-       !is_child(n2, n3) ||
-       !is_parent(n3, n2) ||
-       !is_parent(n2, n1)
+    if !is_child(n1, n2) || !is_child(n2, n3) || !is_parent(n3, n2) || !is_parent(n2, n1)
         throw(
             AssertionError(
                 "[Node Fusion] The given nodes are not connected by edges which is required for node fusion",
@@ -28,49 +23,47 @@ function is_valid_node_fusion_input(
     end
 
     if length(n2.parents) > 1
-        throw(
-            AssertionError(
-                "[Node Fusion] The given data node has more than one parent",
-            ),
-        )
+        throw(AssertionError("[Node Fusion] The given data node has more than one parent"))
     end
     if length(n2.children) > 1
-        throw(
-            AssertionError(
-                "[Node Fusion] The given data node has more than one child",
-            ),
-        )
+        throw(AssertionError("[Node Fusion] The given data node has more than one child"))
     end
     if length(n1.parents) > 1
-        throw(
-            AssertionError(
-                "[Node Fusion] The given n1 has more than one parent",
-            ),
-        )
+        throw(AssertionError("[Node Fusion] The given n1 has more than one parent"))
     end
 
+    @assert is_valid(graph, n1)
+    @assert is_valid(graph, n2)
+    @assert is_valid(graph, n3)
+
     return true
 end
 
+"""
+    is_valid_node_reduction_input(graph::DAG, nodes::Vector{Node})
+
+Assert for a gven node reduction input whether the nodes can be reduced. For the requirements of a node reduction see [`NodeReduction`](@ref).
+
+Intended for use with `@assert` or `@test`.
+"""
 function is_valid_node_reduction_input(graph::DAG, nodes::Vector{Node})
     for n in nodes
         if n ∉ graph
-            throw(
-                AssertionError(
-                    "[Node Reduction] The given nodes are not part of the given graph",
-                ),
-            )
+            throw(AssertionError("[Node Reduction] The given nodes are not part of the given graph"))
         end
+        @assert is_valid(graph, n)
     end
 
     t = typeof(nodes[1].task)
     for n in nodes
         if typeof(n.task) != t
-            throw(
-                AssertionError(
-                    "[Node Reduction] The given nodes are not of the same type",
-                ),
-            )
+            throw(AssertionError("[Node Reduction] The given nodes are not of the same type"))
+        end
+
+        if (typeof(n) <: DataTaskNode)
+            if (n.name != nodes[1].name)
+                throw(AssertionError("[Node Reduction] The given nodes do not have the same name"))
+            end
         end
     end
 
@@ -88,13 +81,16 @@ function is_valid_node_reduction_input(graph::DAG, nodes::Vector{Node})
     return true
 end
 
+"""
+    is_valid_node_split_input(graph::DAG, n1::Node)
+
+Assert for a gven node split input whether the node can be split. For the requirements of a node split see [`NodeSplit`](@ref).
+
+Intended for use with `@assert` or `@test`.
+"""
 function is_valid_node_split_input(graph::DAG, n1::Node)
     if n1 ∉ graph
-        throw(
-            AssertionError(
-                "[Node Split] The given node is not part of the given graph",
-            ),
-        )
+        throw(AssertionError("[Node Split] The given node is not part of the given graph"))
     end
 
     if length(n1.parents) <= 1
@@ -105,28 +101,46 @@ function is_valid_node_split_input(graph::DAG, n1::Node)
         )
     end
 
+    @assert is_valid(graph, n1)
+
     return true
 end
 
+"""
+    is_valid(graph::DAG, nr::NodeReduction)
+
+Assert for a given [`NodeReduction`](@ref) whether it is a valid operation in the graph.
+
+Intended for use with `@assert` or `@test`.
+"""
 function is_valid(graph::DAG, nr::NodeReduction)
     @assert is_valid_node_reduction_input(graph, nr.input)
     @assert nr in graph.possibleOperations.nodeReductions "NodeReduction is not part of the graph's possible operations!"
     return true
 end
 
+"""
+    is_valid(graph::DAG, nr::NodeSplit)
+
+Assert for a given [`NodeSplit`](@ref) whether it is a valid operation in the graph.
+
+Intended for use with `@assert` or `@test`.
+"""
 function is_valid(graph::DAG, ns::NodeSplit)
     @assert is_valid_node_split_input(graph, ns.input)
     @assert ns in graph.possibleOperations.nodeSplits "NodeSplit is not part of the graph's possible operations!"
     return true
 end
 
+"""
+    is_valid(graph::DAG, nr::NodeFusion)
+
+Assert for a given [`NodeFusion`](@ref) whether it is a valid operation in the graph.
+
+Intended for use with `@assert` or `@test`.
+"""
 function is_valid(graph::DAG, nf::NodeFusion)
-    @assert is_valid_node_fusion_input(
-        graph,
-        nf.input[1],
-        nf.input[2],
-        nf.input[3],
-    )
+    @assert is_valid_node_fusion_input(graph, nf.input[1], nf.input[2], nf.input[3])
     @assert nf in graph.possibleOperations.nodeFusions "NodeFusion is not part of the graph's possible operations!"
     return true
 end

src/properties/create.jl

@@ -0,0 +1,73 @@
+"""
+   GraphProperties()
+
+Create an empty [`GraphProperties`](@ref) object.
+"""
+function GraphProperties()
+    return (
+        data = 0.0,
+        computeEffort = 0.0,
+        computeIntensity = 0.0,
+        cost = 0.0,
+        noNodes = 0,
+        noEdges = 0,
+    )::GraphProperties
+end
+
+"""
+   GraphProperties(graph::DAG)
+
+Calculate the graph's properties and return the constructed [`GraphProperties`](@ref) object.
+"""
+function GraphProperties(graph::DAG)
+    # make sure the graph is fully generated
+    apply_all!(graph)
+
+    d = 0.0
+    ce = 0.0
+    ed = 0
+    for node in graph.nodes
+        d += data(node.task) * length(node.parents)
+        ce += compute_effort(node.task)
+        ed += length(node.parents)
+    end
+
+    return (
+        data = d,
+        computeEffort = ce,
+        computeIntensity = (d == 0) ? 0.0 : ce / d,
+        cost = 0.0, # TODO
+        noNodes = length(graph.nodes),
+        noEdges = ed,
+    )::GraphProperties
+end
+
+"""
+   GraphProperties(diff::Diff)
+
+Create the graph properties difference from a given [`Diff`](@ref).
+The graph's properties after applying the [`Diff`](@ref) will be `get_properties(graph) + GraphProperties(diff)`.
+For reverting a diff, it's `get_properties(graph) - GraphProperties(diff)`.
+"""
+function GraphProperties(diff::Diff)
+    d = 0.0
+    ce = 0.0
+    c = 0.0 # TODO
+
+    ce =
+        reduce(+, compute_effort(n.task) for n in diff.addedNodes; init = 0.0) -
+        reduce(+, compute_effort(n.task) for n in diff.removedNodes; init = 0.0)
+
+    d =
+        reduce(+, data(e) for e in diff.addedEdges; init = 0.0) -
+        reduce(+, data(e) for e in diff.removedEdges; init = 0.0)
+
+    return (
+        data = d,
+        computeEffort = ce,
+        computeIntensity = (d == 0) ? 0.0 : ce / d,
+        cost = c,
+        noNodes = length(diff.addedNodes) - length(diff.removedNodes),
+        noEdges = length(diff.addedEdges) - length(diff.removedEdges),
+    )::GraphProperties
+end

src/properties/type.jl

@@ -0,0 +1,17 @@
+"""
+   GraphProperties
+
+Representation of a [`DAG`](@ref)'s properties.
+
+# Fields:
+`.data`: The total data transfer.\\
+`.computeEffort`: The total compute effort.\\
+`.computeIntensity`: The compute intensity, will always equal `.computeEffort / .data`.\\
+`.cost`: The estimated cost.\\
+`.noNodes`: Number of [`Node`](@ref)s.\\
+`.noEdges`: Number of [`Edge`](@ref)s.
+"""
+const GraphProperties = NamedTuple{
+    (:data, :computeEffort, :computeIntensity, :cost, :noNodes, :noEdges),
+    Tuple{Float64, Float64, Float64, Float64, Int, Int},
+}

src/properties/utility.jl

@@ -0,0 +1,57 @@
+"""
+    -(prop1::GraphProperties, prop2::GraphProperties)
+
+Subtract `prop1` from `prop2` and return the result as a new [`GraphProperties`](@ref).
+Also take care to keep consistent compute intensity.
+"""
+function -(prop1::GraphProperties, prop2::GraphProperties)
+    return (
+        data = prop1.data - prop2.data,
+        computeEffort = prop1.computeEffort - prop2.computeEffort,
+        computeIntensity = if (prop1.data - prop2.data == 0)
+            0.0
+        else
+            (prop1.computeEffort - prop2.computeEffort) / (prop1.data - prop2.data)
+        end,
+        cost = prop1.cost - prop2.cost,
+        noNodes = prop1.noNodes - prop2.noNodes,
+        noEdges = prop1.noEdges - prop2.noEdges,
+    )::GraphProperties
+end
+
+"""
+    +(prop1::GraphProperties, prop2::GraphProperties)
+
+Add `prop1` and `prop2` and return the result as a new [`GraphProperties`](@ref).
+Also take care to keep consistent compute intensity.
+"""
+function +(prop1::GraphProperties, prop2::GraphProperties)
+    return (
+        data = prop1.data + prop2.data,
+        computeEffort = prop1.computeEffort + prop2.computeEffort,
+        computeIntensity = if (prop1.data + prop2.data == 0)
+            0.0
+        else
+            (prop1.computeEffort + prop2.computeEffort) / (prop1.data + prop2.data)
+        end,
+        cost = prop1.cost + prop2.cost,
+        noNodes = prop1.noNodes + prop2.noNodes,
+        noEdges = prop1.noEdges + prop2.noEdges,
+    )::GraphProperties
+end
+
+"""
+    -(prop::GraphProperties)
+
+Unary negation of the graph properties. `.computeIntensity` will not be negated because `.data` and `.computeEffort` both are.
+"""
+function -(prop::GraphProperties)
+    return (
+        data = -prop.data,
+        computeEffort = -prop.computeEffort,
+        computeIntensity = prop.computeIntensity,   # no negation here!
+        cost = -prop.cost,
+        noNodes = -prop.noNodes,
+        noEdges = -prop.noEdges,
+    )::GraphProperties
+end

src/scheduler/greedy.jl

@@ -0,0 +1,50 @@
+
+"""
+    GreedyScheduler
+
+A greedy implementation of a scheduler, creating a topological ordering of nodes and naively balancing them onto the different devices.
+"""
+struct GreedyScheduler end
+
+function schedule_dag(::GreedyScheduler, graph::DAG, machine::Machine)
+    nodeQueue = PriorityQueue{Node, Int}()
+
+    # use a priority equal to the number of unseen children -> 0 are nodes that can be added
+    for node in get_entry_nodes(graph)
+        enqueue!(nodeQueue, node => 0)
+    end
+
+    schedule = Vector{Node}()
+    sizehint!(schedule, length(graph.nodes))
+
+    # keep an accumulated cost of things scheduled to this device so far
+    deviceAccCost = PriorityQueue{AbstractDevice, Int}()
+    for device in machine.devices
+        enqueue!(deviceAccCost, device => 0)
+    end
+
+    node = nothing
+    while !isempty(nodeQueue)
+        @assert peek(nodeQueue)[2] == 0
+        node = dequeue!(nodeQueue)
+
+        # assign the device with lowest accumulated cost to the node (if it's a compute node)
+        if (isa(node, ComputeTaskNode))
+            lowestDevice = peek(deviceAccCost)[1]
+            node.device = lowestDevice
+            deviceAccCost[lowestDevice] = compute_effort(node.task)
+        end
+
+        push!(schedule, node)
+        for parent in node.parents
+            # reduce the priority of all parents by one
+            if (!haskey(nodeQueue, parent))
+                enqueue!(nodeQueue, parent => length(parent.children) - 1)
+            else
+                nodeQueue[parent] = nodeQueue[parent] - 1
+            end
+        end
+    end
+
+    return schedule
+end

src/scheduler/interface.jl

@@ -0,0 +1,18 @@
+
+"""
+    Scheduler
+
+Abstract base type for scheduler implementations. The scheduler is used to assign each node to a device and create a topological ordering of tasks.
+"""
+abstract type Scheduler end
+
+"""
+    schedule_dag(::Scheduler, ::DAG, ::Machine)
+
+Interface functions that must be implemented for implementations of [`Scheduler`](@ref).
+
+The function assigns each [`ComputeTaskNode`](@ref) of the [`DAG`](@ref) to one of the devices in the given [`Machine`](@ref) and returns a `Vector{Node}` representing a topological ordering.
+
+[`DataTaskNode`](@ref)s are not scheduled to devices since they do not compute. Instead, a data node transfers data from the [`AbstractDevice`](@ref) of their child to all [`AbstractDevice`](@ref)s of its parents.
+"""
+function schedule_dag end

src/task/compare.jl

@@ -1,11 +1,26 @@
+"""
+    ==(t1::AbstractTask, t2::AbstractTask)
+
+Fallback implementation of equality comparison between two abstract tasks. Always returns false. For equal specific types of t1 and t2, a more specific comparison is called instead, doing an actual comparison.
+"""
 function ==(t1::AbstractTask, t2::AbstractTask)
     return false
 end
 
+"""
+    ==(t1::AbstractComputeTask, t2::AbstractComputeTask)
+
+Equality comparison between two compute tasks.
+"""
 function ==(t1::AbstractComputeTask, t2::AbstractComputeTask)
     return typeof(t1) == typeof(t2)
 end
 
+"""
+    ==(t1::AbstractDataTask, t2::AbstractDataTask)
+
+Equality comparison between two data tasks.
+"""
 function ==(t1::AbstractDataTask, t2::AbstractDataTask)
     return data(t1) == data(t2)
 end

src/task/compute.jl

@@ -0,0 +1,89 @@
+
+"""
+    compute(t::FusedComputeTask, data)
+
+Compute a [`FusedComputeTask`](@ref). This simply asserts false and should not be called. Fused Compute Tasks generate their expressions directly through the other tasks instead.
+"""
+function compute(t::FusedComputeTask, data)
+    @assert false "This is not implemented and should never be called"
+end
+
+"""
+    get_expression(t::FusedComputeTask, device::AbstractDevice, inExprs::Vector{String}, outExpr::String)
+
+Generate code evaluating a [`FusedComputeTask`](@ref) on `inExprs`, providing the output on `outExpr`.
+`inExprs` should be of the correct types and may be heterogeneous. `outExpr` will be of the type of the output of `T2` of t.
+"""
+function get_expression(t::FusedComputeTask, device::AbstractDevice, inExprs::Vector, outExpr)
+    inExprs1 = Vector()
+    for sym in t.t1_inputs
+        push!(inExprs1, gen_access_expr(device, sym))
+    end
+
+    outExpr1 = gen_access_expr(device, t.t1_output)
+
+    inExprs2 = Vector()
+    for sym in t.t2_inputs
+        push!(inExprs2, gen_access_expr(device, sym))
+    end
+
+    expr1 = get_expression(t.first_task, device, inExprs1, outExpr1)
+    expr2 = get_expression(t.second_task, device, [inExprs2..., outExpr1], outExpr)
+
+    full_expr = Expr(:block, expr1, expr2)
+
+    return full_expr
+end
+
+"""
+    get_expression(node::ComputeTaskNode)
+
+Generate and return code for a given [`ComputeTaskNode`](@ref).
+"""
+function get_expression(node::ComputeTaskNode)
+    @assert length(node.children) <= children(node.task) "Node $(node) has too many children for its task: node has $(length(node.children)) versus task has $(children(node.task))\nNode's children: $(getfield.(node.children, :children))"
+    @assert !ismissing(node.device) "Trying to get expression for an unscheduled ComputeTaskNode\nNode: $(node)"
+
+    inExprs = Vector()
+    for id in getfield.(node.children, :id)
+        push!(inExprs, gen_access_expr(node.device, Symbol(to_var_name(id))))
+    end
+    outExpr = gen_access_expr(node.device, Symbol(to_var_name(node.id)))
+
+    return get_expression(node.task, node.device, inExprs, outExpr)
+end
+
+"""
+    get_expression(node::DataTaskNode)
+
+Generate and return code for a given [`DataTaskNode`](@ref).
+"""
+function get_expression(node::DataTaskNode)
+    @assert length(node.children) == 1 "Trying to call get_expression on a data task node that has $(length(node.children)) children instead of 1"
+
+    # TODO: dispatch to device implementations generating the copy commands
+
+    child = node.children[1]
+    inExpr = eval(gen_access_expr(child.device, Symbol(to_var_name(child.id))))
+    outExpr = eval(gen_access_expr(child.device, Symbol(to_var_name(node.id))))
+    dataTransportExp = Meta.parse("$outExpr = $inExpr")
+
+    return dataTransportExp
+end
+
+"""
+    get_init_expression(node::DataTaskNode, device::AbstractDevice)
+
+Generate and return code for the initial input reading expression for [`DataTaskNode`](@ref)s with 0 children, i.e., entry nodes.
+
+See also: [`get_entry_nodes`](@ref)
+"""
+function get_init_expression(node::DataTaskNode, device::AbstractDevice)
+    @assert isempty(node.children) "Trying to call get_init_expression on a data task node that is not an entry node."
+
+    inExpr = eval(gen_access_expr(device, Symbol("$(to_var_name(node.id))_in")))
+    outExpr = eval(gen_access_expr(device, Symbol(to_var_name(node.id))))
+    dataTransportExp = Meta.parse("$outExpr = $inExpr")
+
+    return dataTransportExp
+end

src/task/create.jl

@@ -0,0 +1,31 @@
+"""
+    copy(t::AbstractDataTask)
+
+Fallback implementation of the copy of an abstract data task, throwing an error.
+"""
+copy(t::AbstractDataTask) = error("Need to implement copying for your data tasks!")
+
+"""
+    copy(t::AbstractComputeTask)
+
+Return a copy of the given compute task.
+"""
+copy(t::AbstractComputeTask) = typeof(t)()
+
+"""
+    copy(t::FusedComputeTask)
+
+Return a copy of th egiven [`FusedComputeTask`](@ref).
+"""
+function copy(t::FusedComputeTask{T1, T2}) where {T1, T2}
+    return FusedComputeTask{T1, T2}(
+        copy(t.first_task),
+        copy(t.second_task),
+        copy(t.t1_inputs),
+        t.t1_output,
+        copy(t.t2_inputs),
+    )
+end
+
+FusedComputeTask{T1, T2}(t1_inputs::Vector{String}, t1_output::String, t2_inputs::Vector{String}) where {T1, T2} =
+    FusedComputeTask{T1, T2}(T1(), T2(), t1_inputs, t1_output, t2_inputs)

src/task/print.jl

@@ -1,4 +1,8 @@
+"""
+    show(io::IO, t::FusedComputeTask)
+    
+Print a string representation of the fused compute task to io.
+"""
 function show(io::IO, t::FusedComputeTask)
-    (T1, T2) = get_types(t)
-    return print(io, "ComputeFuse(", T1(), ", ", T2(), ")")
+    return print(io, "ComputeFuse($(t.first_task), $(t.second_task))")
 end

src/task/properties.jl

@@ -1,33 +1,82 @@
+"""
+    compute(t::AbstractTask; data...)
+
+Fallback implementation of the compute function of a compute task, throwing an error.
+"""
 function compute(t::AbstractTask; data...)
     return error("Need to implement compute()")
 end
 
+"""
+    compute(t::FusedComputeTask; data...)
+
+Compute a fused compute task.
+"""
+function compute(t::FusedComputeTask; data...)
+    (T1, T2) = collect(typeof(t).parameters)
+
+    return compute(T2(), compute(T1(), data))
+end
+
+"""
+    compute(t::AbstractDataTask; data...)
+
+The compute function of a data task, always the identity function, regardless of the specific task.
+"""
+compute(t::AbstractDataTask; data...) = data
+
+"""
+    compute_effort(t::AbstractTask)
+
+Fallback implementation of the compute effort of a task, throwing an error.
+"""
 function compute_effort(t::AbstractTask)
     # default implementation using compute
     return error("Need to implement compute_effort()")
 end
 
+"""
+    data(t::AbstractTask)
+
+Fallback implementation of the data of a task, throwing an error.
+"""
 function data(t::AbstractTask)
     return error("Need to implement data()")
 end
 
+"""
+    compute_effort(t::AbstractDataTask)
+
+Return the compute effort of a data task, always zero, regardless of the specific task.
+"""
 compute_effort(t::AbstractDataTask) = 0
-compute(t::AbstractDataTask; data...) = data
+
+"""
+    data(t::AbstractDataTask)
+
+Return the data of a data task. Given by the task's `.data` field.
+"""
 data(t::AbstractDataTask) = getfield(t, :data)
 
+"""
+    data(t::AbstractComputeTask)
+
+Return the data of a compute task, always zero, regardless of the specific task.
+"""
 data(t::AbstractComputeTask) = 0
 
+"""
+    compute_effort(t::FusedComputeTask)
+
+Return the compute effort of a fused compute task. 
+"""
 function compute_effort(t::FusedComputeTask)
-    (T1, T2) = collect(typeof(t).parameters)
-    return compute_effort(T1()) + compute_effort(T2())
+    return compute_effort(t.first_task) + compute_effort(t.second_task)
 end
 
-# actual compute functions for the tasks can stay undefined for now
-# compute(t::ComputeTaskU, data::Any) = mycomputation(data)
+"""
+    get_types(::FusedComputeTask{T1, T2})
 
-function compute_intensity(t::AbstractTask)::UInt64
-    if data(t) == 0
-        return typemax(UInt64)
-    end
-    return compute_effort(t) / data(t)
-end
+Return a tuple of a the fused compute task's components' types.
+"""
+get_types(::FusedComputeTask{T1, T2}) where {T1, T2} = (T1, T2)

src/task/type.jl

@@ -1,13 +1,38 @@
+"""
+    AbstractTask
+
+The shared base type for any task.
+"""
 abstract type AbstractTask end
 
+"""
+    AbstractComputeTask <: AbstractTask
+
+The shared base type for any compute task.
+"""
 abstract type AbstractComputeTask <: AbstractTask end
+
+"""
+    AbstractDataTask <: AbstractTask
+
+The shared base type for any data task.
+"""
 abstract type AbstractDataTask <: AbstractTask end
 
-struct FusedComputeTask{T1 <: AbstractComputeTask, T2 <: AbstractComputeTask} <:
-       AbstractComputeTask end
+"""
+    FusedComputeTask{T1 <: AbstractComputeTask, T2 <: AbstractComputeTask} <: AbstractComputeTask
 
-get_types(::FusedComputeTask{T1, T2}) where {T1, T2} = (T1, T2)
+A fused compute task made up of the computation of first `T1` and then `T2`.
 
-copy(t::AbstractDataTask) =
-    error("Need to implement copying for your data tasks!")
-copy(t::AbstractComputeTask) = typeof(t)()
+Also see: [`get_types`](@ref).
+"""
+struct FusedComputeTask{T1 <: AbstractComputeTask, T2 <: AbstractComputeTask} <: AbstractComputeTask
+    first_task::T1
+    second_task::T2
+    # the names of the inputs for T1
+    t1_inputs::Vector{Symbol}
+    # output name of T1
+    t1_output::Symbol
+    # t2_inputs doesn't include the output of t1, that's implicit
+    t2_inputs::Vector{Symbol}
+end

src/trie.jl

@@ -1,26 +1,49 @@
+"""
+    NodeIdTrie
 
-# helper struct for NodeTrie
+Helper struct for [`NodeTrie`](@ref). After the Trie's first level, every Trie level contains the vector of nodes that had children up to that level, and the TrieNode's children by UUID of the node's children.
+"""
 mutable struct NodeIdTrie
     value::Vector{Node}
     children::Dict{UUID, NodeIdTrie}
 end
 
-# Trie data structure for node reduction, inserts nodes by children
-# Assumes that given nodes have ordered vectors of children (see sort_node)
-# First level is the task type and thus does not have a value
-# Should be constructed with all Types that will be used
+"""
+    NodeTrie
+
+Trie data structure for node reduction, inserts nodes by children.
+Assumes that given nodes have ordered vectors of children (see [`sort_node!`](@ref)).
+First insertion level is the node's own task type and thus does not have a value (every node has a task type).
+
+See also: [`insert!`](@ref) and [`collect`](@ref)
+"""
 mutable struct NodeTrie
     children::Dict{DataType, NodeIdTrie}
 end
 
+"""
+    NodeTrie()
+
+Constructor for an empty [`NodeTrie`](@ref).
+"""
 function NodeTrie()
     return NodeTrie(Dict{DataType, NodeIdTrie}())
 end
 
+"""
+    NodeIdTrie()
+
+Constructor for an empty [`NodeIdTrie`](@ref).
+"""
 function NodeIdTrie()
     return NodeIdTrie(Vector{Node}(), Dict{UUID, NodeIdTrie}())
 end
 
+"""
+    insert_helper!(trie::NodeIdTrie, node::Node, depth::Int)
+
+Insert the given node into the trie. The depth is used to iterate through the trie layers, while the function calls itself recursively until it ran through all children of the node.
+"""
 function insert_helper!(trie::NodeIdTrie, node::Node, depth::Int)
     if (length(node.children) == depth)
         push!(trie.value, node)
@@ -36,6 +59,11 @@ function insert_helper!(trie::NodeIdTrie, node::Node, depth::Int)
     return insert_helper!(trie.children[id], node, depth)
 end
 
+"""
+    insert!(trie::NodeTrie, node::Node)
+
+Insert the given node into the trie. It's sorted by its type in the first layer, then by its children in the following layers.
+"""
 function insert!(trie::NodeTrie, node::Node)
     t = typeof(node.task)
     if (!haskey(trie.children, t))
@@ -44,6 +72,11 @@ function insert!(trie::NodeTrie, node::Node)
     return insert_helper!(trie.children[typeof(node.task)], node, 0)
 end
 
+"""
+    collect_helper(trie::NodeIdTrie, acc::Set{Vector{Node}})
+
+Collects the Vectors of this [`NodeIdTrie`](@ref) node and all its children and puts them in the `acc` argument.
+"""
 function collect_helper(trie::NodeIdTrie, acc::Set{Vector{Node}})
     if (length(trie.value) >= 2)
         push!(acc, trie.value)
@@ -55,7 +88,11 @@ function collect_helper(trie::NodeIdTrie, acc::Set{Vector{Node}})
     return nothing
 end
 
-# returns all sets of multiple nodes that have accumulated in leaves
+"""
+    collect(trie::NodeTrie)
+
+Return all sets of at least 2 [`Node`](@ref)s that have accumulated in leaves of the trie.
+"""
 function collect(trie::NodeTrie)
     acc = Set{Vector{Node}}()
     for (t, child) in trie.children

src/utility.jl

@@ -1,3 +1,15 @@
+"""
+    bytes_to_human_readable(bytes)
+
+Return a human readable string representation of the given number.
+
+```jldoctest
+julia> using MetagraphOptimization
+
+julia> bytes_to_human_readable(4096)
+"4.0 KiB"
+```
+"""
 function bytes_to_human_readable(bytes)
     units = ["B", "KiB", "MiB", "GiB", "TiB"]
     unit_index = 1
@@ -8,15 +20,31 @@ function bytes_to_human_readable(bytes)
     return string(round(bytes, sigdigits = 4), " ", units[unit_index])
 end
 
+"""
+    lt_nodes(n1::Node, n2::Node)
+
+Less-Than comparison between nodes. Uses the nodes' ids to sort.
+"""
 function lt_nodes(n1::Node, n2::Node)
     return n1.id < n2.id
 end
 
+"""
+    sort_node!(node::Node)
+
+Sort the nodes' parents and children vectors. The vectors are mostly very short so sorting does not take a lot of time.
+Sorted nodes are required to make the finding of [`NodeReduction`](@ref)s a lot faster using the [`NodeTrie`](@ref) data structure.
+"""
 function sort_node!(node::Node)
     sort!(node.children, lt = lt_nodes)
     return sort!(node.parents, lt = lt_nodes)
 end
 
+"""
+    mem(graph::DAG)
+
+Return the memory footprint of the graph in Byte. Should be the same result as `Base.summarysize(graph)` but a lot faster.
+"""
 function mem(graph::DAG)
     size = 0
     size += Base.summarysize(graph.nodes, exclude = Union{Node})
@@ -42,12 +70,36 @@ function mem(graph::DAG)
     return size += sizeof(diff)
 end
 
-# calculate the size of this operation in Byte
+"""
+    mem(op::Operation)
+
+Return the memory footprint of the operation in Byte. Used in [`mem(graph::DAG)`](@ref). Unlike `Base.summarysize()` this doesn't follow all references which would yield (almost) the size of the entire graph.
+"""
 function mem(op::Operation)
     return Base.summarysize(op, exclude = Union{Node})
 end
 
-# calculate the size of this node in Byte
+"""
+    mem(op::Operation)
+
+Return the memory footprint of the node in Byte. Used in [`mem(graph::DAG)`](@ref). Unlike `Base.summarysize()` this doesn't follow all references which would yield (almost) the size of the entire graph.
+"""
 function mem(node::Node)
     return Base.summarysize(node, exclude = Union{Node, Operation})
 end
+
+"""
+    unroll_symbol_vector(vec::Vector{Symbol})
+
+Return the given vector as single String without quotation marks or brackets.
+"""
+function unroll_symbol_vector(vec::Vector)
+    result = ""
+    for s in vec
+        if (result != "")
+            result *= ", "
+        end
+        result *= "$s"
+    end
+    return result
+end

test/Project.toml

@@ -1,3 +1,4 @@
 [deps]
+QEDbase = "10e22c08-3ccb-4172-bfcf-7d7aa3d04d93"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"

test/known_graphs.jl

@@ -2,8 +2,8 @@ using Random
 
 function test_known_graph(name::String, n, fusion_test = true)
     @testset "Test $name Graph ($n)" begin
-        graph = parse_abc(joinpath(@__DIR__, "..", "input", "$name.txt"))
-        props = graph_properties(graph)
+        graph = parse_dag(joinpath(@__DIR__, "..", "input", "$name.txt"), ABCModel())
+        props = get_properties(graph)
 
         if (fusion_test)
             test_node_fusion(graph)
@@ -14,13 +14,13 @@ end
 
 function test_node_fusion(g::DAG)
     @testset "Test Node Fusion" begin
-        props = graph_properties(g)
+        props = get_properties(g)
 
         options = get_operations(g)
 
         nodes_number = length(g.nodes)
         data = props.data
-        compute_effort = props.compute_effort
+        compute_effort = props.computeEffort
 
         while !isempty(options.nodeFusions)
             fusion = first(options.nodeFusions)
@@ -29,13 +29,13 @@ function test_node_fusion(g::DAG)
 
             push_operation!(g, fusion)
 
-            props = graph_properties(g)
+            props = get_properties(g)
             @test props.data < data
-            @test props.compute_effort == compute_effort
+            @test props.computeEffort == compute_effort
 
             nodes_number = length(g.nodes)
             data = props.data
-            compute_effort = props.compute_effort
+            compute_effort = props.computeEffort
 
             options = get_operations(g)
         end
@@ -49,7 +49,7 @@ function test_random_walk(g::DAG, n::Int64)
 
         @test is_valid(g)
 
-        properties = graph_properties(g)
+        properties = get_properties(g)
 
         for i in 1:n
             # choose push or pop
@@ -82,7 +82,7 @@ function test_random_walk(g::DAG, n::Int64)
 
         @test is_valid(g)
 
-        @test properties == graph_properties(g)
+        @test properties == get_properties(g)
     end
 end
 

test/node_reduction.jl

@@ -5,51 +5,51 @@ import MetagraphOptimization.make_node
 @testset "Unit Tests Node Reduction" begin
     graph = MetagraphOptimization.DAG()
 
-    d_exit = insert_node!(graph, make_node(DataTask(10)), false)
+    d_exit = insert_node!(graph, make_node(DataTask(10)), track = false)
 
-    s0 = insert_node!(graph, make_node(ComputeTaskS2()), false)
+    s0 = insert_node!(graph, make_node(ComputeTaskS2()), track = false)
 
-    ED = insert_node!(graph, make_node(DataTask(3)), false)
-    FD = insert_node!(graph, make_node(DataTask(3)), false)
+    ED = insert_node!(graph, make_node(DataTask(3)), track = false)
+    FD = insert_node!(graph, make_node(DataTask(3)), track = false)
 
-    EC = insert_node!(graph, make_node(ComputeTaskV()), false)
-    FC = insert_node!(graph, make_node(ComputeTaskV()), false)
+    EC = insert_node!(graph, make_node(ComputeTaskV()), track = false)
+    FC = insert_node!(graph, make_node(ComputeTaskV()), track = false)
 
-    A1D = insert_node!(graph, make_node(DataTask(4)), false)
-    B1D_1 = insert_node!(graph, make_node(DataTask(4)), false)
-    B1D_2 = insert_node!(graph, make_node(DataTask(4)), false)
-    C1D = insert_node!(graph, make_node(DataTask(4)), false)
+    A1D = insert_node!(graph, make_node(DataTask(4)), track = false)
+    B1D_1 = insert_node!(graph, make_node(DataTask(4)), track = false)
+    B1D_2 = insert_node!(graph, make_node(DataTask(4)), track = false)
+    C1D = insert_node!(graph, make_node(DataTask(4)), track = false)
 
-    A1C = insert_node!(graph, make_node(ComputeTaskU()), false)
-    B1C_1 = insert_node!(graph, make_node(ComputeTaskU()), false)
-    B1C_2 = insert_node!(graph, make_node(ComputeTaskU()), false)
-    C1C = insert_node!(graph, make_node(ComputeTaskU()), false)
+    A1C = insert_node!(graph, make_node(ComputeTaskU()), track = false)
+    B1C_1 = insert_node!(graph, make_node(ComputeTaskU()), track = false)
+    B1C_2 = insert_node!(graph, make_node(ComputeTaskU()), track = false)
+    C1C = insert_node!(graph, make_node(ComputeTaskU()), track = false)
 
-    AD = insert_node!(graph, make_node(DataTask(5)), false)
-    BD = insert_node!(graph, make_node(DataTask(5)), false)
-    CD = insert_node!(graph, make_node(DataTask(5)), false)
+    AD = insert_node!(graph, make_node(DataTask(5)), track = false)
+    BD = insert_node!(graph, make_node(DataTask(5)), track = false)
+    CD = insert_node!(graph, make_node(DataTask(5)), track = false)
 
-    insert_edge!(graph, s0, d_exit, false)
-    insert_edge!(graph, ED, s0, false)
-    insert_edge!(graph, FD, s0, false)
-    insert_edge!(graph, EC, ED, false)
-    insert_edge!(graph, FC, FD, false)
+    insert_edge!(graph, s0, d_exit, track = false)
+    insert_edge!(graph, ED, s0, track = false)
+    insert_edge!(graph, FD, s0, track = false)
+    insert_edge!(graph, EC, ED, track = false)
+    insert_edge!(graph, FC, FD, track = false)
 
-    insert_edge!(graph, A1D, EC, false)
-    insert_edge!(graph, B1D_1, EC, false)
+    insert_edge!(graph, A1D, EC, track = false)
+    insert_edge!(graph, B1D_1, EC, track = false)
 
-    insert_edge!(graph, B1D_2, FC, false)
-    insert_edge!(graph, C1D, FC, false)
+    insert_edge!(graph, B1D_2, FC, track = false)
+    insert_edge!(graph, C1D, FC, track = false)
 
-    insert_edge!(graph, A1C, A1D, false)
-    insert_edge!(graph, B1C_1, B1D_1, false)
-    insert_edge!(graph, B1C_2, B1D_2, false)
-    insert_edge!(graph, C1C, C1D, false)
+    insert_edge!(graph, A1C, A1D, track = false)
+    insert_edge!(graph, B1C_1, B1D_1, track = false)
+    insert_edge!(graph, B1C_2, B1D_2, track = false)
+    insert_edge!(graph, C1C, C1D, track = false)
 
-    insert_edge!(graph, AD, A1C, false)
-    insert_edge!(graph, BD, B1C_1, false)
-    insert_edge!(graph, BD, B1C_2, false)
-    insert_edge!(graph, CD, C1C, false)
+    insert_edge!(graph, AD, A1C, track = false)
+    insert_edge!(graph, BD, B1C_1, track = false)
+    insert_edge!(graph, BD, B1C_2, track = false)
+    insert_edge!(graph, CD, C1C, track = false)
 
     @test is_valid(graph)
 

test/runtests.jl

@@ -5,8 +5,10 @@ using Test
     include("unit_tests_utility.jl")
     include("unit_tests_tasks.jl")
     include("unit_tests_nodes.jl")
+    include("unit_tests_properties.jl")
     include("node_reduction.jl")
     include("unit_tests_graph.jl")
+    include("unit_tests_execution.jl")
 
     include("known_graphs.jl")
 end

test/unit_tests_execution.jl

@@ -0,0 +1,177 @@
+import MetagraphOptimization.ABCParticle
+
+using QEDbase
+
+include("../examples/profiling_utilities.jl")
+
+@testset "Unit Tests Execution" begin
+    machine = get_machine_info()
+
+    process_2_2 = ABCProcessDescription(
+        Dict{Type, Int64}(ParticleA => 1, ParticleB => 1),
+        Dict{Type, Int64}(ParticleA => 1, ParticleB => 1),
+    )
+
+    particles_2_2 = ABCProcessInput(
+        process_2_2,
+        ABCParticle[
+            ParticleA(SFourMomentum(0.823648, 0.0, 0.0, 0.823648)),
+            ParticleB(SFourMomentum(0.823648, 0.0, 0.0, -0.823648)),
+        ],
+        ABCParticle[
+            ParticleA(SFourMomentum(0.823648, -0.835061, -0.474802, 0.277915)),
+            ParticleB(SFourMomentum(0.823648, 0.835061, 0.474802, -0.277915)),
+        ],
+    )
+    expected_result = 0.00013916495566048735
+
+    @testset "AB->AB no optimization" begin
+        for _ in 1:10   # test in a loop because graph layout should not change the result
+            graph = parse_dag(joinpath(@__DIR__, "..", "input", "AB->AB.txt"), ABCModel())
+            @test isapprox(execute(graph, process_2_2, machine, particles_2_2), expected_result; rtol = 0.001)
+
+            # graph should be fully scheduled after being executed
+            @test is_scheduled(graph)
+
+            func = get_compute_function(graph, process_2_2, machine)
+            @test isapprox(func(particles_2_2), expected_result; rtol = 0.001)
+        end
+    end
+
+    @testset "AB->AB after random walk" begin
+        for i in 1:1000
+            graph = parse_dag(joinpath(@__DIR__, "..", "input", "AB->AB.txt"), ABCModel())
+            random_walk!(graph, 50)
+
+            @test is_valid(graph)
+
+            @test isapprox(execute(graph, process_2_2, machine, particles_2_2), expected_result; rtol = 0.001)
+
+            # graph should be fully scheduled after being executed
+            @test is_scheduled(graph)
+        end
+    end
+
+    process_2_4 = ABCProcessDescription(
+        Dict{Type, Int64}(ParticleA => 1, ParticleB => 1),
+        Dict{Type, Int64}(ParticleA => 1, ParticleB => 3),
+    )
+    particles_2_4 = gen_process_input(process_2_4)
+    graph = parse_dag(joinpath(@__DIR__, "..", "input", "AB->ABBB.txt"), ABCModel())
+    expected_result = execute(graph, process_2_4, machine, particles_2_4)
+
+    @testset "AB->ABBB no optimization" begin
+        for _ in 1:5   # test in a loop because graph layout should not change the result
+            graph = parse_dag(joinpath(@__DIR__, "..", "input", "AB->ABBB.txt"), ABCModel())
+            @test isapprox(execute(graph, process_2_4, machine, particles_2_4), expected_result; rtol = 0.001)
+
+            func = get_compute_function(graph, process_2_4, machine)
+            @test isapprox(func(particles_2_4), expected_result; rtol = 0.001)
+        end
+    end
+
+    @testset "AB->ABBB after random walk" begin
+        for i in 1:200
+            graph = parse_dag(joinpath(@__DIR__, "..", "input", "AB->ABBB.txt"), ABCModel())
+            random_walk!(graph, 100)
+            @test is_valid(graph)
+
+            @test isapprox(execute(graph, process_2_4, machine, particles_2_4), expected_result; rtol = 0.001)
+        end
+    end
+
+    @testset "AB->AB large sum fusion" for _ in 1:20
+        graph = parse_dag(joinpath(@__DIR__, "..", "input", "AB->AB.txt"), ABCModel())
+
+        # push a fusion with the sum node
+        ops = get_operations(graph)
+        for fusion in ops.nodeFusions
+            if isa(fusion.input[3].task, ComputeTaskSum)
+                push_operation!(graph, fusion)
+                break
+            end
+        end
+
+        # push two more fusions with the fused node
+        for _ in 1:15
+            ops = get_operations(graph)
+            for fusion in ops.nodeFusions
+                if isa(fusion.input[3].task, FusedComputeTask)
+                    push_operation!(graph, fusion)
+                    break
+                end
+            end
+        end
+
+        # try execute
+        @test is_valid(graph)
+        expected_result = 0.00013916495566048735
+        @test isapprox(execute(graph, process_2_2, machine, particles_2_2), expected_result; rtol = 0.001)
+    end
+
+
+    @testset "AB->AB large sum fusion" for _ in 1:20
+        graph = parse_dag(joinpath(@__DIR__, "..", "input", "AB->AB.txt"), ABCModel())
+
+        # push a fusion with the sum node
+        ops = get_operations(graph)
+        for fusion in ops.nodeFusions
+            if isa(fusion.input[3].task, ComputeTaskSum)
+                push_operation!(graph, fusion)
+                break
+            end
+        end
+
+        # push two more fusions with the fused node
+        for _ in 1:15
+            ops = get_operations(graph)
+            for fusion in ops.nodeFusions
+                if isa(fusion.input[3].task, FusedComputeTask)
+                    push_operation!(graph, fusion)
+                    break
+                end
+            end
+        end
+
+        # try execute
+        @test is_valid(graph)
+        expected_result = 0.00013916495566048735
+        @test isapprox(execute(graph, process_2_2, machine, particles_2_2), expected_result; rtol = 0.001)
+    end
+
+    @testset "AB->AB fusion edge case" for _ in 1:20
+        graph = parse_dag(joinpath(@__DIR__, "..", "input", "AB->AB.txt"), ABCModel())
+
+        # push two fusions with ComputeTaskV
+        for _ in 1:2
+            ops = get_operations(graph)
+            for fusion in ops.nodeFusions
+                if isa(fusion.input[1].task, ComputeTaskV)
+                    push_operation!(graph, fusion)
+                    break
+                end
+            end
+        end
+
+        # push fusions until the end
+        cont = true
+        while cont
+            cont = false
+            ops = get_operations(graph)
+            for fusion in ops.nodeFusions
+                if isa(fusion.input[1].task, FusedComputeTask)
+                    push_operation!(graph, fusion)
+                    cont = true
+                    break
+                end
+            end
+        end
+
+        # try execute
+        @test is_valid(graph)
+        expected_result = 0.00013916495566048735
+        @test isapprox(execute(graph, process_2_2, machine, particles_2_2), expected_result; rtol = 0.001)
+    end
+
+end
+println("Execution Unit Tests Complete!")

test/unit_tests_graph.jl

@@ -11,104 +11,101 @@ import MetagraphOptimization.partners
     @test length(graph.appliedOperations) == 0
     @test length(graph.operationsToApply) == 0
     @test length(graph.dirtyNodes) == 0
-    @test length(graph.diff) ==
-          (addedNodes = 0, removedNodes = 0, addedEdges = 0, removedEdges = 0)
-    @test length(get_operations(graph)) ==
-          (nodeFusions = 0, nodeReductions = 0, nodeSplits = 0)
+    @test length(graph.diff) == (addedNodes = 0, removedNodes = 0, addedEdges = 0, removedEdges = 0)
+    @test length(get_operations(graph)) == (nodeFusions = 0, nodeReductions = 0, nodeSplits = 0)
 
     # s to output (exit node)
-    d_exit = insert_node!(graph, make_node(DataTask(10)), false)
+    d_exit = insert_node!(graph, make_node(DataTask(10)), track = false)
 
     @test length(graph.nodes) == 1
     @test length(graph.dirtyNodes) == 1
 
     # final s compute
-    s0 = insert_node!(graph, make_node(ComputeTaskS2()), false)
+    s0 = insert_node!(graph, make_node(ComputeTaskS2()), track = false)
 
     @test length(graph.nodes) == 2
     @test length(graph.dirtyNodes) == 2
 
     # data from v0 and v1 to s0
-    d_v0_s0 = insert_node!(graph, make_node(DataTask(5)), false)
-    d_v1_s0 = insert_node!(graph, make_node(DataTask(5)), false)
+    d_v0_s0 = insert_node!(graph, make_node(DataTask(5)), track = false)
+    d_v1_s0 = insert_node!(graph, make_node(DataTask(5)), track = false)
 
     # v0 and v1 compute
-    v0 = insert_node!(graph, make_node(ComputeTaskV()), false)
-    v1 = insert_node!(graph, make_node(ComputeTaskV()), false)
+    v0 = insert_node!(graph, make_node(ComputeTaskV()), track = false)
+    v1 = insert_node!(graph, make_node(ComputeTaskV()), track = false)
 
     # data from uB, uA, uBp and uAp to v0 and v1
-    d_uB_v0 = insert_node!(graph, make_node(DataTask(3)), false)
-    d_uA_v0 = insert_node!(graph, make_node(DataTask(3)), false)
-    d_uBp_v1 = insert_node!(graph, make_node(DataTask(3)), false)
-    d_uAp_v1 = insert_node!(graph, make_node(DataTask(3)), false)
+    d_uB_v0 = insert_node!(graph, make_node(DataTask(3)), track = false)
+    d_uA_v0 = insert_node!(graph, make_node(DataTask(3)), track = false)
+    d_uBp_v1 = insert_node!(graph, make_node(DataTask(3)), track = false)
+    d_uAp_v1 = insert_node!(graph, make_node(DataTask(3)), track = false)
 
     # uB, uA, uBp and uAp computes
-    uB = insert_node!(graph, make_node(ComputeTaskU()), false)
-    uA = insert_node!(graph, make_node(ComputeTaskU()), false)
-    uBp = insert_node!(graph, make_node(ComputeTaskU()), false)
-    uAp = insert_node!(graph, make_node(ComputeTaskU()), false)
+    uB = insert_node!(graph, make_node(ComputeTaskU()), track = false)
+    uA = insert_node!(graph, make_node(ComputeTaskU()), track = false)
+    uBp = insert_node!(graph, make_node(ComputeTaskU()), track = false)
+    uAp = insert_node!(graph, make_node(ComputeTaskU()), track = false)
 
     # data from PB, PA, PBp and PAp to uB, uA, uBp and uAp
-    d_PB_uB = insert_node!(graph, make_node(DataTask(6)), false)
-    d_PA_uA = insert_node!(graph, make_node(DataTask(6)), false)
-    d_PBp_uBp = insert_node!(graph, make_node(DataTask(6)), false)
-    d_PAp_uAp = insert_node!(graph, make_node(DataTask(6)), false)
+    d_PB_uB = insert_node!(graph, make_node(DataTask(6)), track = false)
+    d_PA_uA = insert_node!(graph, make_node(DataTask(6)), track = false)
+    d_PBp_uBp = insert_node!(graph, make_node(DataTask(6)), track = false)
+    d_PAp_uAp = insert_node!(graph, make_node(DataTask(6)), track = false)
 
     # P computes PB, PA, PBp and PAp
-    PB = insert_node!(graph, make_node(ComputeTaskP()), false)
-    PA = insert_node!(graph, make_node(ComputeTaskP()), false)
-    PBp = insert_node!(graph, make_node(ComputeTaskP()), false)
-    PAp = insert_node!(graph, make_node(ComputeTaskP()), false)
+    PB = insert_node!(graph, make_node(ComputeTaskP()), track = false)
+    PA = insert_node!(graph, make_node(ComputeTaskP()), track = false)
+    PBp = insert_node!(graph, make_node(ComputeTaskP()), track = false)
+    PAp = insert_node!(graph, make_node(ComputeTaskP()), track = false)
 
     # entry nodes getting data for P computes
-    d_PB = insert_node!(graph, make_node(DataTask(4)), false)
-    d_PA = insert_node!(graph, make_node(DataTask(4)), false)
-    d_PBp = insert_node!(graph, make_node(DataTask(4)), false)
-    d_PAp = insert_node!(graph, make_node(DataTask(4)), false)
+    d_PB = insert_node!(graph, make_node(DataTask(4)), track = false)
+    d_PA = insert_node!(graph, make_node(DataTask(4)), track = false)
+    d_PBp = insert_node!(graph, make_node(DataTask(4)), track = false)
+    d_PAp = insert_node!(graph, make_node(DataTask(4)), track = false)
 
     @test length(graph.nodes) == 26
     @test length(graph.dirtyNodes) == 26
 
-    # now for all the edgese
-    insert_edge!(graph, d_PB, PB, false)
-    insert_edge!(graph, d_PA, PA, false)
-    insert_edge!(graph, d_PBp, PBp, false)
-    insert_edge!(graph, d_PAp, PAp, false)
+    # now for all the edges
+    insert_edge!(graph, d_PB, PB, track = false)
+    insert_edge!(graph, d_PA, PA, track = false)
+    insert_edge!(graph, d_PBp, PBp, track = false)
+    insert_edge!(graph, d_PAp, PAp, track = false)
 
-    insert_edge!(graph, PB, d_PB_uB, false)
-    insert_edge!(graph, PA, d_PA_uA, false)
-    insert_edge!(graph, PBp, d_PBp_uBp, false)
-    insert_edge!(graph, PAp, d_PAp_uAp, false)
+    insert_edge!(graph, PB, d_PB_uB, track = false)
+    insert_edge!(graph, PA, d_PA_uA, track = false)
+    insert_edge!(graph, PBp, d_PBp_uBp, track = false)
+    insert_edge!(graph, PAp, d_PAp_uAp, track = false)
 
-    insert_edge!(graph, d_PB_uB, uB, false)
-    insert_edge!(graph, d_PA_uA, uA, false)
-    insert_edge!(graph, d_PBp_uBp, uBp, false)
-    insert_edge!(graph, d_PAp_uAp, uAp, false)
+    insert_edge!(graph, d_PB_uB, uB, track = false)
+    insert_edge!(graph, d_PA_uA, uA, track = false)
+    insert_edge!(graph, d_PBp_uBp, uBp, track = false)
+    insert_edge!(graph, d_PAp_uAp, uAp, track = false)
 
-    insert_edge!(graph, uB, d_uB_v0, false)
-    insert_edge!(graph, uA, d_uA_v0, false)
-    insert_edge!(graph, uBp, d_uBp_v1, false)
-    insert_edge!(graph, uAp, d_uAp_v1, false)
+    insert_edge!(graph, uB, d_uB_v0, track = false)
+    insert_edge!(graph, uA, d_uA_v0, track = false)
+    insert_edge!(graph, uBp, d_uBp_v1, track = false)
+    insert_edge!(graph, uAp, d_uAp_v1, track = false)
 
-    insert_edge!(graph, d_uB_v0, v0, false)
-    insert_edge!(graph, d_uA_v0, v0, false)
-    insert_edge!(graph, d_uBp_v1, v1, false)
-    insert_edge!(graph, d_uAp_v1, v1, false)
+    insert_edge!(graph, d_uB_v0, v0, track = false)
+    insert_edge!(graph, d_uA_v0, v0, track = false)
+    insert_edge!(graph, d_uBp_v1, v1, track = false)
+    insert_edge!(graph, d_uAp_v1, v1, track = false)
 
-    insert_edge!(graph, v0, d_v0_s0, false)
-    insert_edge!(graph, v1, d_v1_s0, false)
+    insert_edge!(graph, v0, d_v0_s0, track = false)
+    insert_edge!(graph, v1, d_v1_s0, track = false)
 
-    insert_edge!(graph, d_v0_s0, s0, false)
-    insert_edge!(graph, d_v1_s0, s0, false)
+    insert_edge!(graph, d_v0_s0, s0, track = false)
+    insert_edge!(graph, d_v1_s0, s0, track = false)
 
-    insert_edge!(graph, s0, d_exit, false)
+    insert_edge!(graph, s0, d_exit, track = false)
 
     @test length(graph.nodes) == 26
     @test length(graph.appliedOperations) == 0
     @test length(graph.operationsToApply) == 0
     @test length(graph.dirtyNodes) == 26
-    @test length(graph.diff) ==
-          (addedNodes = 0, removedNodes = 0, addedEdges = 0, removedEdges = 0)
+    @test length(graph.diff) == (addedNodes = 0, removedNodes = 0, addedEdges = 0, removedEdges = 0)
 
     @test is_valid(graph)
 
@@ -135,19 +132,18 @@ import MetagraphOptimization.partners
     @test length(siblings(s0)) == 1
 
     operations = get_operations(graph)
-    @test length(operations) ==
-          (nodeFusions = 10, nodeReductions = 0, nodeSplits = 0)
+    @test length(operations) == (nodeFusions = 10, nodeReductions = 0, nodeSplits = 0)
     @test length(graph.dirtyNodes) == 0
 
     @test operations == get_operations(graph)
     nf = first(operations.nodeFusions)
 
-    properties = graph_properties(graph)
-    @test properties.compute_effort == 134
+    properties = get_properties(graph)
+    @test properties.computeEffort == 28
     @test properties.data == 62
-    @test properties.compute_intensity ≈ 134 / 62
-    @test properties.nodes == 26
-    @test properties.edges == 25
+    @test properties.computeIntensity ≈ 28 / 62
+    @test properties.noNodes == 26
+    @test properties.noEdges == 25
 
     push_operation!(graph, nf)
     # **does not immediately apply the operation**
@@ -157,27 +153,25 @@ import MetagraphOptimization.partners
     @test length(graph.operationsToApply) == 1
     @test first(graph.operationsToApply) == nf
     @test length(graph.dirtyNodes) == 0
-    @test length(graph.diff) ==
-          (addedNodes = 0, removedNodes = 0, addedEdges = 0, removedEdges = 0)
+    @test length(graph.diff) == (addedNodes = 0, removedNodes = 0, addedEdges = 0, removedEdges = 0)
 
     # this applies pending operations
-    properties = graph_properties(graph)
+    properties = get_properties(graph)
 
     @test length(graph.nodes) == 24
     @test length(graph.appliedOperations) == 1
     @test length(graph.operationsToApply) == 0
     @test length(graph.dirtyNodes) != 0
-    @test properties.nodes == 24
-    @test properties.edges == 23
-    @test properties.compute_effort == 134
+    @test properties.noNodes == 24
+    @test properties.noEdges == 23
+    @test properties.computeEffort == 28
     @test properties.data < 62
-    @test properties.compute_intensity > 134 / 62
+    @test properties.computeIntensity > 28 / 62
 
     operations = get_operations(graph)
     @test length(graph.dirtyNodes) == 0
 
-    @test length(operations) ==
-          (nodeFusions = 9, nodeReductions = 0, nodeSplits = 0)
+    @test length(operations) == (nodeFusions = 9, nodeReductions = 0, nodeSplits = 0)
     @test !isempty(operations)
 
     possibleNF = 9
@@ -185,14 +179,12 @@ import MetagraphOptimization.partners
         push_operation!(graph, first(operations.nodeFusions))
         operations = get_operations(graph)
         possibleNF = possibleNF - 1
-        @test length(operations) ==
-              (nodeFusions = possibleNF, nodeReductions = 0, nodeSplits = 0)
+        @test length(operations) == (nodeFusions = possibleNF, nodeReductions = 0, nodeSplits = 0)
     end
 
     @test isempty(operations)
 
-    @test length(operations) ==
-          (nodeFusions = 0, nodeReductions = 0, nodeSplits = 0)
+    @test length(operations) == (nodeFusions = 0, nodeReductions = 0, nodeSplits = 0)
     @test length(graph.dirtyNodes) == 0
     @test length(graph.nodes) == 6
     @test length(graph.appliedOperations) == 10
@@ -205,16 +197,15 @@ import MetagraphOptimization.partners
     @test length(graph.appliedOperations) == 0
     @test length(graph.operationsToApply) == 0
 
-    properties = graph_properties(graph)
-    @test properties.nodes == 26
-    @test properties.edges == 25
-    @test properties.compute_effort == 134
+    properties = get_properties(graph)
+    @test properties.noNodes == 26
+    @test properties.noEdges == 25
+    @test properties.computeEffort == 28
     @test properties.data == 62
-    @test properties.compute_intensity ≈ 134 / 62
+    @test properties.computeIntensity ≈ 28 / 62
 
     operations = get_operations(graph)
-    @test length(operations) ==
-          (nodeFusions = 10, nodeReductions = 0, nodeSplits = 0)
+    @test length(operations) == (nodeFusions = 10, nodeReductions = 0, nodeSplits = 0)
 
     @test is_valid(graph)
 end

test/unit_tests_nodes.jl

@@ -3,8 +3,7 @@
     nC1 = MetagraphOptimization.make_node(MetagraphOptimization.ComputeTaskU())
     nC2 = MetagraphOptimization.make_node(MetagraphOptimization.ComputeTaskV())
     nC3 = MetagraphOptimization.make_node(MetagraphOptimization.ComputeTaskP())
-    nC4 =
-        MetagraphOptimization.make_node(MetagraphOptimization.ComputeTaskSum())
+    nC4 = MetagraphOptimization.make_node(MetagraphOptimization.ComputeTaskSum())
 
     nD1 = MetagraphOptimization.make_node(MetagraphOptimization.DataTask(10))
     nD2 = MetagraphOptimization.make_node(MetagraphOptimization.DataTask(20))

test/unit_tests_properties.jl

@@ -0,0 +1,52 @@
+
+@testset "GraphProperties Unit Tests" begin
+    prop = GraphProperties()
+
+    @test prop.data == 0.0
+    @test prop.computeEffort == 0.0
+    @test prop.computeIntensity == 0.0
+    @test prop.cost == 0.0
+    @test prop.noNodes == 0.0
+    @test prop.noEdges == 0.0
+
+    prop2 = (
+        data = 5.0,
+        computeEffort = 6.0,
+        computeIntensity = 6.0 / 5.0,
+        cost = 0.0,
+        noNodes = 2,
+        noEdges = 3,
+    )::GraphProperties
+
+    @test prop + prop2 == prop2
+    @test prop2 - prop == prop2
+
+    negProp = -prop2
+    @test negProp.data == -5.0
+    @test negProp.computeEffort == -6.0
+    @test negProp.computeIntensity == 6.0 / 5.0
+    @test negProp.cost == 0.0
+    @test negProp.noNodes == -2
+    @test negProp.noEdges == -3
+
+    @test negProp + prop2 == GraphProperties()
+
+    prop3 = (
+        data = 7.0,
+        computeEffort = 3.0,
+        computeIntensity = 7.0 / 3.0,
+        cost = 0.0,
+        noNodes = -3,
+        noEdges = 2,
+    )::GraphProperties
+
+    propSum = prop2 + prop3
+
+    @test propSum.data == 12.0
+    @test propSum.computeEffort == 9.0
+    @test propSum.computeIntensity == 9.0 / 12.0
+    @test propSum.cost == 0.0
+    @test propSum.noNodes == -1
+    @test propSum.noEdges == 5
+end
+println("GraphProperties Unit Tests Complete!")

test/unit_tests_tasks.jl

@@ -10,11 +10,11 @@
     Data10 = MetagraphOptimization.DataTask(10)
     Data20 = MetagraphOptimization.DataTask(20)
 
-    @test MetagraphOptimization.compute_effort(S1) == 10
-    @test MetagraphOptimization.compute_effort(S2) == 10
-    @test MetagraphOptimization.compute_effort(U) == 6
-    @test MetagraphOptimization.compute_effort(V) == 20
-    @test MetagraphOptimization.compute_effort(P) == 15
+    @test MetagraphOptimization.compute_effort(S1) == 11
+    @test MetagraphOptimization.compute_effort(S2) == 12
+    @test MetagraphOptimization.compute_effort(U) == 1
+    @test MetagraphOptimization.compute_effort(V) == 6
+    @test MetagraphOptimization.compute_effort(P) == 0
     @test MetagraphOptimization.compute_effort(Sum) == 1
     @test MetagraphOptimization.compute_effort(Data10) == 0
     @test MetagraphOptimization.compute_effort(Data20) == 0
@@ -28,15 +28,6 @@
     @test MetagraphOptimization.data(Data10) == 10
     @test MetagraphOptimization.data(Data20) == 20
 
-    @test MetagraphOptimization.compute_intensity(S1) == typemax(UInt64)
-    @test MetagraphOptimization.compute_intensity(S2) == typemax(UInt64)
-    @test MetagraphOptimization.compute_intensity(U) == typemax(UInt64)
-    @test MetagraphOptimization.compute_intensity(V) == typemax(UInt64)
-    @test MetagraphOptimization.compute_intensity(P) == typemax(UInt64)
-    @test MetagraphOptimization.compute_intensity(Sum) == typemax(UInt64)
-    @test MetagraphOptimization.compute_intensity(Data10) == 0
-    @test MetagraphOptimization.compute_intensity(Data20) == 0
-
     @test S1 != S2
     @test Data10 != Data20
 

test/unit_tests_utility.jl

@@ -5,9 +5,7 @@
     @test MetagraphOptimization.bytes_to_human_readable(1025) == "1.001 KiB"
     @test MetagraphOptimization.bytes_to_human_readable(684235) == "668.2 KiB"
     @test MetagraphOptimization.bytes_to_human_readable(86214576) == "82.22 MiB"
-    @test MetagraphOptimization.bytes_to_human_readable(9241457698) ==
-          "8.607 GiB"
-    @test MetagraphOptimization.bytes_to_human_readable(3218598654367) ==
-          "2.927 TiB"
+    @test MetagraphOptimization.bytes_to_human_readable(9241457698) == "8.607 GiB"
+    @test MetagraphOptimization.bytes_to_human_readable(3218598654367) == "2.927 TiB"
 end
 println("Utility Unit Tests Complete!")