[PD] Efficient FIFO in Pd: How?

Roman Haefeli reduzent at gmail.com
Sun Nov 22 09:47:46 CET 2015

On Sun, 2015-11-22 at 01:47 -0500, Matt Barber wrote:
> Your [fifo-list] is very much like [list-fifo] from list-abs, which
> suffers from the poor [list] performance. The message-box one also
> suffers from having to use lists to dequeue.
> I've thought of a way to do it using [list fromsymbol], [list
> tosymbol], and an elaborate array storage scheme which would store the
> length of each list at the beginning of the list like you do in the
> others, and then the length of each symbol before each symbol (or -1
> to store a float). Enqueueing would cost one [list-drip] plus the
> encoding and storing per list, but since the array is random-access,
> it should be O(n) over all with the size of the fifo.
> Retrieving would do it in reverse, which would cost one [list
> prepend]X[t a] loop plus reading and decoding per list, which should
> also be O(n) with the size of the fifo.
> You'd maintain a write and a read index into the array; [array size]
> the array to 2^24. What to do when you reach the end of the array is
> the tricky part. If you want to be able to do a ringbuffer kind of
> thing, you could just maintain another array to prewrite the list
> encoding into. By doing this, you'll know the entire length of what
> needs to be written, and if that exceeds what you have in your table,
> you could write an instruction (-100, say), to start at the beginning
> again, and then reset your write index to 0. You'd need to test to
> make sure that an incoming write doesn't allow your "write head" to
> lap your "read head".

Yeah, I thought about something similar, too. It'll basically look like

[list-fromlist] <- converts any list to list of numbers
[nfifo] <- FIFO using a table as a ring-buffer
[list-tolist] converts back to lists with symbols

> If you needed REALLY arbitrary size, if you got to the end of one
> array, you'd dynamically allocate a new one, and write an instruction
> to move reading to the next array when your read index reaches it.

I guess if I would go for the route of converting everything to numbers
first, I'd use simply a [table] and it could be resized when necessary.

> I have no idea if this would work (it should), or what the constant
> time complexity factors are here; my guess is that it's slower than
> the others for short fifos. [array set] and [array get] are faster
> than you'd think, though, allowing you to write chunks at a time,
> unlike [tabwrite].

> If you make it I'll tweak it (for style) to include in my array-abs
> collection; otherwise I'll add it to my list and make it later.

Sounds interesting to do, but I'm not sure whether I'm going to invest
time in it. [fifop] works pretty well for my current use case.


> On Sat, Nov 21, 2015 at 7:52 PM, Roman Haefeli <reduzent at gmail.com>
> wrote:
>         On Sun, 2015-11-22 at 00:47 +0100, Christof Ressi wrote:
>         > Just in case you don't know: There's the [fifop] object in
>         zexy which works with lists and also lets you set the
>         priority. I'm sure it's also faster than anything one can do
>         with Pd objects.
>         Thanks, somehow I forgot that zexy has that. It is indeed fast
>         (as in
>         linear fast). I'm going to use it.
>         Just out of curiosity, I wonder if there is a O(n) vanilla
>         implementation, too.
>         Roman
>         > > Gesendet: Sonntag, 22. November 2015 um 00:24 Uhr
>         > > Von: "Roman Haefeli" <reduzent at gmail.com>
>         > > An: Pd-List <pd-list at lists.iem.at>
>         > > Betreff: [PD] Efficient FIFO in Pd: How?
>         > >
>         > > Hi all
>         > >
>         > > I'm looking for a way to implement a FIFO buffer in Pd.
>         I'd like it to
>         > > be able enqueue messages with an arbitrary number of
>         elements in order
>         > > to retrieve them in the same order later. I came up with
>         three different
>         > > methods, but they are all either slow at enqueuing or at
>         dequeuing or
>         > > even both. It seems for a quick implementation you need
>         something like a
>         > > ring buffer, but I can't think of any method that would
>         work for
>         > > symbolic elements, too (as opposed to numbers).
>         > >
>         > > Attached patch comparison.pd compares the methods. Isn't
>         there really a
>         > > O(n) implementation as opposed to O(n^2)?
>         > >
>         > > Roman
>         > > _______________________________________________
>         > > Pd-list at lists.iem.at mailing list
>         > > UNSUBSCRIBE and account-management ->
>         http://lists.puredata.info/listinfo/pd-list
>         > >
>         _______________________________________________
>         Pd-list at lists.iem.at mailing list
>         UNSUBSCRIBE and account-management ->
>         http://lists.puredata.info/listinfo/pd-list

-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 473 bytes
Desc: This is a digitally signed message part
URL: <http://lists.puredata.info/pipermail/pd-list/attachments/20151122/eb6b7354/attachment.sig>

More information about the Pd-list mailing list