And keep in mind, currently, the only reason I still use it is because of the incredible cpu efficiency (yes, I DID just say that )

while anything like this could be true, you'd have to come up with a reason for it.

http://en.wikipedia.org/wiki/Clarke%27s_three_laws

Theres a lot of info here :

http://www.kvraudio.com/forum/viewtopic.php?t=333284&postday s=0&postorder=asc&start=0

yes but none of that would explain why a particular host would be better with a particular plugin.

What would be the best way to test this? I did some "benchmarks" when I worked at AVID but they were far from scientific. Not much more than loading a bunch of plugins and watching the activity monitor...

I assume that a plug-in could be written specifically for the purpose of testing how efficiently different DAWS handle certain processes at different sample rates and buffer sizes.

How much of what happens in any given plug-in is actually handled by the host, anyway?

none of what happens in the plugin is ever handled by the host.

the few things that might be influences are:

- alignment of memory. for example audio and event buffers.
- block sizes.
- automatic bypass on zero activity/signal. (HUGE difference for plugs that don't support it.)
- threading.

the only way you could really accurately measure it would be to set up a very specific test case. let's say because we're considering "host x vs. host y more efficient with plugin x vs. plugin y", we could just run a single instance doing exactly the same thing. max out the polyphony for example. then we can just measure the total time spent in the host process (including the plugin) between the hosts.

we're leaving the measurement accuracy up to the system and there might still be a bias. that's why we'd want to maximize the amount of activity. it's likely that any error in the measurement has a non-linear relationship to the magnitude of the measurement. in other words it's probably a fixed bias or overhead. the bigger the measurement, the more it should be averaged out or the less relevant it's scale would become relative to the measurement.

it's definitely possible to get better results using simple things like aligned buffers. if any host were to use unaligned buffers... well, that's more of a bug for the slow host rather than an advantage for the fast one.

ultrajv; you have to realize what tony was talking about is basically just double/multiple buffering. this is kindergarten level stuff.

the only thing you'd be doing there is to increase your buffer size. it would be less likely to see over-runs, but the total cpu time spent would be absolutely identical.

we can't just measure consumption in a moment. you have to measure something big and average it. for example, rendering a complete track.

with host cpu meters you have to know all sorts of things. the same rules apply as for vu meters. are you measuring peak or average? how wide is the window? what type of envelope is being used?

So how do you measure DAW efficiency? Using one or two plugins isnt going to do it. As far as I can see, the Reaper advantage is smoke and mirrors. Lets start here :

http://www.dawbench.com/

first you have to define "daw efficiency".

No I dont

Read the info at DAWBENCH.

http://www.dawbench.com/dawbenchdsp-x-scaling.htm

so you're saying you haven't noticed how they never bother to define it?

That's just their definition....

They do :

"Each application has its own strengths and weaknesses in regards to MP scaling"

Very interesting. Thanks.
I assume that even threading can be handle inside the plug-in since some distribute voices across multiple threads? So the host is mainly just passing data back and forth and prioritizing/syncing certain events?

Is there any way to establish a baseline for how much activity is involved at a minimum to host a plug-in?

plugins could in theory distribute load across threads/cores, but most won't. it's complex and it's unlikely to provide any benefit except with very expensive plugins.

the host only passes things around. it decides when and where the plugins are called. the only way to really learn about this stuff and get a really clear picture is to be a programmer unfortunately.



yes i was actually going to mention this earlier, i just don't want to create it myself and so didn't bother.

all you need is a plugin that does absolutely nothing.

(this would be like testing how effective a door-to-door salesman is by having him run up to each door, open it and close it rapidly, then walk to the next house.)

some interesting things to measure would be which thread each function is called from, what the alignment of each buffer is, whether buffers span page boundaries and possibly a few other things.

i wrote a "host tester" plugin for this kind of thing years ago but i never considered using it to test these issues. time spent in a single plugin has always been a much greater concern for me as loading 10 instances of xhip for example uses 0% cpu according to task manager's timing on any hosts i've ever tested, while i can max out a core easily with one instance by using 100s of voices.