Inefficient differential converter
So, my first attempt at this solution was very slightly more efficient.  With 2 more instructions, I managed 39 fewer cycles.  I'm not exactly certain right now what the difference is (it's pretty close), but I'm not concerned with that right now.



Thinking about this problem some more, I realized there's a mathematical trick going on here that we can make use of to drastically decrease both the number of instructions and the number of cycles.  

A - B == -1 * (B - A)


That is, instead of subtracting left from right for the left column and right from left for the right column, we can just subtract once, pass the positive result to one column and the negative result to the other column.

Using this trick, I'm also able to eliminate an entire node.



As you can see, 201 cycles 5 nodes, 10 instructions.

So, starting with the top left node, we pull A into memory, subtract B, then pass it down.  Middle left just passes it down again.  Bottom left saves it to ACC, passes it down, negates it and passes it right.  The top right node just reads in B and passes it left.  The bottom right node just moves stuff from left to down.

Three of the five nodes are just there to move the values around.



Here's the source...

TOP RIGHT

MOV UP, LEFT


TOP LEFT

MOV UP, ACC
SUB RIGHT
MOV ACC, DOWN


MIDDLE LEFT

MOV UP, DOWN


BOTTOM LEFT

MOV UP, ACC
MOV ACC, DOWN
NEG
MOV ACC, RIGHT


BOTTOM RIGHT

MOV LEFT, DOWN