adding node::Queue; refactoring SinkChannel for code reuse

[ryanolson]

In our original design, we had three entities required to form an edge: a Source, Channel and Sink.

This required constructing three object and making two calls to form an edge, pseudo code

auto source = s.make_source<T>(...);
auto channel = s.make_channel<T>(...);
auto sink = s.make_sink<T>(...);

s.make_edge(source, channel);
s.make_edge(channel, sink);

To reduce complexity for common patterns, it was decided that Sinks would own Channels and provide them to Sources. This had the effect of reducing complexity for edge construction to the creation of a source and a sink and the formation of an edge.

auto source = s.make_source<T>(...);
auto sink = s.make_sink<T>(...);

s.make_edge(source, sink);

While this reduction in complexity is nice, it also creates a limitation in that each Sink owns its own Channel. This makes load-balancing work across multiple downstream Sinks more difficult, because work is being pushed to each Sink. Pushing has several problems:

• Any write to a Sink's channel which is full, fiber yields the writer.
  • This means if we have N Sinks to which we want to write, we need to have a unique writer per Sink or risk stalling a single writer by blocking on write.
• Sinks operating at different speeds, either from heterogeneous hardware or by the fact the operation being performed may have variable length wall time based on inputs, means push based load-balancing will be problematic.

This MR adds the ability for pull based Sinks using a design similar to the original allowing for standalone Queue (Channel holder), but with the default being the current behavior.

// Let:
// - SourceProperties<T> be an IngressAcceptor
// - SinkProperties<T> be an IngressProvider

// If:
// - SourceChannel<T> is an IngressAcceptor
// - SinkChannel<T> can be either an IngressProvider or a ChannelAcceptor
// - Queue<T> is an IngressProivder and a ChannelProvider

// Then, Edges can be from:
// - make_edge(IngressAcceptor<T>, IngressProivder<T>)
// - make_edge(ChannelProvider<T>, ChannelAcceptor<T>)

This enabled the following example's Sink to be a pull based Sink:

        auto source = s.make_object("source", test::nodes::infinite_int_rx_source());
        auto queue  = s.make_object("queue", std::make_unique<node::Queue<int>>());
        auto sink   = s.make_object("sink", test::nodes::int_sink());
        s.make_edge(source, queue);
        s.make_edge(queue, sink);

There is no change to the API or default behavior of node/segment objects.

[mdemoret-nv]

The design is growing more on me. Just had a couple of comments and the branch needs to be merged with the latest changes.

[ryanolson]

@gpucibot merge