Add scheduling, machine info, caching strategies and devices (#9)

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

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