Skip to content

Commit 3c0d624

Browse files
JuliaLangBuildkiteJuliaLangBuildkite
committed
Automatic build\nPublished by build of: SciML/SciMLBenchmarks.jl@6d6807e 
1 parent 7911ebc commit 3c0d624

3 files changed

Lines changed: 264 additions & 0 deletions

File tree

‎docs/Project.toml‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,2 +1,5 @@
11
[deps]
22
Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"
3+
4+
[compat]
5+
Documenter = "1.16.1"

‎markdown/AutomaticDifferentiationSparse/ManualLoopDiffusionSparseAD.md‎

Lines changed: 188 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,188 @@
1+
---
2+
author: "Yolhan Mannes"
3+
title: "Diffusion operator loop sparse AD benchmarks"
4+
---
5+
```julia
6+
using DifferentiationInterface
7+
using DifferentiationInterfaceTest
8+
using LinearAlgebra
9+
using SparseConnectivityTracer: TracerSparsityDetector
10+
using SparseMatrixColorings
11+
import Enzyme, ForwardDiff, Mooncake
12+
import Markdown, PrettyTables, Printf
13+
```
14+
15+
16+
17+
18+
## Backends tested
19+
20+
```julia
21+
bcks = [
22+
AutoEnzyme(mode = Enzyme.Reverse),
23+
AutoEnzyme(mode = Enzyme.Forward),
24+
AutoMooncake(config = nothing),
25+
AutoForwardDiff(),
26+
AutoSparse(
27+
AutoForwardDiff();
28+
sparsity_detector = TracerSparsityDetector(),
29+
coloring_algorithm = GreedyColoringAlgorithm()
30+
),
31+
AutoSparse(
32+
AutoEnzyme(mode = Enzyme.Forward);
33+
sparsity_detector = TracerSparsityDetector(),
34+
coloring_algorithm = GreedyColoringAlgorithm()
35+
)
36+
]
37+
```
38+
39+
```
40+
6-element Vector{ADTypes.AbstractADType}:
41+
ADTypes.AutoEnzyme(mode=EnzymeCore.ReverseMode{false, false, false, Enzyme
42+
Core.FFIABI, false, false}())
43+
ADTypes.AutoEnzyme(mode=EnzymeCore.ForwardMode{false, EnzymeCore.FFIABI, f
44+
alse, false, false}())
45+
ADTypes.AutoMooncake{Nothing}(nothing)
46+
ADTypes.AutoForwardDiff()
47+
ADTypes.AutoSparse(dense_ad=ADTypes.AutoForwardDiff(), sparsity_detector=S
48+
parseConnectivityTracer.TracerSparsityDetector(), coloring_algorithm=Sparse
49+
MatrixColorings.GreedyColoringAlgorithm{:direct, SparseMatrixColorings.Natu
50+
ralOrder}(SparseMatrixColorings.NaturalOrder(), false))
51+
ADTypes.AutoSparse(dense_ad=ADTypes.AutoEnzyme(mode=EnzymeCore.ForwardMode
52+
{false, EnzymeCore.FFIABI, false, false, false}()), sparsity_detector=Spars
53+
eConnectivityTracer.TracerSparsityDetector(), coloring_algorithm=SparseMatr
54+
ixColorings.GreedyColoringAlgorithm{:direct, SparseMatrixColorings.NaturalO
55+
rder}(SparseMatrixColorings.NaturalOrder(), false))
56+
```
57+
58+
59+
60+
61+
62+
## Diffusion operator simple loop
63+
64+
```julia
65+
uin() = 0.0
66+
uout() = 0.0
67+
function Diffusion(u)
68+
du = zero(u)
69+
for i in eachindex(du, u)
70+
if i == 1
71+
ug = uin()
72+
ud = u[i + 1]
73+
elseif i == length(u)
74+
ug = u[i - 1]
75+
ud = uout()
76+
else
77+
ug = u[i - 1]
78+
ud = u[i + 1]
79+
end
80+
du[i] = ug + ud - 2*u[i]
81+
end
82+
return du
83+
end;
84+
```
85+
86+
87+
88+
89+
## Manual jacobian
90+
91+
```julia
92+
function DDiffusion(u)
93+
A = diagm(
94+
-1 => ones(length(u)-1),
95+
0=>-2 .* ones(length(u)),
96+
1 => ones(length(u)-1))
97+
return A
98+
end;
99+
```
100+
101+
102+
103+
104+
## Define Scenarios
105+
106+
```julia
107+
u = rand(1000)
108+
scenarios = [Scenario{:jacobian, :out}(Diffusion, u, res1 = DDiffusion(u))];
109+
```
110+
111+
112+
113+
114+
## Run Benchmarks
115+
116+
```julia
117+
df = benchmark_differentiation(bcks, scenarios)
118+
table = PrettyTables.pretty_table(
119+
String,
120+
df;
121+
backend = Val(:markdown),
122+
header = names(df),
123+
formatters = PrettyTables.ft_printf("%.1e")
124+
)
125+
126+
Markdown.parse(table)
127+
```
128+
129+
```
130+
Test Summary:
131+
132+
133+
134+
| Pass Total Time
135+
Testing benchmarks
136+
137+
138+
139+
| 12 12 2m24.9s
140+
ADTypes.AutoEnzyme(mode=EnzymeCore.ReverseMode{false, false, false, Enzym
141+
eCore.FFIABI, false, false}())
142+
143+
144+
| 2 2 37.7s
145+
ADTypes.AutoEnzyme(mode=EnzymeCore.ForwardMode{false, EnzymeCore.FFIABI,
146+
false, false, false}())
147+
148+
149+
| 2 2 37.5s
150+
ADTypes.AutoMooncake{Nothing}(nothing)
151+
152+
153+
154+
| 2 2 55.5s
155+
ADTypes.AutoForwardDiff()
156+
157+
158+
159+
| 2 2 4.9s
160+
ADTypes.AutoSparse(dense_ad=ADTypes.AutoForwardDiff(), sparsity_detector=
161+
SparseConnectivityTracer.TracerSparsityDetector(), coloring_algorithm=Spars
162+
eMatrixColorings.GreedyColoringAlgorithm{:direct, SparseMatrixColorings.Nat
163+
uralOrder}(SparseMatrixColorings.NaturalOrder(), false))
164+
| 2 2 4.9s
165+
ADTypes.AutoSparse(dense_ad=ADTypes.AutoEnzyme(mode=EnzymeCore.ForwardMod
166+
e{false, EnzymeCore.FFIABI, false, false, false}()), sparsity_detector=Spar
167+
seConnectivityTracer.TracerSparsityDetector(), coloring_algorithm=SparseMat
168+
rixColorings.GreedyColoringAlgorithm{:direct, SparseMatrixColorings.Natural
169+
Order}(SparseMatrixColorings.NaturalOrder(), false)) | 2 2 4.0s
170+
```
171+
172+
173+
174+
| **backend** | **scenario** | **operator** | **prepared** | **calls** | **samples** | **evals** | **time** | **allocs** | **bytes** | **gc_fraction** | **compile_fraction** |
175+
| -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------:| -----------------------------------------------------------------------:| ------------------:| ------------:| ---------:| -----------:| ---------:| --------:| ----------:| ---------:| ---------------:| --------------------:|
176+
| AutoEnzyme(mode=ReverseMode{false, false, false, FFIABI, false, false}()) | Scenario{:jacobian,:out} Diffusion : Vector{Float64} -> Vector{Float64} | value_and_jacobian | 1.0e+00 | 6.4e+01 | 7.0e+00 | 1.0e+00 | 1.3e-01 | 2.3e+03 | 2.8e+08 | 6.9e-02 | 0.0e+00 |
177+
| AutoEnzyme(mode=ReverseMode{false, false, false, FFIABI, false, false}()) | Scenario{:jacobian,:out} Diffusion : Vector{Float64} -> Vector{Float64} | jacobian | 1.0e+00 | 6.3e+01 | 8.0e+00 | 1.0e+00 | 1.3e-01 | 2.3e+03 | 2.8e+08 | 6.9e-02 | 0.0e+00 |
178+
| AutoEnzyme(mode=ForwardMode{false, FFIABI, false, false, false}()) | Scenario{:jacobian,:out} Diffusion : Vector{Float64} -> Vector{Float64} | value_and_jacobian | 1.0e+00 | 6.3e+01 | 6.9e+01 | 1.0e+00 | 8.5e-03 | 3.2e+03 | 1.8e+07 | 0.0e+00 | 0.0e+00 |
179+
| AutoEnzyme(mode=ForwardMode{false, FFIABI, false, false, false}()) | Scenario{:jacobian,:out} Diffusion : Vector{Float64} -> Vector{Float64} | jacobian | 1.0e+00 | 6.3e+01 | 7.6e+01 | 1.0e+00 | 8.6e-03 | 3.2e+03 | 1.8e+07 | 0.0e+00 | 0.0e+00 |
180+
| AutoMooncake{Nothing}(nothing) | Scenario{:jacobian,:out} Diffusion : Vector{Float64} -> Vector{Float64} | value_and_jacobian | 1.0e+00 | 1.0e+00 | 1.0e+00 | 1.0e+00 | 1.1e+00 | 1.2e+04 | 4.0e+09 | 1.5e-01 | 0.0e+00 |
181+
| AutoMooncake{Nothing}(nothing) | Scenario{:jacobian,:out} Diffusion : Vector{Float64} -> Vector{Float64} | jacobian | 1.0e+00 | 0.0e+00 | 1.0e+00 | 1.0e+00 | 1.1e+00 | 1.2e+04 | 4.0e+09 | 1.5e-01 | 0.0e+00 |
182+
| AutoForwardDiff() | Scenario{:jacobian,:out} Diffusion : Vector{Float64} -> Vector{Float64} | value_and_jacobian | 1.0e+00 | 8.5e+01 | 1.4e+02 | 1.0e+00 | 5.5e-03 | 1.7e+02 | 1.7e+07 | 0.0e+00 | 0.0e+00 |
183+
| AutoForwardDiff() | Scenario{:jacobian,:out} Diffusion : Vector{Float64} -> Vector{Float64} | jacobian | 1.0e+00 | 8.4e+01 | 1.5e+02 | 1.0e+00 | 5.5e-03 | 1.7e+02 | 1.7e+07 | 0.0e+00 | 0.0e+00 |
184+
| AutoSparse(dense_ad=AutoForwardDiff(), sparsity_detector=TracerSparsityDetector(), coloring_algorithm=GreedyColoringAlgorithm{:direct, NaturalOrder}(NaturalOrder(), false)) | Scenario{:jacobian,:out} Diffusion : Vector{Float64} -> Vector{Float64} | value_and_jacobian | 1.0e+00 | 2.0e+00 | 2.0e+04 | 1.0e+00 | 2.1e-05 | 8.0e+00 | 9.6e+04 | 0.0e+00 | 0.0e+00 |
185+
| AutoSparse(dense_ad=AutoForwardDiff(), sparsity_detector=TracerSparsityDetector(), coloring_algorithm=GreedyColoringAlgorithm{:direct, NaturalOrder}(NaturalOrder(), false)) | Scenario{:jacobian,:out} Diffusion : Vector{Float64} -> Vector{Float64} | jacobian | 1.0e+00 | 1.0e+00 | 2.3e+04 | 1.0e+00 | 1.8e-05 | 7.0e+00 | 8.8e+04 | 0.0e+00 | 0.0e+00 |
186+
| AutoSparse(dense_ad=AutoEnzyme(mode=ForwardMode{false, FFIABI, false, false, false}()), sparsity_detector=TracerSparsityDetector(), coloring_algorithm=GreedyColoringAlgorithm{:direct, NaturalOrder}(NaturalOrder(), false)) | Scenario{:jacobian,:out} Diffusion : Vector{Float64} -> Vector{Float64} | value_and_jacobian | 1.0e+00 | 2.0e+00 | 2.3e+04 | 1.0e+00 | 1.8e-05 | 1.0e+01 | 9.7e+04 | 0.0e+00 | 0.0e+00 |
187+
| AutoSparse(dense_ad=AutoEnzyme(mode=ForwardMode{false, FFIABI, false, false, false}()), sparsity_detector=TracerSparsityDetector(), coloring_algorithm=GreedyColoringAlgorithm{:direct, NaturalOrder}(NaturalOrder(), false)) | Scenario{:jacobian,:out} Diffusion : Vector{Float64} -> Vector{Float64} | jacobian | 1.0e+00 | 1.0e+00 | 2.5e+04 | 1.0e+00 | 1.4e-05 | 9.0e+00 | 8.9e+04 | 0.0e+00 | 0.0e+00 |
188+

‎script/AutomaticDifferentiationSparse/ManualLoopDiffusionSparseAD.jl‎

Lines changed: 73 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,73 @@
1+
2+
using DifferentiationInterface
3+
using DifferentiationInterfaceTest
4+
using LinearAlgebra
5+
using SparseConnectivityTracer: TracerSparsityDetector
6+
using SparseMatrixColorings
7+
import Enzyme, ForwardDiff, Mooncake
8+
import Markdown, PrettyTables, Printf
9+
10+
11+
bcks = [
12+
AutoEnzyme(mode = Enzyme.Reverse),
13+
AutoEnzyme(mode = Enzyme.Forward),
14+
AutoMooncake(config = nothing),
15+
AutoForwardDiff(),
16+
AutoSparse(
17+
AutoForwardDiff();
18+
sparsity_detector = TracerSparsityDetector(),
19+
coloring_algorithm = GreedyColoringAlgorithm()
20+
),
21+
AutoSparse(
22+
AutoEnzyme(mode = Enzyme.Forward);
23+
sparsity_detector = TracerSparsityDetector(),
24+
coloring_algorithm = GreedyColoringAlgorithm()
25+
)
26+
]
27+
28+
29+
uin() = 0.0
30+
uout() = 0.0
31+
function Diffusion(u)
32+
du = zero(u)
33+
for i in eachindex(du, u)
34+
if i == 1
35+
ug = uin()
36+
ud = u[i + 1]
37+
elseif i == length(u)
38+
ug = u[i - 1]
39+
ud = uout()
40+
else
41+
ug = u[i - 1]
42+
ud = u[i + 1]
43+
end
44+
du[i] = ug + ud - 2*u[i]
45+
end
46+
return du
47+
end;
48+
49+
50+
function DDiffusion(u)
51+
A = diagm(
52+
-1 => ones(length(u)-1),
53+
0=>-2 .* ones(length(u)),
54+
1 => ones(length(u)-1))
55+
return A
56+
end;
57+
58+
59+
u = rand(1000)
60+
scenarios = [Scenario{:jacobian, :out}(Diffusion, u, res1 = DDiffusion(u))];
61+
62+
63+
df = benchmark_differentiation(bcks, scenarios)
64+
table = PrettyTables.pretty_table(
65+
String,
66+
df;
67+
backend = Val(:markdown),
68+
header = names(df),
69+
formatters = PrettyTables.ft_printf("%.1e")
70+
)
71+
72+
Markdown.parse(table)
73+

0 commit comments

Comments
 (0)