libX11: Changes to 'master'
Jamey Sharp
jamey at kemper.freedesktop.org
Tue Nov 4 08:55:20 PST 2008
configure.ac | 2
include/X11/Xlibint.h | 3
src/Makefile.am | 1
src/OpenDis.c | 27 +----
src/XlibInt.c | 85 +++++++++-------
src/Xprivate.h | 15 ++
src/Xxcbint.h | 34 ++----
src/xcb_disp.c | 2
src/xcb_io.c | 254 +++++++++++++++++++++++++++++++-------------------
src/xcb_lock.c | 235 ----------------------------------------------
10 files changed, 249 insertions(+), 409 deletions(-)
New commits:
commit e6a7b70cdb2ae8b713012839a0a0bbb93817b8ef
Author: Jamey Sharp <jamey at minilop.net>
Date: Wed Oct 29 14:00:33 2008 -0700
Support multiple independent internal sync handlers
Xlib has several independent tasks that need to be performed with the
display unlocked. It does this by replacing the existing sync handler with
one of a variety of internal sync handlers. However, if multiple internal
sync handlers need to run, then the last one registering wins and
previously registered internal sync handlers are never invoked. This
manifested as a bug with DRI applications on Xlib/XCB as that requires
both an XID handler after every XID allocation, and the periodic sequence
number handler. The XID handler would win, and the sequence number handler
would never be invoked.
Fix this by unifying the internal sync handler mechanism into a single
function that calls all of the known internal sync handlers. They all need
to deal with being called when not strictly necessary now.
Signed-off-by: Keith Packard <keithp at keithp.com>
Signed-off-by: Jamey Sharp <jamey at minilop.net>
Signed-off-by: Josh Triplett <josh at freedesktop.org>
commit 2dbaaab9c4e3894b33dcae850551dee5473431d5
Author: Keith Packard <keithp at keithp.com>
Date: Sat Oct 11 21:44:21 2008 -0700
Ensure that _XReadEvents always leaves an event in the queue on return
XNextEvent assumes that the event queue will be non-empty on return from
_XReadEvents, but with multiple event readers running, the previous change
could leave the queue empty on return from process_responses. Re-invoke
process_responses until the queue is non-empty.
Signed-off-by: Keith Packard <keithp at keithp.com>
commit bedfe68259037c5564fe52758c92b9c97729640a
Author: Keith Packard <keithp at keithp.com>
Date: Sat Oct 11 21:10:23 2008 -0700
Permit only one Xlib thread to block waiting for events
As Xlib queues events internally, we must prevent multiple Xlib threads from
entering XCB to wait for an event in case the queued event is to be
delivered to the thread which didn't manage to read it. In other words, let
only one Xlib thread into xcb_wait_for_event at a time.
Jamey Sharp looked over my shoulder while making this fix and, while hating
my whitespace conventions, appears happy enough with the actual code.
Signed-off-by: Keith Packard <keithp at keithp.com>
commit cc19618d2eb3ed92a0b574aee26a7da8b4aed5d2
Author: Jamey Sharp <jamey at minilop.net>
Date: Sun Mar 23 16:33:50 2008 -0700
Fix XAllocID race: hold the user display lock until we have a new XID.
Xlib built --without-xcb is also vulnerable to this race, and a similar
fix might work there too.
Also, use an XID that's truly invalid while waiting for the next XID to be
requested.
commit 54e5c0941b0ded1628d559a9f0a3451ea96c299b
Author: Josh Triplett <josh at freedesktop.org>
Date: Sat Mar 15 17:22:23 2008 -0700
Use XCB's new socket handoff mechanism rather than the old XCB Xlib lock.
Previously, Xlib/XCB used XCB's Xlib lock to prevent XCB from sending
requests between calls to Xlib's LockDisplay and UnlockDisplay macros.
Xlib/XCB then sent all of its requests using XCB's xcb_send_request, and
had to flush its requests when unlocking the display.
XCB 1.2 adds a new socket handoff mechanism, xcb_take_socket. Replace
much of the existing Xlib/XCB implementation with the use of
xcb_take_socket to take ownership of the write side of the X connection
socket, and a return_socket callback which writes any outstanding requests
with xcb_writev. This approach allows Xlib/XCB to use the same buffering
as traditional Xlib did. In particular, programs which use Xlib/XCB and
never make XCB calls will never need to hand the socket back to XCB, and
vice versa.
This allows us to discard large quantities of synchronization code from
Xlib/XCB, together with the synchronization bugs present in that code.
Several test cases which previously failed now work perfectly, including
multi-threaded ico. In addition, the infamous locking correctness
assertions, triggered when double-locking or when unlocking without a
previous lock, no longer exist, because Xlib/XCB no longer has any reason
to care more about application locking than traditional Xlib does.
Furthermore, the handoff approach provides great improvements to
performance. Results from x11perf's XNoOp test, which represented the
worst case for the lock-based Xlib/XCB:
Traditional Xlib: average 19100000/sec
Lock-based Xlib/XCB: average 3350000/sec
Handoff-based Xlib/XCB: average 17400000/sec
Thus, for no-ops, the handoff mechanism provides more than a 4x speedup to
Xlib/XCB, bringing Xlib/XCB within 9% of traditional Xlib no-op
performance. Of course, real-world workloads do not use no-op, so your
mileage may vary. In particular, since no-ops represent the worst case,
we expect real workloads to more closely match the performance of
traditional Xlib.
While removing synchronization code, we changed _XReply to not drop any
locks when calling xcb_wait_for_reply; previously, we had to carefully
avoid a deadlock between the Display lock and the XCB Xlib lock. Holding
the locks reduces implementation complexity and should not impact
applications.
Commit by Jamey Sharp and Josh Triplett.
XCB's handoff mechanism inspired by Keith Packard.
More information about the xorg-commit
mailing list