Feed aggregator

Java-Sound-on-Linux

Keith Packard -

Java Sound on Linux

I’m often in the position of having my favorite Java program (AltosUI) unable to make any sounds. Here’s a history of the various adventures I’ve had.

Java and PulseAudio ALSA support

When we started playing with Java a few years ago, we discovered that if PulseAudio were enabled, Java wouldn’t make any sound. Presumably, that was because the ALSA emulation layer offered by PulseAudio wasn’t capable of supporting Java.

The fix for that was to make sure pulseaudio would never run. That’s harder than it seems; pulseaudio is like the living dead; rising from the grave every time you kill it. As it’s nearly impossible to install any desktop applications without gaining a bogus dependency on pulseaudio, the solution that works best is to make sure dpkg never manages to actually install the program with dpkg-divert:

# dpkg-divert --rename /usr/bin/pulseaudio

With this in place, Java was a happy camper for a long time.

Java and PulseAudio Native support

More recently, Java has apparently gained some native PulseAudio support in some fashion. Of course, I couldn’t actually get it to work, even after running the PulseAudio daemon but some kind Debian developer decided that sound should be broken by default for all Java applications and selected the PulseAudio back-end in the Java audio configuration file.

Fixing that involved learning about said Java audio configuration file and then applying patch to revert the Debian packaging damage.

$ cat /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/sound.properties ... #javax.sound.sampled.Clip=org.classpath.icedtea.pulseaudio.PulseAudioMixerProvider #javax.sound.sampled.Port=org.classpath.icedtea.pulseaudio.PulseAudioMixerProvider #javax.sound.sampled.SourceDataLine=org.classpath.icedtea.pulseaudio.PulseAudioMixerProvider #javax.sound.sampled.TargetDataLine=org.classpath.icedtea.pulseaudio.PulseAudioMixerProvider javax.sound.sampled.Clip=com.sun.media.sound.DirectAudioDeviceProvider javax.sound.sampled.Port=com.sun.media.sound.PortMixerProvider javax.sound.sampled.SourceDataLine=com.sun.media.sound.DirectAudioDeviceProvider javax.sound.sampled.TargetDataLine=com.sun.media.sound.DirectAudioDeviceProvider

You can see the PulseAudio mistakes at the top of that listing, with the corrected native interface settings at the bottom.

Java and single-open ALSA drivers

It used to be that ALSA drivers could support multiple applications having the device open at the same time. Those with hardware mixing would use that to merge the streams together; those without hardware mixing might do that in the kernel itself. While the latter is probably not a great plan, it did make ALSA a lot more friendly to users.

My new laptop is not friendly, and returns EBUSY when you try to open the PCM device more than once.

After downloading the jdk and alsa library sources, I figured out that Java was trying to open the PCM device multiple times when using the standard Java sound API in the simplest possible way. I thought I was going to have to fix Java, when I figured out that ALSA provides user-space mixing with the ‘dmix’ plugin. I enabled that on my machine and now all was well.

$ cat /etc/asound.conf pcm.!default { type plug slave.pcm "dmixer" } pcm.dmixer { type dmix ipc_key 1024 slave { pcm "hw:1,0" period_time 0 period_size 1024 buffer_size 4096 rate 44100 } bindings { 0 0 1 1 } } ctl.dmixer { type hw card 1 } ctl.!default { type hw card 1 }

As you can see, my sound card is not number 0, it’s number 1, so if your card is a different number, you’ll have to adapt as necessary.

Neat drm/i915 stuff for 3.15

Daniel Vetter -

So the release of the 3.14 linux kernel already happended and I'm a bit late for our regular look at what cool stuff will land in the 3.15 merge window for the Intel graphics driver.

The first big thing is Ben Widawsky's support for per-process address spaces. Since a long time we've already supported the per-process gtt page tables the hardware provides, but only with one address space. With Ben's work we can now manage multiple address spaces and switch between them, at least on Ivybridge and Haswell. Support for Baytrail and Broadwell for this feature is still in progress. This finally allows multiple different users to use the gpu concurrently without accidentally leaking information between applications. Unfortunately there have been a few issues with the code still so we had to disable this for 3.15 by default.

Another really big feature was the much more fine-grained display power domain handling and a lot of runtime power management infrastructure work from Imre and Paulo. Intel gfx hardware always had lots of automatic clock and power gating, but recent hardware started to have some explicit power domains which need to be managed by the driver. To do that we need to keep track of the power state of each domain, and if we need to switch something on we also need to restore the hardware state. On top of that every platform has it's own special set of power domains and how the logical pieces are split up between them also changes. To make this all manageable we now have an extensive set of display power domains and functions to handle them as abstraction between the core driver code and the platform specific power management backend. Also a lot of work has happened to allow us to reuse parts of our driver resume/suspend code for runtime power management. Unfortunately the patches merged into 3.15 are all just groundwork, new platforms and features will only be enabled in 3.16.

Another long-standing nuisance with our driver was the take-over from the firmware configuration. With the reworked modesetting infrastructure we could take over the output routing, and with the experimental i915.fastboot=1 option we could eschew the initial modeset. This release Jesse provided another piece of the puzzle by allowing the driver to inherit the firmware framebuffer. There's still more work to do to make fastboot solid and enable it by default, but we now have all the pieces in place for a smooth and fast boot-up.

There  have been tons of patches for Broadwell all over the place. And we still have some features which aren't yet fully enabled, so there will be lots more to come. Other smaller features in 3.15 are improved support for framebuffer compression from Ville, again more work still left. 5.4GHz DisplayPort support, which is a required to get 4k working. Unfortunately most 4k DP monitors seem to expose two separate screens and so need a adriver with working MST (multi-stream support) which we don't yet support. On that topic: The i915 driver now uses the generic DP aux helpers from Thierry Redding. Having shared code to handle all the communication with DP sinks should help a lot in getting MST off the ground. And finally I'd like to highlight the large cursor support, which should be especially useful for high-dpi screens.


And of course there's been fixes and small improvements all over the place, as usual.

2014Q1 Intel Graphics Stack has been released

Rodrigo Vivi -

The 2014Q1 highlights are: Baytrail critical fixes and improvements, power domain reworks, HDMI 4k and HDMI stereo 3D support.

On last release, Baytrail had a critical issue where eDP panels weren’t detected causing hard blank screens. This issue has been solved along with many other fixes. Also a preliminary support for MIPI DSI has been added.

The next platform codnamed Broadwell is yet on development but initial support has already landed on this release on 2D and Media drivers and on Kernel under prelimiminary_hw_support flag.

Components of this stack are:

Linux Kernel – 3.13.6 Mesa – 10.1 xf86-video-intel – 2.99.910 Libdrm – 2.4.52 Libva – 1.3.0 vaapi intel-driver – 1.3.0 Cairo – 1.12.16 Xserver Xorg – 1.15.0 Intel-gpu-tools – 1.6

For more details read the full release notes: https://01.org/linuxgraphics/downloads/2014/2014q1-intel-graphics-stack-release

glamor-core

Keith Packard -

Core Rendering with Glamor

I’ve hacked up the intel driver to bypass all of the UXA paths when Glamor is enabled so I’m currently running an X server that uses only Glamor for all rendering. There are still too many fall backs, and performance for some operations is not what I’d like, but it’s entirely usable. It supports DRI3, so I even have GL applications running.

Core Rendering Status

I’ve continued to focus on getting the core X protocol rendering operations complete and correct; those remain a critical part of many X applications and are a poor match for GL. At this point, I’ve got accelerated versions of the basic spans functions, filled rectangles, text and copies.

GL and Scrolling

OpenGL has been on a many-year vendetta against one of the most common 2D accelerated operations — copying data within the same object, even when that operation overlaps itself. This used to be the most performance-critical operation in X; it was used for scrolling your terminal windows and when moving windows around on the screen.

Reviewing the OpenGL 3.x spec, Eric and I both read the glCopyPixels specification as clearly requiring correct semantics for overlapping copy operations — it says that the operation must be equivalent to reading the pixels and then writing the pixels. My CopyArea acceleration thus uses this path for the self-copy case. However, the ARB decided that having a well defined blt operation was too nice to the users, so the current 4.4 specification adds explicit language to assert that this is not well defined anymore (even in the face of the existing language which is pretty darn unambiguous).

I suspect we’ll end up creating an extension that offers what we need here; applications are unlikely to stop scrolling stuff around, and GPUs (at least Intel) will continue to do what we want. This is the kind of thing that makes GL maddening for 2D graphics — the GPU does what we want, and the GL doesn’t let us get at it.

For implementations not capable of supporting the required semantic, someone will presumably need to write code that creates a temporary copy of the data.

PBOs for fall backs

For operations which Glamor can’t manage, we need to fall back to using a software solution. Direct-to-hardware acceleration architectures do this by simply mapping the underlying GPU object to the CPU. GL doesn’t provide this access, and it’s probably a good thing as such access needs to be carefully synchronized with GPU access, and attempting to access tiled GPU objects with the CPU require either piles of CPU code to ‘de-tile’ accesses (ala wfb), or special hardware detilers (like the Intel GTT).

However, GL does provide a fairly nice abstraction called pixel buffer objects (PBOs) which work to speed access to GPU data from the CPU.

The fallback code allocates a PBO for each relevant X drawable, asks GL to copy pixels in, and then calls fb, with the drawable now referencing the temporary buffer. On the way back out, any potentially modified pixels are copied back through GL and the PBOs are freed.

This turns out to be dramatically faster than malloc’ing temporary buffers as it allows the GL to allocate memory that it likes, and for it to manage the data upload and buffer destruction asynchronously.

Because X pixmaps can contain many X windows (the root pixmap being the most obvious example), they are often significantly larger than the actual rendering target area. As an optimization, the code only copies data from the relevant area of the pixmap, saving considerable time as a result. There’s even an interface which further restricts that to a subset of the target drawable which the Composite function uses.

Using Scissoring for Clipping

The GL scissor operation provides a single clipping rectangle. X provides a list of rectangles to clip to. There are two obvious ways to perform clipping here — either perform all clipping in software, or hand each X clipping rectangle in turn to GL and re-execute the entire rendering operation for each rectangle.

You’d think that the former plan would be the obvious choice; clearly re-executing the entire rendering operation potentially many times is going to take a lot of time in the GPU.

However, the reality is that most X drawing occurs under a single clipping rectangle. Accelerating this common case by using the hardware clipper provides enough benefit that we definitely want to use it when it works. We could duplicate all of the rendering paths and perform CPU-based clipping when the number of rectangles was above some threshold, but the additional code complexity isn’t obviously worth the effort, given how infrequently it will be used. So I haven’t bothered. Most operations look like this:

Allocate VBO space for data Fill VBO with X primitives loop over clip rects { glScissor() glDrawArrays() }

This obviously out-sources as much of the problem as possible to the GL library, reducing the CPU time spent in glamor to a minimum.

A Peek at Some Code

With all of these changes in place, drawing something like a list of rectangles becomes a fairly simple piece of code:

First, make sure the program we want to use is available and can be used with our GC configuration:

prog = glamor_use_program_fill(pixmap, gc, &glamor_priv->poly_fill_rect_program, &glamor_facet_polyfillrect); if (!prog) goto bail_ctx;

Next, allocate the VBO space and copy all of the X data into it. Note that the data transfer is simply ‘memcpy’ here — that’s because we break the X objects apart in the vertex shader using instancing, avoiding the CPU overhead of computing four corner coordinates.

/* Set up the vertex buffers for the points */ v = glamor_get_vbo_space(drawable->pScreen, nrect * (4 * sizeof (GLshort)), &vbo_offset); glEnableVertexAttribArray(GLAMOR_VERTEX_POS); glVertexAttribDivisor(GLAMOR_VERTEX_POS, 1); glVertexAttribPointer(GLAMOR_VERTEX_POS, 4, GL_SHORT, GL_FALSE, 4 * sizeof (GLshort), vbo_offset); memcpy(v, prect, nrect * sizeof (xRectangle)); glamor_put_vbo_space(screen);

Finally, loop over the pixmap tile fragments, and then over the clip list, selecting the drawing target and painting the rectangles:

glEnable(GL_SCISSOR_TEST); glamor_pixmap_loop(pixmap_priv, box_x, box_y) { int nbox = RegionNumRects(gc->pCompositeClip); BoxPtr box = RegionRects(gc->pCompositeClip); glamor_set_destination_drawable(drawable, box_x, box_y, TRUE, FALSE, prog->matrix_uniform, &off_x, &off_y); while (nbox--) { glScissor(box->x1 + off_x, box->y1 + off_y, box->x2 - box->x1, box->y2 - box->y1); box++; glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4, nrect); } } GL texture size limits

X pixmaps use 16 bit dimensions for width and height, allowing them to be up to 65536 x 65536 pixels. Because the X coordinate space is signed, only a quarter of this space is actually useful, which makes the useful size of X pixmaps only 32767 x 32767. This is still larger than most GL implementations offer as a maximum texture size though, and while it would be nice to just say ‘we don’t allow pixmaps larger than GL textures’, the reality is that many applications expect to be able to allocate such pixmaps today, largely to hold the ever increasing size of digital photographs.

Glamor has always supported large X pixmaps; it does this by splitting them up into tiles, each of which is no larger than the largest texture supported by the driver. What I’ve added to Glamor is some simple macros that walk over the array of tiles, making it easy for the rendering code to support large pixmaps without needing any special case code.

Glamor also had some simple testing support — you can compile the code to ignore the system-provided maximum texture size and supply your own value. This code had gone stale, and couldn’t work as there were parts of the code for which tiling support just doesn’t make sense, like the glyph cache, or the X scanout buffer. I fixed things so that you could leave those special cases as solitary large tiles while breaking up all other pixmaps into tiles no larger than 32 pixels square.

I hope to remove the single-tile case and leave the code supporting only the multiple-tile case; we have to have the latter code, and so having the single-tile code around simply increases our code size for not obvious benefit.

Getting accelerated copies between tiled pixmaps added a new coordinate system to the mix and took a few hours of fussing until it was working.

Rebasing Many (many) Times

I’m sure most of us remember the days before git; changes were often monolithic, and the notion of changing how the changes were made for the sake of clarity never occurred to anyone. It used to be that the final code was the only interesting artifact; how you got there didn’t matter to anyone. Things are different today; I probably spend a third of my development time communicating how the code should change with other developers by changing the sequence of patches that are to be applied.

In the case of Glamor, I’ve now got a set of 28 patches. The first few are fixes outside of the glamor tree that make the rest of the server work better. Then there are a few general glamor infrastructure additions. After that, each core operation is replaced, one a at a time. Finally, a bit of stale code is removed. By sequencing things in a logical fashion, I hope to make review of the code easier, which should mean that people will spend less time trying to figure out what I did and be able to spend more time figuring out if what I did is reasonable and correct.

Supporting Older Versions of GL

All of the new code uses vertex instancing to move coordinate computation from the CPU to the GPU. I’m also pulling textures apart using integer operations. Right now, we should correctly fall back to software for older hardware, but it would probably be nicer to just fall back to simpler GL instead. Unless everyone decides to go buy hardware with new enough GL driver support, someone is going to need to write simplified code paths for glamor.

If you’ve got such hardware, and are interested in making it work well, please take this as an opportunity to help yourself and others.

Near-term Glamor Goals

I’m pretty sure we’ll have the code in good enough shape to merge before the window closes for X server 1.16. Eric is in charge of the glamor tree, so it’s up to him when stuff is pulled in. He and Markus Wick have also been generating code and reviewing stuff, but we could always use additional testing and review to make the code as good as possible before the merge window closes.

Markus has expressed an interest in working on Glamor as a part of the X.org summer of code this year; there’s clearly plenty of work to do here, Eric and I haven’t touched the render acceleration stuff at all, and that code could definitely use some updating to use more modern GL features.

If that works as well as the core rendering code changes, then we can look forward to a Glamor which offers GPU-limited performance for classic X applications, without requiring GPU-specific drivers for every generation of every chip.

Eating my own dogfood – dynamic page table allocations

Ben Widawsky -

I don’t know if I’ve ever eaten my own dogfood that smells this risky.

A few days ago, I published patches to support dynamic page table allocation and tear-down in the i915 driver http://lists.freedesktop.org/archives/intel-gfx/2014-March/041814.html. This work will eventually help us support expanded page tables (similar to how things work for normal Linux page tables). The patches rely on using full PPGTT support, which still requires some work to get enabled by default. As a result, I’ll be carrying around this work for quite a while. The patches provide a lot of opportunity to uncover all sorts of weird bugs we’ve never seen due to the more stressful usage of the GPU’s TLBs. To avoid the patches getting too stale, and to further the bug extermination, I’ve figured, why not run it myself?

If you feel like some serious pain, or just want to help me debug it, give it a go – there should be absolutely no visible gain for you, only harm. You can either grab the patches from the mailing list, patchwork, or my branch.  Make sure to turn on full PPGTT support with i915.enable_ppgtt=2. If you do decide to opt for the pain, you can take comfort in the fact that you’re helping get the next big piece of prep work in place.

The question is, how long before I get sick of this terrible dogfood? I’m thinking by Monday I’ll be finished

[ANNOUNCE] intel-gpu-tools 1.6

Rodrigo Vivi -

Here goes a new i-g-t quarterly release with the following changes:

- Changes to support Broadwell in the test suite. (Ben, Damien, et al.)

- Updated (now working again!) Android support from Oscar Mateo.

- Test coverage through i-g-t is now officially an integral part of any drm/i915
feature work and also for bugfixes. For more details see:

http://blog.ffwll.ch/2013/11/testing-requirements-for-drmi915.html

- Fix the gen4asm build depency handling, now that the assembler is included in
i-g-t (Ben).

- Improve the cairo object lifetime management of the kmstest helpers (Chris).

- Allow register access to succeed if i915 is loaded but debugfs isn’t found
(i.e. nomodeset is used)

- New kernel modesetting helper library for simpler testcases (Damien).

- New structure logging support for tests. Message at the WARN level be
reflected in the piglit result, also included igt_warn_on macros to simplify
test asserts which should just result in warnings, but not in a test abort.

- Broadwell support for intel_audio_dump (Mengdong Lin).

- API documentation support (Thomas)

Complete list:

Ben Widawsky (52):
chipset: IS_I9XX macro
pciid/bdw: Add Broadwell PCI ids
bdw: Update obvious missing blit support
tests/bdw: gem_exec_faulting_reloc
tests/bdw: gem_cpu_reloc
tests/bdw: gem_evict_*
tests/bdw: gem_exec_blt
tests/bdw: gem_pin
tests/bdw: gem_linear_blits
tests/bdw: pwrite_pread
tests/bdw: Port storedw_loop_vebox to gen8
assembler/bdw: Small cleanup
quick_dump/bdw: Just basic stuff for now
NEWS: Broadwell
NEWS: Broadwell will be in 1.6, not 1.5
NEWS: Restore the 1.4 release info
gem_storedw_batches_loop: Update for gen8
gem_evict_everything: Fix broken blit generalization
gem_evict_alignment: Skip on GEN8 for now
gem_cpu_reloc: Fixed botched BLIT conversion
gem_linear_blits: Fix blit command length
gem_storedw_batches_loop: Fix for real this time
gem_evict_*: Fix batch lengths, broken on gen8 integration
gem_cs_prefetch: more gen8 integration fallout
gem_pipe_control_store_loop: BDW update
drm_vma_limiter_cached: Missed gen8 BLT updates
gem_write_read_ring_switch: Missed gen8 BLT updates
gem_persistent_relocs: Update for gen8 BLT cmds
gem_reloc_vs_gpu: Update for gen8 BLT cmds
Kill XY_COLOR_BLT_CMD
gen8 rendercpy: temporarily disable
gem_exec_faulting_reloc: Update gen8 BLT cmds
intel-gpu-tools: Version information
shader-debugger: Use in tree gen4asm
gem_exec_blit: gen8 updates for blit
configure.ac: Remove GEN4ASM define
configure.ac: Fixup conditional shader debugger
configure.ac: Fix shader debugger for real
gem_storedw_batches_loop: Fix for BDW
.gitignore: Add pycache
quick_dump: Fix the indentation
quick_dump: Allow comments in the register files
quick_dump/hsw: Watermark debug
quick_dump/broadwell: Use haswell_other
quick_dump/watermarks: lp3, misc and debug
gem_storedw_batches_loop: Fix for pre-BDW
quick_dump: Refactor to allow future code
quick_dump: Add a file argument
quick_dump/gen7: Add other GFX_MODE registers
quick_dump/haswell: Add gen7 stuff + VECS_MODE
quick_dump/broadwell: Add gen7 ring mode registers
quick_dump: Add missed broadwell autodetect

Chon Ming Lee (2):
tools/quick_dump: Update Baytrail DPIO names to reflect to the
driver change.
Update dpio read/write to take in extra PHY parameter.

Chris Wilson (26):
tests/pm_pc8: Fix invalid pointer-to-integer casting
drmtest: Fix weird signage on errno
kmstest: Fix up lifetimes of cairo objects
tests: Add gem_gtt_hog
gem_gtt_hog: Print elapsed time in ms
tests/gem_pipe_control_store_loop: Delete bogus assertion
gem_gtt_hog: use a normal exit()
kms_flip: Try to consume all fences after a flip
intel_error_decode: Protect against missing ring registers
igt/gem_concurrent_blit: Scale resource usage to RAM correctly
igt/gem_close_race: Fix blit commands for BDW
lib: Capture errno on entry
tests: Add gem_madvise
tests: Add gen7_forcewake_mt
Add i915_pciids.h
kms_flip: Try to make hang_gpu() robust against hanging the GPU
tests: Compile all threaded tests with -pthread when appropriate
kms_flip: Assert that hang_gpu() should only fail is the GPU is
already hung
kms_flip: Skip tests that try to inject GPU hangs if already
terminally wedged
gem_render_linear_blits: Trim usage to fit within RAM
gem_render_tiled_blits: Trim usage to fit within RAM
lib: Test against available swap
evictions: Limit the number of minor eviction surfaces to fit in RAM
igt/gem_pwrite_pread: Fix XY_SRC_COPY command length for gen8+
igt/gem_pwrite_pread: Fix relocation offsets for gen8+
igt/gem_pwrite_pread: Fix relocation offsets for gen8+

Damien Lespiau (68):
bdw: Add gen8 to the IS_9XX() macro
bdw: Add gen8 to intel_gen()
bdw: Add gen8 specific instdone bits
tests/bdw: Port storedw_loop_render to bdw
assembler/bdw: Add gen8_instruction from mesa
assembler/bdw: Support some basic gen8 intructions
assembler/bdw: Make the validation functions take a
brw_program_instruction
assembler/bdw: Add the start of a gen8 disassembler
assembler/bdw: Preliminary gen8 send & msgtarget support
assembler/bdw: Use gen8_set_exec_size() to set the execution size
rendercopy/bdw: Add gen8_render.h to the file list
rendercopy/bdw: Fix the original implementation
rendercopy/bdw: Add AUB annotations for states
list-workarounds/bdw: Add Broadwell to the list of valid platorms
gitignore: Ignore the newly introduced pm_psr
gitignore: Ignore gem_reset_stats
intel_dump_decode: Actually parse the -d option
intel_dump_decode: Support the INTEL_DEVID_OVERRIDE env variable
rendercopy/bdw: Fix the STATE_SIP instruction length
rendercopy/bdw: Fix the various 3DSTATE_CONSTANT_* instruction length
rendercopy/bdw: Fix the 3DSTATE_HIER_DEPTH_BUFFER instruction length
rendercopy/bdw: Fix the 3DSTATE_STENCIL_BUFFER instruction length
kms_fbc_crc: Remove unused variable
gitignore: Ignore kms_fbc_crc
gitignore: Ignore gem_media_fill
lib: Include the necessary stdint.h in gen6_render.h
intel_error_decode: Factor out common decoding code
intel_reg: Renamed INST_DONE to INSTDONE
instdone: Add an assert to make sure we never overflow instdone_bits
lib: Move the INSTDONE bit definitions to instdone.c
lib: Use INSTDONE_I965 and INSTDONE_1 for gen6
tools: Removed unused tools/intel_iosf_read.c
tools: Remove intel_disable_clock_gating
gem_ring_sync_copy: Add a ring to ring synchronization test
lib: Introduce a modeset API
kms_pipe_crc_basic: Port to the new modeset API
lib: Introduce symbolic names for display planes
lib: Introduce a for_each_connected_output() macro
kms_pipe_crc_basic: Use for_each_connected_output()
lib/display: Add an accessor to retrieve the number of pipes
kms_pipe_crc_basic: Use igt_display_get_n_pipes() instead of hardcoding 3
tests/kms_cursor_crc: Move the array of cursor fb_ids to the stack
lib/display: Fix the SetCrtc disabling log message
lib/display: Add support for the cursor plane
lib/display: Add a way to specify we don’t care about the pipe to use
kms_cursor_crc: Port the test to the new modeset API
lib/display: Allow to override the display verbosity with an env variale
lib/display: Check if we’re trying to use the same pipe on 2 outputs
lib/crc: Factor out reading a single CRC value
lib/crc: Add a helper to read a single CRC value
tests/kms_cursor_crc: Use igt_pipe_crc_collect_crc()
lib/display: Add support for DRM planes
lib: Introduce a new helper kmstest_create_color_fb()
kms_cursor_crc: Use kmstest_create_color_fb()
lib: Include drm_fourcc.h from igt_kms.h
kms_pipe_crc_basic: Use kmstest_create_color_fb()
lib: Add a helper to wait for a keypress
lib/display: Add a way to wait at every commit for inspection
lib/display: Print the fb id, not its pointer in the set_fb() log message
lib/display: Wait for a vblank after SetPlane()
lib/display: Fix assertion in set_plane()
kms_plane: Start a basic display plane test
lib: Don’t wait in igt_wait_for_keypress() if stdin is not a tty
lib: Fix igt_ouput_get_plane() typo (output)
kms_pipe_crc_basic: Remove igt_display_get_n_pipes() usage in main
lib/display: Fix typo in igt_plane_get_fd_id() (fb)
kms_plane: Remove spurious inclusion of glib.h
kms_pipe_crc_basic: Remove spurious inclusion of glib.h

Daniel Vetter (91):
NEWS: Remove spurious -
tests/gem_reloc_overflow: Polish after Rafael’s patch
tests/gem_overflow_reloc: Rework subtest enumeration
Revert “tests/gem_ctx_bad_exec: Check the errno, too”
NEWS: Android.mk updates!
NEWS: Make testing requirements official
lib: adjust oom_score
tests/gem_cs_prefetch: Fix bdw damage
tests: More bdw fallout
tests: More bdw fallout
tests/gem_reset_stats: Use macros a bit more
tools/reg_dumper: Add FW_BLC regs
tests/gem_reset_stats: More macros!
tests: Document per-ring naming conventions
tests: Document exec naming convention for execbuf related tests
lib: Don’t put functional code into asserts
test/gem_concurrent_blt
Revert “test/gem_concurrent_blt”
tests: rename get_client_auth to have a core_ prefix
tests/core_get_client_auth: new subtests for always authenticated
lib: add gem_available_aperture_size helper
tests/gem_ctx_exec: Add eviction test
tests/gem_reset_stats: document the new subtest a bit better
tests: drm_open_any doesn’t fail
lib: add igt_pipe_crc_check
lib: make igt_pipe_crc_start never fail
lib: Always print errno in igt assert/require macros
lib: Add host platform to version string
lib: print uname information in the version string
lib: igt_simple_main/init for subtest-less tests
tests: gem_close_race has subtests!
tests: roll out igt_simple_init/igt_simple_main
ignore version.h
tests: Move gem_reset_stats to the right place
tests: Document the Makefile variables a bit better
README: Document how to avoid Waffle with piglit
README: Fix spelling fail
NEWS updates
tests/NAMING-CONVENTION: s/snooped/snoop/
tests/gem_ctx_exec: fix ram requirement fumble
tests: fixup igt_simple_main fallout
tests/gem_largeobject: Prefault instead of pin
tests/prime_nv_pcopy: disable swizzle tests
tests/primve_nv_pcopy: Comment out unused check_swizzle function
tests/gem_gtt_hog: Use igt_simple_main
tools: Install them all
tests: Move pm_rps to the right Makefile target
tests: Add gem_fd_exhaustion
lib: extract igt_drop_root
debugger: avoid global variable shadowing
tests/pm_rps: Add missing static
lib: add __gem_create
tests/gem_fd_exhaustion: Make it work
tests/pm_rps: rename basic test to “basic-api”
fix make distcheck
tests/pm_rps: Fix compilation on Linux
tests/pm_rps: Round requested freq correctly
tests/pm_rps: remove setfreq
tests/gem_reset_stats: Correctly wrap global test code
lib/drmtest: Fix up skip_henceforth checks
lib: fix header include
tests/gem_close_race: Properly wrap init code in fixtures
tests/gem_bad_ctx_exec: Properly wrap in igt_fixtures
tests/gem_madvise: use correct main block
test/gem_gtt_hog: bail out earlier
lib: install exit handler only on success for prefault control
lib: Make igt_skip noreturn
NEWS: Mention Damien’s new helper library
lib: (somewhat) structured logging support
test/pm_rps: use igt logging
tests/gem_seqno_wrap: use igt logging
tests/kms_flip: use igt logging
NEWS: Mention new logging support
testdisplay: implement dpms test
testdisplay: Allow to specify the dpms level
test/kms_flip: fix up igt logging conversion
configure: Bump libdrm requirements
NEWS: intel_audio_dump has now bdw support
tests/drv_missed_irq_hang: Remove debug output
tests/gem_exec_blt: More reasonable runtime
tests/drv_missed_irq_hand: Make it robuster
gtk-doc: Document the docs
lib: extract ioctl_wrappers.c
lib/ioctl_wrappers: api doc
lib: extract igt_core.c
lib/igt_core: api documentation
lib: move prefault helpers to igt_debugfs.c
lib/ioctl_wrappers: api doc fixup
lib: make igt_debugfs_open infallible
lib/igt_debugfs: drop drm_fd argument from igt_pipe_crc_new
lib/igt_debugfs: api docs

Devon Davies (1):
build: Added -UNDEBUG to tools/Android.mk

Imre Deak (5):
kms_flip: fix seq_step for 2xcrtc subtests
kms_flip: keep drm_fd open for the dpms restore exit handler
kms_flip: consolidate run_test_on_{crtc,crtc_pair}
lib/drmtest: fix hang in quiescent_gpu_at_exit due to
signal-unsafe asprintf
kms_setmode: Add clone-single-crtc subtest

Jeff McGee (18):
pm_rps: Use unbuffered I/O on sysfs files
pm_rps: Assert that valid sysfs writes return success
pm_rps: Fix test to target original min and max
pm_rps: Use igt exit handler for restore
pm_rps: Add read back checking on sysfs writes
pm_rps: Convert to subtest structure
pm_rps: Fix verbose option and streamline its use
pm_rps: Expand on min and max config testing
pm_rps: Remove repeat sysfs reads
pm_rps: Make frequency logging more compact
pm_rps: New subtest min-max-config-idle
lib/drmtest: Add igt_wait_helper
pm_rps: Add load helper for loading gpu
pm_rps: New subtest min-max-config-loaded
pm_rps: Add stop rings injection utility
pm_rps: Load helper should stall for last write
pm_rps: Add variable load support to load helper
pm_rps: New subtest for gpu reset

Jesse Barnes (8):
rendercopy/bdw: Initial gen8 rendercopy
mmio: allow register init even if debugfs isn’t available and
i915 isn’t loaded
quick_dump: more vlv dpio regs
NEWS: update with nomodeset register access change
mmio: use intel_iosf.c for DPIO reads and writes
mmio: drop unused i915_loaded fn
dpio: make dpio reg read/write output like normal reg read/write output
iosf: make iosf_rw take a larger addr

Joao Santos (1):
build: Skip kms_plane on Android

Kenneth Graunke (2):
rendercopy/bdw: Emit 3DSTATE_WM_HZ_OP.
rendercopy/bdw: Fix length of a bunch of zeroed out packets.

Mengdong Lin (15):
intel_audio_dump/bdw: add support for Broadwell
intel_audio_dump/bdw: dump debug registers for audio immediate commands
intel_audio_dump/bdw: dump audio chicken bit register
intel_audio_dump/bdw: dump audio DP and DIP FIFO debug status
intel_audio_dump/bdw: dump audio M CTS readback register
quick_dump/bdw: dump audio configuration registers for Haswell
and Broadwell
quick_dump/bdw: dump audio debug registers for Haswell and Broadwell
quick_dump/bdw: support Broadwell in device auto-detection
intel_audio_dump: support using base address plus an offset to
dump registers
intel_audio_dump: move definitions of
transcoder/pipe/port/converter earlier
intel_audio_dump: define IS_HASWELL_PLUS to cover Haswell and
its successors
intel_audio_dump: define get_num_pipes() to get number of pipes
for a device ID
intel_audio_dump: share common audio dump code for Ironlake,
Haswell & Broadwell
intel_audio_dump: adjust code alignment
intel_audio_dump: add support for Valleyview

Mika Kuoppala (10):
tests: add gem_reset_stats
tests/gem_reset_stats: add support for BDW+
tests/gem_reset_stats: stop rings after injecting hang
tests/gem_reset_stats: check non root access to reset_stats
lib/drmtest: Fix filedesc leak on gem_quiescent_gpu
tests/gem_reset_stats: add close-pending-fork
tests/gem_reset_stats: add reverse order in close-pending-fork
tests/gem_reset_stats: split ctx tests
tests/gem_reset_stats: run tests on all rings
tests/gem_reset_stats: stop only one ring when submitting hang

Oscar Mateo (14):
tests/drv_suspend: Replace “&> /dev/null” with “> /dev/null 2>&1″
build: list all test/tool/lib source files in their own Makefile.sources
build: Fix missing “\” in tests/Makefile.sources
build: Move logic to tests/Makefile.am and away from Makefile.sources
lib: Move kms stuff from drmtest.c over to igt_kms.c
rendercopy: Remove rendercopy.c
tests/drm_get_client_auth: In Android, use gettid() instead of
syscall(SYS_gettid)
tests/gem_vmap_blits: Finish extracting gem_read
build: Fix assorted compilation warnings
lib/drmtest: Get the correct basename() under Android
lib/igt_display: workaround a name conflict in Android
build: New Android makefiles
tests/gem_close_race: Adapt the test for Full PPGTT
build: Create version and config information files in Android

Paulo Zanoni (40):
tests/pm_pc8: move teardown_environment next to setup_environment
tests/pm_pc8: return void on test_i2c
tests/pm_pc8: extract i2c_subtest_check_environment
tests/pm_pc8: add modeset-lpsp-stress
tests/pm_pc8: add debugfs/sysfs tests
tests/pm_pc8: remove “batch” and “stress-test” subtests
tests/pm_pc8: add some GEM tests
tests/pm_pc8: reorganize main function
tests/pm_pc8: add support for runtime PM
tests/pm_pc8: check for PC8 status, not residency in most cases
tests/pm_pc8: fix debugfs-forcewake-user for PC8-only cases
tests/pm_pc8: rename some variables
tests/pm_pc8: remove compare_registers subtest
tests/pm_pc8: add some more stress tests
tests/pm_pc8: add –quick option
tests/pm_pc8: rename some subtests
tests/pm_pc8: try harder to reach PC8+ residencies
tests/pm_pc8: try to reuse FBs when possible
tests/pm_pc8: add “resuming” state
lib: rename some power well bit names
tests: add pm_lpsp
tests/kms_setmode: avoid 2 connectors on the same encoder
tests/pm_pc8: check if we can’t become DRM master
drmtest: don’t leak memory when parsing the arguments
tests/kms_flip: don’t leak the connector when setting DPMS
tests/kms_flip: don’t leak the CRTC
tests/kms_flip: don’t leak the connector_config struct
tests/kms_flip: free the test_output struct when counting modes
tests/gen7_forcewake_mt: use -lpthread
tests/pm_pc8: remove sleep() call when setting up the environment
tests/pm_pc8: add gem-idle subtest
tests/pm_pc8: try to modprobe i2c-dev
tests/pm_pc8: try to modprobe msr
tests/pm_pc8: add reg-read-ioctl subtest
tests/pm_pc8: add pci-d3-state subtest
tests/pm_pc8: add “stay” mode
tests/pm_pc8: use XY_COLOR_BLT instead of just COLOR_BLT
tests/pm_pc8: BDW should also support PC8 residencies
tests/pm_pc8: use intel_gen instead of a big IS_GEN check
tests/pm_pc8: be more verbose on test_i2c failures

Rafael Barbalho (6):
tests/gem_reloc_overflow: Add gen8+ specifc tests
android: Handle the case when android doesn’t have mmap64
android: Clean-up common makefile directives
android: Add makefile for the lib directory
android: Add the generation of vesion.h & config.h to lib
android: Change tests & tools directory to use the lib directory

Robert Beckett (1):
igt: tests/Android.mk: fix LOCAL_PATH usage

Rodrigo Vivi (1):
bump version to 1.6 and add the release date

Thomas Wood (10):
assembler: define YY_NO_INPUT to prevent unused symbol warnings
lib: fix signed/unsigned comparison issues
debugger: fix the -p option
assembler: fix condition for printing a warning
tests/gem_seqno_wrap: fix over allocation of arrays
tests: fix sub-test enumeration
Add API documentation support
drmtest: reformat the API documentation
lib: Add missing header to Makefile.sources
tests: add missing assertion

Tvrtko Ursulin (8):
build: Make sure asserts are enabled for tests
build: Skip kms_fbc_crc on Android
drmtest: Avoid wrong PID/TID after clone races
Revert “lib/drmtest: ducttape over fork race”
tests/gem_media_fill: Remove unnecessary include
tools: Allow building on Android after noinst_PROGRAMS is not
defined any more
tests/gem_evict_everything: Factor out eviction logic
tests/eviction_common: Avoid submitting duplicate objects

Ville Syrjälä (11):
lib: Fix pipe_crc->ctl_fd assert
kms_cursor_crc: Fix crc readout after a subtest failure
rendercopy: Pass context to rendercopy functions
lib: Add gem_sw_finish()
lib: Add gem_bo_busy
kms_fbc_crc: Add a CRC based FBC test
quick_dump: Restore execture permission on quick_dump.py
tests: Drop glib.h include from kms_cursor_crc and kms_fbc_crc
kms_flip: Restore rings to running state in unhang_gpu()
kms_flip: Fail the subtest if page flip hang recovery wasn’t
actually tested
kms_flip: Add dpms-vs-vblank-race and modeset-vs-vblank-race subtests

Xiang, Haihao (16):
assembler/bdw: Set math function
assembler/bdw: Disable mask control for advanced mode
assembler/bdw: Set jip/uip offsets used by flow control instructions
assembler/bdw: Set thread switch for multiple branch instructions
assembler/bdw: Data port message
assembler/bdw: Thread Spawn message
assembler/bdw: Video Motion Estimation(VME) message
assembler/bdw: Check & Refinement Engine message
assembler/bdw: SEND instruction
tests: add gem_media_fill
tests/gem_media_fill: add support for gen8
tests/gem_media_fill: add support for gen7
tests/gem_media_fill: the assembly code for the shader used in the case
lib: Clean the batch buffer store after reset
rendercopy/bdw: Set Instruction Buffer size Modify Enable to 1
assembler/bdw: Update write(…)

Zhao Yakui (5):
tests/bdw: Port storedw_loop_bsd to gen8
tests/bdw: Port storedw_loop_blt to gen8
assembler/bdw: Add the support of align1 register-indirect
addressing mode on Gen8
assembler/bdw: Add the DATA_PORT_CACHE1 shared function for Gen8+
Assembler/bdw: Remove the unsupported cache agent for WRITE(…)

git tag: intel-gpu-tools-1.6

http://xorg.freedesktop.org/archive/individual/app/intel-gpu-tools-1.6.tar.bz2
MD5
:  e823be446e06d31195c66e354752fb0b  intel-gpu-tools-1.6.tar.bz2
SHA1: 87a066862f6cd4090b7bbb6a4ebc59e7aee330cd  intel-gpu-tools-1.6.tar.bz2
SHA256: 6b29e04fd08c3b66639969c6e128db979d729f891017932e30034037df106cc6
intel-gpu-tools-1.6.tar.bz2

http://xorg.freedesktop.org/archive/individual/app/intel-gpu-tools-1.6.tar.gz
MD5
:  ae257d0231eea0992afe55be2db40d88  intel-gpu-tools-1.6.tar.gz
SHA1: 54b49a28144072a43d94df48f407e3d08e74bba6  intel-gpu-tools-1.6.tar.gz
SHA256: 9aff9c59ba315c500e0329d1421bb2892d5749797444c2661d6ef290678b63ac
intel-gpu-tools-1.6.tar.gzHere goes a new i-g-t quarterly release with the following changes:

- Changes to support Broadwell in the test suite. (Ben, Damien, et al.)

- Updated (now working again!) Android support from Oscar Mateo.

- Test coverage through i-g-t is now officially an integral part of any drm/i915
feature work and also for bugfixes. For more details see:

http://blog.ffwll.ch/2013/11/testing-requirements-for-drmi915.html

- Fix the gen4asm build depency handling, now that the assembler is included in
i-g-t (Ben).

- Improve the cairo object lifetime management of the kmstest helpers (Chris).

- Allow register access to succeed if i915 is loaded but debugfs isn’t found
(i.e. nomodeset is used)

- New kernel modesetting helper library for simpler testcases (Damien).

- New structure logging support for tests. Message at the WARN level be
reflected in the piglit result, also included igt_warn_on macros to simplify
test asserts which should just result in warnings, but not in a test abort.

- Broadwell support for intel_audio_dump (Mengdong Lin).

- API documentation support (Thomas)

Complete list:

Ben Widawsky (52):
chipset: IS_I9XX macro
pciid/bdw: Add Broadwell PCI ids
bdw: Update obvious missing blit support
tests/bdw: gem_exec_faulting_reloc
tests/bdw: gem_cpu_reloc
tests/bdw: gem_evict_*
tests/bdw: gem_exec_blt
tests/bdw: gem_pin
tests/bdw: gem_linear_blits
tests/bdw: pwrite_pread
tests/bdw: Port storedw_loop_vebox to gen8
assembler/bdw: Small cleanup
quick_dump/bdw: Just basic stuff for now
NEWS: Broadwell
NEWS: Broadwell will be in 1.6, not 1.5
NEWS: Restore the 1.4 release info
gem_storedw_batches_loop: Update for gen8
gem_evict_everything: Fix broken blit generalization
gem_evict_alignment: Skip on GEN8 for now
gem_cpu_reloc: Fixed botched BLIT conversion
gem_linear_blits: Fix blit command length
gem_storedw_batches_loop: Fix for real this time
gem_evict_*: Fix batch lengths, broken on gen8 integration
gem_cs_prefetch: more gen8 integration fallout
gem_pipe_control_store_loop: BDW update
drm_vma_limiter_cached: Missed gen8 BLT updates
gem_write_read_ring_switch: Missed gen8 BLT updates
gem_persistent_relocs: Update for gen8 BLT cmds
gem_reloc_vs_gpu: Update for gen8 BLT cmds
Kill XY_COLOR_BLT_CMD
gen8 rendercpy: temporarily disable
gem_exec_faulting_reloc: Update gen8 BLT cmds
intel-gpu-tools: Version information
shader-debugger: Use in tree gen4asm
gem_exec_blit: gen8 updates for blit
configure.ac: Remove GEN4ASM define
configure.ac: Fixup conditional shader debugger
configure.ac: Fix shader debugger for real
gem_storedw_batches_loop: Fix for BDW
.gitignore: Add pycache
quick_dump: Fix the indentation
quick_dump: Allow comments in the register files
quick_dump/hsw: Watermark debug
quick_dump/broadwell: Use haswell_other
quick_dump/watermarks: lp3, misc and debug
gem_storedw_batches_loop: Fix for pre-BDW
quick_dump: Refactor to allow future code
quick_dump: Add a file argument
quick_dump/gen7: Add other GFX_MODE registers
quick_dump/haswell: Add gen7 stuff + VECS_MODE
quick_dump/broadwell: Add gen7 ring mode registers
quick_dump: Add missed broadwell autodetect

Chon Ming Lee (2):
tools/quick_dump: Update Baytrail DPIO names to reflect to the
driver change.
Update dpio read/write to take in extra PHY parameter.

Chris Wilson (26):
tests/pm_pc8: Fix invalid pointer-to-integer casting
drmtest: Fix weird signage on errno
kmstest: Fix up lifetimes of cairo objects
tests: Add gem_gtt_hog
gem_gtt_hog: Print elapsed time in ms
tests/gem_pipe_control_store_loop: Delete bogus assertion
gem_gtt_hog: use a normal exit()
kms_flip: Try to consume all fences after a flip
intel_error_decode: Protect against missing ring registers
igt/gem_concurrent_blit: Scale resource usage to RAM correctly
igt/gem_close_race: Fix blit commands for BDW
lib: Capture errno on entry
tests: Add gem_madvise
tests: Add gen7_forcewake_mt
Add i915_pciids.h
kms_flip: Try to make hang_gpu() robust against hanging the GPU
tests: Compile all threaded tests with -pthread when appropriate
kms_flip: Assert that hang_gpu() should only fail is the GPU is
already hung
kms_flip: Skip tests that try to inject GPU hangs if already
terminally wedged
gem_render_linear_blits: Trim usage to fit within RAM
gem_render_tiled_blits: Trim usage to fit within RAM
lib: Test against available swap
evictions: Limit the number of minor eviction surfaces to fit in RAM
igt/gem_pwrite_pread: Fix XY_SRC_COPY command length for gen8+
igt/gem_pwrite_pread: Fix relocation offsets for gen8+
igt/gem_pwrite_pread: Fix relocation offsets for gen8+

Damien Lespiau (68):
bdw: Add gen8 to the IS_9XX() macro
bdw: Add gen8 to intel_gen()
bdw: Add gen8 specific instdone bits
tests/bdw: Port storedw_loop_render to bdw
assembler/bdw: Add gen8_instruction from mesa
assembler/bdw: Support some basic gen8 intructions
assembler/bdw: Make the validation functions take a
brw_program_instruction
assembler/bdw: Add the start of a gen8 disassembler
assembler/bdw: Preliminary gen8 send & msgtarget support
assembler/bdw: Use gen8_set_exec_size() to set the execution size
rendercopy/bdw: Add gen8_render.h to the file list
rendercopy/bdw: Fix the original implementation
rendercopy/bdw: Add AUB annotations for states
list-workarounds/bdw: Add Broadwell to the list of valid platorms
gitignore: Ignore the newly introduced pm_psr
gitignore: Ignore gem_reset_stats
intel_dump_decode: Actually parse the -d option
intel_dump_decode: Support the INTEL_DEVID_OVERRIDE env variable
rendercopy/bdw: Fix the STATE_SIP instruction length
rendercopy/bdw: Fix the various 3DSTATE_CONSTANT_* instruction length
rendercopy/bdw: Fix the 3DSTATE_HIER_DEPTH_BUFFER instruction length
rendercopy/bdw: Fix the 3DSTATE_STENCIL_BUFFER instruction length
kms_fbc_crc: Remove unused variable
gitignore: Ignore kms_fbc_crc
gitignore: Ignore gem_media_fill
lib: Include the necessary stdint.h in gen6_render.h
intel_error_decode: Factor out common decoding code
intel_reg: Renamed INST_DONE to INSTDONE
instdone: Add an assert to make sure we never overflow instdone_bits
lib: Move the INSTDONE bit definitions to instdone.c
lib: Use INSTDONE_I965 and INSTDONE_1 for gen6
tools: Removed unused tools/intel_iosf_read.c
tools: Remove intel_disable_clock_gating
gem_ring_sync_copy: Add a ring to ring synchronization test
lib: Introduce a modeset API
kms_pipe_crc_basic: Port to the new modeset API
lib: Introduce symbolic names for display planes
lib: Introduce a for_each_connected_output() macro
kms_pipe_crc_basic: Use for_each_connected_output()
lib/display: Add an accessor to retrieve the number of pipes
kms_pipe_crc_basic: Use igt_display_get_n_pipes() instead of hardcoding 3
tests/kms_cursor_crc: Move the array of cursor fb_ids to the stack
lib/display: Fix the SetCrtc disabling log message
lib/display: Add support for the cursor plane
lib/display: Add a way to specify we don’t care about the pipe to use
kms_cursor_crc: Port the test to the new modeset API
lib/display: Allow to override the display verbosity with an env variale
lib/display: Check if we’re trying to use the same pipe on 2 outputs
lib/crc: Factor out reading a single CRC value
lib/crc: Add a helper to read a single CRC value
tests/kms_cursor_crc: Use igt_pipe_crc_collect_crc()
lib/display: Add support for DRM planes
lib: Introduce a new helper kmstest_create_color_fb()
kms_cursor_crc: Use kmstest_create_color_fb()
lib: Include drm_fourcc.h from igt_kms.h
kms_pipe_crc_basic: Use kmstest_create_color_fb()
lib: Add a helper to wait for a keypress
lib/display: Add a way to wait at every commit for inspection
lib/display: Print the fb id, not its pointer in the set_fb() log message
lib/display: Wait for a vblank after SetPlane()
lib/display: Fix assertion in set_plane()
kms_plane: Start a basic display plane test
lib: Don’t wait in igt_wait_for_keypress() if stdin is not a tty
lib: Fix igt_ouput_get_plane() typo (output)
kms_pipe_crc_basic: Remove igt_display_get_n_pipes() usage in main
lib/display: Fix typo in igt_plane_get_fd_id() (fb)
kms_plane: Remove spurious inclusion of glib.h
kms_pipe_crc_basic: Remove spurious inclusion of glib.h

Daniel Vetter (91):
NEWS: Remove spurious -
tests/gem_reloc_overflow: Polish after Rafael’s patch
tests/gem_overflow_reloc: Rework subtest enumeration
Revert “tests/gem_ctx_bad_exec: Check the errno, too”
NEWS: Android.mk updates!
NEWS: Make testing requirements official
lib: adjust oom_score
tests/gem_cs_prefetch: Fix bdw damage
tests: More bdw fallout
tests: More bdw fallout
tests/gem_reset_stats: Use macros a bit more
tools/reg_dumper: Add FW_BLC regs
tests/gem_reset_stats: More macros!
tests: Document per-ring naming conventions
tests: Document exec naming convention for execbuf related tests
lib: Don’t put functional code into asserts
test/gem_concurrent_blt
Revert “test/gem_concurrent_blt”
tests: rename get_client_auth to have a core_ prefix
tests/core_get_client_auth: new subtests for always authenticated
lib: add gem_available_aperture_size helper
tests/gem_ctx_exec: Add eviction test
tests/gem_reset_stats: document the new subtest a bit better
tests: drm_open_any doesn’t fail
lib: add igt_pipe_crc_check
lib: make igt_pipe_crc_start never fail
lib: Always print errno in igt assert/require macros
lib: Add host platform to version string
lib: print uname information in the version string
lib: igt_simple_main/init for subtest-less tests
tests: gem_close_race has subtests!
tests: roll out igt_simple_init/igt_simple_main
ignore version.h
tests: Move gem_reset_stats to the right place
tests: Document the Makefile variables a bit better
README: Document how to avoid Waffle with piglit
README: Fix spelling fail
NEWS updates
tests/NAMING-CONVENTION: s/snooped/snoop/
tests/gem_ctx_exec: fix ram requirement fumble
tests: fixup igt_simple_main fallout
tests/gem_largeobject: Prefault instead of pin
tests/prime_nv_pcopy: disable swizzle tests
tests/primve_nv_pcopy: Comment out unused check_swizzle function
tests/gem_gtt_hog: Use igt_simple_main
tools: Install them all
tests: Move pm_rps to the right Makefile target
tests: Add gem_fd_exhaustion
lib: extract igt_drop_root
debugger: avoid global variable shadowing
tests/pm_rps: Add missing static
lib: add __gem_create
tests/gem_fd_exhaustion: Make it work
tests/pm_rps: rename basic test to “basic-api”
fix make distcheck
tests/pm_rps: Fix compilation on Linux
tests/pm_rps: Round requested freq correctly
tests/pm_rps: remove setfreq
tests/gem_reset_stats: Correctly wrap global test code
lib/drmtest: Fix up skip_henceforth checks
lib: fix header include
tests/gem_close_race: Properly wrap init code in fixtures
tests/gem_bad_ctx_exec: Properly wrap in igt_fixtures
tests/gem_madvise: use correct main block
test/gem_gtt_hog: bail out earlier
lib: install exit handler only on success for prefault control
lib: Make igt_skip noreturn
NEWS: Mention Damien’s new helper library
lib: (somewhat) structured logging support
test/pm_rps: use igt logging
tests/gem_seqno_wrap: use igt logging
tests/kms_flip: use igt logging
NEWS: Mention new logging support
testdisplay: implement dpms test
testdisplay: Allow to specify the dpms level
test/kms_flip: fix up igt logging conversion
configure: Bump libdrm requirements
NEWS: intel_audio_dump has now bdw support
tests/drv_missed_irq_hang: Remove debug output
tests/gem_exec_blt: More reasonable runtime
tests/drv_missed_irq_hand: Make it robuster
gtk-doc: Document the docs
lib: extract ioctl_wrappers.c
lib/ioctl_wrappers: api doc
lib: extract igt_core.c
lib/igt_core: api documentation
lib: move prefault helpers to igt_debugfs.c
lib/ioctl_wrappers: api doc fixup
lib: make igt_debugfs_open infallible
lib/igt_debugfs: drop drm_fd argument from igt_pipe_crc_new
lib/igt_debugfs: api docs

Devon Davies (1):
build: Added -UNDEBUG to tools/Android.mk

Imre Deak (5):
kms_flip: fix seq_step for 2xcrtc subtests
kms_flip: keep drm_fd open for the dpms restore exit handler
kms_flip: consolidate run_test_on_{crtc,crtc_pair}
lib/drmtest: fix hang in quiescent_gpu_at_exit due to
signal-unsafe asprintf
kms_setmode: Add clone-single-crtc subtest

Jeff McGee (18):
pm_rps: Use unbuffered I/O on sysfs files
pm_rps: Assert that valid sysfs writes return success
pm_rps: Fix test to target original min and max
pm_rps: Use igt exit handler for restore
pm_rps: Add read back checking on sysfs writes
pm_rps: Convert to subtest structure
pm_rps: Fix verbose option and streamline its use
pm_rps: Expand on min and max config testing
pm_rps: Remove repeat sysfs reads
pm_rps: Make frequency logging more compact
pm_rps: New subtest min-max-config-idle
lib/drmtest: Add igt_wait_helper
pm_rps: Add load helper for loading gpu
pm_rps: New subtest min-max-config-loaded
pm_rps: Add stop rings injection utility
pm_rps: Load helper should stall for last write
pm_rps: Add variable load support to load helper
pm_rps: New subtest for gpu reset

Jesse Barnes (8):
rendercopy/bdw: Initial gen8 rendercopy
mmio: allow register init even if debugfs isn’t available and
i915 isn’t loaded
quick_dump: more vlv dpio regs
NEWS: update with nomodeset register access change
mmio: use intel_iosf.c for DPIO reads and writes
mmio: drop unused i915_loaded fn
dpio: make dpio reg read/write output like normal reg read/write output
iosf: make iosf_rw take a larger addr

Joao Santos (1):
build: Skip kms_plane on Android

Kenneth Graunke (2):
rendercopy/bdw: Emit 3DSTATE_WM_HZ_OP.
rendercopy/bdw: Fix length of a bunch of zeroed out packets.

Mengdong Lin (15):
intel_audio_dump/bdw: add support for Broadwell
intel_audio_dump/bdw: dump debug registers for audio immediate commands
intel_audio_dump/bdw: dump audio chicken bit register
intel_audio_dump/bdw: dump audio DP and DIP FIFO debug status
intel_audio_dump/bdw: dump audio M CTS readback register
quick_dump/bdw: dump audio configuration registers for Haswell
and Broadwell
quick_dump/bdw: dump audio debug registers for Haswell and Broadwell
quick_dump/bdw: support Broadwell in device auto-detection
intel_audio_dump: support using base address plus an offset to
dump registers
intel_audio_dump: move definitions of
transcoder/pipe/port/converter earlier
intel_audio_dump: define IS_HASWELL_PLUS to cover Haswell and
its successors
intel_audio_dump: define get_num_pipes() to get number of pipes
for a device ID
intel_audio_dump: share common audio dump code for Ironlake,
Haswell & Broadwell
intel_audio_dump: adjust code alignment
intel_audio_dump: add support for Valleyview

Mika Kuoppala (10):
tests: add gem_reset_stats
tests/gem_reset_stats: add support for BDW+
tests/gem_reset_stats: stop rings after injecting hang
tests/gem_reset_stats: check non root access to reset_stats
lib/drmtest: Fix filedesc leak on gem_quiescent_gpu
tests/gem_reset_stats: add close-pending-fork
tests/gem_reset_stats: add reverse order in close-pending-fork
tests/gem_reset_stats: split ctx tests
tests/gem_reset_stats: run tests on all rings
tests/gem_reset_stats: stop only one ring when submitting hang

Oscar Mateo (14):
tests/drv_suspend: Replace “&> /dev/null” with “> /dev/null 2>&1″
build: list all test/tool/lib source files in their own Makefile.sources
build: Fix missing “\” in tests/Makefile.sources
build: Move logic to tests/Makefile.am and away from Makefile.sources
lib: Move kms stuff from drmtest.c over to igt_kms.c
rendercopy: Remove rendercopy.c
tests/drm_get_client_auth: In Android, use gettid() instead of
syscall(SYS_gettid)
tests/gem_vmap_blits: Finish extracting gem_read
build: Fix assorted compilation warnings
lib/drmtest: Get the correct basename() under Android
lib/igt_display: workaround a name conflict in Android
build: New Android makefiles
tests/gem_close_race: Adapt the test for Full PPGTT
build: Create version and config information files in Android

Paulo Zanoni (40):
tests/pm_pc8: move teardown_environment next to setup_environment
tests/pm_pc8: return void on test_i2c
tests/pm_pc8: extract i2c_subtest_check_environment
tests/pm_pc8: add modeset-lpsp-stress
tests/pm_pc8: add debugfs/sysfs tests
tests/pm_pc8: remove “batch” and “stress-test” subtests
tests/pm_pc8: add some GEM tests
tests/pm_pc8: reorganize main function
tests/pm_pc8: add support for runtime PM
tests/pm_pc8: check for PC8 status, not residency in most cases
tests/pm_pc8: fix debugfs-forcewake-user for PC8-only cases
tests/pm_pc8: rename some variables
tests/pm_pc8: remove compare_registers subtest
tests/pm_pc8: add some more stress tests
tests/pm_pc8: add –quick option
tests/pm_pc8: rename some subtests
tests/pm_pc8: try harder to reach PC8+ residencies
tests/pm_pc8: try to reuse FBs when possible
tests/pm_pc8: add “resuming” state
lib: rename some power well bit names
tests: add pm_lpsp
tests/kms_setmode: avoid 2 connectors on the same encoder
tests/pm_pc8: check if we can’t become DRM master
drmtest: don’t leak memory when parsing the arguments
tests/kms_flip: don’t leak the connector when setting DPMS
tests/kms_flip: don’t leak the CRTC
tests/kms_flip: don’t leak the connector_config struct
tests/kms_flip: free the test_output struct when counting modes
tests/gen7_forcewake_mt: use -lpthread
tests/pm_pc8: remove sleep() call when setting up the environment
tests/pm_pc8: add gem-idle subtest
tests/pm_pc8: try to modprobe i2c-dev
tests/pm_pc8: try to modprobe msr
tests/pm_pc8: add reg-read-ioctl subtest
tests/pm_pc8: add pci-d3-state subtest
tests/pm_pc8: add “stay” mode
tests/pm_pc8: use XY_COLOR_BLT instead of just COLOR_BLT
tests/pm_pc8: BDW should also support PC8 residencies
tests/pm_pc8: use intel_gen instead of a big IS_GEN check
tests/pm_pc8: be more verbose on test_i2c failures

Rafael Barbalho (6):
tests/gem_reloc_overflow: Add gen8+ specifc tests
android: Handle the case when android doesn’t have mmap64
android: Clean-up common makefile directives
android: Add makefile for the lib directory
android: Add the generation of vesion.h & config.h to lib
android: Change tests & tools directory to use the lib directory

Robert Beckett (1):
igt: tests/Android.mk: fix LOCAL_PATH usage

Rodrigo Vivi (1):
bump version to 1.6 and add the release date

Thomas Wood (10):
assembler: define YY_NO_INPUT to prevent unused symbol warnings
lib: fix signed/unsigned comparison issues
debugger: fix the -p option
assembler: fix condition for printing a warning
tests/gem_seqno_wrap: fix over allocation of arrays
tests: fix sub-test enumeration
Add API documentation support
drmtest: reformat the API documentation
lib: Add missing header to Makefile.sources
tests: add missing assertion

Tvrtko Ursulin (8):
build: Make sure asserts are enabled for tests
build: Skip kms_fbc_crc on Android
drmtest: Avoid wrong PID/TID after clone races
Revert “lib/drmtest: ducttape over fork race”
tests/gem_media_fill: Remove unnecessary include
tools: Allow building on Android after noinst_PROGRAMS is not
defined any more
tests/gem_evict_everything: Factor out eviction logic
tests/eviction_common: Avoid submitting duplicate objects

Ville Syrjälä (11):
lib: Fix pipe_crc->ctl_fd assert
kms_cursor_crc: Fix crc readout after a subtest failure
rendercopy: Pass context to rendercopy functions
lib: Add gem_sw_finish()
lib: Add gem_bo_busy
kms_fbc_crc: Add a CRC based FBC test
quick_dump: Restore execture permission on quick_dump.py
tests: Drop glib.h include from kms_cursor_crc and kms_fbc_crc
kms_flip: Restore rings to running state in unhang_gpu()
kms_flip: Fail the subtest if page flip hang recovery wasn’t
actually tested
kms_flip: Add dpms-vs-vblank-race and modeset-vs-vblank-race subtests

Xiang, Haihao (16):
assembler/bdw: Set math function
assembler/bdw: Disable mask control for advanced mode
assembler/bdw: Set jip/uip offsets used by flow control instructions
assembler/bdw: Set thread switch for multiple branch instructions
assembler/bdw: Data port message
assembler/bdw: Thread Spawn message
assembler/bdw: Video Motion Estimation(VME) message
assembler/bdw: Check & Refinement Engine message
assembler/bdw: SEND instruction
tests: add gem_media_fill
tests/gem_media_fill: add support for gen8
tests/gem_media_fill: add support for gen7
tests/gem_media_fill: the assembly code for the shader used in the case
lib: Clean the batch buffer store after reset
rendercopy/bdw: Set Instruction Buffer size Modify Enable to 1
assembler/bdw: Update write(…)

Zhao Yakui (5):
tests/bdw: Port storedw_loop_bsd to gen8
tests/bdw: Port storedw_loop_blt to gen8
assembler/bdw: Add the support of align1 register-indirect
addressing mode on Gen8
assembler/bdw: Add the DATA_PORT_CACHE1 shared function for Gen8+
Assembler/bdw: Remove the unsupported cache agent for WRITE(…)

git tag: intel-gpu-tools-1.6

http://xorg.freedesktop.org/archive/individual/app/intel-gpu-tools-1.6.tar.bz2
MD5
:  e823be446e06d31195c66e354752fb0b  intel-gpu-tools-1.6.tar.bz2
SHA1: 87a066862f6cd4090b7bbb6a4ebc59e7aee330cd  intel-gpu-tools-1.6.tar.bz2
SHA256: 6b29e04fd08c3b66639969c6e128db979d729f891017932e30034037df106cc6
intel-gpu-tools-1.6.tar.bz2

http://xorg.freedesktop.org/archive/individual/app/intel-gpu-tools-1.6.tar.gz
MD5
:  ae257d0231eea0992afe55be2db40d88  intel-gpu-tools-1.6.tar.gz
SHA1: 54b49a28144072a43d94df48f407e3d08e74bba6  intel-gpu-tools-1.6.tar.gz
SHA256: 9aff9c59ba315c500e0329d1421bb2892d5749797444c2661d6ef290678b63ac
intel-gpu-tools-1.6.tar.gz

glamor-hacking

Keith Packard -

Brief Glamor Hacks

Eric Anholt started writing Glamor a few years ago. The goal was to provide credible 2D acceleration based solely on the OpenGL API, in particular, to implement the X drawing primitives, both core and Render extension, without any GPU-specific code. When he started, the thinking was that fixed-function devices were still relevant, so that original code didn’t insist upon “modern” OpenGL features like GLSL shaders. That made the code less efficient and hard to write.

Glamor used to be a side-project within the X world; seen as something that really wasn’t very useful; something that any credible 2D driver would replace with custom highly-optimized GPU-specific code. Eric and I both hoped that Glamor would turn into something credible and that we’d be able to eliminate all of the horror-show GPU-specific code in every driver for drawing X text, rectangles and composited images. That hadn’t happened though, until now.

Fast forward to the last six months. Eric has spent a bunch of time cleaning up Glamor internals, and in fact he’s had it merged into the core X server for version 1.16 which will be coming up this July. Within the Glamor code base, he’s been cleaning some internal structures up and making life more tolerable for Glamor developers.

Using libepoxy

A big part of the cleanup was a transition all of the extension function calls to use his other new project, libepoxy, which provides a sane, consistent and performant API to OpenGL extensions for Linux, Mac OS and Windows. That library is awesome, and you should use it for everything you do with OpenGL because not using it is like pounding nails into your head. Or eating non-tasty pie.

Using VBOs in Glamor

One thing he recently cleaned up was how to deal with VBOs during X operations. VBOs are absolutely essential to modern OpenGL applications; they’re really the only way to efficiently pass vertex data from application to the GPU. And, every other mechanism is deprecated by the ARB as not a part of the blessed ‘core context’.

Glamor provides a simple way of getting some VBO space, dumping data into it, and then using it through two wrapping calls which you use along with glVertexAttribPointer as follows:

pointer = glamor_get_vbo_space(screen, size, &offset); glVertexAttribPointer(attribute_location, count, type, GL_FALSE, stride, offset); memcpy(pointer, data, size); glamor_put_vbo_space(screen);

glamor_get_vbo_space allocates the specified amount of VBO space and returns a pointer to that along with an ‘offset’, which is suitable to pass to glVertexAttribPointer. You dump your data into the returned pointer, call glamor_put_vbo_space and you’re all done.

Actually Drawing Stuff

At the same time, Eric has been optimizing some of the existing rendering code. But, all of it is still frankly terrible. Our dream of credible 2D graphics through OpenGL just wasn’t being realized at all.

On Monday, I decided that I should go play in Glamor for a few days, both to hack up some simple rendering paths and to familiarize myself with the insides of Glamor as I’m getting asked to review piles of patches for it, and not understanding a code base is a great way to help introduce serious bugs during review.

I started with the core text operations. Not because they’re particularly relevant these days as most applications draw text with the Render extension to provide better looking results, but instead because they’re often one of the hardest things to do efficiently with a heavy weight GPU interface, and OpenGL can be amazingly heavy weight if you let it.

Eric spent a bunch of time optimizing the existing text code to try and make it faster, but at the bottom, it actually draws each lit pixel as a tiny GL_POINT object by sending a separate x/y vertex value to the GPU (using the above VBO interface). This code walks the array of bits in the font and checking each one to see if it is lit, then checking if the lit pixel is within the clip region and only then adding the coordinates of the lit pixel to the VBO. The amazing thing is that even with all of this CPU and GPU work, the venerable 6x13 font is drawn at an astonishing 3.2 million glyphs per second. Of course, pure software draws text at 9.3 million glyphs per second.

I suspected that a more efficient implementation might be able to draw text a bit faster, so I decided to just start from scratch with a new GL-based core X text drawing function. The plan was pretty simple:

  1. Dump all glyphs in the font into a texture. Store them in 1bpp format to minimize memory consumption.

  2. Place raw (integer) glyph coordinates into the VBO. Place four coordinates for each and draw a GL_QUAD for each glyph.

  3. Transform the glyph coordinates into the usual GL range (-1..1) in the vertex shader.

  4. Fetch a suitable byte from the glyph texture, extract a single bit and then either draw a solid color or discard the fragment.

This makes the X server code surprisingly simple; it computes integer coordinates for the glyph destination and glyph image source and writes those to the VBO. When all of the glyphs are in the VBO, it just calls glDrawArrays(GL_QUADS, 0, 4 * count). The results were “encouraging”:

1: fb-text.perf 2: glamor-text.perf 3: keith-text.perf 1 2 3 Operation ------------ ------------------------- ------------------------- ------------------------- 9300000.0 3160000.0 ( 0.340) 18000000.0 ( 1.935) Char in 80-char line (6x13) 8700000.0 2850000.0 ( 0.328) 16500000.0 ( 1.897) Char in 70-char line (8x13) 6560000.0 2380000.0 ( 0.363) 11900000.0 ( 1.814) Char in 60-char line (9x15) 2150000.0 700000.0 ( 0.326) 7710000.0 ( 3.586) Char16 in 40-char line (k14) 894000.0 283000.0 ( 0.317) 4500000.0 ( 5.034) Char16 in 23-char line (k24) 9170000.0 4400000.0 ( 0.480) 17300000.0 ( 1.887) Char in 80-char line (TR 10) 3080000.0 1090000.0 ( 0.354) 7810000.0 ( 2.536) Char in 30-char line (TR 24) 6690000.0 2640000.0 ( 0.395) 5180000.0 ( 0.774) Char in 20/40/20 line (6x13, TR 10) 1160000.0 351000.0 ( 0.303) 2080000.0 ( 1.793) Char16 in 7/14/7 line (k14, k24) 8310000.0 2880000.0 ( 0.347) 15600000.0 ( 1.877) Char in 80-char image line (6x13) 7510000.0 2550000.0 ( 0.340) 12900000.0 ( 1.718) Char in 70-char image line (8x13) 5650000.0 2090000.0 ( 0.370) 11400000.0 ( 2.018) Char in 60-char image line (9x15) 2000000.0 670000.0 ( 0.335) 7780000.0 ( 3.890) Char16 in 40-char image line (k14) 823000.0 270000.0 ( 0.328) 4470000.0 ( 5.431) Char16 in 23-char image line (k24) 8500000.0 3710000.0 ( 0.436) 8250000.0 ( 0.971) Char in 80-char image line (TR 10) 2620000.0 983000.0 ( 0.375) 3650000.0 ( 1.393) Char in 30-char image line (TR 24)

This is our old friend x11perfcomp, but slightly adjusted for a modern reality where you really do end up drawing billions of objects (hence the wider columns). This table lists the performance for drawing a range of different fonts in both poly text and image text variants. The first column is for Xephyr using software (fb) rendering, the second is for the existing Glamor GL_POINT based code and the third is the latest GL_QUAD based code.

As you can see, drawing points for every lit pixel in a glyph is surprisingly fast, but only about 1/3 the speed of software for essentially any size glyph. By minimizing the use of the CPU and pushing piles of work into the GPU, we manage to increase the speed of most of the operations, with larger glyphs improving significantly more than smaller glyphs.

Now, you ask how much code this involved. And, I can truthfully say that it was a very small amount to write:

Makefile.am | 2 glamor.c | 5 glamor_core.c | 8 glamor_font.c | 181 ++++++++++++++++++++ glamor_font.h | 50 +++++ glamor_priv.h | 26 ++ glamor_text.c | 472 +++++++++++++++++++++++++++++++++++++++++++++++++++++ glamor_transform.c | 2 8 files changed, 741 insertions(+), 5 deletions(-) Let’s Start At The Very Beginning

The results of optimizing text encouraged me to start at the top of x11perf and see what progress I could make. In particular, looking at the current Glamor code, I noticed that it did all of the vertex transformation with the CPU. That makes no sense at all for any GPU built in the last decade; they’ve got massive numbers of transistors dedicated to performing precisely this kind of operation. So, I decided to see what I could do with PolyPoint.

PolyPoint is absolutely brutal on any GPU; you have to pass it two coordinates for each pixel, and so the very best you can do is send it 32 bits, or precisely the same amount of data needed to actually draw a pixel on the frame buffer. With this in mind, one expects that about the best you can do compared with software is tie. Of course, the CPU version is actually computing an address and clipping, but those are all easily buried in the cost of actually storing a pixel.

In any case, the results of this little exercise are pretty close to a tie — the CPU draws 190,000,000 dots per second and the GPU draws 189,000,000 dots per second. Looking at the vertex and fragment shaders generated by the compiler, it’s clear that there’s room for improvement.

The fragment shader is simply pulling the constant pixel color from a uniform and assigning it to the fragment color in this the simplest of all possible shaders:

uniform vec4 color; void main() { gl_FragColor = color; };

This generates five instructions:

Native code for point fragment shader 7 (SIMD8 dispatch): START B0 FB write target 0 0x00000000: mov(8) g113<1>F g2<0,1,0>F { align1 WE_normal 1Q }; 0x00000010: mov(8) g114<1>F g2.1<0,1,0>F { align1 WE_normal 1Q }; 0x00000020: mov(8) g115<1>F g2.2<0,1,0>F { align1 WE_normal 1Q }; 0x00000030: mov(8) g116<1>F g2.3<0,1,0>F { align1 WE_normal 1Q }; 0x00000040: sendc(8) null g113<8,8,1>F render ( RT write, 0, 4, 12) mlen 4 rlen 0 { align1 WE_normal 1Q EOT }; END B0

As this pattern is actually pretty common, it turns out there’s a single instruction that can replace all four of the moves. That should actually make a significant difference in the run time of this shader, and this shader runs once for every single pixel.

The vertex shader has some similar optimization opportunities, but it only runs once for every 8 pixels — with the SIMD format flipped around, the vertex shader can compute 8 vertices in parallel, so it ends up executing 8 times less often. It’s got some redundant moves, which could be optimized by improving the copy propagation analysis code in the compiler.

Of course, improving the compiler to make these cases run faster will probably make a lot of other applications run faster too, so it’s probably worth doing at some point.

Again, the amount of code necessary to add this path was tiny:

Makefile.am | 1 glamor.c | 2 glamor_polyops.c | 116 ++++++++++++++++++++++++++++++++++++++++++++++++++-- glamor_priv.h | 8 +++ glamor_transform.c | 118 +++++++++++++++++++++++++++++++++++++++++++++++++++++ glamor_transform.h | 51 ++++++++++++++++++++++ 6 files changed, 292 insertions(+), 4 deletions(-) Discussion of Results

These two cases, text and points, are probably the hardest operations to accelerate with a GPU and yet a small amount of OpenGL code was able to meet or beat software easily. The advantage of this work over traditional GPU 2D acceleration implementations should be pretty clear — this same code should work well on any GPU which offers a reasonable OpenGL implementation. That means everyone shares the benefits of this code, and everyone can contribute to making 2D operations faster.

All of these measurements were actually done using Xephyr, which offers a testing environment unlike any I’ve ever had — build and test hardware acceleration code within a nested X server, debugging it in a windowed environment on a single machine. Here’s how I’m running it:

$ ./Xephyr -glamor :1 -schedMax 2000 -screen 1024x768 -retro

The one bit of magic here is the ‘-schedMax 2000’ flag, which causes Xephyr to update the screen less often when applications are very busy and serves to reduce the overhead of screen updates while running x11perf.

Future Work

Having managed to accelerate 17 of the 392 operations in x11perf, it’s pretty clear that I could spend a bunch of time just stepping through each of the remaining ones and working on them. Before doing that, we want to try and work out some general principles about how to handle core X fill styles. Moving all of the stipple and tile computation to the GPU will help reduce the amount of code necessary to fill rectangles and spans, along with improving performance, assuming the above exercise generalizes to other primitives.

Getting and Testing the Code

Most of the changes here are from Eric’s glamor-server branch:

git://people.freedesktop.org/~anholt/xserver glamor-server

The two patches shown above, along with a pair of simple clean up patches that I’ve written this week are available here:

git://people.freedesktop.org/~keithp/xserver glamor-server

Of course, as this now uses libepoxy, you’ll need to fetch, build and install that before trying to compile this X server.

Because you can try all of this out in Xephyr, it’s easy to download and build this X server and then run it right on top of your current driver stack inside of X. I’d really like to hear from people with Radeon or nVidia hardware to know whether the code works, and how it compares with fb on the same machine, which you get when you elide the ‘-glamor’ argument from the example Xephyr command line above.

MicroPeak Approved for NAR Contests

Keith Packard -

MicroPeak Approved for NAR Contests

The NAR Contest Board has approved MicroPeak for use in contests requiring a barometric altimeter starting on the 1st of April, 2014. You can read the announcement message on the contestRoc Yahoo message board here:

Contest Board Approves New Altimeter

The message was sent out on the 30th of January, but there is a 90 day waiting period after the announcement has been made before you can use MicroPeak in a contest, so the first date approved for contest flights is April 1. After that date, you should see MicroPeak appear in Appendix G of the pink book, which lists the altimeters approved for contest use

Thanks much to the NAR contest board and all of the fliers who helped get MicroPeak ready for this!

Altos1.3.2

Keith Packard -

AltOS 1.3.2 — Bug fixes and improved APRS support

Bdale and I are pleased to announce the release of AltOS version 1.3.2.

AltOS is the core of the software for all of the Altus Metrum products. It consists of firmware for our cc1111, STM32L151, LPC11U14 and ATtiny85 based electronics and Java-based ground station software.

This is a minor release of AltOS, including bug fixes for TeleMega, TeleMetrum v2.0 and AltosUI .

AltOS Firmware — GPS Satellite reporting and APRS improved

Firmware version 1.3.1 has a bug on TeleMega when it has data from more than 12 GPS satellites. This causes buffer overruns within the firmware. 1.3.2 limits the number of reported satellites to 12.

APRS now continues to send the last known good GPS position, and reports GPS lock status and number of sats in view in the APRS comment field, along with the battery and igniter voltages.

AltosUI — TeleMega GPS Satellite, GPS max height and Fire Igniters

AltosUI was crashing when TeleMega reported that it had data from more than 12 satellites. While the TeleMega firmware has been fixed to never do that, AltosUI also has a fix in case you fly a TeleMega board without updated firmware.

GPS max height is now displayed in the flight statistics. As the u-Blox GPS chips now provide accurate altitude information, we’ve added the maximum height as computed by GPS here.

Fire Igniters now uses the letters A through D to label the extra TeleMega pyro channels instead of the numbers 0-3.

FOSDEM: Testing Kernel GPU Drivers

Daniel Vetter -

So as usual FOSDEM was a blast and as usual the hallway track was great too. The beer certainly helped with that ... Big props to the entire conference crew for organizing a stellar event and specifically to Luc and the other graphics devroom people.

I've also uploaded the slides for my Kernel GPU Driver Testing talk. My OCD made me remove that additional dot and resurrect the missing 'e' in one of the slides even. FOSDEM also had live-streaming and rendering videos should eventually show up, I'll add the link as soon as it's there.

No Fosdem

Keith Packard -

Missing FOSDEM

I’m afraid Eric and I won’t be at FOSDEM this weekend; our flight got canceled, and the backup they offered would have gotten us there late Saturday night. It seemed crazy to fly to Brussels for one day of FOSDEM, so we decided to just stay home and get some work done.

Sorry to be missing all of the fabulous FOSDEM adventures and getting to see all of the fun people who attend one of the best conferences around. Hope everyone has a great time, and finds only the best chocolates.

GLSL multidimensional array... madness?

Ian Romanick -

Multidimensional arrays are added to GLSL via either GL_ARB_arrays_of_arrays extension or GLSL 4.30. I've had a couple people tell me that the multidimensional array syntax is either wrong or just plain crazy. When viewed from the proper angle, it should actually be perfectly logical to any C / C++ programmer. I'd like to clear up a bit of the confusion.

Staring with the easy syntax, the following does what you expect:

vec4 a[2][3][4];

If a is inside a uniform block, the memory layout would be the same as in C. cdecl would call this, "declare a as array 2 of array 3 of array 4 of vec4".

Using GLSL constructor syntax, the array can also be initialized:

vec4 a[2][3][4] = vec4[][][](vec4[][](vec4[](vec4( 1), vec4( 2), vec4( 3), vec4( 4)), vec4[](vec4( 5), vec4( 6), vec4( 7), vec4( 8)), vec4[](vec4( 9), vec4(10), vec4(11), vec4(12))), vec4[][](vec4[](vec4(13), vec4(14), vec4(15), vec4(16)), vec4[](vec4(17), vec4(18), vec4(19), vec4(20)), vec4[](vec4(21), vec4(22), vec4(23), vec4(24))));

If that makes your eyes bleed, GL_ARB_shading_language_420pack and GLSL 4.20 add the ability to use C-style array and structure initializers. In that model, a can be initialized to the same values by:

vec4 a[2][3][4] = { { { vec4( 1), vec4( 2), vec4( 3), vec4( 4) }, { vec4( 5), vec4( 6), vec4( 7), vec4( 8) }, { vec4( 9), vec4(10), vec4(11), vec4(12) } }, { { vec4(13), vec4(14), vec4(15), vec4(16) }, { vec4(17), vec4(18), vec4(19), vec4(20) }, { vec4(21), vec4(22), vec4(23), vec4(24) } } };

Functions can be declared that take multidimensional arrays as parameters. In the prototype, the name of the parameter can be present, or it can be omitted.

void function_a(float a[4][5][6]); void function_b(float [4][5][6]);

Other than the GLSL constructor syntax, there hasn't been any madness yet. However, recall that array sizes can be associated with the variable name or with the type. The prototype for function_a associates the size with the variable name, and the prototype for function_b associates the size with the type. Like GLSL constructor syntax, this has existed since GLSL 1.20.

Associating the array size with just the type, we can declare a (from above) as:

vec4[2][3][4] a;

With multidimensional arrays, the sizes can be split among the two, and this is where it gets weird. We can also declare a as:

vec4[3][4] a[2];

This declaration has the same layout as the previous two forms. This is usually where people say, "It's bigger on the inside!" Recall the cdecl description, "declare a as array 2 of array 3 of array 4 of vec4". If we add some parenthesis, "declare a as array 2 of (array 3 of array 4 of vec4)", and things seem a bit more clear.

GLSL ended up with this syntax for two reasons, and seeing those reasons should illuminate things. Without GL_ARB_arrays_of_arrays or GLSL 4.30, there are no multidimensional arrays, but the same affect can be achieved, very inconveniently, using structures containing arrays. In GLSL 4.20 and earlier, we could also declare a as:

struct S1 { float a[4]; }; struct S2 { S1 a[3]; }; S2 a[2];

I'll spare you having to see GLSL constructor initializer for that mess. Note that we still end up with a[2] at the end.

Using typedef in C, we could also achieve the same result using:

typedef float T[3][4]; T a[2];

Again, we end up with a[2]. If cdecl could handle this (it doesn't grok typedef), it would say "declare a as array 2 of T", and "typedef T as array 3 of array 4 of float". We could substitue the description of T and, with parenthesis, get "declare a as array 2 of (array 3 of array 4 of float)".

Where this starts to present pain is that function_c has the same parameter type as function_a and function_b, but function_d does not.

void function_c(float[5][6] a[4]); void function_d(float[5][6] [4]);

However, the layout of parameter for function_e is the same as function_a and function_b, even though the actual type is different.

struct S3 { float a[6]; }; struct S4 { S3 a[5]; }; void function_e(S4 [4]);

I think if we had it to do all over again, we may have disallowed the split syntax. That would remove the more annoying pitfalls and the confusion, but it would also remove some functionality. Most of the problems associated with the split are caught at compile-time, but some are not. The two obvious problems that remain are transposing array indices and incorrectly calculated uniform block layouts.

layout(std140) uniform U { float [1][2][3] x; float y[1][2][3]; float [1][2] z[3]; };

In this example x and y have the same memory organization, but z does not. I wouldn't want to try to debug that problem.

Altos1.3.1

Keith Packard -

AltOS 1.3.1 — Bug fixes and improved APRS support

Bdale and I are pleased to announce the release of AltOS version 1.3.1.

AltOS is the core of the software for all of the Altus Metrum products. It consists of firmware for our cc1111, STM32L151, LPC11U14 and ATtiny85 based electronics and Java-based ground station software.

This is a minor release of AltOS, including bug fixes for TeleMega, TeleMetrum v2.0 and AltosUI .

AltOS Firmware — Antenna down fixed and APRS improved

Firmware version 1.3 has a bug in the support for operating the flight computer with the antenna facing downwards; the accelerometer calibration data would be incorrect. Furthermore, the accelerometer self-test routine would be confused if the flight computer were moved in the first second after power on. The firmware now simply re-tries the self-test several times.

I went out and bought a “real” APRS radio, the Yaesu FT1D to replace my venerable VX 7R. With this in hand, I changed our APRS support to use the compressed position format, which takes fewer bytes to send, offers increased resolution and includes altitude data. I took the altitude data out of the comment field and replaced that with battery and igniter voltages. This makes APRS reasonably useful in pad mode to monitor the state of the flight computer before boost.

Anyone with a TeleMega should update to the new firmware eventually, although there aren’t any critical bug fixes here, unless you’re trying to operate the device with the antenna pointing downwards.

AltosUI — TeleMega support and offline map loading improved.

I added all of the new TeleMega sensor data as possible elements in the graph. This lets you see roll rates and horizontal acceleration values for the whole flight. The ‘Fire Igniter’ dialog now lists all of the TeleMega extra pyro channels so you can play with those on the ground as well.

Our offline satellite images are downloaded from Google, but they restrict us to reading 50 images per minute. When we tried to download a 9x9 grid of images to save for later use on the flight line, Google would stop feeding us maps after the first 50. You’d have to poke the button a second time to try and fill in the missing images. We fixed this by just limiting how fast we load maps, and now we can reliably load an 11x11 grid of images.

Of course, there are also a few minor bug fixes, so it’s probably worth updating even if the above issues don’t affect you.

Neat drm/i915 stuff for 3.14

Daniel Vetter -

Kernel v3.13 is nearing its release, so it's time at our regular look at what the next version will bring to the Intel gfx driver.

This time around there was a lot of infrastructure work for improved power management. Imre Deak implemented code to manage display power wells in a more generic way so that the current Haswell support is also ready for other platforms. Unfortunately new platform support hasn't landed yet. But for Haswell we now have working runtime D3 support, contributed by Paulo Zanoni. For Baytrail/Valleyview Deepak S provided improvements to the GT power well  force-wake code - on these mobile platforms it is split up between the render engine and more auxiliary engines like the blitter and the video decode hardware.

Back to the topic of display and power management Ville Syrjälä contributed a lot of patches to fix little issues in the watermark computation code and als for the framebuffer compression support. The motivation for this is Ville's atomic pageflip feature work which not only needs to update all the scanout targets (primary plane, sprites, ...) but also all derived state perfectly synchronized to the next vblank. And especially the watermark updates have proven to be really tricky to get right. Finally Jani Nikula has completely rewritten our low-level backlight code. This has already fixed a few bugs, and hopefully this new code will give us fewer headaches in the future than the old one. Note that this is just about the raw backlight interface provided by Intel's integrated gpu, almost all machines use some other PWM or at least have some fanciness (written in ACPI scripts) on top of that. So don't expect your backlight to magically work perfectly, this is just a tiny piece of the puzzle.

Looking at GEM related features the big thing is the reset statistics ioctl from Mika Kuoppala. This is the kernel code to implement the GLX_ARB_robustness extension, and the further building blocks on top of that. This extension is shipping in Mesa 10.0.x releases and is necessary to implement browser support for WebGL in a sane way. Thjs release cycle has also seen more patches from Ben Widawsky towards full ppgtt support, but the final bits didn't make the cut due to a few regressions that popped up at the last minute.

For platform support the big thing is that we've removed the prelimary hardware support tag for Broadwell, which means 3.14 and later kernels will use the real i915.ko driver by default. There's still a few features missing for full-blown Broadwell kernel support, but all the basics to boot the system and so avoid users getting stuck with black screens are there. Baytrail also has seen lots of smaller improvements, like a vga hotplug fix from Imre, DSI improvements from Deepak and tons of other patches from Jesse Barnes, Ville and Chon Lee Ming.

One last piece new in 3.14 is the deprecation of the legacy UMS support. We've kept this code on live support since a few years already, but now it's getting in the way of some of the plans for improving the driver load and teardown code. So long-term we want this gone. For now there's still a kernel config option to keep the code around. Another new&nifty kernel option disables the legacy fbdev support. This is not something for your regular desktop linux system yet since the boot splash and a bunch of other things rely on it. And you also need to manually make sure that the vga driver doesn't load. But it does allow us to rip out all the legacy linux framebuffer support code, which is beneficial for embedded systems. And with efforts like David Herrmann's kmscon also where the future is heading towards in general.

gl-and-bitmaps

Keith Packard -

X bitmaps vs OpenGL

Of course, you all know that X started life as a monochrome window system for the VS100. Back then, bitmaps and rasterops were cool; you could do all kinds of things simple bit operations. Things changed, and eventually X bitmaps became useful only off-screen for clip masks, text and stipples. These days, you’ll rarely see anyone using a bitmap — everything we used to use bitmaps for has gone all alpha-values on us.

In OpenGL, there aren’t any bitmaps. About the most ‘bitmap-like’ object you’ll find is an A8 texture, holding 8 bits of alpha value for each pixel. There’s no way to draw to or texture from anything where each pixel is represented as a single bit.

So, as Eric goes about improving Glamor, he got a bit stuck with bitmaps. We could either:

  • Support them only on the CPU, uploading copies as A8 textures when used as a source in conjunction with GPU objects.

  • Support them as 1bpp on the CPU and A8 on the GPU, doing fancy tracking between the two objects when rendering occurred.

  • Fix the CPU code to deal with bitmaps stored 8 bits per pixel.

I thought the latter choice would be the best plan — directly share the same object between CPU and GPU rendering, avoiding all reformatting as things move around in the server.

Why is this non-trivial?

Usually, you can flip formats around with reckless abandon in X, it has separate bits-per-pixel and depth values everywhere. That’s how we do things like 32 bits-per-pixel RGB surfaces; we just report them as depth 24 and everyone is happy.

Bitmaps are special though. The X protocol has separate (and overly complicated) image formats for single bit images, and those have to be packed 1 bit per pixel. Within the server, bitmaps are used for drawing core text, stippling and creating clip masks. They’re the ‘lingua franca’ of image formats, allowing you to translate between depths by pulling a single “plane” out of a source image and painting it into a destination of arbitrary depth.

As such, the frame buffer rendering code in the server assumes that bitmaps are always 1 bit per pixel. Given that it must deal with 1bpp images on the wire, and given the history of X, it certainly made sense at the time to simplify the code with this assumption.

A blast from the past

I’d actually looked into doing this before. As part of the DECstation line, DEC built the MX monochrome frame buffer board, and to save money, they actually created it by populating a single bit in each byte rather than packed into 8 pixels per byte. I have this vague memory that they were able to use only 4 memory chips this way.

The original X driver for this exposed a depth-8 static color format because of the assumptions made by the (then current) CFB code about bitmap formats.

Jim Gettys wandered over to MIT while the MX frame buffer was in design and asked how hard it would be to support it as a monochrome device instead of the depth-8 static color format. At the time, fixing CFB would have been a huge effort, and there wasn’t any infrastructure for separating the wire image format from the internal pixmap format. So, we gave up and left things looking weird to applications.

Hacking FB

These days, the amount of frame buffer code in the X server is dramatically less; CFB and MFB have been replaced with the smaller (and more general) FB code. It turns out that the number of places which need to deal with individual bits in a bitmap are now limited to a few stippling and CopyPlane functions. And, in those functions, the number of individual read operations from the bitmap are few in number. Each of those fetches looked like:

bits = READ(src++)

All I needed to do was make this operation return 32 bits by pulling one bit from each of 8 separate 32-bit chunks and merge them together. The first thing to do was to pad the pixmap out to a 32 byte boundary, rather than a 32 bit boundary. This ensured that I would always be able to fetch data from the bitmap in 8 32-bit chunks. Next, I simply replaced the READ macro call with:

bits = fb_stip_read(src, srcBpp); src += srcBpp;

The new fb_stip_read function checks srcBpp and packs things together for 8bpp images:

/* * Given a depth 1, 8bpp stipple, pull out * a full FbStip worth of packed bits */ static inline FbStip fb_pack_stip_8_1(FbStip *bits) { FbStip r = 0; int i; for (i = 0; i < 8; i++) { FbStip b; uint8_t p; b = FB_READ(bits++); #if BITMAP_BIT_ORDER == LSBFirst p = (b & 1) | ((b >> 7) & 2) | ((b >> 14) & 4) | ((b >> 21) & 8); r |= p << (i << 2); #else p = (b & 0x80000000) | ((b << 7) & 0x40000000) | ((b << 14) & 0x20000000) | ((b << 21) & 0x10000000); r |= p >> (i << 2); #endif } return r; } /* * Return packed stipple bits from src */ static inline FbStip fb_stip_read(FbStip *bits, int bpp) { switch (bpp) { default: return FB_READ(bits); case 8: return fb_pack_stip_8_1(bits); } }

It turns into a fairly hefty amount of code, but the number of places this ends up being used is pretty small, so it shouldn’t increase the size of the server by much. Of course, I’ve only tested the LSBFirst case, but I think the MSBFirst code is correct.

I’ve sent the patches to do this to the xorg-devel mailing list, and they’re also on the ‘depth1’ branch in my repository

git://people.freedesktop.org/~keithp/xserver.git Testing

Eric also hacked up the test suite to be runnable by piglit, and I’ve run it in that mode against these changes. I had made a few mistakes, and the test suite caught them nicely. Let’s hope this adventure helps Eric out as he continues to improve Glamor.

The X Test Suite

Eric Anholt -

In the process of hacking on glamor, I got once again to the point of wondering how to test my changes. Sure, I can run some clients in Xephyr and wiggle windows around and see if things look good, but I'd like to be better than that.

Now, if you talk to any X developer about how to test your changes, they'll tell you to run the X Test Suite. This is them trolling you. Nobody runs the X Test Suite. They certainly don't themselves. While whot, dbn, Peter Harris, Kibi, and others did amazing work getting the ancient tree up to the point that it could be built by mortals, and run with "make run-tests", you ended up with a log saying "a bunch of things failed", and no idea what your implementation actually rendered. Selecting tests is awful, the reports tools are a mystery, and there are a million lame wrappers for executing tests (the best of which on the wikis was lost in the homedir backup failure, and the best keithp knows of lived only on his disk). If you do go looking at the error output, you see crap like this:


100 90 24
2328,0
100 90 24
25d,0
19,1
4b,0
19,1
4b,0
19,1
4b,0
19,1
4b,0
19,1
4b,0
19,1
4b,0
19,1
...


Does that look like an image to you? It didn't to me.

On the airplane to LCA, I set about fixing this. I grabbed piglit, which is my hammer for every case of "I've got a bunch of tests to run and compare between commits", and built a little test suite that takes a link to your built X Test Suite repository, finds all the tests in it, sets the environment for running them, and goes about running them. Then you get all the nice test filtering and spawning and results comparison of piglit.

Then, keithp dug into the error log format, and figured out that it's RLE encoded pixel values after a width/height/depth header, with a drawn image and a reference image in each log file (so that snippet above is "you got all 0 pixel values, when you should have had 0s with a 25-pixel-wide rectangle of 1s. Yes, 25."). From that, he built a tool to read those error logs and produce pairs of pngs with color values distributed around HSV. I run that tool on the output of the tests, save them off, and link them in the piglit summaries so you can actually see what your rendering did wrong, right next to the failure report.

I've ripped up our wiki stuff for the X Test Suite, which was full of ancient lies, and replaced it with: http://wiki.x.org/wiki/XorgTesting/

Present-pixmap-lifetimes-part-deux

Keith Packard -

Pixmap ID Lifetimes under Present Redirection (Part Deux)

I recently wrote about pixmap content and ID lifetimes. I think the pixmap content lifetime stuff was useful, but the pixmap ID stuff was not quite right. I’ve just copied the section from the previous post and will update it.

PresentRedirect pixmap ID lifetimes (reprise)

A compositing manager will want to know the lifetime of the pixmaps delivered in PresentRedirectNotify events to clean up whatever local data it has associated with it. For instance, GL compositing managers will construct textures for each pixmap that need to be destroyed when the pixmap disappears.

Present encourages pixmap destruction

The PresentPixmap request says:

PresentRegion holds a reference to ‘pixmap’ until the presentation occurs, so ‘pixmap’ may be immediately freed after the request executes, even if that is before the presentation occurs.

Breaking this when doing Present redirection seems like a bad idea; it’s a very common pattern for existing 2D applications.

New pixmap IDs for everyone

Because pixmap IDs for present contents are owned by the source application (and may be re-used immediately when freed), Present can’t use that ID in the PresentRedirectNotify event. Instead, it must allocate a new ID and send that instead. The server has it’s own XID space to use, and so it can allocate one of those and bind it to the same underlying pixmap; the pixmap will not actually be destroyed until both the application XID and the server XID are freed.

The compositing manager will receive this new XID, and is responsible for freeing it when it doesn’t need it any longer. Of course, if the compositing manager exits, all of the XIDs passed to it will automatically be freed.

I considered allocating client-specific XIDs for this purpose; the X server already has a mechanism for allocating internal IDs for various things that are to be destroyed at client shut-down time. Those XIDs have bit 30 set, and are technically invalid XIDs as X specifies that the top three bits of every XID will be zero. However, the cost of using a server ID instead (which is a valid XID) is small, and it’s always nice to not intentionally break the X protocol (even as we continue to take advantage of “accidental” breakages).

(Reserving the top three bits of XIDs and insisting that they always be zero was a nod to the common practice of weakly typed languages like Lisp. In these languages, 32-bit object references were typed by using few tag bits (2-3) within the value. Most of these were just pointers to data, but small integers, that fit in the remaining bits (29-30), could be constructed without allocating any memory. By making XIDs only 29 bits, these languages could be assured that all XIDs would be small integers.)

Pixmap Destroy Notify

The Compositing manager needs to know when the application is done with the pixmap so that it can clean up when it is also done; destroying the extra pixmap ID it was given and freeing any other local resources. When the application sends a FreePixmap request, that XID will become invalid, but of course the pixmap itself won’t be freed until the compositing manager sends a FreePixmap request with the extra XID it was given.

Because the pixmap ID known by the compositing manager is going to be different from the original application XID, we need an event delivered to the compositing manager with the new XID, which makes this event rather Present specific. We don’t need to select for this event; the compositing manager must handle it correctly, so we’ll just send it whenever the composting manager has received that custom XID.

PresentPixmapDestroyNotify ┌─── PresentPixmapDestroyNotify type: CARD8 XGE event type (35) extension: CARD8 Present extension opcode sequence-number: CARD16 length: CARD32 0 evtype: CARD16 Present_PixmapDestroyNotify eventID: XFIXESEVENTID event-window: WINDOW pixmap: pixmap └───

This event is delivered to the clients selecting for SubredirectNotify for pixmaps which were delivered in a PresentRedirectNotify event and for which the originating application Pixmap has been destroyed. Note that the pixmap may still be referenced by other objects within the X server, by a pending PresentPixmap request, as a window background, GC tile or stipple or Picture drawable (among others), but this event serves to notify the selecting client that the application is no longer able to access the underlying pixmap with it’s original Pixmap ID.

Subscribe to Linux Graphics aggregator