Remove all get_ function prefixes (#76)

AntonReinhard · web-flow · commit 4c81ef58d6b1 · 2025-10-24T10:55:34.000+02:00
* Remove all get_ function prefixes

* Fix rename in print

* Include docs in Codecov
diff --git a/.github/workflows/BuildDeployDoc.yml b/.github/workflows/BuildDeployDoc.yml
@@ -4,6 +4,7 @@ on:
   push:
     branches:
       - main
+      - dev
     tags: "*"
   pull_request:
 
@@ -15,13 +16,26 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: julia-actions/setup-julia@v1
+      - uses: julia-actions/setup-julia@v2
         with:
-          version: "1.10"
+          version: '1.10'
+      - name: Add Julia cache
+        uses: julia-actions/cache@v2
       - name: Install dependencies
         run: |
           julia --project=docs/ -e 'using Pkg; Pkg.develop(PackageSpec(path=pwd())); Pkg.instantiate()'
+
       - name: Build and deploy
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # If authenticating with GitHub Actions token
-        run: julia --project=docs/ docs/make.jl
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: julia --code-coverage=@src --project=docs/ docs/make.jl
+
+      - name: Process code coverage
+        uses: julia-actions/julia-processcoverage@v1
+
+      - name: Upload code coverage
+        uses: codecov/codecov-action@v4
+        with:
+          files: ./lcov.inf
+          flags: unittests
+          token: ${{ secrets.CODECOV_TOKEN }}
diff --git a/ext/devices/cuda/impl.jl b/ext/devices/cuda/impl.jl
@@ -6,11 +6,11 @@ function ComputableDAGs.measure_device!(device::CUDAGPU; verbose::Bool)
 end
 
 """
-    get_devices(::Type{CUDAGPU}; verbose::Bool)
+    devices(::Type{CUDAGPU}; verbose::Bool)
 
 Return a Vector of [`CUDAGPU`](@ref)s available on the current machine. If `verbose` is true, print some additional information.
 """
-function ComputableDAGs.get_devices(::Type{CUDAGPU}; verbose::Bool = false)
+function ComputableDAGs.devices(::Type{CUDAGPU}; verbose::Bool = false)
     devices = Vector{ComputableDAGs.AbstractDevice}()
 
     if !CUDA.functional()
diff --git a/ext/devices/oneapi/impl.jl b/ext/devices/oneapi/impl.jl
@@ -6,11 +6,11 @@ function ComputableDAGs.measure_device!(device::oneAPIGPU; verbose::Bool)
 end
 
 """
-    get_devices(::Type{oneAPIGPU}; verbose::Bool = false)
+    devices(::Type{oneAPIGPU}; verbose::Bool = false)
 
 Return a Vector of [`oneAPIGPU`](@ref)s available on the current machine. If `verbose` is true, print some additional information.
 """
-function ComputableDAGs.get_devices(::Type{oneAPIGPU}; verbose::Bool = false)
+function ComputableDAGs.devices(::Type{oneAPIGPU}; verbose::Bool = false)
     devices = Vector{ComputableDAGs.AbstractDevice}()
 
     if !oneAPI.functional()
diff --git a/ext/devices/rocm/impl.jl b/ext/devices/rocm/impl.jl
@@ -6,11 +6,11 @@ function ComputableDAGs.measure_device!(device::ROCmGPU; verbose::Bool)
 end
 
 """
-    get_devices(::Type{ROCmGPU}; verbose::Bool = false)
+    devices(::Type{ROCmGPU}; verbose::Bool = false)
 
 Return a Vector of [`ROCmGPU`](@ref)s available on the current machine. If `verbose` is true, print some additional information.
 """
-function ComputableDAGs.get_devices(::Type{ROCmGPU}; verbose::Bool = false)
+function ComputableDAGs.devices(::Type{ROCmGPU}; verbose::Bool = false)
     devices = Vector{ComputableDAGs.AbstractDevice}()
 
     if !AMDGPU.functional()
diff --git a/src/ComputableDAGs.jl b/src/ComputableDAGs.jl
@@ -16,7 +16,7 @@ export GraphProperties
 export insert_node!, insert_edge!
 export is_entry_node, is_exit_node
 export compute, data, compute_effort
-export get_properties, get_exit_node
+export properties, exit_node
 
 # graph operation related
 export reset_graph!
@@ -39,7 +39,7 @@ export fixpoint_reached, optimize_to_fixpoint!
 export graph
 
 # machine info
-export get_machine_info, cpu_st
+export machine_info, cpu_st
 
 # GPU Extensions
 export kernel, CUDAGPU, ROCmGPU, oneAPIGPU
diff --git a/src/code_gen/tape_machine.jl b/src/code_gen/tape_machine.jl
@@ -239,7 +239,7 @@ function gen_tape(
 
     # get input symbols
     input_syms = Dict{String, Vector{Symbol}}()
-    for node in get_entry_nodes(dag)
+    for node in entry_nodes(dag)
         if !haskey(input_syms, node.name)
             input_syms[node.name] = Vector{Symbol}()
         end
@@ -248,7 +248,7 @@ function gen_tape(
     end
 
     # get out_symbol
-    out_sym = Symbol(to_var_name(get_exit_node(dag).id))
+    out_sym = Symbol(to_var_name(exit_node(dag).id))
 
     assign_inputs = gen_input_assignment_code(input_syms, instance, machine)
 
diff --git a/src/code_gen/utils.jl b/src/code_gen/utils.jl
@@ -75,9 +75,9 @@ function lower(schedule::Vector{Tuple{Node, AbstractDevice}}, machine::Machine)
 
     for (node, device) in schedule
         if (node isa DataTaskNode && length(node.children) == 0)
-            push!(calls, get_init_function_call(node, entry_device(machine)))
+            push!(calls, init_function_call(node, entry_device(machine)))
         else
-            push!(calls, get_function_call(node, device))
+            push!(calls, function_call(node, device))
         end
     end
 
diff --git a/src/devices/detect.jl b/src/devices/detect.jl
@@ -1,13 +1,13 @@
 """
-    get_machine_info(verbose::Bool)
+    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)
+function machine_info(; verbose::Bool = Base.is_interactive)
     devices = Vector{AbstractDevice}()
 
     for device in device_types()
-        devs = get_devices(device; verbose = verbose)
+        devs = devices(device; verbose = verbose)
         for dev in devs
             push!(devices, dev)
         end
diff --git a/src/devices/interface.jl b/src/devices/interface.jl
@@ -28,16 +28,16 @@ end
 
 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)
+See also: [`device_types`](@ref), [`devices`](@ref)
 """
 DEVICE_TYPES = Vector{Type}()
 
 """
-    get_devices(t::Type{T}; verbose::Bool) where {T <: AbstractDevice}
+    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
+function devices end
 
 """
     measure_device!(device::AbstractDevice; verbose::Bool)
diff --git a/src/devices/numa/impl.jl b/src/devices/numa/impl.jl
@@ -22,11 +22,11 @@ function measure_device!(device::NumaNode; verbose::Bool)
 end
 
 """
-    get_devices(deviceType::Type{T}; verbose::Bool) where {T <: NumaNode}
+    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}
+function devices(deviceType::Type{T}; verbose::Bool = false) where {T <: NumaNode}
     devices = Vector{AbstractDevice}()
     no_numa_nodes = highest_numa_node()
 
diff --git a/src/estimator/global_metric.jl b/src/estimator/global_metric.jl
@@ -39,10 +39,10 @@ function cost_type(::GlobalMetricEstimator)
 end
 
 function graph_cost(::GlobalMetricEstimator, dag::DAG)
-    properties = get_properties(dag)
+    p = properties(dag)
     return CDCost(
-        properties.data,
-        properties.compute_effort
+        p.data,
+        p.compute_effort
     )
 end
 
diff --git a/src/graph/mute.jl b/src/graph/mute.jl
@@ -216,13 +216,13 @@ function _remove_edge!(
 end
 
 """
-    get_snapshot_diff(dag::DAG)
+    snapshot_diff(dag::DAG)
 
 Return the graph's [`Diff`](@ref) since last time this function was called. Then, clear the current diff.
 
 See also: [`revert_diff!`](@ref), [`AppliedOperation`](@ref) and [`revert_operation!`](@ref)
 """
-function get_snapshot_diff(dag::DAG)
+function snapshot_diff(dag::DAG)
     t = deepcopy(dag.diff)
     empty!(dag.diff)
     return t
diff --git a/src/graph/print.jl b/src/graph/print.jl
@@ -59,8 +59,8 @@ function Base.show(io::IO, dag::DAG)
     end
     println(io)
     println(io, "  Edges: ", number_of_edges)
-    properties = get_properties(dag)
-    println(io, "  Total Compute Effort: ", properties.compute_effort)
-    println(io, "  Total Data Transfer: ", properties.data)
-    return println(io, "  Total Compute Intensity: ", properties.compute_intensity)
+    props = properties(dag)
+    println(io, "  Total Compute Effort: ", props.compute_effort)
+    println(io, "  Total Data Transfer: ", props.data)
+    return println(io, "  Total Compute Intensity: ", props.compute_intensity)
 end
diff --git a/src/graph/properties.jl b/src/graph/properties.jl
@@ -1,23 +1,20 @@
 """
-    get_properties(dag::DAG)
+    properties(dag::DAG)
 
 Return the graph's [`GraphProperties`](@ref).
 """
-function get_properties(dag::DAG)
+function properties(dag::DAG)
     # make sure the graph is fully generated
     apply_all!(dag)
-
-    properties = GraphProperties(dag)
-
-    return properties
+    return GraphProperties(dag)
 end
 
 """
-    get_exit_node(dag::DAG)
+    exit_node(dag::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(dag::DAG)
+function exit_node(dag::DAG)
     for (id, node) in dag.nodes
         if (is_exit_node(node))
             return node
@@ -27,11 +24,11 @@ function get_exit_node(dag::DAG)
 end
 
 """
-    get_entry_nodes(dag::DAG)
+    entry_nodes(dag::DAG)
 
 Return a vector of the graph's entry nodes.
 """
-function get_entry_nodes(dag::DAG)
+function entry_nodes(dag::DAG)
     apply_all!(dag)
     result = Vector{Node}()
     for (id, node) in dag.nodes
diff --git a/src/graph/validate.jl b/src/graph/validate.jl
@@ -5,7 +5,7 @@ Return whether the given graph is connected.
 """
 function is_connected(dag::DAG)
     node_queue = Deque{UUID}()
-    push!(node_queue, get_exit_node(dag).id)
+    push!(node_queue, exit_node(dag).id)
     seen_nodes = Set{UUID}()
 
     while !isempty(node_queue)
diff --git a/src/models/interface.jl b/src/models/interface.jl
@@ -10,7 +10,7 @@ function input_type end
 """
     graph(problem_instance)
 
-Generate the [`DAG`](@ref) for the given `problem_instance`. Every entry node (see [`get_entry_nodes`](@ref)) to the graph must have a name set. Implement [`input_expr`](@ref) to return a valid expression for each of those names.
+Generate the [`DAG`](@ref) for the given `problem_instance`. Every entry node (see [`entry_nodes`](@ref)) to the graph must have a name set. Implement [`input_expr`](@ref) to return a valid expression for each of those names.
 
 For more details on the `problem_instance`, please refer to the documentation.
 """
diff --git a/src/operation/apply.jl b/src/operation/apply.jl
@@ -119,7 +119,7 @@ function node_reduction!(dag::DAG, nodes::Vector{NodeType}) where {NodeType <: N
     @assert is_valid_node_reduction_input(dag, nodes)
 
     # clear snapshot
-    get_snapshot_diff(dag)
+    snapshot_diff(dag)
 
     n1 = nodes[1]
     n1_children = children(dag, n1)
@@ -159,7 +159,7 @@ function node_reduction!(dag::DAG, nodes::Vector{NodeType}) where {NodeType <: N
         end
     end
 
-    return get_snapshot_diff(dag)
+    return snapshot_diff(dag)
 end
 
 """
@@ -175,7 +175,7 @@ function node_split!(
     @assert is_valid_node_split_input(dag, n1)
 
     # clear snapshot
-    get_snapshot_diff(dag)
+    snapshot_diff(dag)
 
     n1_parents = parents(dag, n1)
     local parent_indices = Dict()
@@ -202,5 +202,5 @@ function node_split!(
         end
     end
 
-    return get_snapshot_diff(dag)
+    return snapshot_diff(dag)
 end
diff --git a/src/properties/create.jl b/src/properties/create.jl
@@ -56,8 +56,8 @@ 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)`.
+The graph's properties after applying the [`Diff`](@ref) will be `properties(graph) + GraphProperties(diff)`.
+For reverting a diff, it's `properties(graph) - GraphProperties(diff)`.
 """
 function GraphProperties(diff::Diff)
     ce =
diff --git a/src/scheduler/greedy.jl b/src/scheduler/greedy.jl
@@ -11,7 +11,7 @@ function schedule_dag(::GreedyScheduler, dag::DAG, machine::Machine)
     # the stack makes sure that closely related nodes will be scheduled one after another
 
     # use a priority equal to the number of unseen children -> 0 are nodes that can be added
-    for node in get_entry_nodes(dag)
+    for node in entry_nodes(dag)
         push!(node_stack, node)
     end
 
diff --git a/src/task/compute.jl b/src/task/compute.jl
@@ -1,12 +1,12 @@
 using StaticArrays
 
 """
-    get_function_call(n::Node)
-    get_function_call(t::AbstractTask, device::AbstractDevice, in_symbols::NTuple{}, out_symbol::Symbol)
+    function_call(n::Node)
+    function_call(t::AbstractTask, device::AbstractDevice, in_symbols::NTuple{}, out_symbol::Symbol)
 
 For a node or a task together with necessary information, a [`FunctionCall`](@ref)s for the computation of the node or task.
 """
-function get_function_call(
+function function_call(
         t::AbstractComputeTask,
         device::AbstractDevice,
         in_symbols::NTuple{N, Symbol},
@@ -15,20 +15,20 @@ function get_function_call(
     return FunctionCall(compute, (t,), [in_symbols...], [out_symbol], Type[Any], device)
 end
 
-function get_function_call(node::ComputeTaskNode, device::AbstractDevice)
+function function_call(node::ComputeTaskNode, device::AbstractDevice)
     # make sure the node is sorted so the arguments keep their order
     sort_node!(node)
 
-    return get_function_call(
+    return function_call(
         node.task,
         device,
         (Symbol.(to_var_name.(getindex.(node.children, 1)))...,),
         Symbol(to_var_name(node.id)),
     )
 end
 
-function get_function_call(node::DataTaskNode, device::AbstractDevice)
-    @assert length(node.children) == 1 "trying to call get_function_call on a data task node that has $(length(node.children)) children instead of 1\nchildren: $(node.children)"
+function function_call(node::DataTaskNode, device::AbstractDevice)
+    @assert length(node.children) == 1 "trying to call function_call on a data task node that has $(length(node.children)) children instead of 1\nchildren: $(node.children)"
 
     # TODO: dispatch to device implementations generating the copy commands
     return FunctionCall(
@@ -41,8 +41,8 @@ function get_function_call(node::DataTaskNode, device::AbstractDevice)
     )
 end
 
-function get_init_function_call(node::DataTaskNode, device::AbstractDevice)
-    @assert isempty(node.children) "trying to call get_init_function_call on a data task node that is not an entry node."
+function init_function_call(node::DataTaskNode, device::AbstractDevice)
+    @assert isempty(node.children) "trying to call init_function_call on a data task node that is not an entry node."
 
     return FunctionCall(
         identity,
diff --git a/test/random_arithmetic/impl.jl b/test/random_arithmetic/impl.jl
@@ -32,7 +32,7 @@ const EPS = 1.0e-6
 @compute_task FMA 1 fma
 
 function _add_node(g::DAG, rng, c)
-    input_nodes = ComputableDAGs.get_entry_nodes(g)
+    input_nodes = ComputableDAGs.entry_nodes(g)
 
     n = rand(rng, 1:9)
 
diff --git a/test/strassen_test.jl b/test/strassen_test.jl
