How does Spatial figure out the data dependencies in a Streaming controller?

For the pipelined schedule, is it a prerequisite that the capacity is 2? Trying to figure out how to determine if a pipeline is full.

Also, +1 on the above question. Wondering if it would cause correctness issues if a stage starts before its previous stage completes.

So essentially in this case, are we basically seeing that Pipelining is the same concept of a thread being able to work on the next task when the resource is freed up with the laundry example? How exactly is pipelining different than the examples with threads we saw earlier on in the class with the laundry example. Also, I'm kind of confused about what makes this pipelining special compared to normal multithreading since the professor mentioned it's kind of a "free lunch" type thing in parallel processing, but isn't this basically the fundamental idea of multithreading?

@derrick I think that if we perform pipelining in software, we have to consider synchronization overhead. For example, if we pipeline some complex software, at each stage we would have to synchronize parallel threads at each stage which would cost a ton of performance. However, in hardware different stages in a pipeline are inherently synchronized since they execute within a clock cycle.

What is the difference here between stalled and starved? Is this just based on the state of the intermediate FIFO, i.e. full vs empty? What way can we avoid this, can we make a larger intermediate FIFO or an infinite FIFO?

I am also not sure about the difference between stalled and starved here.

Stalled refers to the output, starved refers to the input. If something upstream of you is stuck and you can't get work, that is starved. If something downstream of you is stuck and you can't pass on your work to them, that is stalled.

I am confused on how exactly we implement a FIFO structure to ensure an even more packed pipelined execution in the streamed schedule. Would this be a sequence of buffers or memory accesses that the outer controllers take care of? How does this differ from pipelining in Spatial's hardware organization of those accesses?

I am confused about the Stream option. What goes in the FIFO? How does it help work flow better?

Would the FIFO based approach require more complex circuitry to implement? I imagine that there would be some overhead of checking the buffer to see if there is a work item, and also to check if the buffer has the capacity to accept the result.

It seems that in the pipeline schedule, each stage depends on the previous to complete, while in the stream schedule, stages can start in an overlapped manner. What makes it possible to start the next stage before the previous is complete in the stream schedule?