Highlights
- Starfield’s optimization has caused crashes and performance issues, with the game’s memory allocation and inefficient execution of commands being major factors.
- Vkd3d developer Hans-Kristian Arntzen has discovered that Starfield’s misalignment of memory allocation can easily lead to crashes and memory corruption.
- Starfield’s use of ExecuteIndirect calls and sequential processing instead of batching together commands further exacerbate the impact on performance, but a fix has been released by the Vulkan developer.
Starfield’s optimization has been a major point of contention in the community in the past few weeks, with widespread crashes and performance issues ailing the game’s launch. While Todd Howard believes it’s the players’ hardware that is to blame (thanks, TheGamer), a new report says the real reason could be different.
A new discovery by Vkd3d developer Hans-Kristian Arntzen sheds some more light on the crashes and performance issues players have been facing in Starfield. Vkd3d is the library that Starfield and a lot of other games use to implement Direct3D 12 API on top of Vulkan. In a new pull request (which is equivalent to an update for software, in simpler terms), the developer highlights that Starfield has a number of inefficient ways of handling things which can cause performance issues. While the developer’s comments are quite technical and might not make sense to you unless you’re into that sort of thing, Redditor Nefsen402 has simplified the whole thing.
The first issue is Starfield’s incorrect allocation of memory, where Starfield’s memory allocation is not aligned with CPU page size. This is likely the root cause for the crashes, as a misalignment can easily cause memory corruption. However, more than the crashes, it is the other two programming faults that are likely creating more of an impact.
Starfield uses a Vkd3d feature called ExecuteIndirect to give some inputs to the GPU. Think of it as you giving your friend directions while they are driving a car. Now instead of giving clear directions, you end up telling your friend to go both right and left. This will cause your friend to reevaluate your directions, making the process inefficient.
While this is an extremely high-level idea, it is somewhat similar to what Starfield is doing, giving vague hints to the GPU, consequently leading it to do unnecessary work. These vague hints cause “bubbles”, which cause the GPU to reevaluate its decisions. To make matters even worse, these ExecuteIndirect calls are repeatedly sent to the GPU one after the other, instead of being batched together which further amplifies the impact of the previous issue.
Thankfully, the Vulkan developer has released a fix for it, where they evaluate the ExecuteIndirect commands to decide whether they need to take any decision at all, which saves the overhead needed to reevaluate it. Additionally, similar commands are batched together as well, which makes it way more efficient than the sequential approach Starfield takes.
This is not the first time Bethesda has been under the scanner for its programming faults. If we roll back the clock to Skyrim Special Edition’s release, the game’s inefficient handling of mutexes was taking a huge toll on the performance. For starters, mutexes prevent multiple threads from changing the same thing. For instance, if we go back to the car analogy, it’s like you and your friend trying to control the steering at the same time.
Thankfully, this was spotted by the community and a mod was released to address it, and the same is expected for Starfield as well. While the issue has been found and addressed, it will be interesting to see when this change finally makes its way to players and how much of an impact it makes.
[ad_2]
