August 17, 2026
Earlier this yr, I blogged about work I did to enhance VRAM administration
for video games. Now, after many months of floating round in mailing lists, the kernel patches
are lastly merged upstream and queued for Linux 7.3! Hooray!
To rejoice, let’s look a bit deeper at one sentence I wrote in my earlier publish:
[Games] ought to carry out way more steady – so long as the sport itself doesn’t
use extra VRAM than you even have.
So, one might ask: What in the event that they do, actually, use extra VRAM than you even have?
Typical expectations for this appear to be that when this occurs you’re just about screwed.
Video games will begin crashing left and proper, efficiency plummets to unplayable ranges,
gaming expertise turns into not possible.
However is that basically simply an unavoidable truth of life? What actually makes operating out of
VRAM suck so arduous? And, most significantly: How can we make it suck as little as potential?
In idea, operating out of VRAM ought to solely be a efficiency situation, not a stability one.
Help for overcommitting VRAM has existed for so long as GPU drivers have: If the driving force
overcommits VRAM, you might be usually allowed to request as a lot VRAM as you’d like,
and also you’ll get as a lot because the kernel driver decides it will possibly match into the bodily reminiscence that exists on GPU.
On the efficiency facet, the big-picture motive for unhealthy efficiency whenever you run out of VRAM is pretty easy.
As quickly as the sport requests extra VRAM than is bodily current, a number of the sport’s reminiscence will
should be moved/evicted to CPU RAM as a substitute. For the GPU, accessing CPU RAM is far slower than VRAM:
Not solely is CPU RAM slower than a devoted GPU’s VRAM on the whole, all reminiscence accesses additionally
should go over the PCI bus. The PCI bus provides latency and is often additionally the limiting consider bandwidth when
fetching from CPU reminiscence.
Attributable to PCI velocity limitations, there are some actually unavoidable efficiency constraints when overcommitting VRAM.
Assuming the GPU is attached through a PCIe 4.0×16 connection, you get rather less than 32GiB/s of bandwidth. Every
millisecond, that PCIe bus can switch ~32.2MiB of information. For a minimal framerate of 30 frames per second (33.3ms
per body), absolutely the most quantity of information the GPU is ready to entry is ~1,075.5MiB, a tiny bit over 1GiB of
information. In different phrases, if a lot reminiscence will get evicted that the GPU must fetch greater than 1GiB from evicted reminiscence
in a single single body, it’s merely not possible to nonetheless hit 30 FPS.
Not all reminiscence is equal
On the identical time, simply studying a little bit little bit of CPU reminiscence on the GPU shouldn’t be instantly a dying sentence for efficiency.
In actual fact, GPU drivers typically determine to let issues like command buffer information and associated allocations stay in CPU
RAM even when there’s loads of VRAM obtainable! Each time the GPU executes these instructions, it has to entry CPU reminiscence, and but
in these instances all the things runs fully wonderful. So what makes these accesses totally different – why are they wonderful and but
operating out of VRAM appears catastrophic?
One factor that influences the calculus considerably is caching. Because the entry latency in case of a cache hit is identical
no matter whether or not the cached reminiscence lives on CPU or GPU, the excessive preliminary price of fetching over the PCI bus will be
amortized by cache hits (to some extent). We will estimate latency variations between fetching CPU RAM and VRAM by writing microbenchmarks
that measure entry latency for various buffer sizes
(utilizing an adversarial entry sample to reduce cache hitrates so far as potential). The consequence you get might
look one thing like this (captured on RDNA3):
As anticipated, if the buffer matches into L2 (or any higher-level cache), entry latencies are precisely the identical for
reminiscence backed by CPU RAM and reminiscence backed by VRAM, as a result of the information will get fetched instantly from cache in both case.
At a measurement of 6MB (the L2 cache measurement on RDNA3), CPU reminiscence latencies go as much as about 2400 cycles per entry,
whereas system reminiscence latencies keep inside the identical tough ballpark.
Observe that VRAM accesses additionally undergo the Infinity Cache, however CPU reminiscence accesses don’t (they hit PCIe instantly on an L2 miss).
I believe it’s because the Infinity Cache sits instantly on prime of VRAM, so any entry that doesn’t hit VRAM additionally doesn’t attain
the Infinity Cache.
Clearly, reminiscence doesn’t begin off with being cached wherever, so the primary entry will nonetheless have significantly greater
latency. Additionally, shedding the Infinity Cache undoubtedly hurts as effectively: PCIe fetches appear to have someplace round 7.3x as a lot
latency than an Infinity Cache hit, and round 4.6x as a lot latency as a fetch from VRAM.
This elevated latency wants actually excessive cache hitrates to totally amortize the price of going over PCIe.
Which means there’s solely a small set of use instances the place utilizing CPU reminiscence has such minuscule slowdowns
that you simply’d actively determine to make use of it in favor of VRAM when you might have the selection. Whenever you’re evicting reminiscence from VRAM, there
will nearly unavoidably be not less than some extent of slower efficiency.
Nonetheless, although slowdown is unavoidable, there’s going to be reminiscence the place eviction issues extra and reminiscence
the place eviction has a lesser impact on total perf. Reminiscence that’s accessed in very cache-friendly methods shouldn’t be
affected by the slowdown of CPU RAM as a lot. If the entry patterns aren’t cache-friendly however the reminiscence isn’t accessed very
usually, issues may nonetheless be wonderful for the reason that GPU solely not often wants to truly fetch information from CPU RAM. There could be many
reminiscence allocations the place the GPU will solely entry a small a part of the full allocation measurement, and by no means even learn the remaining.
If these allocations have been to be evicted, you may evict a number of GiBs of information, however nonetheless stay effectively beneath the 1GiB arduous restrict of information
that’s truly accessed per body.
All of those variables make it surprisingly arduous to foretell how efficiency truly pans out in apply when reminiscence is being
evicted. However in brief: Relying on how a lot the evicted reminiscence will get accessed and the way effectively these accesses cache, you may simply have the ability to run out
of VRAM with out (fully) ruining efficiency!
We’ve theorycrafted ourselves all the best way in the direction of having performant VRAM overcommitment now. Nice! Let’s simply boot up SteamOS, begin some sport and crank
up the setti-radv/amdgpu: Not sufficient reminiscence for command submission.
oh.
Because it seems, operating out of VRAM in apply does carry loads of stability points with it.
This error isn’t fairly like an everyday “couldn’t allocate, out of reminiscence” error, although. Observe that the message particularly complains about
command submission: RADV prints this message when the kernel returns -ENOMEM when attempting to submit instructions, however merely submitting
instructions doesn’t allocate any new assets! All of the command buffers have been allotted prematurely, and clearly their allocation succeeded.
Though all reminiscence was efficiently allotted, utilizing it in a GPU submission abruptly ends in “out of reminiscence” errors being thrown.
It’s time for one more kernel journey! Certainly getting the kernel to just accept the submission can’t be that arduous – in spite of everything, the kernel already
accepted all of the allocations!
The horrors of kernel locking
One factor the amdgpu driver has to do on each submission, earlier than it will possibly direct the GPU to start out executing instructions, is to be sure that
all reminiscence which will doubtlessly be referenced by the GPU instructions is accessible. With extra fashionable bindless graphics APIs, it’s important to assume
all allotted reminiscence might in some unspecified time in the future get referenced. Subsequently, amdgpu will attempt to ensure all allotted reminiscence can be accessible.
Every reminiscence allocation carries details about which kind of reminiscence (for our functions right here, system RAM or GPU VRAM) it may be correctly accessed
from. Most allocations will be accessed from both CPU RAM or VRAM, and amdgpu will probably be proud of the reminiscence allocation being in both of those
reminiscence sorts. Some allocations, nevertheless, should be positioned in VRAM and VRAM solely. If these reminiscence allocations have been evicted to system RAM as a result of
another utility allotted VRAM within the meantime, amdgpu must transfer them again into VRAM. As a result of there isn’t a free VRAM obtainable in any respect,
transferring the allocation again requires evicting one thing else. For some motive, that failed and the kernel
reported an out-of-memory situation.
So as to clarify why evicting one thing randomly fails, we’ll should take a small detour to take a look at how the kernel handles (CPU-side) locking for GPU allocations.
So as to evict a reminiscence allocation, it’s important to purchase a lock related to that allocation. Nonetheless, throughout a submission, you additionally should lock
each allocation that’s referenced in a submission, to stop another utility from transferring the allocation some other place when you’re busy getting ready
GPU work. But when one other GPU submission is doing the identical factor concurrently, you may find yourself in a scenario like this:
If one submit desires to evict an allocation that one other submit has already locked, however that different submit additionally must lock an allocation from the primary one
to make progress, we now have a textbook ABBA impasse situation.
However concern not, the kernel is aware of find out how to detect and resolve deadlocks! The main points about how impasse detection works are
defined on this kernel documentation web page, however in very broad strokes, the
kernel associates locking operations with a “transaction” (which mainly simply retains observe of which locks have been acquired). If two transactions would
impasse, one of many transactions is marked as “wounded”, and the subsequent time it tries to amass a lock, the -EDEADLCK error is returned.
This error requests the transaction to be aborted: All locks acquired throughout the transaction needs to be launched, and the transaction is restarted
from scratch. Within the context of command submission, this simply means the driving force will restart the method of going over all reminiscence allocations and making
positive they’re accessible.
So the place’s the catch? There isn’t one. This method is rock stable and works rather well.
At the least so long as it’s truly carried out in all places.
Within the graphics subsystem, the gritty internals of the wound-abort-retry loop are abstracted utilizing a small helper library referred to as drm_exec. As an alternative of
having to manually observe which allocations are locked, and launch the locks when you run into -EDEADLCK, you merely use the drm_exec_lock_obj helper.
In the event you research the locking code in TTM,
the shared Linux GPU reminiscence administration layer, you’ll discover a profound lack of utilization of drm_exec.
As an alternative, there even is a remark noting that -EDEADLCK will trigger eviction to fail. There we go, we discovered our situation! As quickly as this impasse
situation is encountered due to intense reminiscence strain throughout command submission, the kernel bails out and rejects the submission as a substitute of
retrying.
There already are some patchsets to hook up the drm_exec helper in TTM,
despatched all the best way again in 2024, however these by no means made it in for just a few causes,
amongst which have been some remaining bugs that hadn’t been discovered. My work had been reduce out for me right here: Rebase the patchset on prime of
my kernel model and work out what these remaining bugs are.
Rebasing the patchset wasn’t an excessive amount of of a trouble, and determining the bugs solely took one single week of intense struggling with video games randomly hanging 3 minutes
into heavy VRAM rivalry. Not the worst!
I attempted resending the patchset with fixes for all bugs I discovered within the
hopes it will get on this time, however there’s going to be extra work needing to be finished with it earlier than it may be merged.
Now that operating out of VRAM not less than received’t crash your apps at random, we are able to not less than correctly crank up the settings and have a look at perf. The preliminary
consequence gave me a fully wonderful efficiency graph like this:
Maintain On The place Did All The Perf Go
Determining why efficiency is so rubbish requires determining what the system is definitely doing that’s this gradual. For broad “what’s the kernel driver doing??”
questions like that, I like utilizing gpuvis. gpuvis makes use of kernel tracepoints to construct a timeline of issues that occurred
(together with “GPU work submission began/stopped”, from which the time taken for every submission will be inferred).
Booting up gpuvis with a hint taken whereas the system is operating out of VRAM, the timeline reveals a scenario like this:
Seems, most of that point isn’t truly spent on dealing with the submission (that’s the gfx_0.0.0 exercise), however as a substitute transferring round reminiscence in preparation
for that submission (sdma0 exercise)!
The explanation why there are such a lot of buffer strikes on a regular basis turns into extra apparent should you use gpuvis’s occasion record, along with a filter to indicate solely captured
transfer occasions for a selected buffer object (I selected one at random right here, most buffer objects have an identical sample):
The record reveals fairly clearly that contending processes (on this case, gamescope and the sport itself) will continually take turns evicting and transferring
again the identical piece of reminiscence, time and again. That’s actually unhealthy! And it’s very harking back to one thing I wrote in my first blogpost:
Typically, two competing purposes will be anticipated to roughly take turns executing GPU work – first one utility submits work, then the opposite, then the primary once more, and so forth.
With that method, reminiscence would preserve being moved backwards and forwards after each single submission. One utility will get kicked out and instantly moved again in, kicking the opposite out (which strikes reminiscence again within the subsequent step). All this transferring ended up with
worse efficiency than if the reminiscence had by no means been moved within the first place.
This described an previous situation the place overly aggressive VRAM allocation would result in ping-pong-like strikes occurring continually. However that situation had since been
mounted by merely not attempting to say VRAM when there isn’t any free VRAM left, and the kernel solely began being considerably aggressive after I carried out
VRAM safety with dmem cgroups. Clearly, this will need to have reintroduced the ping-ponging someway.
Conceptually, the design of the dmem cgroup VRAM safety ought to by no means end in ping-pong strikes, as a result of the kernel is just presupposed to evict reminiscence that
doesn’t have any cgroup VRAM safety related to it. With none VRAM safety, it is best to sometimes not be allowed to evict protected VRAM.
The one exception to this rule is reminiscence that completely has to stay in VRAM for issues to work correctly. These sorts of reminiscence allocations are all the time
allowed to be moved to VRAM to make sure system stability. Sometimes, nearly nothing coming from an utility is absolutely required to stay in VRAM for proper operation,
however there’s one buffer object coming from an utility that does: The buffer containing picture information to be scanned out to the show.
Show {hardware} is funky
Not solely does the show {hardware} like scanned-out photographs to be in VRAM, it additionally fully skips previous the GPU’s digital reminiscence structure and
works with bodily addresses solely. In consequence, scanned-out photographs additionally should be contiguous in bodily reminiscence.
With digital reminiscence and the facility of web page tables, typical utility buffers are solely contiguous in digital reminiscence, and could also be scattered round
throughout bodily reminiscence. The primary web page of a buffer at digital tackle 0x5000 could also be mapped within the web page tables to level to bodily tackle
0x1234000, however the second web page at digital tackle 0x6000 may level to bodily tackle 0x4321000, someplace fully totally different!
Here’s a diagram visualizing the mapping of digital allocations to bodily ones in case the place there’s a variety of fragmentation (which usually
is the case whenever you’re very low on VRAM):
The arrows present web page desk mappings to bodily reminiscence segments for the totally different segments of the primary allocation.
They’re not noted for all different allocations for readability.
In the event you’re allocating show scanout information, this fragmentation shouldn’t be an possibility because the bodily reminiscence needs to be contiguous. This has very, very
unlucky interactions with eviction of different information particularly. Let’s assume the scanout information has already been evicted, however now it’s
time for that information to be scanned out, so it needs to be moved again into VRAM.
Merely evicting one buffer received’t be adequate, even when that buffer is identical measurement because the show scanout information, as a result of evicting it doesn’t
end in sufficient contiguous bodily house to position the scanout information in! To make issues worse, the eviction algorithm doesn’t take into
account bodily reminiscence constraints in any respect. It’s a very simplistic loop alongside the traces of
evict(getLeastRecentlyUsedBuffer())
if (tryAllocate(newBuffer) == SUCCESS)
break;
}
Utilizing this algorithm (assuming the allocations are organized in LRU order), even should you evict the primary 3 allocations (inexperienced, blue, and pink), there received’t be a big
sufficient house to carry the scanout buffer! Even the most important potential free house is ever so barely too small, as is seen on this up to date diagram:
To seek out a big sufficient bodily contiguous reminiscence area in our instance, each single allocation in VRAM would find yourself being evicted! In
real-world situations, I noticed as much as 4GiB of VRAM being nuked simply to create space for scanout photographs (that are ~32MiB of pixel information per picture for a R11G11B10
pixel format). That’s going to harm actual arduous! Merely the act of transferring all that information out from VRAM would already price not less than ~130ms, in keeping with
the PCIe switch fee estimated earlier.
Throwing heuristics on the drawback
Whereas scanout is unquestionably probably the most egregious failure case right here, this situation is extra basic: There are all the time going to make certain reminiscence allocations
that will probably be moved to VRAM time and again, doubtlessly kicking out some reminiscence that an utility may desire to remain in VRAM. Resisting this and
attempting to maneuver the evicted reminiscence again in will almost definitely backfire.
Though dmem cgroup safety shouldn’t be a whole answer to this drawback, it does scale back the issue scope by loads. With cgroup safety, you
can make certain that any random app received’t attempt to kick out essential sport assets willy-nilly. Any reminiscence that does get moved again into VRAM by power
in all probability has motive to be in VRAM. Subsequently, even with dmem cgroup safety, we needs to be cautious and never attempt to reclaim evicted reminiscence again
by power.
With some iterative testing, I feel I’ve arrived at a set of heuristics that work moderately effectively for many instances a sport would encounter within the wild
(not being too aggressive when stuff will get evicted by essential system allocations is one factor, nevertheless it additionally must be moderately fast at reclaiming
evicted reminiscence if e.g. the sport is paused and the Steam menu runs as a substitute, evicting a number of sport reminiscence, after which the sport is resumed).
The heuristics work one thing like this:
When the kernel detects an utility’s reminiscence is being evicted, it enters a “arduous throttle” part for just a few milliseconds. Throughout this part, it does
not attempt transferring any reminiscence for that app again into VRAM by any means (so long as all reminiscence will be correctly accessed, after all).
After this era, it switches a “mushy throttle” part, throughout which it could reclaim free house by transferring issues again into VRAM, however doesn’t
attempt evicting any reminiscence that different apps have allotted. This era might final up to a couple seconds, to make further positive all the things reached a steady state.
If the “mushy throttle” part has accomplished with none additional reminiscence being evicted once more, the system is assumed to have reached a reasonably steady state
and restrictions on evicting different purposes’ reminiscence are eliminated.
IME, this achieves an appropriate stability between not capturing oneself within the foot with overaggressive eviction of different apps, whereas nonetheless recovering
moderately quick when a number of your reminiscence was abruptly evicted, for instance as a result of the sport was paused and the consumer browsed round on Steam as a substitute of
taking part in.
Getting someplace
With these heuristics in place, let’s lastly attempt cranking up the settings for actual this time.
I ended up going with Indiana Jones: The Nice Circle, because it conveniently exposes a setting for streaming pool sizes that you simply
can mess with to switch VRAM consumption just about instantly.
Lo and behold, even when the settings are turned as much as a considerably ridiculous level, the place the sport requests 9GiB of 8GiB VRAM (aka. a complete 1GiB of
overcommitted sport assets dwelling in CPU reminiscence), efficiency isn’t cratering into oblivion anymore! A 19.6ms per body common is what I’d nonetheless
name completely playable.
I may bump the settings to much more ridiculous ranges and double the quantity of overcommitted reminiscence, with the sport requesting 10GiB of VRAM
on this 8GiB system (and thus 2GiB of assets being overcommitted). Frametime variance goes up rather a lot at this level, with spikes
reaching above 33.3ms occurring regularly. The general common is round 29.8ms which isn’t the worst, however particularly paired with the variance,
this could begin being noticeable in gameplay.
Whereas that is already an enormous step ahead, we aren’t fairly there but. The expertise underneath VRAM overcommit can typically nonetheless be a bit hit-or-miss,
and frametimes might noticeably differ relying on which objects within the sport you’re .
Keep in mind that for truly good eviction efficiency, it issues loads how the evicted reminiscence is utilized by the GPU.
Proper now, this isn’t taken under consideration in any respect! If we have been capable of base our eviction selections extra on how effectively the appliance’s accesses work
with CPU reminiscence, a variety of this variance may merely disappear.
The sophisticated factor concerning the utility’s reminiscence entry patterns is that they’re solely actually identified to the appliance.
Subsequently, the driving force isn’t actually capable of take them under consideration as-is. Ideally there could be some API the place the appliance
can provide hints to the driving force about how effectively a selected reminiscence allocation is suited to being evicted.
One thing precisely like vkSetDeviceMemoryPriorityEXT!
The VK_EXT_pageable_device_local_memory extension offers exactly what we want right here, by permitting purposes to speak any precedence
they need for any piece of system reminiscence they need. So long as purposes present affordable hints by way of this extension, implementing
prioritization within the kernel after which using app-provided priorities has the potential to stabilize issues by loads!
Hooking up priorities within the kernel seems to be loads much less of a difficulty than you may count on. The kernel already maintains a Least-Not too long ago-Used
record of reminiscence allocations that, on eviction, are traversed so as. For every entry on that LRU record, eviction is tried till there’s sufficient
free house for regardless of the eviction was for.
This LRU record offers heuristic for which utility’s reminiscence needs to be evicted first. Functions that haven’t submitted something in an extended
whereas are unlikely to want the reminiscence quickly, and since their reminiscence is Not Not too long ago Used, it is going to seem early within the LRU record and be evicted first.
When an utility makes use of a set of buffers, that set of buffers is moved to the very finish of the LRU record in a single bulk. Nonetheless, the order of allocations
inside that bulk shouldn’t be explicitly managed in any respect. Which means as soon as the kernel closes in on some utility to evict its reminiscence, which particular
items of reminiscence get evicted is kind of undefined. A simplified visualization may look one thing like this:
If the kernel walks the LRU record like this, it will evict the buffer with a precedence worth of two first, although there are a lot lower-priority buffers
elsewhere within the LRU record. If solely the primary buffer of precedence 2 will get evicted, issues could be okay, but when the extremely essential buffer with precedence 4
finally ends up evicted as effectively, there are probably going to be issues.
Provided that we already know particular priorities for the person allocations, this LRU record is a quite simple place to combine them. It’s so simple as ordering
the record entries inside a single utility by their precedence:
Now, when the kernel goes over the LRU record to search out one thing to evict, the very very first thing it is going to discover and attempt to evict are the lowest-priority buffers.
The very best-priority buffers are final within the record, and thus solely get evicted when evicting all of the lower-priority buffers was not sufficient.
Reminiscence precedence adoption in apps
Sadly, not all purposes truly set priorities through VK_EXT_pageable_device_local_memory. As for native Vulkan purposes,
I haven’t noticed any idTech sport utilizing the extension instantly, not less than :/
The D3D facet appears loads higher, as a result of vkd3d-proton already makes use of VK_EXT_pageable_device_local_memory when obtainable, and interprets each the
ID3D12Device::MakeResident/ID3D12Device::Evict API calls in addition to priorities set through ID3D12Device1::SetResidencyPriority to precedence values
set utilizing the Vulkan vkSetDeviceMemoryPriority command. A number of D3D12 video games make the most of not less than certainly one of these APIs, so the hints these video games present will now be
utilized.
I don’t have tremendous stable numbers for a way a lot reminiscence precisely is overcommitted by most D3D12 apps, as they don’t sometimes expose the full quantity of
VRAM they request in an easy-to-access manner like idTech’s efficiency overlay does. Nonetheless, correctly honoring reminiscence priorities usually appears to have
likelihood to enhance the expertise. Efficiency usually seems extra steady over time (since you’re not counting on luck with which buffers the
kernel evicts as a lot). In some spots I had comparability level at, I believe it elevated efficiency in comparison with the kernel evicting random
issues by as much as 30% in the perfect case – however once more, take this quantity with a mountain of salt because it relies upon nearly fully on luck close to eviction.
When all is claimed and finished, how effectively does operating out of VRAM maintain up?
I’d say it’s fairly alright! In lots of instances, it’s possible you’ll be shocked how a lot efficiency you may retain even when evicting a gigabyte or extra of reminiscence!
Then once more, that’s after all a fairly optimistic case, and the mistaken factor ending up in CPU RAM can in a short time trigger very vital slowdowns. Eviction is
tough to get excellent, and to an extent, efficiency will all the time be dragged down. If a sport is struggling to hit 30fps even with all the things
in VRAM, needing to evict one thing on prime of all that would typically simply unavoidably end in that 30fps goal being missed.
Regardless, what I hope this blogpost can exhibit is that even when you find yourself with some reminiscence evicted to system RAM, the slowdown will be manageable. There’s
measures that drivers (notably, the kernel driver) can take to make overcommit work as quick as potential, and even purposes can do their
half in coordinating with the driving force stack to mitigate the results of their reminiscence being evicted. With all the things in place, VRAM overcommit isn’t
actually as large of a deal as one might imagine it’s at first sight.
All of the work I described right here has already been launched in SteamOS for a while now (it’s each in Secure and Preview. So long as your system is up-to-date, it’s good to go!).
A be aware on upstreaming
In fact, I’m already engaged on upstreaming all this work so it’s obtainable to everybody! Nonetheless, there’s a variety of transferring elements and a variety of deep
refactors of some fairly core ideas at play right here, so it is going to probably want time to prepare dinner at the beginning is merged upstream.
On the identical time, I don’t wish to put up a blogpost speaking about a number of cool code simply to complete it with “truly you may’t see for your self,
go wait till it’s all upstream lol”, both.
As a center floor, I’ve rebased the kernel work onto a current upstream model of the kernel and revealed a git department
right here.
Whereas it ought to theoretically yield related results, it didn’t undergo as rigorous testing the SteamOS kernel did. There’ll probably
be bugs and instabilities that weren’t there within the SteamOS model. Use at your personal threat, mainly.
I don’t count on to be sustaining this department in any vital capability, as I’d fairly deal with getting the patches into upstream correctly.
So as to go by way of utility precedence hints to the kernel, additionally, you will want a customized Mesa department I pushed
right here.
Related concerns because the kernel department apply right here, as effectively.
Questions of my very own
Whereas I’d declare to have a reasonably good overview of the driving force facet of reminiscence administration at this level, I’m not very conversant in how
purposes determine on supplying reminiscence administration heuristics internally, in any respect. I’d suspect optimizing instances the place you’ve already run out of
VRAM isn’t precisely the highest merchandise on developer TODOs (who is aware of, perhaps the reminiscence shortage is altering that? :P), so perhaps there’s some
unexplored room for efficiency enhancements there?
In the event you, pricey reader, occur to find out about VRAM administration for bigger video games/engines (particularly when operating out), I’d love to talk! I’ve a hunch that
there’s nonetheless perf to be gained by making apps and drivers coordinate higher, however I’m additionally plainly enthusiastic about how issues look from an utility
developer’s viewpoint.
