Cost Estimation interface (#14)

See issue #13

Reviewed-on: Rubydragon/MetagraphOptimization.jl#14
Co-authored-by: Anton Reinhard <anton.reinhard@proton.me>
Co-committed-by: Anton Reinhard <anton.reinhard@proton.me>

src/estimator/global_metric.jl

@@ -0,0 +1,65 @@
+
+"""
+   CDCost
+
+Representation of a [`DAG`](@ref)'s cost as estimated by the [`GlobalMetricEstimator`](@ref).
+
+# Fields:
+`.data`: The total data transfer.\\
+`.computeEffort`: The total compute effort.\\
+`.computeIntensity`: The compute intensity, will always equal `.computeEffort / .data`.
+
+
+!!! note
+    Note that the `computeIntensity` doesn't necessarily make sense in the context of only operation costs. 
+    For example, for node fusions this will always be 0, since the computeEffort is zero. 
+    It will still work as intended when adding/subtracting to/from a `graph_cost` estimate.
+"""
+const CDCost = NamedTuple{(:data, :computeEffort, :computeIntensity), Tuple{Float64, Float64, Float64}}
+
+function +(cost1::CDCost, cost2::CDCost)::CDCost
+    d = cost1.data + cost2.data
+    ce = computeEffort = cost1.computeEffort + cost2.computeEffort
+    return (data = d, computeEffort = ce, computeIntensity = ce / d)::CDCost
+end
+
+function -(cost1::CDCost, cost2::CDCost)::CDCost
+    d = cost1.data - cost2.data
+    ce = computeEffort = cost1.computeEffort - cost2.computeEffort
+    return (data = d, computeEffort = ce, computeIntensity = ce / d)::CDCost
+end
+
+struct GlobalMetricEstimator <: AbstractEstimator end
+
+function cost_type(estimator::GlobalMetricEstimator)
+    return CDCost
+end
+
+function graph_cost(estimator::GlobalMetricEstimator, graph::DAG)
+    properties = get_properties(graph)
+    return (
+        data = properties.data,
+        computeEffort = properties.computeEffort,
+        computeIntensity = properties.computeIntensity,
+    )::CDCost
+end
+
+function operation_effect(estimator::GlobalMetricEstimator, graph::DAG, operation::NodeFusion)
+    return (data = -data(operation.input[2].task), computeEffort = 0.0, computeIntensity = 0.0)::CDCost
+end
+
+function operation_effect(estimator::GlobalMetricEstimator, graph::DAG, operation::NodeReduction)
+    s = length(operation.input) - 1
+    return (
+        data = s * -data(operation.input[1].task),
+        computeEffort = s * -compute_effort(operation.input[1].task),
+        computeIntensity = typeof(operation.input) <: DataTaskNode ? 0.0 : Inf,
+    )::CDCost
+end
+
+function operation_effect(estimator::GlobalMetricEstimator, graph::DAG, operation::NodeSplit)
+    s = length(operation.input.parents) - 1
+    d = s * data(operation.input.task)
+    ce = s * compute_effort(operation.input.task)
+    return (data = d, computeEffort = ce, computeIntensity = ce / d)::CDCost
+end

src/estimator/interface.jl

@@ -0,0 +1,44 @@
+
+"""
+    AbstractEstimator
+
+Abstract base type for an estimator. An estimator estimates the cost of a graph or the difference an operation applied to a graph will make to its cost.
+
+Interface functions are
+- [`graph_cost`](@ref)
+- [`operation_effect`](@ref)
+"""
+abstract type AbstractEstimator end
+
+"""
+    cost_type(estimator::AbstractEstimator)
+
+Interface function returning a specific estimator's cost type, i.e., the type returned by its implementation of [`graph_cost`](@ref) and [`operation_effect`](@ref).
+"""
+function cost_type end
+
+"""
+    graph_cost(estimator::AbstractEstimator, graph::DAG)
+
+Get the total estimated cost of the graph. The cost's data type can be chosen by the implementation, but should have usable comparison operators (<, <=, >, >=, ==) and basic math operators (+, -, *, /).
+"""
+function graph_cost end
+
+"""
+    operation_effect(estimator::AbstractEstimator, graph::DAG, operation::Operation)
+
+Get the estimated effect on the cost of the graph, such that `graph_cost(estimator, graph) + operation_effect(estimator, graph, operation) ~= graph_cost(estimator, graph_with_operation_applied)`. There is no hard requirement for this, but the better the estimate, the better an optimization algorithm will be.
+
+!!! note
+    There is a default implementation of this function, applying the operation, calling [`graph_cost`](@ref), then popping the operation again.
+    
+    It can be much faster to overload this function for a specific estimator and directly compute the effects from the operation if possible.
+"""
+function operation_effect(estimator::AbstractEstimator, graph::DAG, operation::Operation)
+    # This is currently not stably working, see issue #16
+    cost = graph_cost(estimator, graph)
+    push_operation!(graph, operation)
+    cost_after = graph_cost(estimator, graph)
+    pop_operation!(graph)
+    return cost_after - cost
+end