Microsoft has released a preview build for Windows 10 that promises to dramatically increase the number of plugins that you can run in your DAW.
The company is testing a ‘FLS Slot Limit Increase’. Here’s what they have to say about it:
“As PCs get more powerful, musicians have created increasingly complex projects with more tracks, more instruments, and deeper effects chains. As a result, some of those musicians were running up against a FLS (Fiber Local Storage) slot allocation ceiling that prevented them from loading into their DAWs (Digital Audio Workstations) as many unique plugins as they’d like.
This build greatly raises that per-process FLS slot allocation ceiling, allowing loading potentially thousands of unique plugins.
Beyond musicians, this change will positively impact any application that dynamically loads hundreds or thousands of unique DLLs that have statically-linked Visual C++ runtimes, or otherwise allocate FLS slots.”
We asked Microsoft Windows Pro audio and music person Pete Brown to help us understand what this update means for musicians. He explained that the current limitation has been there for years, but musicians are now running into it, because they’re using beefier systems and creating more and more complex projects:
“What was happening was that the DAW was using, say 40 slots itself, and then people with really complex projects were using many unique plugins (not instances, but completely different plugins) in their projects, and were running into problems loading the last ones that would have put the FLS count > 128.
That’s typically a very complex project on a pretty beefy system, but some folks were actually hitting that. The DAW would simply refuse to add an instance of that next plugin. They could use new instances of existing plugins in the DAW, because the code had already been loaded and initialized, but new plugins (new DLLs that haven’t already been loaded into the project) would just fail.
Now, we’d really like developers to dynamically link the runtime so that we could service it (bug and security fixes) without requiring developers to recompile their plugins. But we know that’s not likely to happen anytime soon, and for old plugins: never. So we changed the limit of slots from 128 to just over 4000.
Developers don’t need to do anything, but end users will no longer have their DAW plugin count capped by this limitation. The new count means that, today, users will run out of memory and processor time before they run out of FLS slots. But we’ve made it much easier for us to change in the future if/when we need to make it more than 4000.
The limitation goes back to the Vista and XP timeframe. The reason folks are running into it now, is PCs have gotten so powerful, that musicians are hitting this limit where before they would simply run out of memory or CPU.”
We also asked Brown to give us a layman’s summary of what the FLS change means for musicians:
“It’s a bit hard to put this completely in layman’s terms because it’s a change to the kernel code in Windows. But here’s a shot:
FLS slots are how we manage small in-memory storage locations for what are called “Fibers”. Fibers are lightweight threads. Threads are bits of code that execute in parallel, sometimes on different processor cores. Almost everything done in parallel in a DAW is using either Fibers or Threads to allow that code to be run. How that is handled differs from DAW to DAW.
DAWs are a process that can load external code (plugins) that are contained in DLLs. DLLs (Dynamic Link Libraries) are compiled code that is packaged specifically to be loaded by other processes. DLLs are the main way code is shared on Windows.
Most VST plugins for Windows are compiled using a version of Visual C++. Visual C++ has a runtime library full of functions that are used by anything compiled with it. That runtime library allocates (depending upon version) one or two FLS slots per instance of the library loaded in a process.
Now, for convenience and ease of installation, most plug-in authors statically link that runtime. That means that the runtime code is included inside the plugin DLL, instead of referenced from another DLL. So, if you have 50 different unique plugins loaded in the DAW, and each plugin statically links the runtime, there will be 50 copies of that runtime code loaded into the DAW process. Each copy of that runtime code will allocate one or two FLS slots, so you can end up with between 50 and 100 FLS slots used just by the runtime.
If the plugin dynamically links the runtime (that is, the plugin references a runtime DLL that is installed with the plugin, or is already present on the system), only as many copies of the runtime will be loaded in the DAW process as there are unique versions of that runtime. So, if there are 50 plugins in the process, but collectively they use, say, 5 unique versions of the runtime, there will be only 5 copies of that code loaded into memory. This is obviously better for memory usage, but also better because there will only be between 5 and 10 FLS slots used.
There’s a bit more complexity here based on how the runtime is installed (app local, global, etc.) and the versions available, but this captures the gist of it.
The DAW itself also tends to use a number of FLS slots. This varies significantly by product. The slot may be just for a variable used in the fiber to, say, keep track of a pointer into an audio buffer, or something else.”
If you’re a technically knowledgeable user and have hit this limit in the past, you can test the update. Since it’s pre-release software, Microsoft says that you should use the Insider build on a non-critical PC to test it out. Details are available at Microsoft’s site.
For other users, Microsoft expects to release the change in their upcoming ’19H1′ release. There’s no date set for this release yet, but the name means “first half of 2019”.