We have received reports in the past about X-Plane 11’s seaplane dynamics when the aircraft is in the water.
If you would like to test sea plane water dynamics with an experimental build, please email Austin directly – he has some fixes for seaplane behavior and he is looking for early testing.
Update: fearless leader^H^H^H^H^H^H^H^H^H^HAustin says he is only looking for testers who have experience flying a real world small float plane with pontoons, so that he can get test feedback from someone who can validate the reality of the physics.
(You will need to install a custom build from him on top of X-Plane 11.31 to do this.)
This blog post is more or less a “stern talking to” for plugin developers, but before I go there, I want to acknowledge that we (Laminar) screwed up the docs here in a way I didn’t even realize until working on a bug report. A decade ago when the plugin SDK was young, we did have clear docs that the plugin APIs were not at all thread-safe. Sandy and I were also on the plugin dev email list and we’d administer a Scottish-style beating to anyone who even started typing the first few letters of “threading”.
However, this document was lost in the migration from the old XSquawkBox server to developer.x-plane.com. I’m working with Jennifer on new docs now, and I apologize for the thrash any plugin developer gets hit with from not knowing the threading guidelines.
With that in mind: the X-Plane plugin API is not thread-safe. You can only call plugin APIs on the thread that called you. No exceptions!
The plugin SDK was invented for X-Plane 6. At the time, multi-CPU and multi-core hardware was totally unavailable to the flight sim community. Apple hadn’t released the dual-G5 yet, and the Pentium D hadn’t come out yet. There was no point in thinking about multi-core because there weren’t multiple cores.
The plugin guidelines were therefore set up very simply: the API is single threaded; call us back on the thread we call you. The SDK internally has no locks or handling of re-entrancy and has no model to cope with resource sharing or data integrity across threads.
Furthermore, X-Plane’s crash detection system is not meant to categorize other-thread crashes, so you can’t easily tell that your plugin is crashing the sim. You might even crash a different plugin, or some internal part of X-Plane.
One more way we’re not thread safe that might not be obvious: when you read a dataref, you are executing code from another plugin. You can’t do this on a thread if the XPLM isn’t thread-safe, but you also can’t do this if the other plugin isn’t thread safe.
Stopping the Bleeding
In X-Plane 11.30 we made a change to stabilize the sim: we added code to actively detect and ignore plugin calls to the XPLMTerrainProbe APIs from background threads. We did this after seeing automatically reported crashes that turned out to be due to plugins calling the SDK terrain probe API from worker threads. By ignoring the call, we avoid the crash.
My plan is to start doing this for all plugin calls at a patch point in the next few months. The problem here is that there’s basically no such thing as a benign threading bug – the table stakes here are the complete destabilization of the sim.
If you are a plugin author and you are using background threads to call XPLM APIs, please stop doing this now. Please plan to fix this in your plugin as soon as possible. The change will probably not make things any worse – my current idea is to no-op the calls, just like we did with terrain probes. But if your plugin is using these async calls and sometimes succeeding but sometimes crashing, you’re going to stop seeing the crashing and the sometimes lucky “success”.
I’m working with Tyler and Jennifer on a docs update now – hopefully this week all of the docs should be completely consistent. But they’re going to say what I’ve said above: no calls to the XPLM on worker threads.
Will We Ever Be Thread-Safe?
Sandy and I did some work back in the XPLM 2.0 days to start making the SDK partly thread-safe. This work was not completed, but the idea was to at least make a small number of APIs callable from worker threads. For example, by making flight loop callbacks schedulable from worker threads, a plugin could “wake up” SDK code from an async IO callback. That idea still makes some sense and we may get there someday.
For expensive tasks, we’ve already made API changes to address the underlying performance problems. For example, you can’t load an object synchronously from a thread, but you can ask us to load it asynchronously and call you back, and we use one of our threads to offload the work.
Some APIs I expect to never be thread safe. For example, we can’t sanely provide a threaded API to datarefs because we can’t promise that the plugin on the other side of the call is thread-safe. Given that a dataref read function can call other datarefs or other arbitrary plugin code, the opportunity for dead-locks is limitless.
Tyler’s Fever Dream
I should mention something that Tyler has been looking at as a future SDK initiative. This is somewhere between pie-in-the-sky and a fever-dream: plugins running asynchronously in separate processes.
The idea is to have a version of the main SDK APIs that are “fundamentally asynchronous” (e.g. the response comes later and that’s baked into the contract). This would allow plugins to run in another process, with results being communicated via IPC. Out-of-process plugins would have a bunch of advantages:
- You could write a plugin in pretty much any language we can write a binding for. Right now, plugins must fit into an unmanaged DLL inside X-Plane; this would allow the full “async API” to be used in .net or even Matlab. The requirement would only be that the plugin “app” environment be able to host unmanaged C code. This is a much less difficult requirement to meet.
- Plugins would be isolated by process boundaries; if a plugin crashes, the sim keeps running. Plugins can’t go around trashing each other’s memory.
- Use of multiple cores for plugin CPU processing is basically free, because the plugins can execute in parallel.*
- Plugins can each have their own CEF instance – or any other library that doesn’t like to be multiply instantiated in a single process.
One of the major hurdles to implementing an API like this was sharing graphics across the process boundary. As it turns out, we have to solve this problem for Vulkan anyway – the same APIs that share surfaces between Metal/Vulkan and OpenGL are IPC-friendly from day 1. So a 2-d plugin OpenGL window in Vulkan doesn’t have to be in X-Plane’s process.
I don’t see async plugins ever replacing 100% of in-process plugins, and this isn’t a plan to kill off the current C API. But I do think out-of-process plugins would be a much better fit for a wide range of plugin tasks.
* Users familiar with game programming will appreciate one of the fundamental dangers here: plugins in other processes might steal oversubscribed cores from the sim itself, causing stutters and unreliable framerate. Tyler and I have talked about that a little bit, and have some ideas for taking plugin background work into account and giving plugins ways to opt in and say “please run this background work for me at a time that won’t hose framerate.”
EDIT: See the recording of the Q&A session here on YouTube!
We’ve been posting about this on social media for a bit, but realized we hadn’t talked about it here.
Today at 11 am Eastern (16:00 UTC; click here for time zone math) we’ll be doing another live Q&A on our YouTube channel. We’ll be taking questions in the YouTube comments, but if you can’t make it live, we’ll try to answer a few questions from the comments on this post.
In case you missed the first, second, and third (part 1 & part 2) rounds of this, this is a streaming broadcast featuring:
- Austin Meyer, owner & creator of X-Plane
- Ben Supnik, desktop product manager
- Chris Serio, mobile product manager
- Alex Unruh, art director
- …and a handful of other special X-Plane friends.
X-Plane 11.32 is available as a opt-in public beta for Laminar and Steam users. If you are seeing the sim randomly crash more frequently than before the X-Plane 11.30 series, please try this beta.
NOAA dropped non-HTTPS access to weather data today, causing Real Weather to fail; this is fixed in this beta build. The NOAA issue should not affect any weather add-ons, nor will the fix.
Edit: 11.32 release candidate 1 appears to fix only part of the problem; upper winds are all “zero”. I’m traveling now so it will be a few days before this is fixed.
Most of the crashes we’ve seen have been the GPU driver failing to get us memory. We don’t know if 11.32 will help, but we have tried a change to how we work with the driver that is more like 11.26 and more conservative, that we are hoping will be more stable.
Edit: there have been very few auto-reported crashes with 11.32 – less so than the number of “it crashed” blog comments! Remember to it “send” on the auto-reporter if X-Plane crashes; you don’t need to enter any data, just hitting send captures your Log file and where the sim crashed, which is what we need most.
Inevitably after a large update to X-Plane like 11.30, new bugs go undetected during the beta process. We do a quick update to try to kill off these bugs as quickly as we can, e.g. X-Plane 11.11, 11.26, 11.31.
Yesterday we shipped 11.31. Unfortunately this isn’t the end of X-Plane 11.30 bugs, and in two cases, 11.31 appears to have introduced new problems.
We are working now on X-Plane 11.32, and our rough plan is:
- Fix all the really serious bugs (crashes, performance so bad you can’t fly) and ship that ASAP.
- Fix the rest of the lingering 11.30 bugs.
- Take a moment to question life choices.
If you are seeing crashes in X-Plane 11.30 or 11.31, the most useful thing you can do is to auto-report them, preferably with your email address in the report, so that we can contact you to run special builds.
The rest of this post is an update on the state of some of these bugs.
Older Intel OpenGL drivers contained a bug in their pre-processor that caused them to reject our HDR shadowing shaders. I rewrote the shaders to work around this bug for 11.31, and the rewrite has exposed a bug in OS X OpenGL drivers from 10.10.5. I have already fixed this and confirmed the fix with users who still run 10.10.5, so this bug fix will ship in 11.32 for sure. In the meantime, turn off HDR to work around the problem.
Also, if you are a Mac user running 10.10.5, consider updating to a newer Mac OS!
The most mysterious crash we see is new to 11.31 – a mysterious crash in the weather code. This crash is mysterious to us because nothing changed anywhere near this code from 11.30 to 11.31. The crash reports also don’t make a ton of sense – Sidney and I spent a few hours last night staring at disassembly and being baffled.
I have been contacting users who auto-reported this crash, and fortunately the response to running some test builds for this has been quite positive. I’m hoping to narrow down the change that caused this so that we can wrap our heads around what went wrong.
This weather crash is the one I am most concerned about because it is both unrelated to anything we changed and introduced in 11.31 – a tiny release designed to stabilize, not destabilize the sim. I don’t have a work-around at the time because I don’t have anything like causal steps to reproduce.
Please do not contact me with “I have a crash, can I help” – if we haven’t seen your crash report, there’s no way for you to know if the crash you have is this one or something else. If your email address is in your auto-reports, we can ping you.
Running Out of Mapped GPU Memory
The largest source of instability we’ve seen recently comes from 11.30, and it’s the GPU not being able to provide X-Plane with mapped memory. Since we radically changed the rendering engine in 11.30 (as part of our port toward Vulkan) I am not surprised to see a major GPU problem, but it is still a top priority to fix it. This bug is equally common in 11.30 and 11.31, appears to affect AMD and NVidia windows users (but perhaps AMD more – we’re not sure), but isn’t something we see on our lab machines. Sidney and I have some ideas on how to at least work around the problem so that people can fly.
We’ve heard a lot of chatter about performance problems and complaints about performance loss, and we are collecting detailed performance reports from users so we can see what’s going on. Since the performance tests are automated, it’s relatively quick for us to gather this data.
So far, while we have seen a lot of mediocre performance (and mediocre hardware!), we have not yet measured via tests the kind of “catastrophic” performance problems that one might expect from the amount of complaining on forums, etc. That doesn’t mean there isn’t a serious problem out there, it just means we haven’t seen it.
For performance, my view is: if we find something truly awful (e.g. the sim used to run at 25 fps and now runs at 5 fps after the update), we’ll go fix it. I don’t want to make anyone’s copy of X-Plane impossible to use.
But if someone is seeing a 5-10% loss of performance, at this point it’s better to ignore it, because the same engineers who would analyze and fix the performance problems (Sidney and myself) are the ones who are doing the Vulkan port, and the Vulkan port gives us a better shot at fixing performance than trying to beat more performance out of the OpenGL driver stack. In fact, even analyzing the problem is more possible with Vulkan, because the OpenGL drivers do a number of expensive things that they give us no visibility into.
To give you an example of what I mean: we captured performance data from a user with an older Ryzen 16-core CPU and a GeForce 1080 GTX. Our analysis showed: 20-30 fps in the highest fps test (basically everything maxed out), 50-60 fps in medium settings, and 60-70 fps at the lowest settings. At all times, the GeForce 1080 was not maxed out and the CPU was the bottleneck.
Here’s the thing: the older Ryzen CPU has a single-core Geekbench score about as good as my 2014 iMac – that is, it’s not a top tier CPU, it’s old, and it was never optimized for single threaded performance. The user’s system is unbalanced for X-Plane (a lot more GPU than needed for that CPU), and 20-30 fps with everything maxed out is all I would expect from a CPU of that performance level.
So there’s no sign that the machine is underperforming our expectations. And the obvious thing to do to make the system faster is to be more multi-core (since the machine has 16 cores). And that means: focus on Vulkan.
So when it comes to performance, I’m going to beg patience and try to not lose momentum on the Vulkan/Metal port. In the long term it’s a better way to help everyone go faster. If we find something truly bad though, we will go and investigate more.
I don’t know what the ETA is for 11.32, but my plan is days, not weeks. The crash bugs are our top priority right now.
X-Plane 11.31 is available to test – run our installer, update X-Plane, and check “get betas”. Full list of bug fixes here.
X-Plane 11.31 contains bug fixes that we could get done quickly, that almost made it into 11.30, and that were high priority, e.g. crashing on some Intel GPUs is fixed, and the external visuals don’t randomly lose sync.
We do still have some other fixes to get in at a later time. For example, there are a number of particle replay bugs where X-Plane isn’t saving the data needed to replay the particle effect; we will patch those in a separate patch where we can add more data to the .rep/.sit structures.
Some users have reported performance bugs, and we are gathering data and looking into them, but I’m not treating them as a five-alarm fire. We’re at a point where we are making rapid progress on the Vulkan port, and I don’t want that progress to grind to a halt as we investigate OpenGL performance problems; we already know that the long term solution to OpenGL performance problems is going to be Vulkan, not stabbing the OpenGL code repeatedly with a fork in the hope that it’s better behaved.
If we find something blatantly wrong with the OpenGL code in 11.30, we’ll fix it, but when it comes to ensuring performance, the very fact that the engine is OpenGL and not Vulkan limits us. At this point the IHVs are making their best performance analysis tools for Vulkan and Metal, not OpenGL, and Vulkan provides an API where the drivers performance is deterministic. (What we’ve seen so far is differing OpenGL performance for basically the same hardware drivers.)
X-Plane 11.30 was a really big code update to X-Plane – it had a major update on our route to re-writing the rendering engine, hence all of the rendering bugs we’re fixing. Over the next few updates I think we’ll have less code change as we stabilize, paired with art updates. We’ll take gateway airports and we have some landmarks ready to go.
Posted in News
by Ben Supnik
Gateway scenery artists may be interested in this document that contains useful tips
for building better Gateway airports. It provides a lot of examples so you can save a little construction time and take your scenery to the next level. Topics include:
- terrain polygons
- using facades (terminal kit, jetway kit, etc)
- managing road networks
- taxi networks
- and more
It’s out the door! (Steam should go “final” tomorrow morning, but you can get the final now – it’s still marked as a “beta”.) Here’s everything that happened.
I expect we’ll do an 11.31 bug fix patch in the next week or two – 11.30 release candidate three was just critical fixes, e.g. fixing crashes on startup for Nvidia users with Windows 10 and the moon and stars aligned just right. Some less super-critical bugs are fixed and waiting for the bug fix patch.
Posted in News
by Ben Supnik
As a developer, you’ll (hopefully) want your products to be VR compatible. To do so, you can of course use a real headset. If the need for debugging arises, that may not be very practical.
So, here’s how to fake VR in X-Plane:
- For starters, you’ll want to bind a key combination to the “Toggle the 3-d mouse cursor in VR” command. This can be done in Settings -> Keyboard, and will allow you to switch between using the mouse in VR, and in the normal window to exit VR mode. It can by quite hard to get out of VR mode without this shortcut.
- Start X-Plane with the
--fake_vr command line argument (see “Using the Command Line Options” if unsure how to do that).
- In the Settings menu, the VR options should now be enabled. When checking the “Enable VR Hardware” checkbox, the left-eye view will be rendered in the X-Plane window.
There are a couple of noteworthy things to keep in mind when using this. Let me start with the good news: this also works on Mac! On to the bad news… this is very much in the category of “nasty hacks”, which means:
- Quite a number of rendering artifacts when faking VR, but it should be good enough for testing out things like user interfaces and the like.
- No support for VR controllers
- …or even for actually moving the fake headset about 🙁
X-Plane 11.30 Release Candidate 1 is out – we fixed a lot of bugs!
As you can tell by the release name, we’re getting ready to kick this thing out the door. Most of the team is no longer working on 11.30, and those of us who are are trying to make very small, tactical changes to not further screw things up. I wouldn’t bet against an RC2 (we’ve needed more than one try for all of the “really big” patches we’ve done in the last decade) but at this point if you haven’t tested your add-on against 11.30, you’re really late to the party.
Auto Toe Brakes
Flight simulators sometimes have to deal with unrealistic problems specific to being simulators and not real airplanes. One category of these “unrealistic problems” is dealing with user input hardware that is less complex than the real control inputs of the airplane. You might have a single throttle lever on your joystick, and not the 4 throttles with reversers of the 747. You might not have a twist axis or rudder pedals. You might be flying with a mouse!
Automatic toe brakes are a feature where X-Plane automatically applies differential toe brakes at times that we think might be useful if you don’t have toe brake hardware and no plugin is controlling the toe brakes. For example, an aircraft with a free-castering nose-wheel might be impossible to steer at low speeds without toe brakes. (You can’t turn the nose wheel directly, and the rudder will lack authority at low speed.) X-Plane can apply the left toe brake for you when you apply a lot of left rudder to help you turn.
In previous versions of X-Plane, this automatic toe-brake behavior was automatically applied based on some rules that Austin coded into X-Plane. When they worked, they really helped (and we know they sometimes worked because when we removed some of them in 11.30 we got bug reports), but at other times they weren’t tuned properly for a particular aircraft.
Starting in X-Plane 11.30 release candidate 1, aircraft authors can now explicitly control whether toe brakes are auto-applied for users without hardware, and if so, how aggressively. This control is auto-populated for older aircraft with the choices X-Plane 11.26 and earlier would have made, so you shouldn’t see a change in older aircraft behavior. The aircraft updating guide has the full details.
I believe that changes to these automatic rules may have been responsible for changes in third party aircraft ground handling in late 11.30 betas; hopefully with the new code, we should see complete compatibility.