# Average Load to CPU Utilization Ratio

Okay, I think I understand what you’re saying. I’ll explain by way of an example…

Let’s say that a “time slice” is 20 msec long. So that means there are 1000msec/20msec = 50 time slices/sec.

If Cubase takes 2 msec to transfer a chunk of audio to a hardware buffer (via the OS), then the peak meter would display 100 × 2msec/20msec = 10 (where 100 is a scaling factor that converts the utilization-fraction to percent).

Now let’s say that due to the large number of plugins used in a project Cubase utilizes many time slices to perform the necessary DSP calculations. Continuing the example above, let’s say that Cubase requires 40 time slices each second. In this case the average meter will read 100 x 40/50 = 80.

Is this correct?

The frequency of callbacks never changes. LIkewise, the period for callbacks never changes. It is always buffer size/SR. In other words, the allowable duration of a time slice is constant for a given buffer size and SR. The peak meter shows the highest recent percentage of that period that was required by the plugins and DAW to perform their realtime work to process a single buffer.

So, assuming a buffer size of 256 and a SR of 44100, that gives a period of approx. 5.8 ms. If my peak meter is showing 10, that means it recently took approx. 0.58 ms for the plugins and DAW to perform their realtime work, yes?

Using the same buffer size and SR above, and seeing that the average meter reads 50, can we similarly relate this “unitless” number to (numerical values) of system properties?

That’s not quite the way I would say it. I would say: recently, the longest it took to process a block was .58 ms.

Using the same buffer size and SR above, and seeing that the average meter reads 50, can we similarly relate this “unitless” number to (numerical values) of system properties?

I’m sorry, I don’t understand your question. 50 in this example is a percentage. Is that what you mean by “unitless number”? What system properties? If you mean the system cpu meter, as I mentioned above, the relationship between these two is quite complicated due to load balancing, among other things.

Yes.

Yes, that is what I was asking.

The reason is that I’m still very curious to understand the discrepancy between avg meter load (Cubase) and CPU load (Windows). You’ve convinced me that it’s complicated, but that doesn’t mean it’s unknowable. And, according to the VI-Control post I refereced earlier in this thread, it’s also possible to nearly saturate CPU load bringing it much closer to that reflected on the avg meter. I’d like to know how to do this even if it means changing the way I work in Cubase. In the end it would remove the anxiety/frustration associated with frequent drop-outs.

Thanks for all the info, it’s been very enlightening!

You’ve convinced me that it’s complicated, but that doesn’t mean it’s unknowable.

Sure. By “complicated” I mean it’s a difficult calculus to determine one from the other, with many variables, most notably your signal routing. But it is not an unknowable mystery . Just because I put 8 parts in Omnisphere when I designed it doesn’t mean you should always use it in a single multitimbral instance. That’s why you often see recommendations to use multiple monotimbral instances to help with cpu usage.

Okay, so I went ahead and ran a test to understand what the Avg Load meter actually measures. Below is a description of what I did.

First, I created a Cubase Pro (10.5.20) project with 10 Instrument tracks and 10 Group tracks (see screenshot “project_mixer_view” below).

Each Instrument track contains one VI (Omnisphere 2) and either one (Case 1) or two (Case 2) insert FX(s) (Ozone 8).

In addition to the two Cases there are 11 Setups which varied as follows.

Setup 0 was a special case in that all 10 Instrument tracks and all 10 Group busses were routed directly to the Output (2BUS).

In Setup 1, all 10 Group busses were routed directly to 2BUS (just as in Setup 0), but here all 10 Instrument tracks were routed to the first Group buss (GBUS 01).

All the remaining Setups had a specific number of ‘dependencies’ introduced by routing one or more of the Group busses to each other. For example, in Setup 1, GBUS 01 was routed to GBUS 02 (while the remaining Group busses were routed to 2BUS). In Setup 2, GBUS 01 was routed to GBUS 02 and GBUS 02 was routed to GBUS 03 (while all the remaining Group busses were routed to 2BUS). And so on. (see screenshot “design_matrix” for the full design matrix).

Note, the total number of plugins (VIs [Omnisphere] and FXs [Ozone]) were identical across all Setups and varied only between the two Cases (Case 1 = 10 VIs + 20 FXs; Case 2 = 10 VIs + 40 FXs).

Second, I measured three different values: Avg Load, Reatime Load, and CPU Load (via the Win10 TaskMgr) for each Setup, and for both Cases.

Third, I calculated an aggregate measure of the total computation of the project (Total_Comps) as follows:

Total_Comps = Direct_Routes + Dependencies

Where:

Direct_Routes = 20-Indirect_Routes
Dependencies = 10*Indirect_Routes

Fourth, I created two plots (Case 1 & Case 2) each showing how the Avg Load (red), RT Load (green), and CPU Load (blue) varied as a function of the Setups (see screenshot “plots”). In both plots all three Loads were plotted against Total_Comps on the X-axis (this is how I chose to represent the different Setups).

Regarding the results we see a few interesting things:

1. RT Load seemed constant across all Setups, and for both Cases 1 & 2.

2. CPU Load was only weakly anti-correlated to Total_Comps, but was clearly different for Case 1 (30%) vs Case 2 (46%). As a reminder, Case 1 had one row of Ozone plugins whereas Case 2 had two rows.

3. We see a clear variation of Avg Load both across Setups (Total_Comps) and between the two Cases 1 & 2. The relationship between Avg Load and Total_Comps seems to be linear as evidenced by the fairly high r^2 value of the linear fit model (see equations in plots).

Thus my conclusion is that Avg Load seems to reflect both CPU Load and the dependencies (interactions) between tracks. As a reminder, the dependencies varied without any change in the number of plugins or the number of tracks. So the variation of Avg Load across Setups may be a result of the need to compute the input signal before it reaches the next processing stage on its way to 2BUS. For example, in Setup 1 (for both Cases 1 & 2), the plugins on GBUS 01 need to know the input signals coming from all 10 Instrument tracks before they can compute an output.

Well, this is as far as my understanding takes me. Perhaps GlennO or someone more knowlegeable about DAW design can explain the results further.

Cheers…

That’s good taste in virtual instruments, thanks