RollingCache.ccc performance debugging and tuning … How?

2025.01.03 - Ideas for a happy new Rolling Cache ecosystem

Beware, this post is of the very long-ish kind.

To continue the new year with more constructive remarks related to the Rolling Cache I would like to lay out a number of constructive ideas for how to improve the caching system of FS2024.

The fundamental tradeoff in computing is

  • Waste memory or waste computation cycles?

In a trivial case like “multiplication” one could decide between those two strategies:

  • Compute every possible multiplication once … and remember (cache) all results in some memory.
  • Compute the individual result on demand … and then forget it.

While it may look silly in the context of “multiplication” the decision becomes harder once we get to problems like

  • prime numbers
  • a query result that has to scan 5 petabytes of data
  • the medium LOD textures and 3D mesh of this or that aircraft

In real computing it always is a mix of both strategies.

Caching is like Garbage Collection

As memory is always (too?) limited, even in computers, we can not store (remember) everything that we would like to store. Ignoring the legal aspects, I clearly would love to have a full copy of the FS2024 globe for “offline flying”. But 5 petabytes is too much for a goose.

So the next level of constraints and questions that a system like FS2024 needs to answer is:

  • A) How much cache memory do I need at least to have a useful system?
  • B) Above what size will caching start to cause problems … to someone or something?

(A) is very hard to answer, as we all know, because “useful” means different things to different people at different times.
(B) seems to have been answered by the FS2024 team with … 16 GB … mainly due to Xbox limitations.

So we basically are looking at 5,000,000 GB of orgin data from which we need to extract the 16 GB of relevant data. So the minimum FS2024 cache size is just at 0,00032 % of the origin. Hmmm.

  • C) How do I know which data is relevant?
  • D) How do I decide which relevant data is now “garbage” … once my cache is full?

Housekeeping matters

In real world computing automatically the next question(s) will pop up:

  • E) How much effort (memory and computation) does it take to maintain the cache?
    • Insert new data
    • Decide what old data is garbage
    • Remove old data
  • F) At what point will my caching system (algorithm) become “the problem”.
    • A cache should make a system faster … not slower.

Now we are entering the …

The Art of Caching

The ideas of caching are as old as the ideas of computing. Caching is both: science and art.

A lot of research has been made and published. Here are just three resources that can provide some background or can serve as examples for those readers who want to dive deeper:

I am not “recommending” any of the above algorithms. I mainly want to show that caching research is going on for decades and that there are many different strategies out there.

Least Recently Used (LRU)

In previous posts I tried to explain why I think that today the RollingCache.ccc file is governed by a simple Least Recently Used (LRU) cache replacement policy.

LRU dates back to at least 1993. Its key assumtions are:

  • All units of data are equal … therefore
  • the only (meta) information that can inform the caching algorithm is
    • the time of the most recent usage of each unit of data.

So it is based on a single piece of meta information.

LRU and other caching algorithms have usually been developed to make computer chips (CPUs) faster, by avoiding copying data the “long distance” from the main memory (RAM).

But even todays CPUs have:

  • Data category specific … instruction and data caches
  • Layered (generational) … L1 and L2 caches
  • Predictive caching … due to predictive code execution
  • … and Wikipedia will provide a lot more details

Does FS2024 really know less about the nature of its data then the underlying CPU?

Why FS2024 can have a happy new Rolling Cache ecosystem

So what meta information can FS2024 use to decide what to keep (cache) and what to throw away? I would propose the following “quick” high level list:

  • G) The time of the most recent usage … obvious. The only meta info used today.
  • H) Usage history
  • I) The data category
  • J) Pilot preferences
  • K) Game mode
  • L) Current flight plan

However, to be fair, today there already are “alternative” caching strategies …

  • M) The asset is part of the predefined FS2024 software installation “minimum” permanent asset collection
    • … and so it will be “streamed” during or after the first launch
      • … and cached outside of the RC in the normal filesystem.
  • N) A sound file for a streamed aircraft
    • … will, on demand, be cached outside of the RC in the normal filesystem.

But let us get back to the meta info categories (H) to (L).

(H) Usage history

FS2024 already remembers the time of usage. But how often was this “unit of data” read from the cache?

  • The more often the sim or the pilot needs this data
    • … the more important it seems to be
    • … and the higher the probability should be of future use.

With such a simple addition the deletion of the “blue text” index sections that are needed on every sim launch could be protected from destructive deletion.

(I) The data category

Not all data is “equal” in FS2024. A very quick list might look like this:

  • Scenery Index
  • Aircraft
    • Thumbnails and “Metadata”
    • My (frequently or recently used) aircraft
      • The LOD needed for aircraft and livery selection
      • The LOD needed for being “Ready to fly”
      • The LOD for sitting inside the cockpit
    • All owned aircraft
    • Static aircraft
  • Airports
    • My (frequently or recently visited) airports
    • All owned airports
    • “Metadata” like parking locations, runway info etc.
  • Vehicles and “ground stuff”
    • Airport ground vehicles
    • Regular city trucks, busses and cars
    • whatever
  • People
    • My Avatar
    • My Career Instructor
    • Airport people
    • other people … for career mode
  • Career Mode
    • My Office
    • People
      • My Instructor
      • Passengers
  • Challenges
    • The aircraft
    • The landscape
  • Marketplace
    • Metainfo
    • Thumbnails
    • Showcase pictures
  • Globe (landscape)
    • textures
      • LOD … required for the high level globe view
      • LOD … common for free flight airport selection
      • LOD … for low above ground flights
    • Elevation or TIN data
      • LODs … as for the textures?
  • Live data
    • Weather
    • airtraffic
    • Peer player aircraft

Each of the above categories will differ in their characteristics:

  • small … vs. … large data units
  • few … vs. … many data units
  • immutable … vs. … frequently updated
  • high reuse … vs. … no reuse likely
  • everybody needs it … vs. … individual needs
  • on every flight … vs. … on one or few flights

So why not have a RollingCache folder which contains a dedicated cache file for each of the above categories? (I know, I know … but that will be a topic of the next post).

(J) Pilot preferences

If I “like” (buy?) and aircraft or airport it indicated higher probability of reuse. So it should not be considered “cache garbage” if there is still less liked content filling up the cache … like TIN landscape from about an hour ago, of places that I might never ever return to.

(K) Game mode

Data that I need for some kind of profession in career mode has a higher probability of reuse.

Data that I need for the latest challenges has a higher probability of reuse. I might want to retry it tomorrow, to get a better score. So why is all this long gone landscape from my current long-haul flight deleting the landscape and aircraft of my favorite challenges?

(L) Current flight plan

The FS2024 team has invested so much effort into the new flight planning website and its game integration.

Some pilots … ok, not a sightseeing goose like me … invest a lot of time in planning their flights. Why ruin such passion with broken landscape or missing airports or stutters on final approach?

Why does an active flight plan not trigger constant precaching of the destination airport, or the necessary landscape for the next X minutes of flight, or the distance X ahead?

Since this post is so text heavy, allow me to underline my case with two pictures from my yesterdays “long-haul” flight, where I escorted flight VN32 from EDDM to VVTS.

Approaching Mount Ararat was a true pleasure …

… and looking at Pakistan (a country with very interesting landscape, especially in the north) was … well … not a pleasure.

There are so many possible (and easy) ways to make the caching strategy of FS2024 more efficient. As a result the stress on the servers and the stress on the (frustrated?) pilots will decrease. This should also reduce the stress on the FS2024 team.

Good caching is good … for everybody.

In my next post I will try to outline some even more concrete implementation ideas … a “Cache Hotfix” and maybe also a “Brave New Cache” idea.

To summarize my ideas and claims from above:

  • Todays Least Recently Used (LRU) strategy does not fit the nature of FS2024.
    • LRU was designed for random data with no meta info.
  • FS2024 has and can collect a lot of meta information about the data:
    • Usage history
    • The data category
    • Pilot preferences
    • Game mode
    • Current flight plan
    • etc.
  • Manual caching (a.k.a. “installing a package”) is a possible hot fix
  • … but FS2024 should and could also provide way better on demand caching options … e.g.
    • Data category specific caching
    • Layered (generational) caching
    • Predictive caching
8 Likes

It’s interesting. The Logbook can, potentially, paint a picture of user use behavior/patterns.

Thinking on my own Logbook from 2020 (with its years of accumulated flights), it’s pretty clear where and what I fliy with regularity.

It’s also really clear where/what I might fly if a prediction were to be established based on my flight history.

Interesting thought processes.

1 Like

Yes, the Logbook seems like a very good source for predictions.

However, sadly in FS2024 they still use this “unique” (misguided?) logic for (not) detecting takeoff and landing events, which already made the Logbook close to useless (for pilots like me) in FS2020.

2 Likes

Absolutely. I do not wish to derail your excellent thread, but it is beyond me that 2024 didn’t revise the usefulness and accuracy of the logbook.

Regardless, there are patterns there that AI could parse.

3 Likes

Lots of good detail.

As you say the RC is just another file.

All I need is to semi-permanently download 2 planes and 6 airports to get 99% hit ratio in my flights. (perhaps into a unique folder/file in a more sophisticated cache architecture)
.
In other words, almost zero streaming into my rolling cache, which is now 200GB.

Simple!

Btw If you look back in the dev vids Seb did say we would get a force-download option. He did not say when. After the difficult 2024 marketplace/library rebuild is my estimate.

1 Like

2025.01.05 - v1.2.8.0 - A more detailed Rolling Cache data access analysis

Before I will try to outline ideas for some “better” caching strategies I should have a “better” understanding of the existing system. So I tried to investigate the following questions:

  • What is the “actual” structure of the RollingCache.ccc file?
  • How does the sim use the RC,
    • … and what are todays real world “read” and “write” access patterns?

A cache is a cache is a filesystem is … just like many other data structures. So an educated guess allows to intepret the structure and the file access patterns by taking a quick look at the filesystem events.

My analysis is based on the following steps:

  • Focus on Test 1
    • … because it has the smallest RC data set
    • … and is far from being 100% full.
    • This makes reading the event logs easier.
  • Use Process Monitor to focus on the RC related file events
    • … and luckily it allows to export them to a human readable CSV format.
    • I then removed and modified some content to make the lines shorter, for easier reading.
  • Read the “text” and try to find some obvious patterns.

The event log starts like this:

"Time of Day","Process Name","PID","Operation","Path","Result","Detail"

"12:11:58.4121343",,,"IRP_MJ_CREATE","RC","NAME NOT FOUND","Desired Access: Generic Read, Disposition: Open, Options: Synchronous IO Non-Alert, Non-Directory File, Attributes: N, ShareMode: Read, AllocationSize: n/a"

"12:11:58.4125169",,,"IRP_MJ_CREATE",,,"Desired Access: Generic Read/Write, Disposition: OpenIf, Options: Synchronous IO Non-Alert, Non-Directory File, Attributes: N, ShareMode: None, AllocationSize: 0, OpenResult: Created"
"12:11:58.4127136",,,"FASTIO_QUERY_INFORMATION",,,"Type: QueryStandardInformationFile, AllocationSize: 0, EndOfFile: 0, NumberOfLinks: 1, DeletePending: False, Directory: False"
"12:11:58.4127221",,,"FASTIO_QUERY_INFORMATION",,,"Type: QueryStandardInformationFile, AllocationSize: 0, EndOfFile: 0, NumberOfLinks: 1, DeletePending: False, Directory: False"

"12:11:58.4148297",,,"IRP_MJ_WRITE",,,"O: 4,194,303, L: 1, Priority: Normal"
"12:11:58.4151712",,,"IRP_MJ_WRITE",,,"O: 2,097,152, L: 1,048,576, I/O Flags: Non-cached, Paging I/O, Synchronous Paging I/O, Priority: Normal"
"12:11:58.4174319",,,"IRP_MJ_WRITE",,,"O: 3,145,728, L: 1,048,576, I/O Flags: Non-cached, Paging I/O, Synchronous Paging I/O, Priority: Normal"
"12:11:58.4196896",,,"IRP_MJ_READ",,,"O: 4,161,536, L: 32,767, I/O Flags: Non-cached, Paging I/O, Synchronous Paging I/O, Priority: Normal"
"12:11:58.4200925",,,"FASTIO_WRITE","RC","FAST IO DISALLOWED","O: 8,388,607, L: 1"
"12:11:58.4201059",,,"IRP_MJ_WRITE",,,"O: 8,388,607, L: 1, Priority: Normal"
"12:11:58.4204259",,,"IRP_MJ_WRITE",,,"O: 6,291,456, L: 1,048,576, I/O Flags: Non-cached, Paging I/O, Synchronous Paging I/O, Priority: Normal"
..
"12:12:33.7768419",,,"IRP_MJ_WRITE",,,"O: 17,178,820,608, L: 1,048,576, I/O Flags: Non-cached, Paging I/O, Synchronous Paging I/O, Priority: Normal"
"12:12:33.7790722",,,"IRP_MJ_READ",,,"O: 17,179,865,088, L: 4,095, I/O Flags: Non-cached, Paging I/O, Synchronous Paging I/O, Priority: Normal"
"12:12:33.7842176",,,"FASTIO_WRITE",,,"O: 17,179,869,156, L: 28"
  • One can see that opening the missing RC fails … “NAME NOT FOUND”
  • The next “IRP_MJ_CREATE” will produce a clean new file … with the access options:
    • Generic Read/Write
    • Synchronous IO Non-Alert
    • etc.
  • Then the “zero fill” beginns with “Non-cached” writes of 1 MB each
    • … “L(ength): 1,048,576”
    • … and it continues until all 16 GB have been permanently allocated on the drive.

Good. But that is not really surprising. However some “zero fill” ranges have been “skipped” … a.k.a. went missing. And that is not what I assumed in the past. Ergo:

Beware … as I discovered during this analysis, Process Monitor does not “record” all events. Some seem to get “lost”. So actual numbers are always higher than reported (recorded) because some events are missing in the “recording”.

Now lets turn to the more important aspects of the RC. The real data access after the RC creation.

"Time of Day","Process Name","PID","Operation","Path","Result","Detail"

"12:12:33.7842176",,,"FASTIO_WRITE",,,"O: 17,179,869,156, Length: 28"
"12:12:33.7853861",,,"FASTIO_WRITE",,,"O: 48, L: 28"
"12:12:33.7854149",,,"FASTIO_WRITE",,,"O: 76, L: 4"
"12:12:33.7854231",,,"FASTIO_WRITE",,,"O: 80, L: 292"
"12:12:33.7854306",,,"FASTIO_WRITE",,,"O: 0, L: 48"
"12:12:33.7868739",,,"FASTIO_WRITE",,,"O: 48, L: 28"
"12:12:33.7868864",,,"FASTIO_WRITE",,,"O: 76, L: 4"
"12:12:33.7868938",,,"FASTIO_WRITE",,,"O: 80, L: 292"
"12:12:33.7869037",,,"FASTIO_WRITE",,,"O: 0, L: 48"
"12:12:44.6066764",,,"FASTIO_WRITE",,,"O: 536,877,473, L: 28"
"12:12:44.6067005",,,"FASTIO_WRITE",,,"O: 536,877,501, L: 1,308"
"12:12:44.6067079",,,"FASTIO_WRITE",,,"O: 536,878,809, L: 1,102"
"12:12:44.6067183",,,"FASTIO_WRITE",,,"O: 536,879,911, L: 28"
"12:12:44.6067253",,,"FASTIO_WRITE",,,"O: 536,879,939, L: 1,305"
"12:12:44.6067325",,,"FASTIO_WRITE",,,"O: 536,881,244, L: 3,003"
..
"12:15:42.0853050",,,"FASTIO_WRITE",,,"O: 671,426,698, L: 28"
"12:15:42.0853124",,,"FASTIO_WRITE",,,"O: 671,426,726, L: 1,312"
"12:15:42.0853198",,,"FASTIO_WRITE",,,"O: 671,428,038, L: 235,132"
..
"13:04:57.6448378",,,"FASTIO_WRITE",,,"O: 900,976,425, L: 28"
"13:04:57.6448706",,,"FASTIO_WRITE",,,"O: 900,976,453, L: 1,466"
"13:04:57.6448864",,,"FASTIO_WRITE",,,"O: 900,977,919, L: 4,194,304"
"13:04:57.6475707",,,"FASTIO_WRITE",,,"O: 905,172,223, L: 4,194,304"
..
"13:10:17.2693941",,,"FASTIO_WRITE",,,"O: 48, L: 28"
"13:10:17.2694331",,,"FASTIO_WRITE",,,"O: 76, L: 4"
"13:10:17.2694411",,,"FASTIO_WRITE",,,"O: 80, L: 889,420"
"13:10:17.2696212",,,"FASTIO_WRITE",,,"O: 0, L: 48"
..

There seem to be two major areas (which matches the content classification pictures from previous posts).

  • The index area
    • … that tiny purple line … is starting at “Offset: 80”
      • … but has some additional TOC (table of contents) data from “Offset: 0”.
    • For Test 1
      • … it seems to have a size of at least “Length: 889,420” bytes.
      • The event record “O: 80, Length: 889,420” is followed by many other write operations
        • … so it seems like the final index write is missing in the Process Monitor recordings.
      • With around 13,000 items in the cache (based on the “Length: 28” writes)
        • … each cache index item would require around 68 bytes
          • … which is an odd number for a 64 bit system … like 8.5 * 64 bit.
          • Performance wants native 64 bit alignment
            • … so lets say there are not 8.5 but … 9 * 64 bit = 72 (or 80?) bytes per index item.
    • There are periodic, (what seems to be) full dumps (writes) of the index area from a memory representation into the RC file.
      • This needs to be investigated in more detail, as it can become a (major) performance issue with big RC files.
  • The blob area
    • … seems to start after the index … at “O: 536,877,473”.
    • Each blob item seems to consist of three parts:
      • A kind of TOC
        • … with 28 bytes.
      • Some kind of HEADER
        • … with around 1 KB.
      • The blob (chunk) BODY
        • … with sizes from 32 bytes to 40 MB or more.
          • The write operations seem to take place in 4 MB chunks.

Looking at Test E or Test P … which have been real flights I would guess:

  • The average blob item is perhaps 50,000 to 100,000 bytes long.
    • Also remember that the “HTTP status 206” from the “mea culpa” event indicates chunked downloads
      • … so assets may require multiple blob items.
        • or at least some “housekeeping” inside the RC to remember which chunks already have arrived.

Regarding the access pattern the following is a very common … or “the common”? … story in the recorded events:

"12:15:42.0853050",,,"FASTIO_WRITE",,,"O: 671,426,698, L: 28"
"12:15:42.0853124",,,"FASTIO_WRITE",,,"O: 671,426,726, L: 1,312"
"12:15:42.0853198",,,"FASTIO_WRITE",,,"O: 671,428,038, L: 235,132"
..
"12:58:27.4431598",,,"FASTIO_READ",,,"O: 671,426,698, L: 236,472"
  • First the 3 blob item parts get written, one after the other,
    • … and a lot later all three parts are read back into memory in one operation.
  • This form of access can be seen all over the place
    • … and it does suggest a “Read after write” access pattern.
    • This makes sense because the RC seems to serve as a way to decouple chunked (rainy) server downloads from (blue skies) sim data usage.
    • However, there (hopefully) might also be a code path which does allow data usage prior to a “write-read cycle”
      • … as this adds significant latency.

The above is not real “science” but I would consider it statistically backed guessing. A rule of thumb approach.

From all the above I would derive this summary:

  • Process Monitor does not “record” all events. Some events seem to get “lost”.
  • With 72 (or 80?) bytes per index item
    • … and an index block size of 512 MB
    • … the index can hold up to around 7,456,000 references to blob items.
  • With an average blob item of perhaps 50,000 to 100,000 bytes (0,1 MB)
    • a RollingCache.ccc file larger than 745 GB may run out of index space.
    • So there is plenty of room to grow a single RC file.
      • However, the performance problems may then be more related to in RAM index lookup (search) codes
        • … or the periodic index “full? dump to disk” persistency strategy.
    • Somewhat confusing is, that for many blob items the HEADER is (far) larger than the BODY.
      • This feels like a waste of memory.
      • And why is there a need for a 1 KB HEADER in the first place?
        • 1 KB * 500,000 items = 0,5 GB of “waste?” storage.
      • And there are lots of “strange” blobs with 32 bytes to BODY.
      • Hmmm. Many interesting questions.
  • The access does suggest a “Read after write” access pattern.
    • This makes sense because the RC seems to serve as a way to decouple chunked (rainy) server downloads from (blue skies) sim data usage.

It seems like at some point I might try to dive a little deeper into the actual blob item content. But with the above it now becomes possible to investigate the: RC read:write ratio numbers.

To be continued …

9 Likes

I fully agree with you, @PilotJedi668 , on the “manual caching outside the RC” part (= forced download). This will solve many problems.

However …

… you still will see heavy activity in your RC, and on the streaming side, as the sim will still download:

  • landscape textures
  • elevation data
  • cars and trucks and people
  • etc.

And since some index information (the blue text area) will still be only in the cache, it will still be wiped out by landscape during long flights … even after all the “forced downloads” that I would like to make.

So for many data items there is no “manual cache” (= install) button or option.

Yes, the “Install” option what was announced (for Market Place Launch?) and will take away a lot of pressure. But IMHO the FS2024 team should still try to make caching better … like … a lot better. They (and we) will need it for many years to come.

3 Likes

I have been flight simming since the dawn of flight sims. And in that time, I have engaged in discussions of flight sims on a variety of platforms. BBS’s, Usenet, forums, Facebook, Reddit.

This one of the best threads I have ever encountered. Thank you for what you are doing.

11 Likes

This is a fascinating read and absolutely great research.

Thanks for taking the time to do it, document, and explain it all. I admit I’ve also wondered if cached data could be used by the sim before being written or if it was alway written and then read in. I keep a monitor open to see what is happening when the sim slows down on approach. Not always but a good portion of the time it is writing to the rolling cache file. I’d think if data could be used before / while being written it would be beneficially to performance, right?

This research makes the case the SSD/Disk write speed could be a major factor for overall performance too.

First … I agree with you.

However … I have the feeling that there are a number of factors which affect performance and stutters, that I am convinced I do not see or understand (yet) … and to truly be able to “name and blame” those factors, one would have to study the actual code (and I am not planning to dive that deep).

So as a general remark:

  • Multithreaded code … requires coordinated data access
    • … and I am so glad that FS2024 raised the amount of multithreading.
      • = less “non-FPS-critical” work on the main thread.

The coordination can be achieved basically in two ways:

(A) is what most code is build upon. And IMHO (A) is a major trap for really high performance software (like FS2024).

So if the access to the RC is guarded by technique (A) … then the “game engine” might actually be blocked for some period … stutter. Clearly, the shorter that period the better.

Your second point about the SSD speed would be correct and a key factor. It would fit the blocking API (A) assumption.

However, I am still not completely convinced … and I want to show that part in the future once I understand it better. But briefly:

  • The RC seems to get “mapped” into memory by the OS, even when it is not “officially” a real memory mapped file.
  • Some file access events force a synchronous IO = blocking call.
  • This can not be prevented … because the RC needs to stay “consistent”
    • … so some writes need to be “atomic” commits
      • … even if that takes some time … ergo … is blocking other access to the RC.

And again … briefly:

  • Having individual installed (small) files in the local filesystem would make things even worse.
    • This causes a lot more context switches etc. pp.

Now … here is one of many “alternative” stories:

  • There are too many threads inside the system
  • … and some might force the “main game thread” to get stopped for too long because the kernel is really busy doing “important” file IO and memory management.

I have no clue which features Windows or its gaming mode offers. But very high performance systems (e.g. databases, embedded stuff) try to remove the risk of “CPU cores switching to other threads”. Unless I can “pin a thread to a core” I will be at the mercy of the OS thread scheduler, I will always trash my L1-L2 caches, etc.

Again … yes … a fast SSD always reduces the risk of “back-pressure”. And so would a small RC size, because small data sets are always faster. (I think I will write a post about the RC fragmentation issue).

However, my point is and will be …

  • The solution is not to remove the caching
  • … but to make it “better” and “bigger” at the same time.

So … my hope (and claim) is … that FS2024 could (and should) be able to run stutter free even from a RC on a rusty old IDE HDD with a size of 100 GB.

4 Likes

Monumental effort, but wondering if there are any operational take aways to date? Right from the start I set mine to 128GB intuitively, but not sure it has been much of a benefit though I basically fly the same terrain and airports in Northern California.

Its essential that thread safe code uses memory locking. Then the CPU hardware can delay one thread trying to access the same memory, until another thread has released the lock.

As you probably know, making old code thread safe can be very hard. It becomes easier to start again with modern tools and techniques, choosing the battles you can win carefully…

Other details:

  • Regarding RC file handling, yes Windows can cache files in spare ram. It happens behind the scenes at the OS file I/O…
    Obviously it works well with data files opened readonly…such as texture meshes.
    So I wouldn’t worry too much about sim data files stored permanently (until deleted or updated by newer versions). There will be a sweet spot for the granularity of file sizes, which I’m sure Asobo understand.

  • Don’t forget RC streaming was triggered by 500GB consoles not being able to store more sim data.

  • I have some mechanical 1GB drives lying unloved in a drawer, that could outperform a streamed RC, unless CDN can deliver sustained 10Gig bandwith globally to all users…which is impossible in 2025.

1 Like

Good point.

I will try to extract the really actionable information and put it in the very first post as a summary. It really has become impossible to locate those remarks now.

A couple of weeks ago I had this in one summary, which I would so far (sadly) consider the only results that we as pilots can act upon:

  • Increase the size of your RC as much as possible
    • … but I might change my opinion on this, once I take a closer look at the “tiny purple line” at the beginning of the cache.
  • Manually cache (aka. “Install”) as many relevant FS2024 Marketplace assets (aircraft, airports) as you can outside of the RC.

PS: I just updated the first thread post accordingly.

5 Likes

I appreciate the technical issues here as I actually have written code for flight simulation in C++ and memory management is a nightmare. This is even worse with the additional issues of differing drivers for different platforms and MS’s need to have a lowest common denominator (XBOX) for the basic capabilities.

Good luck and if I can do anything to try and peer into my 128GB cache to see what it is actually doing, ask. It seems to be a black box. My test is the FPS of the rendering of runway textures… with my 3070ti I have had to texture resolutions of Medium and various other tricks to get acceptable FPS. I do note that it appears to me to run faster after many take offs and landings on the same runway… maybe an illusion…

2025.01.08 - v1.2.8.0 - Rolling Cache read-to-write ratio

What is a clear sign of a good cache design? I already hinted at this a few times before:

  • A high cache “hit to miss” ratio … or
    • … a high read access, with a very low write access.

When I gave my opinion about the CDN caches in FS2024, I claimed:

  • A good CDN cache can reach a hit ratio of more than … 1 Million (hits to 1 miss).
  • FS2024 seems to reach CDN hit ratios of around … 30 (hits to 1 miss).

In this analysis I want to present information that will allow to better understand this question:

  • How good is the RollingCache.ccc file in reducing network access?
    • This basically comes down to the “read vs write” ratio in real usage.

The following table contains the relevant metrics I collected with the Process Monitor event recordings.

Beware … As I noticed and outlined in a previous analysis, those numbers are not “byte perfect” as the Process Monitor event recordings are not able to capture 100% of all event. But the numbers are still “pretty close to reality”.

The meaning of the table columns is:

  • Test
    • The identifier which I used in the tests that have been published in previous posts.
    • The identifier prefix …
      • z … includes the initial RC zero-fill write activities.
      • i … is the initial sim start after the fresh installation of the Aviator Edition.
      • s … tests which only performed a simple sim start … double-click to main menu.
      • c … simple aircraft configuration and UI test … no flights.
      • d … short drone camera (free) flights.
      • f … “short” free flight.
      • t … dedicated TIN landscape test flights … with the drone or an aircarft.
      • l … “long” free flights with a duration of multiple hours.
  • R:W ratio
    • The “read MB” divided by “write MB”.
  • RC MB read
    • The MB which have been read from the RollingCache.ccc.
  • RC MB write
    • The MB which have been written to the RollingCache.ccc.
  • IP MB read
    • The MB which have been read from the servers over the TCP-IPv4/6 network connections.
Test R:W ratio RC MB read RC MB write IP MB read
z 1 n.a. 488 9,323 2,338
i 1 0.7 488 666 2,338
s A 258.4 1,292 5 47
s I 0.7 414 571 650
s J 0.5 385 704 1,112
c 2 0.9 2,793 2,924 3,353
c 3 3.1 4,291 1,391 1,602
c 4 1.6 2,911 1,853 2,193
c 5 1.9 4,920 2,460 3,340
c 6 1.5 5,029 3,318 4,085
c 7 2.3 5,307 2,320 2,846
c 8 0.9 6,113 6,553 7,685
d 9 1.3 7,888 6,242 6,750
d C 1.5 9,323 6,170 6,728
d D 1.3 12,331 9,673 12,430
d E 1.0 9,667 9,689 12,042
d F 1.0 10,700 10,931 12,676
d G 1.6 19,924 12,069 12,766
f B 3.4 21,738 6,329 5,086
f N 2.0 15,254 7,472 12,893
t H 1.0 31,693 30,718 31,015
t L 1.0 20,631 20,101 24,471
t M 7.8 17,382 2,213 3,558
t O 1.6 10,386 6,526 6,774
l K 1.0 20,631 20,101 24,471
l P 0.9 21,106 24,308 25,643
l Q 0.4 29,754 68,357 38,068
l R 0.6 13,379 23,124 13,314

What do these numbers say? I want to be careful her, because …

  • As mentioned above … the numbers are “wrong” (always too low)
    • … due to the way Process Monitor collects this data.
      • Perhaps the single threaded recording process at some point can not keep up with the multithreaded actions of the system.
      • Sadly the documentation is not fully clear about this … but definitely see that events are missing in the Test 1 recording.
  • The “R:W ratio” is not the same metric as a cache “hit:miss ratio”!
    • hit:miss … is usually defined on a per “item request” and not per “byte read” level.
    • Additionally the blob items in FS2024 are of (greatly) different size.
      • They clearly are not based on a fixed block size.
  • Furthermore my tests are obviously not representative of the “average FS2024 usage”.
    • Each test tried to tigger a certain “response” and most have not been normal flights.
    • But these test data are all I have.
  • Also, the RC is not the only cache in the local FS2024 (process).

Beware … the following does contain some highly speculativ “claims” which I marked with … “?? Idea”

After all these notes of caution, I want to give my comments on the numbers based on each of the test categories, as they should show (somewhat) comparable results.

One common RC file

  • Test 1 to P
    • All are using the 16 GB RC file that was initially created during Test 1.
  • Test 1 to G
    • All share the “blue” text (scenery index?) area at the beginning of the blob item section,
      • … which was created (cached) in Test 1.
  • Test 8 to P
    • 16 GB RC is now 100% full.
      • A gzip compression has no significant benefit
      • … and there are no “zero” blocks visible at the end of the file anymore.
    • Fragmentation is starting, as white “zero” lines show up all over the blob item section.

Category z and i … zero-fill and initial sim start

  • Test 1
    • … shows a “R:W ratio” of 0.7 (if the “zero-fill” effect is removed).
    • This was the only test related to the installation process of FS2024.
    • “RC MB read” is very low … because the cache was just created from zero.
    • “RC MB write” is very large … mainly because of the initial “zero-fill”.
      • Only 8,657 initial “zero-fill” events, each with a 1 MB write, have been recorded.
        • That leaves around 666 MB of “RC MB write” for the non-zero-fill.
        • This numbers seems plausible, as it matches very closely the actual new bytes inside the RC file.
    • The 488 MB “RC MB read” and the actual 666 MB of “RC MB write” are very close.
      • This again suggests at Read after Write usage pattern.
        • A network download first copies (writes) all received data to the RC.
        • Once all data is in the RC the sim will read it for further processing, e.g.
          • building the virtual file system (VFS) tree,
          • reading JSON index files to decided which other files to download, …
    • “IP MB read” is far bigger than the final content in the RC
      • … which contains ca. 664 MB of blob items plus 0.9 MB index items.
      • ?? Idea 1
        • Around 2.3 GB of data have been written to the filesystem … and not the RC.
          • So that would give a good (perfect!) match for the size of “IP MB read”
        • But where did the 664 MB of RC come from then?
        • ?? Idea 2
          • The initial process downloads a lot of “blue” index (JSON, XML) text assets.
            • This sort of data allows very high compression over HTTPS
            • … but the data in the RC and the filesystem seems uncompressed (JSON, XML, etc.)
      • ?? Idea 3
        • However, in combination the above suggests that network downloads are first cached in memory
          • … and data for the regular filesystem is not buffered in the RC first.
          • Otherwise there are 2.3 GB of filesystem write
            • … that could not be accounted for with matching writes inside the RC events.

This is the content classification of Test 1 … with the fresh (empty) RC and the “iconic” blue area, that I already showed in other posts:

Category s … a simple sim start

  • Test A
    • … shows an extremly high R:W ratio of around 258.
    • This is a “perfect” start where all relevant data was already in the RC.
    • The visible downloads are related to the (unnecessary) rewrites of index files outside the RC.
  • Test I and J
    • … show a low R:W ratio of 0.5.
    • The previous Test H did wipe out all important (1.3 GB) of “sim start essential” data.
    • Due to slow servers the necessary files could not be all downloaded during Test I
      • … and the missing downloads then also ruined the “R:W ratio” of the next Test J.
    • To be clear … the sim launches without that data into the main menu
      • … but in the background it still does (try to) download the “sim start essential” data.
    • Those very low “R:W ratio” numbers are caused by the Least Recently Used (LRU) cache replacement policy.

Category c … aircraft configuration

  • Test 2 to 8
    • Those tests where designed to try to find out, if the cache uses a trivial FIFO cache replacement policy.
      • No … it does not, as it turned out.
    • All tests tried to trigger and allow high (aircraft model) content reuse.
    • So “R:W ratio” numbers above 1 seem easy to explain.
      • It did intentionally look at 1 or 2 aircraft from previous tests
        • … and revisited one (of those) aircraft more than once during each test.
    • The higher IP download numbers in all (c) tests seem related to the sound files, which get stored outside the RC.
  • Test 2
    • … only shows a low “R:W ratio” of 0.9.
    • Being the first test, I only revisited one aircraft
    • ?? Idea 4
      • The poor ratio could originate from the fact that some aircraft features are downloaded and cached, which are not needed (read) during the aircraft config menu.
        • Those features might be other LOD levels etc, which would be needed after clicking “Start Flight”.
  • Tests 3 to 7
    • … show a high “R:W ratio” of 1.5 to 3.1.
    • In those tests I revisited 3 or 4 aircraft … and that is reflected in R:W ratios.
  • Test 8
    • … again only shows a low “R:W ratio” of around 0.9.
    • ?? Idea 5
      • In this test I looked at twice as many aircraft as in previous tests.
        • This is reflected in the IP download numbers.
      • Additionally I only revisited one aircraft.
      • So the “R:W ratio” seems plausible and I would explain in like in Test 2 and Idea 4.

Category f … “short” free flight.

  • Test B
    • … shows a high “R:W ratio” of 3.4 … which is plausible.
    • Flying around the small island of Maui for around 1 hour
      • … with the drone and a previously used (cached) aircraft.
      • Many places have been visited more than once.
  • Test N
    • … shows a “R:W ratio” of 2.0 … which is plausible.
    • This 15 minute flight at KIKK was mainly a check of static ground aircraft
      • … using the drone camera a lot while inspecting the same aircraft over and over again.
    • I have no idea how to explain the high IP download
      • … as there have not been any significant writes outside the RC.

Category t … TIN landscape test flights

  • Test H and L
    • … show a “R:W ratio” of 1.0 to 1.6 … and that is plausible.
    • The tests took place in a region that was not yet cached
      • … and tried to download a large amount TIN landscape without revisiting the same place again.
  • Test M
    • … shows a “R:W ratio” of 7.8 … and that is plausible too.
    • Here I revisited LA after a previous test in the same region
      • … and then I checked the same place over and over again
      • … hoping to trigger some “TIN healing” (which did not happen).
  • Test O
    • … shows a “R:W ratio” of 1.6 … and that is also plausible.
    • I did revisit the KLAX airport and the LA landscape.
    • Some data (ground vehicles? static aircraft?) have been already in the cache.

Category l … “long” multi-hour free flights

  • Test K

    • … shows a “R:W ratio” of 1.0.
    • This was a 3.5 hour flight, at 70 ktas and 3,000 ft … from KORD (US) to KIKK (US).
    • Sometimes the servers seemed stressed
      • … e.g. downloads of static ground aircraft took veeeeery long.
    • A lot of data originated in the TIN landscape of Chicago.
  • Test P

    • … shows a “R:W ratio” of 0.9.
    • This was a 4 hour flight, at 70 ktas and different altitudes … from KIKK (US) to KORD (US).
    • I explained all the details of this flight in the posting:
  • Test Q
    • … shows a “R:W ratio” of 0.4.
    • This was a 11.5 hour flight, at Mach 0.98 and 20,000 ft … from EDDM (DE) to VVTS (VN).
    • This test used live weather and live air traffic.
    • Sometimes the servers seemed “gone”
      • … e.g. ground textures where basically missing for hours.
    • “IP MB read” matches “RC MB read” … but “RC MB write” is almost twice as high.
    • ?? Idea 6
      • The very poor “R:W ratio” might be related to a lot of cache reorg and “zero-fill” block cleanup.
        • I do consider such “zero-fill” unnecessary for a “game”, and I will return to this topic in a future post.
  • Test R
    • … shows a “R:W ratio” of 0.6.
    • This was a 7 hour flight, at 150 ktas and 15,000 ft … from FACT (ZA) to FNBL (AO).
    • This test used live weather and live air traffic.
    • Sometimes the servers seemed “busy”
      • … e.g. ground textures with too much blur (“wrong” LOD).
    • “IP MB read” matches “RC MB read” … but “RC MB write” is almost twice as high.
      • I would again explain this with Idea 6.

Just to leave one example of the Process Monitor recordings. This is for Test R and it shows the network and file access results:

Since this was (again) such a text heavy post, I want to leave at least one pretty picture from Test R and the biome around FNBL in Angola.

To me the picture above is both:

  • The magic of FS2024 and the reason why I will never go back to FS2020.
  • The challenge for a streaming-caching system design, that is not up to the task yet.
    • Close to the ground the landscape data volume goes up dramatically
      • … and today FS2024 usually can not keep up (reliably).

To summarize the findings from above:

  • It is highly likely that network downloads are initially cached in memory … and not inside the RC.
    • Only data intended for the RC is then written to the RC.
    • Data intended for the regular filesystem is not buffered in the RC first.
  • The observed Read:Write ratio numbers of the RC fit the different test characteristics
    • … and the Least Recently Used (LRU) cache replacement policy.
  • The RC remembers too much “useless” data and forgets too much “important” data.
    • Landscape data is usually (naturally) rarely reused
      • … which results in “R:W ratio” number of 1.0 or below.
    • Other categories of data (airports, aircraft, etc.) … can result in higher “R:W ratio” numbers
      • … but a RC with a small size and a LRU policy, will struggle to keep them in the RC.
    • Especially the FS2024 speciality, flying low and enjoying the new ground details and bioms,
      • … will result in landscape wiping out important data that should stay in the RC.
  • Overall real use “R:W ratio” number for the RC are barely above 1.0.
    • The RC mostly acts like a buffer (queue) and only rarely like a real cache.
  • The current RC design does not seem to take away significants load from the API, CDN or Origin servers.
17 Likes

2025.01.10 - Ideas for a “Hotfix” release of the Rolling Cache

I hope that I have by now provided enough background about the existing caching architecture of FS2024, and establish enough evidence for present problems, that ideas for better solutions will not be seen as unreasonable or unnecessary.

However at this point, especially for a quick cache “Hotfix”, I think that it is important to define some fundamental constraints:

  1. Any local caching solution must be able to work at the 16 GB default cache size.
  2. No changes to the LRU Cache code base … or the present CCC file structure.

I will try to present some “Brave New World” ideas in the future, but at this point especially contraint (2) is essential:

  • While not very efficient as a caching strategy … the current code:
    • … does not causes crashes … so it is a robust well tested code base.
    • … does work according to specification … even when strict LRU is not a perfect choice.

So what would I consider to be the key goals of a cache “Hotfix”:

  1. Increase the cache Read:Write ratio … significantly.
    • This will require to reduce the observed cache thrashing tendencies.
  2. Avoid increased cache item lookup latency.
  3. Avoid too many necessary code changes in the sim.
    • This is related to code that uses the “LRU code” from point (2).

Introduce a config for Rolling Caches

The first idea would be to add a new config section to the UserCfg.opt file. Today I would describe the FS2024 RC system like this:

{RollingCaches
	Version 1.0
	DefaultBaseFolderPath "C:\..d8bbwe\LocalCache\"
	SizeTotalMinimumInGB 16
	{CacheFile.1
		Path "ROLLINGCACHE.CCC"
		SizeMinimumInGB 16
		SizeRelative 1.0
		ContentCategory All
	}
}

Introduce 3 new Caching Content categories

To increase the Read:Write ratio I would propose to introduce three new ContentCategory options:

  • H) HighReuse
  • M) MediumReuse
  • L) LowReuse = AllOther

A new config could then look like this:

{RollingCaches
	Version 2.0
	DefaultBaseFolderPath "C:\..d8bbwe\LocalCache\"
	SizeTotalMinimumInGB 16
	{CacheFile.1
		Path "RC_HIGH_REUSE.CCC"
		SizeMinimumInGB 8
		SizeRelative 0.5
		ContentCategory HighReuse
	}
	{CacheFile.2
		Path "RC_MEDIUM_REUSE.CCC"
		SizeMinimumInGB 2
		SizeRelative 0.25
		ContentCategory MediumReuse
	}
	{CacheFile.3
		Path "RC_LOW_REUSE.CCC"
		SizeMinimumInGB 4
		SizeMaximumInGB 32
		SizeRelative 0.25
		ContentCategory AllOther
	}
}

The user interface for resizing the caches in the Settings area could remain a simple “Total Gigabytes” slider.

The existing rule, that the cache size can only increase, should also remain in a “Hotfix”.

The math to calculate the new sizes would require a little code, where the SizeMinimumInGB and SizeMaximumInGB should have a higher priority than the SizeRelative factor. But that obviously is trivial.

In the above example we would get:

  • HighReuse = 8 GB
  • MediumReuse = 4 GB
  • LowReuse = AllOther = 4 GB

ContentCategory = HighReuse

It should be of little surprise that the actual “magic” needs to be in a wise definition of what is a HighReuse content category.

Because of the fundamental constraint (2) the underlying LRU cache files will not be able to provide us with information about real usage rates.

If I revisit the long category list of one of my previous posts (2025.01.03 - Ideas for a happy new Rolling Cache ecosystem):

… then I might want to use the following distinctions:

  • small … vs. … large data units
  • few … vs. … many data units
  • immutable … vs. … frequently updated
  • high reuse … vs. … no reuse likely
  • everybody needs it … vs. … individual needs
  • on every flight … vs. … on one or few flights

But the FS2024 backend (origin) does, most likely, not have or does not provide such information to the local caching system of the sim.

Besides that, splitting the same resources over multiple cache files will, in the existing system, result in higher cache lookup cost. So we would violate constraint (4).

So practically, for a “Hotfix”, we are left with a single, suboptimal option: We can only use the data category.

Beware … I actually do not even know if that is “trivial” today. But looking at the SimObjectPaths config I assume that there is some predictable structure in the HTTPS request URLs and the resulting virtual file system (VFS) paths.

With that I would define HighReuse as:

  • Scenery Index
  • Aircraft
    • Thumbnails and “Metadata”
    • All owned aircraft
  • Airports
    • My (frequently or recently visited) airports
    • All owned airports
    • Metainfo … like parking locations, runway info, etc.
  • Vehicles and “ground stuff”
    • Airport ground vehicles
    • Regular city trucks, busses and cars
  • People
    • My avatar
    • Airport people

I would guess that the above might reach a Read:Write ratio of 100 or more.

ContentCategory = MediumReuse

In the MediumReuse I would see:

  • Aircraft
    • Static aircraft
  • Airports
    • All “autogenerated” airports
  • Ships
  • Career Mode
    • My office
    • People
      • My instructor
      • Passengers
  • Challenges
    • Metainfo … like descriptions, path indicators, etc.
  • Marketplace
    • Metainfo
    • Thumbnails
    • Showcase pictures
  • Globe (landscape)
    • Textures
      • Low zoom levels … 0 to 6
        • … required for the high level globe view
      • Med zoom levels … 7 to 8
        • … common for free flight airport selection

I would guess that the above might reach a Read:Write ratio of 10 to 100.

Regarding the globe (landscape texture) data I would like outline the following assumptions.

Map sources are often using a zoom level approach, which for example can be seen in the OpenStreetMap (OSM) ecosystem. Technically it is also a form of LOD but I will call it a “zoom level” to avoid confusion.

If I take the globe in the FS2024 main menu or the initial free flight location selection I would take OSM zoom level 4 as the actual starting point. The following shows the maximum cache size requirements for real world sat image data in the OSM ecosystem for each zoom level:

  • Zoom level 4 = 16 MB
    • You can identify countries.
  • Zoom level 5 = 62 MB
  • Zoom level 6 = 244 MB
    • You can identify major cities.
  • Zoom level 7 = 770 MB
  • Zoom level 8 = 2700 MB
    • You should be able to place most airport markers.
  • etc.

So, no surprise, as each zoom level adds factor 4 more map tiles, the average storage requirement goes up by factor 4 with each level.

I have no idea how the Bing sat image data compares, in size per tile, but the order of magnitude should be similar.

IMHO a maximum of 4 GB of sat image (up to zoom level 8) data can be considerd as MediumReuse landscape. One could even argue that zoom level 0 to 6 (around 300 MB) might qualify as HighReuse landscape.

ContentCategory = LowReuse

In the LowReuse category I would see … AllOther data. Basically this should be a form of “catch all” unless already cached somewhere else.

This would imply:

  • Globe (landscape)
    • Textures
      • High zoom levels … 9 and up
        • … for actual flights at normal altitudes.
    • Elevation or TIN data
  • Live data
    • Weather
    • Air traffic
    • Peer player aircraft

I would guess that the above would operate at a Read:Write ratio 1 or below … which is what todays RollingCache.ccc file usually achieves during a flight.

Index tuning?

With 3 cache files instead of just 1 the total amount of index area storage would go up from 0.5 GB to 1.5 GB. So in total the combined blob area would shrink by 1 GB.

Now one could argue, that a dramatic increase in Read:Write ratio justifies such nominal reduction of usable storage, because it increases the hit rate.

However, it should also be very easy to reduce the index area size in such a “Hotfix” scenario. An index with 128 MB should be able to manage around 1.7 Mio blob items, per cache file.

Even with a fairly low average blob item size of just 20 KB that translates to cache files with a blob area size of up to 32 GB each. And that seems like a worst case to me, because as I posted previously, it seems like the real average is perhaps 50 to 100 KB per blob item. Especially in the HighReuse cache category I would expect blob items to be multiple orders of magnitude larger.

Reality check

Going back to the common ideas for caching strategies that I mentioned in previous posts …

  • Data category specific caching
  • Layered (generational) caching
  • Predictive caching

… the “Hotfix” ideas outlined above only touch the first concept in that list. The other two would require more brave or radical code changes.

And just to be very clear, I again need to repeat this: What I have written here is not an announcement, not a prediction, not “insider” talk. I have absolutely no clue what the FS2024 team is doing or planning.

I am just a goose with opinions and ideas … and obviously with nothing more interesting to do at this time of the year.

To summarize the ideas presented above:

  • A “Hotfix” cache update should respect key constraints:
    1. Any local caching solution must be able to work at the 16 GB default cache size.
    2. No changes to the LRU Cache code base … or the present CCC file structure.
  • A “Hotfix” cache should try to achieve the following key goals:
    • Increase the cache Read:Write ratio … significantly.
    • Avoid increased cache item lookup latency.
    • Avoid too many necessary code change in the sim.
  • This could be achieved by splitting todays RC file into three cache files for different content categories:
    • HighReuse = Scenery Index, Aircraft, Airports, …
    • MediumReuse = Globe (landscape) low + med zoom levels, Challenges, Marketplace, …
    • LowReuse or AllOther = Globe (landscape) high zoom levels, Live data, …
  • Multiple cache files would allow to reduce the index area size in each file.
  • Introducing a config section in the UserCfg.opt file during a “Hotfix” would …
    • allow easy customzation for nerd pilots who want to tune their PC system.
    • prepare the ground for a “Brave New World” cache future.
11 Likes

The depth of the deep dive and the thoughtfulness of the analysis is exceptional here.

7 Likes

I moved my 256GB cache and booted FS24, then created a new 300GB cache (took forever).

I found a sys-internals app in my downloads folder that analyses the system, including files.

File Manager said the cache was 300GB but the app said the contents were 7GB, which was probably right. Seems like a very useful app if your hobby is deciphering files!

I will search out the source of app and post it here.

1 Like

Possibly not. I can imagine a multi threaded CPU or GPU processing multiple cache in parallel.
Windows often maps files in RAM and some RAM is already shared with the GPU.

There was recent chatter on the DirectStorage Discord about future Nvidia modules having a dedicated texture decompression unit. Currently decompression is done by the CPU.

If Nvidia continue their technical growth they would support decompression of multiple textures in parallel…which could be fed by multiple cache files. There might be granularity issues, like there should be 1 to N cache files where exceeding N slows the system.

[However, my design thoughts may need a newer iteration of the PCIe bus, which has always doubled system bandwidth for the next version
Current GPUs often have a PCI 4.0 interface, PCI 6.0 on say, early 2026 motherboards, will be 4x faster in data transfer]

The SysInternals tool is RAMMap:

2 Likes