1 reply to this topic

[Aaron]

Hello:

We are trying to implement a rolling memory buffer in ImpulseC. I do not have much of a background in hardware, so I apologize if the following explanation of our problem is semantically rough.

The details of our problem are:

1) We want to store multiple frames (let's say 4, for concreteness) of in-streaming video data in an external memory buffer.
2) The frame data will be written to the buffer via an (upstream) hardware function.
3) The frame data will be read from the buffer via a (downstream) hardware function.
4) The first 4 frames will be written to sequential memory space until the buffer is full.
5) When the 5th frame comes in, it will write over the memory containing the 1st frame.
6) When the 6th frame comes in, it will write over the memory containing the 2nd frame.
7) Etc., etc.

We need a mechanism in place, though, to ensure that a pixel in a particular frame in memory is not written over with a subsequent pixel until the (downstream) hardware function has performed its functionality on that frame.

What I am wondering is this: what is the best (or standard) approach for creating this mechanism? I understand that the memory itself will be accessed via the "co_memory_xxx" calls. However, should the logic preventing premature pixel overwrites use 1) co_registers, 2) co_signals, or 3) something more exotic? Does there happen to exist an example of a rolling memory buffer either somewhere in the ImpulseC examples or elsewhere?

Thank you very much!

Aaron

[RalphBodenner]

Hi Aaron,

You could use a pair of co_signals between the two processes to indicate "done storing frame" and "done reading frame".

Ralph