Shuffle files and functions around for more consistent naming and smaller files

src/operation/utility.jl

@@ -0,0 +1,107 @@
+
+function isempty(operations::PossibleOperations)
+   return isempty(operations.nodeFusions) && 
+          isempty(operations.nodeReductions) && 
+          isempty(operations.nodeSplits)
+end
+
+function length(operations::PossibleOperations)
+   return (nodeFusions = length(operations.nodeFusions),
+           nodeReductions = length(operations.nodeReductions),
+           nodeSplits = length(operations.nodeSplits))
+end
+
+function delete!(operations::PossibleOperations, op::NodeFusion)
+   delete!(operations.nodeFusions, op)
+   return operations
+end
+
+function delete!(operations::PossibleOperations, op::NodeReduction)
+   delete!(operations.nodeReductions, op)
+   return operations
+end
+
+function delete!(operations::PossibleOperations, op::NodeSplit)
+   delete!(operations.nodeSplits, op)
+   return operations
+end
+
+
+function can_fuse(n1::ComputeTaskNode, n2::DataTaskNode, n3::ComputeTaskNode)
+   if !is_child(n1, n2) || !is_child(n2, n3)
+      # the checks are redundant but maybe a good sanity check
+      return false
+   end
+
+   if length(n2.parents) != 1 || length(n2.children) != 1 || length(n1.parents) != 1
+      return false
+   end
+
+   return true
+end
+
+function can_reduce(n1::Node, n2::Node)
+   if (n1.task != n2.task)
+      return false
+   end
+   
+   n1_length = length(n1.children)
+   n2_length = length(n2.children)
+
+   if (n1_length != n2_length)
+      return false
+   end
+
+   # this seems to be the most common case so do this first
+   # doing it manually is a lot faster than using the sets for a general solution
+   if (n1_length == 2)
+      if (n1.children[1] != n2.children[1])
+         if (n1.children[1] != n2.children[2])
+            return false
+         end
+         # 1_1 == 2_2
+         if (n1.children[2] != n2.children[1])
+            return false
+         end
+         return true
+      end
+
+      # 1_1 == 2_1
+      if (n1.children[2] != n2.children[2])
+         return false
+      end
+      return true
+   end
+
+   # this is simple
+   if (n1_length == 1)
+      return n1.children[1] == n2.children[1]
+   end
+   
+   # this takes a long time
+   return Set(n1.children) == Set(n2.children)
+end
+
+function can_split(n::Node)
+   return length(parents(n)) > 1
+end
+
+function ==(op1::Operation, op2::Operation)
+   return false
+end
+
+function ==(op1::NodeFusion, op2::NodeFusion)
+   # there can only be one node fusion on a given data task, so if the data task is the same, the fusion is the same
+   return op1.input[2] == op2.input[2]
+end
+
+function ==(op1::NodeReduction, op2::NodeReduction)
+   # node reductions are equal exactly if their first input is the same
+   return op1.input[1].id == op2.input[1].id
+end
+
+function ==(op1::NodeSplit, op2::NodeSplit)
+   return op1.input == op2.input
+end
+
+copy(id::UUID) = UUID(id.value)