What could be the best practice of a Stream wrapper of sliding window mechanism?

[dzx-dzx]

To implement a convolution layer in CNN, the hardware will first extract, in sequential or in parallel, all possible subsets from the input array. And since every subset overlaps with its neighbour and shares the same data, it is often wise to use a set of shift registers. But how does it fit into the Stream model?
Specifically, I'd like to ask if and how the following design can be made:
Given a row of input pixels:

1, 2, 3, 4, 5

In sequential, the hardware will output:

1, 2, 3
2, 3, 4
3, 4, 5

[Readon]

It seems like a fifo whose content can be read by index.
Have you tried History module? With some combination code.

[Readon]

one option is that use History to monitor a stream, which means you can push to History when the monitored stream fire.

[dzx-dzx]

Let's see... Is this what you mean?

class PE(g: PEGenerics) extends Component {
  import g._
  val io = new Bundle {
    val input  = slave Stream (Pixel)
    val output = master Stream (Vec(Pixel, 3))
  }
  io.output << io.input.translateWith{
    History(io.input.payload,3,io.input.fire)
  }
}

But the valid signal will pull up as soon as the first handshake is completed I'm afraid.

[Readon]

I think it could be as below if it fits your requirements.

class PE(g: PEGenerics) extends Component {
  import g._
  val io = new Bundle {
    val input  = slave Stream (Pixel)
    val output = master Stream (Pixel)
    val hist = out Vec(Pixel)
  }
  val hist = History(io.input.payload,3,io.input.fire)
  io.hist <> hist
  io.output << io.input
}

If you really want the data is in the stream pipeline.
Then the design could be (not tested).

    val hist = Vec(Stream(Pixel), 3)
    for(i <- 0 until 2) {
       hist(i) <-< hist(i+1)
    }
    hist(2) <-< input
    output <-< hist(0)

[dzx-dzx]

Ah yes, the latter is what I'm expecting(and actually experimenting). Thanks!

[Readon]

It's @kleinai 's idea. 😆

[kleinai]

If it's a small window I've tried using multiple stream stages then concatenating the data from each one. This also exposes the valid signals. You'll need some logic to let it fill properly.

[Readon]

using a Vec with for loop?

[dzx-dzx]

Well I've written my own version as per @kleinai 's idea. Any suggestions?

class PE(g: PEGenerics) extends Component {
  import g._
  val io = new Bundle {
    val input  = slave Stream (Pixel)
    val output = master Stream (Vec(Pixel, 3))
  }
  val shift = Vec(Stream(Pixel), 3)
  shift.last <-< io.input
  for (i <- 0 until (shift.length - 1)) {
    shift(i) <-< shift(i + 1)
  }
  io.output << shift(0).haltWhen(~shift.map(_.valid).andR).translateWith {
    Vec(shift.map(_.payload))
  }
}

[Readon]

You can look at HistoryModifiable as a reference.
I prefer to expose the valid also, it can show you if the data in the pipeline is valid, when your logic care about the first N points.

[dzx-dzx]

You can look at HistoryModifiable as a reference.

Oh my, this is quite sophisticated...

[Readon]

It's worth noting that it's not tested in synthesis environment, it's mainly designed for formal verification.
Maybe it's in a wrong place.

In practical design, a modification on arbitrary position is not widely required.

[dzx-dzx]

Thanks for your information!

[dzx-dzx]

I'm sorry to revive this old post but... I'm considering whether it is sensible to use the proposed design, under scenarios when the payload is small(one bit as an extreme example) and the overhead might be... not negligible.
And generally speaking, may I inquire if and when the design would entail manual controls over the ready and valid signals?

[Readon]

The ready signal is normally used when you need back pressure, if you do not need it, you can use Flow which only have valid.

The data and control signals are normally required separately, because the receiver need to know when the signal is valid, in this case at least two signals are required.
However, there are exceptions that if your data is transferred continuously then no control is required.
Or if your data is transferred by some condition, then you can reuse that for control.