Merge pull request #394 from ChrisRackauckas-Claude/runic-formatting

Switch from JuliaFormatter to Runic.jl for code formatting

Author: ChrisRackauckas

.JuliaFormatter.toml

@@ -1,13 +1,19 @@
-name: "Format Check"
+name: format-check
 
 on:
   push:
     branches:
       - 'master'
+      - 'main'
+      - 'release-'
     tags: '*'
   pull_request:
 
 jobs:
-  format-check:
-    name: "Format Check"
-    uses: "SciML/.github/.github/workflows/format-check.yml@v1"
+  runic:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: fredrikekre/runic-action@v1
+        with:
+          version: '1'

.github/workflows/FormatCheck.yml

@@ -5,14 +5,20 @@ include("pages.jl")
 cp("./docs/Manifest.toml", "./docs/src/assets/Manifest.toml", force = true)
 cp("./docs/Project.toml", "./docs/src/assets/Project.toml", force = true)
 
-makedocs(sitename = "DiffEqGPU.jl",
+makedocs(
+    sitename = "DiffEqGPU.jl",
     authors = "Chris Rackauckas",
     modules = [DiffEqGPU],
     clean = true, doctest = false, linkcheck = true,
     warnonly = [:missing_docs],
-    format = Documenter.HTML(assets = ["assets/favicon.ico"],
-        canonical = "https://docs.sciml.ai/DiffEqGPU/stable/"),
-    pages = pages)
+    format = Documenter.HTML(
+        assets = ["assets/favicon.ico"],
+        canonical = "https://docs.sciml.ai/DiffEqGPU/stable/"
+    ),
+    pages = pages
+)
 
-deploydocs(repo = "github.com/SciML/DiffEqGPU.jl.git";
-    push_preview = true)
+deploydocs(
+    repo = "github.com/SciML/DiffEqGPU.jl.git";
+    push_preview = true
+)

docs/make.jl

@@ -1,26 +1,36 @@
 # Put in a separate page so it can be used by SciMLDocs.jl
 
-pages = ["index.md",
+pages = [
+    "index.md",
     "getting_started.md",
     "Tutorials" => Any[
-        "GPU Ensembles" => Any["tutorials/gpu_ensemble_basic.md",
+        "GPU Ensembles" => Any[
+            "tutorials/gpu_ensemble_basic.md",
             "tutorials/parallel_callbacks.md",
             "tutorials/modelingtoolkit.md",
             "tutorials/multigpu.md",
             "tutorials/lower_level_api.md",
-            "tutorials/weak_order_conv_sde.md"],
-        "Within-Method GPU" => Any["tutorials/within_method_gpu.md"]],
+            "tutorials/weak_order_conv_sde.md",
+        ],
+        "Within-Method GPU" => Any["tutorials/within_method_gpu.md"],
+    ],
     "Examples" => Any[
         "GPU Ensembles" => Any[
             "examples/gpu_ensemble_random_decay.md",
             "examples/sde.md",
             "examples/ad.md",
-            "examples/reductions.md"],
-        "Within-Method GPU" => Any["examples/reaction_diffusion.md",
-            "examples/bruss.md"]],
-    "Manual" => Any["manual/ensemblegpukernel.md",
+            "examples/reductions.md",
+        ],
+        "Within-Method GPU" => Any[
+            "examples/reaction_diffusion.md",
+            "examples/bruss.md",
+        ],
+    ],
+    "Manual" => Any[
+        "manual/ensemblegpukernel.md",
         "manual/ensemblegpuarray.md",
         "manual/backends.md",
         "manual/optimal_trajectories.md",
-        "manual/choosing_ensembler.md"]
+        "manual/choosing_ensembler.md",
+    ],
 ]

docs/pages.jl

@@ -6,7 +6,7 @@ using .AMDGPU
 import .AMDGPU: ROCBackend
 
 function DiffEqGPU.EnsembleGPUArray(cpu_offload::Float64)
-    DiffEqGPU.EnsembleGPUArray(ROCBackend(), cpu_offload)
+    return DiffEqGPU.EnsembleGPUArray(ROCBackend(), cpu_offload)
 end
 DiffEqGPU.maxthreads(::ROCBackend) = 256
 DiffEqGPU.maybe_prefer_blocks(::ROCBackend) = ROCBackend()

ext/AMDGPUExt.jl

@@ -6,7 +6,7 @@ using .CUDA
 import .CUDA: CUDABackend
 
 function DiffEqGPU.EnsembleGPUArray(cpu_offload::Float64)
-    DiffEqGPU.EnsembleGPUArray(CUDABackend(), cpu_offload)
+    return DiffEqGPU.EnsembleGPUArray(CUDABackend(), cpu_offload)
 end
 DiffEqGPU.maxthreads(::CUDABackend) = 256
 DiffEqGPU.maybe_prefer_blocks(::CUDABackend) = CUDABackend(; prefer_blocks = true)

ext/CUDAExt.jl

@@ -156,22 +156,24 @@ struct EnsembleGPUKernel{Dev} <: EnsembleKernelAlgorithm
     cpu_offload::Float64
 end
 
-cpu_alg = Dict(GPUTsit5 => (GPUSimpleTsit5(), GPUSimpleATsit5()),
+cpu_alg = Dict(
+    GPUTsit5 => (GPUSimpleTsit5(), GPUSimpleATsit5()),
     GPUVern7 => (GPUSimpleVern7(), GPUSimpleAVern7()),
-    GPUVern9 => (GPUSimpleVern9(), GPUSimpleAVern9()))
+    GPUVern9 => (GPUSimpleVern9(), GPUSimpleAVern9())
+)
 
 # Work around the fact that Zygote cannot handle the task system
 # Work around the fact that Zygote isderiving fails with constants?
 function EnsembleGPUArray(dev)
-    EnsembleGPUArray(dev, 0.2)
+    return EnsembleGPUArray(dev, 0.2)
 end
 
 function EnsembleGPUKernel(dev)
-    EnsembleGPUKernel(dev, 0.0)
+    return EnsembleGPUKernel(dev, 0.0)
 end
 
 function ChainRulesCore.rrule(::Type{<:EnsembleGPUArray})
-    EnsembleGPUArray(0.0), _ -> NoTangent()
+    return EnsembleGPUArray(0.0), _ -> NoTangent()
 end
 
 ZygoteRules.@adjoint function EnsembleGPUArray(dev)

src/algorithms.jl

@@ -9,38 +9,52 @@ function generate_callback(callback::ContinuousCallback, I, ensemblealg)
     condition = function (out, u, t, integrator)
         version = get_backend(u)
         wgs = workgroupsize(version, size(u, 2))
-        continuous_condition_kernel(version)(_condition, out, u, t, integrator.p;
+        continuous_condition_kernel(version)(
+            _condition, out, u, t, integrator.p;
             ndrange = size(u, 2),
-            workgroupsize = wgs)
-        nothing
+            workgroupsize = wgs
+        )
+        return nothing
     end
 
     affect! = function (integrator, event_idx)
         version = get_backend(integrator.u)
         wgs = workgroupsize(version, size(integrator.u, 2))
-        continuous_affect!_kernel(version)(_affect!, event_idx, integrator.u,
+        return continuous_affect!_kernel(version)(
+            _affect!, event_idx, integrator.u,
             integrator.t, integrator.p;
             ndrange = size(integrator.u, 2),
-            workgroupsize = wgs)
+            workgroupsize = wgs
+        )
     end
 
     affect_neg! = function (integrator, event_idx)
         version = get_backend(integrator.u)
         wgs = workgroupsize(version, size(integrator.u, 2))
-        continuous_affect!_kernel(version)(_affect_neg!, event_idx, integrator.u,
+        return continuous_affect!_kernel(version)(
+            _affect_neg!, event_idx, integrator.u,
             integrator.t, integrator.p;
             ndrange = size(integrator.u, 2),
-            workgroupsize = wgs)
+            workgroupsize = wgs
+        )
     end
 
-    return VectorContinuousCallback(condition, affect!, affect_neg!, I,
-        save_positions = callback.save_positions)
+    return VectorContinuousCallback(
+        condition, affect!, affect_neg!, I,
+        save_positions = callback.save_positions
+    )
 end
 
 function generate_callback(callback::CallbackSet, I, ensemblealg)
-    return CallbackSet(map(cb -> generate_callback(cb, I, ensemblealg),
-        (callback.continuous_callbacks...,
-            callback.discrete_callbacks...))...)
+    return CallbackSet(
+        map(
+            cb -> generate_callback(cb, I, ensemblealg),
+            (
+                callback.continuous_callbacks...,
+                callback.discrete_callbacks...,
+            )
+        )...
+    )
 end
 
 generate_callback(::Tuple{}, I, ensemblealg) = nothing
@@ -55,10 +69,12 @@ function generate_callback(prob, I, ensemblealg; kwargs...)
     kwarg_cb = get(kwargs, :merge_callbacks, false) ? get(kwargs, :callback, ()) : ()
 
     if (prob_cb === nothing || isempty(prob_cb)) &&
-       (kwarg_cb === nothing || isempty(kwarg_cb))
+            (kwarg_cb === nothing || isempty(kwarg_cb))
         return nothing
     else
-        return CallbackSet(generate_callback(prob_cb, I, ensemblealg),
-            generate_callback(kwarg_cb, I, ensemblealg))
+        return CallbackSet(
+            generate_callback(prob_cb, I, ensemblealg),
+            generate_callback(kwarg_cb, I, ensemblealg)
+        )
     end
 end