XDC 2023 - X.Org Developer's Conference 2023

16 Oct 2023, 09:00 → 19 Oct 2023, 21:00 Europe/Madrid

Palexco

Daniel Vetter (Intel) , José María Casanova Crespo (Igalia) , Neal Gompa, Ricardo Garcia (Igalia, S.L.) , Samuel Iglesias Gonsálvez (Igalia)

The X.Org Developer's Conference - XDC 2023 is the event for developers working on all things Open graphics (Linux kernel, Mesa, DRM, Wayland, X11, etc.). XDC 2023 is happening as a physical conference from the 17th to the 19th of October 2023 in A Coruña, Spain. The event is free to attend and open to the public.

Monday, 16 October

19:30 → 21:30 Social Event: Welcome Cocktail

Tuesday, 17 October

09:00 → 17:35 Main Track

09:00 Tuesday Opening Session

Speaker: Samuel Iglesias Gonsálvez (Igalia)

09:20 The rainbow treasure map: advanced color management on Linux with AMD/Steam Deck

A guided tour of the AMD display driver code to identify hardware color capabilities on different versions, connect relevant parts of the shared code to DRM, and ultimately deliver a broader range of color features to the userspace. This work is another step towards advanced GPU-accelerated color management for Linux compositors, and it has already enabled improvements to HDR display support in SteamOS/Gamescope. So, what's the next treasure hunt?

Speaker: Melissa Wen (Igalia)

xdc2023-TheRainbowTreasureMap-MelissaWen.pdf

09:45 Rainbow Frogs: HDR + Color Management in Gamescope/SteamOS

An overview of Gamescope and our journey to support HDR content and color management at scanout and composite for Steam Deck and Desktop.
Covering the issues we faced along the way from all aspects to UX, to getting HDR and 10-bit on XWayland games/clients, to DRM, and to the future of what we need from the new DRM atomic color management pipeline.

Speaker: Joshua Ashton (Valve Software)

Rainbow Frogs HDR and Color Management in Gamescope-1.pdf

10:10 Nouveau/NVK update

Karol and Faith will talk about what has happened in the nouveau project in the last year, including the latest on kernel GSP support, NVK, and the future of the nouveau GL driver.

Speaker: Faith Ekstrand (Collabora)

2023-10-17 XDC 2023 - Nouveau NVK Update.pdf

10:55 Break

11:25 Writing compilers in Rust

The new back-end compiler for NVIDIA hardware, jokingly named NAK, has been almost entirely written in Rust. In this talk, Faith will do a bit of a postmortem on her Rust compiler experience and talk about challenges and advantages of Rust for Mesa in general and compilers in particular.

Speaker: Faith Ekstrand (Collabora)

2023-10-17 XDC 2023 - Writing compilers in Rust.pdf

12:15 Unleash the (graphics) magic

Twelve moons ago, we demoed early OpenGL 2.1 and OpenGL ES 2.0 drivers running on Linux on the Apple M1. Since then, we've shipped OpenGL 3.1 and passed the OpenGL ES 3.1 conformance tests on the M1 and M2 families! This spellbinding talk will reveal the hardware incantations that make the magic happen... involving some truly cursed driver code. And yes, there will be a demo 🪄

Speakers: Lina Asahi, Alyssa Rosenzweig

AlyssaRosenzweig-UnleashTheGraphicsMagic.pdf

13:00 Lunch

14:00 Zink: reducing stutters with uber shaders

Being a layered OpenGL driver, Zink sometimes needs to emulate some legacy features, that are not exposed by vulkan, using shader passes. Due to OpenGL's design it is not possible to know exactly what needs to be emulated ahead of time and until now Zink has dealt with this by compiling shader variants at draw time, leading to upwards of 100ms spikes in frametime. A possible way of solivng this is by creating some uber shaders as early as possible which can handle different pipeline states dynamically. This talk will discuss some details of how Zink currently handles shader compilation and caching, the changes that were needed and also the challenges in adapting emulation passes for this purpose.

Speaker: Antonino Maniscalco (Collabora)

zink_2023.pdf

14:50 Status of KUnit tests on DRM subsystem

The KUnit adoption in the kernel had been in its early stage, having the first DRM KUnit tests into mainline only around the mid of 2022. Since then, there was an active commitment to increase the presence of KUnit tests on DRM, which had involved porting existent self-tests and writing new ones.

In this presentation, we will point out the current status of KUnit tests on DRM, as well as the path taken to it and what to expect in the future.

Speakers: Arthur Grillo Queiroz Cabral (University of São Paulo) , Carlos Eduardo Gallo Filho (University of São Paulo)

Status of KUnit tests on DRM subsystem.pdf

15:15 GSoC 2023: wlroots frame scheduling

Over the summer, Future Me (hopefully) added support to wlroots for intelligently and dynamically changing when, relative to a previous frame, a compositor starts to render. It's better to start it later for lower latency but that comes with a risk of missing the deadline if rendering takes longer than expected. The work includes an API for specifying when rendering should start and a "stock" algorithm for predicting a good value for that parameter, along with some necessary infrastructure in wlroots. I'll talk about how the project went and what came out of it.

Speaker: Rose Hudson (University of Bristol)

GSoC 2023: wlroots frame scheduling.pdf

15:35 Break

16:00 Improving the World's Slowest Raytracer

At XDC 2022, RADV's raytracing implementation was dubbed the "World's Slowest Raytracer". Over the course of the last year, RADV has seen lots of exciting progress in its raytracing implementation: Starting with Mesa 23.2, raytracing is even enabled by default.

This talk will cover the challenges of improving RADV's implementation and making it work with more games and other software, as well as the milestones we've reached along the way. I'll also show how RADV raytracing stacks up today: What does and doesn't (yet) work, and, of course, how the performance looks like.

Speaker: Friedrich Vock (Valve Corporation)

Raytracing.pdf

16:50 Freedreno on Android

Over the last few years the quality of Mesa's drivers has increased exponentially, to the point where many prefer the use of the open source driver to their proprietary counterparts. Open source drivers can have better compatibility, less bugs, and more frequent updates to resolve issues. Because of this uptick in quality, you may want to run the open source drivers on other operating systems such as Android.

In this talk we will explore the work that was required to get Freedreno running on Android. This will include setting up the development environment, loading the driver on real hardware, development tips & tricks, running tests, setup of debugging environment, issues encountered during the porting process, and lastly we will explore some areas of Mesa that could be updated to simplify porting to other operating systems. This talk should provide a guide for anyone looking to get their Mesa driver running on Android.

Speaker: Lucas Fryzek (Igalia S.L.)

XDC_2023_Lucas_Fryzek_Freedreno_on_Android.pdf

14:00 → 16:00 Workshop: Workshops

14:00 KMS API color management workshop

Color is a visual perception. Human eyes can detect a broader range of colors than any devices in the graphics chain. Since each device can generate, capture or reproduce a specific subset of colors and tones, color management controls color conversion and calibration across devices to ensure a more accurate and consistent color representation. We can expose a GPU-accelerated display color management pipeline to support this process and enhance results, but color capabilities differ between HW versions and GPU vendors.

DRM/KMS API for advanced color management has been an ongoing discussion in the community for a few years, and we are now in a new stage with the generic color management proposal [1] from April-2023 Display Hackfest [2]. Therefore, this workshop is a follow-up of last year's HDR KMS API workshop [3] and Display Hackfest discussions and also the status update of all work done by the DRI community so far to provide a solution that covers the needs of all parties involved.

References:
[1] https://lore.kernel.org/dri-devel/QMers3awXvNCQlyhWdTtsPwkp5ie9bze_hD5nAccFW7a_RXlWjYB7MoUW_8CKLT2bSQwIXVi5H6VULYIxCdgvryZoAoJnC5lZgyK1QWn488=@emersion.fr/
[2] https://wiki.gnome.org/action/login/Hackfests/ShellDisplayNext2023
[3] https://indico.freedesktop.org/event/2/contributions/75/
[4] https://gitlab.freedesktop.org/wayland/wayland-protocols/-/merge_requests/14
[5] https://gitlab.freedesktop.org/pq/color-and-hdr
[6] https://lore.kernel.org/dri-devel/20230523221520.3115570-1-mwen@igalia.com/
[7] https://lore.kernel.org/dri-devel/20230621081031.7876-1-jacopo.mondi@ideasonboard.com/
[8] https://lore.kernel.org/all/20210906213904.27918-1-uma.shankar@intel.com/
[9] https://lore.kernel.org/dri-devel/20210426173852.484368-1-harry.wentland@amd.com/

Speaker: Melissa Wen (Igalia)

XDC 2023 - KMS Color Management Workshop.pdf

17:40 → 17:50 Demos / Lightning talks I: Demos/Lightning talks

Demos have priority over lightning talks in this session.

Lightning talks get schedule as time permits throughout the assigned time block. Please be ready!

17:40 Wayfire - Making an OpenGL Wayland compositor render using Pixman

This demo will showcase the Wayfire OpenGL Wayland compositor running on the Raspberry Pi 3 using Pixman to render the desktop. We will briefly discuss the efforts involved with converting an OpenGL compositor to render using Pixman and some of the issues we encountered on the way. We will also discuss multiple performance optimizations targeted specifically at improving the Pixman rendering path that dramatically improved the user experience, showcasing before-and-after comparisons.

Speaker: Mr Christopher Michael (Igalia)

18:15 → 19:45 Social Event: Guided Tour

Wednesday, 18 October

09:00 → 17:50 Main Track

09:00 Wednesday Opening Session

Speaker: Samuel Iglesias Gonsálvez (Igalia)

09:15 How does the Mesa3D CI manage to balance fast-paced development and quality of the code?

Mesa3D CI, through the use of GitLab CI pipelines, conducts extensive testing across numerous farms and a multitude of GPUs. With thousands of tests being run, the scale and complexity of this project are immense.
For over three years, we've been running pre-merge testing for various GPUs. You might wonder, how do we manage this feat?
In our presentation, we will provide insights into the measures we've taken to manage and enhance this complex project. We will share intriguing details about how we maintain and improve our beloved CI. Furthermore, we will give a glimpse into the future developments planned for MesaCI. Join us as we unravel the intricacies of our operations and discuss what lies ahead

Speakers: David Heidelberg (Collabora) , Sergi Blanch Torné (Collabora)

MesaCI.pdf

10:05 Hosting a CI system at home - Slaying the regression dragon to bring stability to driver kingdom

Hear, hear!

Come witness the tale of a lone Mesa developer who, after the 101st regression caused by external changes, vowed to slay the bisection dragon once and for all by guarding their driver kingdom with CI pre-merge testing!

Too little did they know the sirens of automated testing would take them on an unexpected journey in far-away lands they only ever heard tales of, and tested their skills in new and scary ways on their path to self-discovery.

Through their years of battle, they learned that the regression dragon is just one of the many monsters that are threatening its users, and became wise-enough to tame them and bring stability to the driver kingdom.

Come to hear how!

---

Workshop instructions: https://docs.google.com/document/d/1bhiAWPQ70wkGCfsNd-YAafchJhBMkEl-O4gMtCB28jk/edit

Speakers: Martin Roukala (né Peres) (MuPuF TMI / Valve contractor) , Eric Engestrom (Igalia / Mesa) , David Heidelberg

Hosting a CI system at home

10:50 Break

11:20 Automated graphical testing on real hardware: adventures with OpenQA

OpenQA is a powerful testing tool developed originally for openSUSE and now used by various major distributions for integration testing. Within Codethink we're also using it to test mainline Linux on hardware across several CPU architectures and GPU stacks.

This talk will show how to create screenshot tests that can quickly verify your graphics pipeline is working. First I'll show how to quickly run the tests in a developer laptop using the QEMU backend. Then we'll look at a pipeline that builds a custom kernel and tests it on real hardware, using the same OpenQA testsuite.

Speaker: Sam Thursfield (Codethink, GNOME)

2023 XDC - openQA.pdf

11:45 On-going challenges in the Raspberry Pi driver stack: OpenGL 3, Vulkan and more

This talk will discuss various on-going efforts in the driver stack for Raspberry Pi 4. Particularly:

OpenGL 3.x on Raspberry Pi 4 (v3d)

The Raspberry Pi 4 isn’t capable of OpenGL 3 but it can implement a large part of it, sufficient to enable many applications to work on the platform. We will discuss the major limitations of the hardware platform for this and what we are doing to close the gap as much as we can.

Improvements to CPU job handling in the Vulkan driver (v3dv)

At XDC 2022 we discussed that one of the pain points in the driver was the need to execute some parts of the command buffer in the CPU, for things the GPU can’t do, which required user-space flushes/stalls and caused a number of issues. Here we will discuss some of the work we have been doing to improve this situation using a combination of compute shaders and a new CPU kernel queue.

Global GPU stats

We will discuss our efforts to obtain global GPU usage stats from the kernel and on-going efforts in DRM to provide a cross-platform solution.

Speakers: Iago Toral (Igalia, S.L.) , Mr Juan A. Suarez (Igalia, S.L.) , Maíra Canal (Igalia)

on_going_challenges_in_the_raspberry_pi_driver_stack.pdf

12:10 Rusticl Status Update

Quite a lot has happened since last year and I want to talk about what we've implemented since last year, what's the short term lookout and other project related updates.

Speaker: Karol Herbst (Red Hat, Nouveau)

main.pdf

12:35 Status Update of the VKMS DRM driver

It has been a while since the last XDC talk about the VKMS and a lot has changed. VKMS now supports multiple formats, the composition is now performed in CRTC, the performance was improved and the planes now have the ability to rotate. And there is more coming: 1D LUT, multi-planar formats, full blend mode support...

So, let's explore a bit of the current status of VKMS, see the current state of its IGT test coverage, and also cover some current use cases for it.

Speakers: Maíra Canal (Igalia) , Melissa Wen (Igalia)

Status Update of the VKMS DRM driver.pdf

12:55 Lunch

14:25 Having fun with GPU resets in Linux

GPUs (and their stack) nowadays are too complex as any other systems and subject to errors and bugs. On top of that, along with the device getting stuck, all the stack need to propagate the error correctly so it can recover and move along.

In this talk, I'll present what happens after a DRM device resets in Linux, the challenges in the way to recover from resets, how to report what caused the reset in the first place and some proposals to improve the situation.

Speaker: André Almeida (Igalia)

GPU_Resets_XDC_2023.pdf

15:15 Defense in Depth: Isolating mesa from the kernel

In the context of a web browser, GL and Vulkan drivers are exposed to hostile content, in the form of webgl and webgpu. In the case of Vulkan, the spec explicitly declares that invalid usage is undefined behavior. But even for a GL driver it isn't so hard to find a way to trigger a potentially exploitable crash. The browser can sandbox the usermode gl/vk driver (UMD) into it's own process with limited privileges. But the UMD still needs access the drm kernel driver (KMD).

Or does it? Building on, and re-using, the drm native-context approach for running native UMD in a VM guest, tunneling the interface to host KMD over virtgpu, we can split kernel access into a hardened helper process with minimal performance penalty. In this way, if (when) an attacker achieves code execution in the UMD, they do not have a clear path to chain that exploit with a kernel bug to achieve code execution in the kernel.

Speaker: Rob Clark (Google)

Defense in Depth: Isolating mesa from the kernel.pdf

15:35 Break

16:00 Xen based GPU virtualization - VirtIO/Passthrough

Xen is one of the most popular hypervisors in the world, however, the GPU virtualization on Xen is currently lacking in quite a few areas. VirtIO GPU is widely used on KVM, but less so on Xen and a number of features, including vulkan, are not currently functional in a guest VM.
To address this, we are working to have more complete graphics and multimedia support on Xen. Earlier this year, we started pushing out the first patches[1] to support venus, passthrough gpu, and virgl video on Xen + QEMU, and were invited to present it at the Xen summit [2][3] in June. We have continued improving Xen support for GPUs, adding new functionality like dGPU PRIME (Passthrough GPU rendering + VirtIO GPU display in one guest VM), and introducing virtio native context which is a more straightforward and performant way to use native drivers instead of virgl/venus in a guest VM.
This talk will provide an overview of AMDs experiences enabling GPU virtualization on Xen based platforms.

Reference:
[1] https://www.phoronix.com/news/AMD-GPU-Better-Xen
[2] https://xen2023.sched.com/event/1LKln
[3] https://www.phoronix.com/news/AMD-Xen-GPU-For-Cars
[4] https://www.phoronix.com/news/AMD-GPU-Xen-Hypervisor-S3
[5] https://lore.kernel.org/lkml/20230312120157.452859-1-ray.huang@amd.com/
[6] https://lore.kernel.org/xen-devel/20230312075455.450187-1-ray.huang@amd.com/
[7] https://lore.kernel.org/qemu-devel/20230312092244.451465-1-ray.huang@amd.com/
[8] https://gitlab.freedesktop.org/virgl/virglrenderer/-/merge_requests/1068
[9] https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/22108
[10] https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/23680

Speaker: Ray Huang (AMD)

Steam game (vulkan) demo with VirtIO GPU on Xen Guest

Xen_Based_GPU_Virtualization_VirtIO_Passthrough_XDC2023.pdf

16:25 Linux DRM Bridge: A Potential Replacer for the DRM Encoder to Standardise a Single API?

Display and graphic drivers in Linux are part of the Linux DRM subsystem and are using DRM resources like memory management, interrupt handling, and DMA via Kernel Mode Settings (KMS) that act as an abstraction layer to provide uniform access to applications.

Encoders are one of the key KMS components that takes pixel data from a CRTC and converts it to a format suitable for an attached connector. Early Linux-4.0 encoders play a crucial role in connecting display hardware attributes to KMS however, for new-age display solutions like Bridges, Converters, and Switches it becomes hard for the encoder to handle these topologies in order to support various functionalities.

Linux-v4.0 has introduced a DRM bridge, a linear link structure of objects always attached to a single encoder at a time and connected directly or chain of bridges to the connector of a given KMS pipeline. Supporting bridge chains to new-age display solutions will end up an encoder becoming a dumb encoder without any operations limited.

This progressive change of moving the DRM drivers from the encoder to the bridge will standardize the single API, So it becomes simple and clear for implementing a drm drivers for new-age display solutions without touching the existing KMS pipeline.

This talk explains how the conversion of the encoder to bridge has been done by considering real-time solutions submitted to Mainline Linux on Samsung DSIM IP with a conclusion that are encoders replaced or removed from the drm stack?

Speaker: Jagan Teki (U-Boot Allwinner, SPI, SPI Flash Maintainer, Linux DRM Bridge Contributor and Maintainer, AI/Ml-enthusiast)

XDC2023 - Linux DRM Bridge A Potential Replacer for the DRM Encoder to Standardise a Single API.pdf

16:50 Board of Directors Meeting

14:25 → 16:25 Workshop: Workshops

14:25 CI workshop: Set up your bare-metal test farm in under 2h

In this workshop, we would like to demonstrate how to set up a CI system at home!

We will provide deployment examples and the necessary hardware to experiment with it:

• amd64- or arm64-based CI gateway
• Power cutting and monitoring using wireless smart plugs
• arm64 test machines
• serial consoles

Attendees should be able to deploy a CI system within 30 minutes.

Feel free to bring your own hardware, if you need help with that :)

Workshop instructions: https://docs.google.com/document/d/1bhiAWPQ70wkGCfsNd-YAafchJhBMkEl-O4gMtCB28jk/edit

Speakers: Martin Roukala (né Peres) (MuPuF TMI / Valve contractor) , Eric Engestrom (Igalia / Mesa)

Thursday, 19 October

09:00 → 16:00 Main Track

09:00 Thursday Opening Session

Speaker: Samuel Iglesias Gonsálvez (Igalia)

09:15 With great power comes less responsibility

Modern GPUs and modern graphics APIs leave less and less responsibilities to kernel GPU drivers, moving those to some firmware or to the usermode driver.

Throughout this presentation we will detail some of the aspects that make recently submitted DRM drivers different from what we had previously, and why things are structured like that. We will also give clues about what modern drivers should look like and the APIs that are being added or extended to facilitate their development, all of this being backed by some examples gathered from the two GPU drivers we were involved in:

• Panthor (formerly known as PanCSF), which is adding support for the second iteration of Mali Valhall GPUs
• PowerVR, which is adding support for Series 6XT and Series A Imagination GPUs

Speakers: Boris Brezillon (Collabora) , Danilo Krummrich (Red Hat)

with-great-power-comes-less-responsibility.pdf

10:05 DRM MSM Display and Graphics Update

DRM MSM display and graphics driver has evolved quite a bit over the years both in terms of feature set , chipsets supported and also complexity.

This talk will focus broadly on the historical context , achievements, current IGT CI based workflow, IGT bug fixes/enhancements which were done for MSM, feature and chipset roadmap (both current and near future) for display and graphics drivers.

Speakers: Abhinav Kumar (Qualcomm Innovation Center) , Dmitry Baryshkov (Linaro) , Rob Clark (Google)

XDC2023 DRM MSM Display and Graphics Update-1.pdf

10:50 Break

11:20 etnaviv: status update

This talk will discuss various on-going efforts in the etnaviv driver stack.

Expanding the board farm

Having a good CI coverage on different GPUs is crucial if we want to catch regressions before they are introduced into the codebase. I will present the current state of the CI board farm used to archive this job.

Road towards OpenGL ES 3.0

More recent GPU models from VeriSilicon/Vivante support OpenGL ES 3.x more or less in pure hardware. I will discuss the steps need to be taken to bring etnaviv to the next level and enable support for this newer OpenGL ES version.

Legacy model love

This section acknowledges the continued support for older GPU models and their ability to gain new features. We will have a brief look what clever software/shader tricks we could use to help us out.

Speaker: Christian Gmeiner

etnaviv_status_update.pdf

11:45 Debugging GPU faults: QoL tools for your driver

GPU faults aren't easy to debug and half of the time near the end you think "What if I was able to quickly edit this GPU packet", "What if I was able to dump GPU memory here?", "It would have been nice to print that shader register!".

Finally I caved in and spent time implementing these little improvements for Turnip driver. Was it worth it? Spoiler: Yes!

In this talk I'll show unsophisticated tools that were written for Turnip which greatly improved the debugging workflow and could be implemented in other drivers.

Speaker: Danylo Piliaiev (Igalia S.L.)

xdc-2023-danylo-piliaiev-debugging-gpu-faults.pdf

12:35 Wayland Shells for Embedded Systems

Many embedded Linux systems that feature a display, nowadays, use a Wayland compositor as the base for the GUI. Using standard desktop technology simplifies application development and increases consistency across products. However, as a significant difference to desktops, the system developer – not the user – decides how to arrange the surfaces on the screen.

Various Wayland compositors and shells address the embedded use case in different ways and with varying complexity: The Weston kiosk-shell, cage, the agl-compositor, the Weston IVI-shell, and phosh are just a few examples. Each shell comes with its own set of hard-coded assumptions, and the trade-offs and suitability for a certain use case may not be obvious at a first glance. Often, developers end up forking the compositor and hacking the shell until it fits the use case, causing an additional maintenance burden and further fragmentation of the ecosystem.

I will give an overview of use cases and requirements of different GUIs in embedded systems, highlight the differences between the existing shells, and spark a discussion, how to improve the flexibility and reuse of Wayland shells for future embedded use cases.

Speaker: Michael Tretter (Pengutronix)

Slides

YouTube Stream

12:55 Lunch

14:00 Wayland driver for Wine: The story so far

The journey to implement a Wayland driver for Wine started a few years ago as an experiment with an uncertain future. Since then the experimental driver has grown to fully support a multitude of GDI and GPU accelerated applications and games and is now in the process of being upstreamed.

In this talk I will present the history of and future plans for the project. I will also discuss the challenges we faced in the development of the driver, many of which are rooted in the impedance mismatch between the Windows and Wayland worlds, and our current solutions (or workarounds) to these challenges.

Speaker: Alexandros Frantzis (Collabora)

Wayland driver for Wine: The story so far.pdf

14:50 Wine & Windowing - An Impedance Mismatch

One of the biggest challenges to have a good experience running Windows software on Linux via Wine (and the various downstreams, including Proton) is windowing. Win32 API is very unlike what we have on X or Wayland.

Displaying and having a window behave correctly when alt+tabbing, etc. is hard to get right and the whole area is quite brittle.

I'm going to present challenges we are facing and how hacky some of solutions are. I hope to spark a discussion on how we can do things better and if we can cater to some of those needs on the X / Wayland side.

Speaker: Arkadiusz Hiler (CodeWeavers)

wine_windowing_ogv.pdf

15:15 State of the X.Org Foundation

State of the X.Org Foundation

Speaker: Daniel Vetter (Intel)

xorg-state-2023.pdf

15:30 Break

16:00 → 17:20 Lightning Talks II: Lightning Talks

16:00 To crash or not to crash: if you do, at least recover fast!

What could be possibly worse that an almost unbeatable boss in a game or a tough maze that consume hours of gameplay with not much progress? How about a Linux kernel crash that makes you lose all the game progress with no apparent reason or feedback?

Though rare, it is a real possibility that would make gamers quite annoyed, given that Linux is used more and more as a platform for playing games.
Some technologies are available to collect logs and feedback the user in case such disastrous events happen, mostly related with kernel crashes handling mechanisms. The main ones available are kdump and pstore, but still there are work to be done in this area...

In this talk we're going to present the basics about kernel crash handling, like how a kernel panic might happen, how to deal with that (with an overall discussion about kdump and pstore techs) and the kdumpst tool, developed specially to deal with this situation on Steam Deck (and generically on Arch Linux); also we're gonna discuss some missing pieces / ideas to make it even less likely gamers need to complain that their device just got hang for no reason!

Speaker: Guilherme G. Piccoli (Igalia)

to_crash_or_not_lightening.pdf

16:05 dGPU prime on VM

The dGPU prime feature allows an integrated GPU (iGPU) to display output data rendered by a discrete GPU(dGPU). This is a collection of features in the Linux kernel[1], mesa[2] and various drivers under Linux system. The dGPU exports it's render buffer to iGPU so that iGPU can display it. This allows switching between iGPU and dGPU to handle more use cases requiring different levels of performance. Usually on bare metal, iGPU and dGPU would use native drivers that support dma-buf operations so this feature works fine. But on XEN guest VM, the iGPU is using the virtio-gpu driver and the passthrough dGPU is using a native driver, so the iGPU cannot import the output data that rendered by the passthrough dGPU directly. This talk introduces our design and implementation of the dGPU prime feature on XEN guest VMs.It creates the display buffer on the iGPU and lets the passthrough dGPU import it as linear buffer and blit the rendered data to it for display. With this, we can now run applications which require high performance on the passthrough dGPU and display on the iGPU in a XEN guest VM.

References:
[1] https://lore.kernel.org/dri-devel/20230705035622.2841499-1-julia.zhang@amd.com/
[2] https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/23896

Speaker: Julia Zhang

dGPU prime on XEN.pdf

16:10 Enabling Solid Fill Planes

The Qualcomm display pipeline accepts solid color as a valid input for DRM planes.

This talk will introduce the background, use cases and benefits of solid fill planes. In addition, it will give an overview of a proposal to enable solid fill planes by introducing core DRM framework changes.

Speakers: Jessica Zhang (Qualcomm) , Abhinav Kumar

003-20231017-jessica-zhang-solid-fill-lightning-talk.pdf

16:15 Status of the Vulkan Video ecosystem

The Vulkan Video extension has been in development since 2018, with the intention of exposing video codec blocks as a new acceleration API. AVC and HEVC are shipping with good support for decode, and nascent encode support. AV1 and VP9 are in the works.

While several APIs exist amid the convenience/control/portability tradeoff, the Vulkan extension exposes a much greater level of fine-grained control, portability and tight-integration that none of the existing solutions offer, at the expense of convenience.

In this talk we will very briefly explore the API, cover the recent developments of the extension, and discuss plans for future work. This talk will provide background information for anyone interested in integrating codec acceleration within their application.

Speaker: Charles Turner (Igalia)

Status of the Vulkan Video ecosystem.pdf

16:20 v3dv: experience using gfxreconstruct/apitrace traces for performance evaluation

In addition to increasing the feature range and stability, the v3d/v3dv team has been continuously working on improving the performance of both drivers.

One of the tools used to check if a change would provide a performance gain/penalty, were to run several gfxreconstruc/apitrace traces, with and without such change, and compare the outcome of both runs.

This presentation will summarize our experience with this approach, and their pros and cons.

Speaker: Mr Alejandro Piñeiro Iglesias (Graphics Team, Igalia)

v3dv-lightning-talk-xdc-2023.pdf

16:30 The case for an "icon" protocol

Migrating to Wayland also means to bid farewell to X11 Window Manager features that were popular in a few niches. Among them: The ability to set WM hints for an icon window.

This talk will present a brief recap on what this feature was used for, sketch a proposal for a Wayland protocol for this use-case. Including a short demonstration of a prototype implementation in protocol and compositor.

Speaker: Mr Philipp Kaeser (Google)

007-The case for an icon protocol - Philipp Kaeser.pdf

16:35 Stop merging regressions - The Marge workflow

A regression is reported, but it is working for you, developers are always -EBUSY and it feels the technical debts just increases. In the open-source world it is hard to get usage data back from users to choose which bug to prioritize. Also, other developers are worried about their use cases and they don't care much if they broke yours (or maybe they just don't have the hardware to test it). Annoying, isn't it?

In this talk we will check the benefits of pre-merge tests, what Marge bot is and how the Marge workflow is working well with Mesa3D project, avoiding regressions to even being accepted and increasing your confidence to the community.

Speaker: Helen Koike (Collabora)

16:40 Focus on exciting development, delegate tedious dependencies update

Whoops! There is a reminder to check your project's dependencies and update the revisions used. Oof, again we need to deal with job failures caused by changes made long ago. You tell yourself it's something you should do more often, but monitoring those dependencies is tedious.

Continuous Integration is here to help us during development. We have automated the testing process, so we can handle a test-driven design. But still, some tasks interrupt the genuine challenges that need to be solved.

We would like to propose to you a solution to do this automatically: it is called ci-uprev. It can generate a proposal merge request when a new revision of the dependency can be used. If there are further problems than the updated expectations, it can generate an issue with the information. The information is fresh and comes from recent changes, so the people around still remember why they were required.

But what if there is some information in the jobs pipeline that you have to browse individually? Uprev also needed that functionality so we created a tool called ci-collate. It allows you to define which jobs are interesting for you, and generates a JSON structure detailing what all those jobs have.

A practical application for this is the "nightly runs", where we do more extensive tests in Mesa than what we can do in the "pre-merge". If there are some expectations to update, you can have a patch (or even a merge request) based on the results of your pipeline. Get it automatically; you can use cron or launch it from your console.

Speaker: Sergi Blanch Torné (Collabora)

ci-uprev.pdf

16:45 Being a Mesa release maintainer

Quick presentation of what being a Mesa release maintainer entails, with a call for volunteers to reach out.

Speaker: Eric Engestrom (Igalia / Mesa)

Being a Mesa release maintainer

16:50 Vivante NPU driver

Quick summary of the current status and plans for the future, for this and for similar IP.

Speaker: Tomeu Vizoso (Independent contractor)

XDC_2023_TV.odp

16:55 The WayLand Conformance Suite (WLCS)

A collection of integration tests designed to ensure compositors' adherence to, and agreement on the interpretation of, the Wayland protocol and extensions.

Speaker: Michał Sawicz (Canonical)

WLCS Lightning talk - XDC 2023.pdf

17:00 KMS Color Workshop Report

I brief summary of the discussions that happened in the KMS Color Management Workshop.

Speaker: Melissa Wen (Igalia)

XDC 2023 - KMS Color Management Workshop Report.pdf

XDC 2023 - KMS Color Management Workshop Report_updated_participants.pdf

17:05 Road to HDR10 on ChromeOS

Currently CrOS supports a custom format for HDR content. While this works well enough, HDR10 support is ideal for the increasing HDR content on the web.

Speaker: Sasha McIntosh (Google)

sashamcintosh@ XDC 2023 (2).pdf

17:10 Optimizing testing workflow with ci_run_n_monitor

Stop using mouse. Use power of command line with FDO GitLab CI.

Speaker: David Heidelberg

17:15 XDC2023 - CI workshop

Feedback on the CI workshop: the plan, reality, and discussions

Speaker: Martin Roukala (né Peres) (MuPuF TMI / Valve contractor)

XDC 2023 - CI workshop.pdf

17:20 → 17:35 Main Track: Closing Session

17:20 Closing Session

Speaker: Samuel Iglesias Gonsálvez (Igalia)