Chaos Computer Club - archive feed

Due to its nature, the display stack can be hard to test. Indeed, the component we want to test often sends the pixels to an external display without any way to retrieve the image being output, let alone make sure it's correct.

And while a human can perform some of those tests by looking at the screen, some issues can prove to be difficult to spot, such as colours being slightly off or pixels being offset. More complex tests can also be tedious to set up or hard to trigger.

The ecosystem of devices that Linux supports also adds further constraints on the display interfaces we want to test, but also on the system size, the tools available, the connectivity of the device, etc.

In this talk, we will first discuss the constraints and what makes testing the display stack unique. We will then talk about the existing solutions, their limitations, and what we have been working on to improve the situation.

about this event: https://c3voc.de

I'm going to present a summary of the last 10 years or so of participating to the moderation and animation of the xorg-security@ mailing lists.

This is an opportunity for people interested in taking over this responsibility to have an insight of the kind of issues that are submitted and how we've been dealing with them.

about this event: https://c3voc.de

Modern applications in areas like Machine Learning, Artificial Intelligence, and 3D Graphics, require a synergistic software/hardware ecosystem that allow developers to take full advantage of hardware accelerators. In this scenario, it is critical to have a low-level API that can easily support and adapt to any device, in order to minimize the impact in upper-levels of the software stack when exposing novel hardware capabilities to higher-level programming models and frameworks.

Level-Zero API, part of Intel OneAPI product, defines a device-independent, vendor-agnostic, low-level, direct-to-metal interface to accelerator devices that abstracts users and upper-level components of the software stack from the specifics of the target devices, while providing them with the access needed to fully exploit their hardware capabilities. This is essential for Intel to expose new hardware features at a faster pace and to effectively compete against established CUDA-based ecosystem from NVIDIA.

This presentation offers an overview of the rich set of interfaces defined in Level-Zero, focusing on capabilities such as unified-shared memory, peer-to-peer communication, and inter-process communication. Additionally, the status of the implementation of Level-Zero and its adoption by higher-level compiler, analysis tools, performance libraries and other frameworks are presented.

about this event: https://c3voc.de

We talk about a new programming interface “Sysman” which is part of level zero library.

Sysman (System Resource Management) is used to monitor and control the power, frequency, temperature etc , of accelerator devices.

Sysman is an API that will,

• Enable HPC (High Performance Compute) GPU servers to optimize/track power, temperature ,utilization, memory bandwidth & scheduling of Intel discrete graphics cards for the kind of workloads that run in those environments.

• Provide system level monitoring of important telemetry like power, frequencies, temperature and updating the firmwares

• Be integrated as part of OneAPI Level0 with hooks into the Level Zero UMD driver.

about this event: https://c3voc.de

After the talk "SSA-based Register Allocation for GPU Architectures", this workshop will be for people considering implementing SSA-based register allocation or wanting to understand the ACO and Freedreno implementations. We can also go more in-depth with different strategies and heuristics used to optimize the register allocation problem, if there is interest.

about this event: https://c3voc.de

This talk presents an overview of the KWinFT project in 2021. The following topics will be discussed:

- original motives for founding the KWinFT project,

- recap of previous developments in 2020,

- overview of current developments,

- project organisation and scaling,

- embedding in the ecosystem: long-term plan for KWinFT as a C++ library collection for the creation of feature-rich Wayland (and X11) compositors.

about this event: https://c3voc.de

At last year's XDC, Jason gave an overview of the VK_KHR_ray_tracing extensions and how they can be used to implement a ray-tracing render from a client POV. In this talk, Jason will discuss the implementation of those extensions in Intel's Linux Vulkan driver. We'll cover over-all architecture as well as detailed topics such as bindless thread dispatch on Intel HW, Shader call/return lowering, and BVH building with OpenCL kernels. Watching last year's talk as preparation is highly recommended.

about this event: https://c3voc.de

Broken and flickering geometry, corrupted textures, and even hangs in real-world games and apps are common issues in open-source graphics driver development. While conformance tests are mostly narrow and confined, finding driver problems when running triple-A games can be a challenging task.

This talk will show a major misrendering example when running a game and the steps taken to pinpoint the underlying problem in shader compilation using RenderDoc. We will briefly touch the taxonomy of different issues, typical causes, and generic methods to try.

about this event: https://c3voc.de

Ever wondered what happens when you mix Emscripten, Graphviz, and a Vulkan driver? I couldn’t help myself and tried: What started as a simple visualizer for shader control flow has since grown into a port of Mesa’s shader compiler ACO running in the browser, capable of compiling thousands of shaders on-the-fly. Don’t believe it? Demo included!

Putting this experiment into wider context reveals a landscape of powerful debugging tools rarely utilized in low-level programming: With robust and efficient code left at the core, external web-based tools benefit from quicker iteration cycles and easier UI prototyping.

This talk doesn’t present ground-breaking ideas: At worst, you’ll see a cool tool made with love. At best, you’ll walk away with new ideas for creating debuggable systems.

about this event: https://c3voc.de

With the ever-increasing focus on testing found in our community, let's try to coordinate the efforts of every individual.

The main focus for this workgroup will be two-fold:

- Ramp up the trace-based testing in Mesa CI / DXVK / ...

- Bring kernel testing to more drivers than i915

Please ping mupuf on IRC on OFTC's #freedesktop to add additional topics or show interest in one.

about this event: https://c3voc.de