Hi,

For over a year now, we have been observing very rare but strange GPU or Weston behavior on hardware that we distribute.

These issues occasionally result in our GUI application, written in Qt/C++, being killed.

It looks as if the GPU stops responding. After about 40 seconds, Weston crashes and our application goes down with it.

Despite many attempts and very different approaches, we have not been able to identify the root cause of the problem.

We tested multiple builds and ran various GPU, CPU, and memory stresstests, but without success.

Replacing the MediaPlayer component, which internally uses GStreamer, with a sequence of Image widgets significantly reduced the frequency of the issue.

However, some users still encounter it.

The device runs a custom Yocto based distribution, so building applications for it is quite time-consuming, which makes debugging even harder.

Another complication is that the hardware uses a 32-bit ARM processor (i.MX6).

My next idea was to create a Rust-based project that would stress the GPU in various ways.

I managed to build a simple prototype using Slint, where JPEG images were received over a UDP stream and displayed in 25 image widgets with some gradients applied.

However, this approach seems limited in terms of deeper GPU testing.

I also experimented with wgpu, glutin, and similar libraries, but even with AI assistance I was not able to create a meaningful project that would reliably run on our target platform.

I tried pulling random wgpu based projects from the internet, but I consistently ran into one of two problems:

• Compilation errors - many projects relied on dependencies that required external system libraries. After spending some time fighting with those, it became clear that such projects are not worth the effort and that it is better to focus on something that compiles more easily.

I'm trying to compile everything with single command:

cargo zigbuild --release --target armv7-unknown-linux-gnueabihf.2.28

• runtime errors - since our device uses Wayland, projects that did compile often failed at runtime due to missing X11 support. Typically these were older applications that did not support Wayland at all(I tested random projects from ~2020).

As mentioned earlier, the only project I managed to cross-compile successfully and run without issues was Slint

Unfortunately, I do not see a good way to use it for more in-depth GPU testing.

Do you know of any Rust based projects (games or applications) that can be used with quite automatic way to stresstest the GPU, for example by rendering specific workloads or scenes?

1 post - 1 participant

Read full topic