[PD] poor performance when saving an abstraction when many copies are loaded in a patch

[matteo sisti sette]

> Otherwise, think about converting some of the abstractions to subpatches


Please don't interprete what I'm gonna say as sarchastic or offensive
to whom wrote the above sentence (which however has been suggested by
more than one person). Just take it as a general and (hopefully)
constructive discussion about PD issues...

Would you ever say to someone writing an application in C++:

"Think about converting some of your functions to macros"???

That is just not an option.
And converting abstractions to subpatches is much more limiting than that.

Inefficiencies in handling a great number of instances of abstractions
are a great obstacle to applying "good" programming  practices to PD
patches.
Using and reusing a great number of abstractions with many many levels
of nesting is the only reasonable way (I can think of) of developing a
large, complex, scalable, reusable "application" in PD.

This reminds me about a discussion I lounched in the list some months
ago about whether PD can be considered an environment for "production"
development, or just a tool for "prototyping". I do use it in
production, that is I use it  to develop "applications" that have to
be used on stage, and I don't rewrite them in any other language: I
just develop them in PD and run them in PD. And that causes me a lot
of frustration because I often find out that PD starts to be somewhat
unstable and unreliable when things get "big". At least (or
especially) when GUI is involved.
Note that I do take all the care to make sure that cpu or memory usage
does not increase more than it should when making things "bigger"
(e.g. always switch~ing off any audio processing stuff that is not
really being "used", etc.)

I would love to provide examples or specific information useful for
debugging, but when I get that kind of problems, I've never been able
to isolate them. In one case I had a big, complex, structured patch
with a lot of stuff inside. Just adding one more instance of an
abstraction there were tens of instances of (and the whole patch
worked great up to that moment), made it crash on open.

Now a practical question: it has been mentioned that PD manages the
patch structure with linked lists which make it inefficient in
renewing it when saving an abstraction that is used many times. Does
this linked-list implementation cause other efficiency issues that may
affect the working of things during the normal flowing of data (i.e.
running the patch) or is it "only" an issue when saving?


-- 
Matteo Sisti Sette
matteosistisette at gmail.com
http://www.matteosistisette.com