present: Send GLX_BufferSwapComplete events from present extension
PATCH 1/1 present: Send GLX_BufferSwapComplete events from present extension
This allows GL to support the GLX_INTEL_swap_event extension
---
This is the X server side; the mesa patch will be sent shortly (it's tiny)
glx/Makefile.am | 3 ++- glx/glxcmds.c | 69 +++++++++++++++++++++++++++++++++++++++++++++++++ glx/glxdri2.c | 26 +++++-------------- glx/glxext.c | 3 +++ glx/glxserver.h | 9 +++++++ present/present.h | 9 +++++++ present/present_event.c | 10 +++++++ 7 files changed, 109 insertions(+), 20 deletions(-)
glx/Makefile.am +2 -1
@@ -20,7 +20,8 @@ AM_CPPFLAGS = \ -I$(top_srcdir)/hw/xfree86/os-support/bus \ -I$(top_srcdir)/hw/xfree86/common \ -I$(top_srcdir)/hw/xfree86/dri \ - -I$(top_srcdir)/mi + -I$(top_srcdir)/mi \ + -I$(top_srcdir)/present if DRI2_AIGLX AM_CPPFLAGS += -I$(top_srcdir)/hw/xfree86/dri2
glx/glxcmds.c +69 -0
72 lines not on this page · raw message
glx/glxdri2.c +7 -19
@@ -177,36 +177,24 @@ __glXdriSwapEvent(ClientPtr client, void *data, int type, CARD64 ust, CARD64 msc, CARD32 sbc) {__GLXdrawable *drawable = data; -xGLXBufferSwapComplete2 wire = { - .type = __glXEventBase + GLX_BufferSwapComplete - }; - -if (!(drawable->eventMask &GLX_BUFFER_SWAP_COMPLETE_INTEL_MASK )) -return ; - +int glx_type;switch (type) {case DRI2_EXCHANGE_COMPLETE : - wire.event_type =GLX_EXCHANGE_COMPLETE_INTEL ; + glx_type =GLX_EXCHANGE_COMPLETE_INTEL ;break ;case DRI2_BLIT_COMPLETE : - wire.event_type =GLX_BLIT_COMPLETE_INTEL ; + glx_type =GLX_BLIT_COMPLETE_INTEL ;break ;case DRI2_FLIP_COMPLETE : - wire.event_type =GLX_FLIP_COMPLETE_INTEL ; + glx_type =GLX_FLIP_COMPLETE_INTEL ;break ;default :/* unknown swap completion type */ - wire.event_type =0 ; + glx_type =0 ;break ; } - wire.drawable = drawable->drawId; - wire.ust_hi = ust >>32 ; - wire.ust_lo = ust &0xffffffff ; - wire.msc_hi = msc >>32 ; - wire.msc_lo = msc &0xffffffff ; - wire.sbc = sbc; - -WriteEventsToClient (client,1 , (xEvent *) &wire); + +__glXsendSwapEvent (drawable, glx_type, ust, msc, sbc); }/*
glx/glxext.c +3 -0
@@ -399,6 +399,9 @@ GlxExtensionInit(void) __glXErrorBase = extEntry->errorBase; __glXEventBase = extEntry->eventBase; +#if PRESENT +__glXregisterPresentCompleteNotify (); +#endif }/************************************************************************/
glx/glxserver.h +9 -0
@@ -120,6 +120,15 @@ void glxResumeClients(void);void __glXsetGetProcAddress (void (*(*get_proc_address) (const char *)) (void ));void *__glGetProcAddress (const char *); +void +__glXsendSwapEvent (__GLXdrawable *drawable,int type,CARD64 ust, +CARD64 msc,CARD32 sbc); + +#if PRESENT +void +__glXregisterPresentCompleteNotify (void ); +#endif +/* ** State kept per client. */
present/present.h +9 -0
@@ -115,4 +115,13 @@ present_event_abandon(RRCrtcPtr crtc); extern _X_EXPORT Boolpresent_screen_init (ScreenPtr screen,present_screen_info_ptr info); +typedef void (*present_complete_notify_proc )(WindowPtr window, +CARD8 mode, +CARD32 serial, +uint64_t ust, +uint64_t msc); + +extern _X_EXPORT void +present_register_complete_notify (present_complete_notify_proc proc); +#endif /* _PRESENT_H_ */
present/present_event.c +10 -0
@@ -137,6 +137,14 @@ present_send_config_notify(WindowPtr window, int x, int y, int w, int h, int bw, } } +static present_complete_notify_proc complete_notify; + +void +present_register_complete_notify (present_complete_notify_proc proc) +{ + complete_notify = proc; +} +void present_send_complete_notify (WindowPtr window,CARD8 kind,CARD8 mode,CARD32 serial,uint64_t ust,uint64_t msc) {
@@ -165,6 +173,8 @@ present_send_complete_notify(WindowPtr window, CARD8 kind, CARD8 mode, CARD32 se } } } +if (complete_notify) + (*complete_notify)(window, mode, serial, ust, msc); }void
Signature · 6 lines
1.8.4.2 _______________________________________________ [email protected]: X.Org development Archives: http://lists.x.org/archives/xorg-devel Info: http://lists.x.org/mailman/listinfo/xorg-devel
A message that is not in the archive (sent off-list or not yet received): 1385103256-24620-1-git-send-email-keithp-aN4HjG94KOLQT0dZR+AlfA@public.gmane.org
Eric Anholt
Reviewed-byQuoted 3 lines · Keith Packard
This allows GL to support the
GLX_INTEL_swap_eventextensionSigned-off-by Keith Packard <[email protected]>
There's a minor behavior change that the event now gets sent to the drawable owner rather than the caller of DRI2SwapBuffers.
I don't expect it to matter in practice (I expect that the swap-requesting client using this GLX extension is also the drawable-creating one), and either choice seems wrong compared to "send the event to everyone listening for the event on this drawable". That would be a separate change, anyway.
_______________________________________________
[email protected]: X.Org development
Archives: http://lists.x.org/archives/xorg-devel
Info: http://lists.x.org/mailman/listinfo/xorg-devel
Quoted 2 lines · Eric Anholt
There's a minor behavior change that the event now gets sent to the drawable owner rather than the caller of DRI2SwapBuffers.
Yeah, probably not ideal, especially when the GLX drawable is created using the window XID (as is the case for some older GLX clients). I don't have the original client at the time the event is generated, but I think I can go back and stick it in; will require tracking when the client exits, of course.
Quoted 5 lines
I don't expect it to matter in practice (I expect that the swap-requesting client using this GLX extension is also the drawable-creating one), and either choice seems wrong compared to "send the event to everyone listening for the event on this drawable". That would be a separate change, anyway.
I think the original behaviour, sending the event to the client who sent the PresentPixmap request is the only sane plan, and only a bit more complicated than sending it to the drawable owner.
I'll cook up an alternate patch and send that along; we can then compare the two approaches at least.
Signature · 1 line
[email protected]
_______________________________________________
mesa-dev mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/mesa-dev
cover Clean up dri3 SBC handling, enable GLX_INTEL_swap_event
I've split the GLX_INTEL_swap_event enabling patch into four bits -- the first three just fix the existing code to track SBC values correctly and to fix wait_for_sbc. The fourth is the trivial patch to actually turn on the new extension; all of the hard work for that is actually dealt with in the X server.
[PATCH 1/4] dri3: Clean up struct dri3_drawable
Trivial struct member cleanup -- a couple of unused fields, and one oddly placed field.
[PATCH 2/4] dri3: Track full 64-bit SBC numbers, instead of just
This switches all of the internal SBC tracking to use 64-bit values. I use uint64_t because I don't trust compilers with signed integer comparisons that may wrap any more.
[PATCH 3/4] dri3: Fix dri3_wait_for_sbc to wait for completion of
This one makes wait_for_sbc actually wait for the completion of the specified swap, rather than the queuing of that value. Makes *far* more sense this way.
[PATCH 4/4] dri3: Enable GLX_INTEL_swap_event
The trivial patch that just adds the extension to the list.
-keith
PATCH 1/4 dri3: Clean up struct dri3_drawable
Move the depth field up with width and height.
Remove unused previous_time and frames fields.
--- src/glx/dri3_priv.h | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-)
src/glx/dri3_priv.h +1 -5
@@ -177,7 +177,7 @@ dri3_pixmap_buf_id(enum dri3_buffer_type buffer_type)struct dri3_drawable {__GLXDRIdrawable base;__DRIdrawable *driDrawable; -int width, height; +int width, height, depth;int swap_interval;uint8_t have_back;uint8_t have_fake_front;
@@ -193,13 +193,9 @@ struct dri3_drawable {/* For WaitMSC */ uint32_t present_msc_request_serial;uint32_t present_msc_event_serial; - -uint64_t previous_time; -unsigned frames;struct dri3_buffer *buffers[DRI3_NUM_BUFFERS ];int cur_back; -int depth;uint32_t *stamp;
Signature · 1 line
1.8.4.4
Re: [PATCH 1/4] dri3: Clean up struct dri3_drawable
Quoted 27 lines · Keith Packard
Move the depth field up with width and height.
Remove unused
previous_timeand frames fields.Signed-off-by Keith Packard <[email protected]>--- src/glx/dri3_priv.h | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-)src/glx/dri3_priv.h +1
-1@@ -177,7 +177,7 @@ dri3_pixmap_buf_id(enum dri3_buffer_type buffer_type)struct dri3_drawable {__GLXDRIdrawable base;__DRIdrawable *driDrawable; -int width, height; +int width, height, depth;int swap_interval;uint8_t have_back;uint8_t have_fake_front;@@ -193,13 +193,9 @@ struct dri3_drawable {/* For WaitMSC */ uint32_t present_msc_request_serial;uint32_t present_msc_event_serial;
src/glx/dri3_priv.h struct dri3_drawable { · line 201
Quoted 10 lines
src/glx/dri3_priv.h +0
-4- -uint64_t previous_time; -unsigned frames;struct dri3_buffer *buffers[DRI3_NUM_BUFFERS ];int cur_back; -int depth;uint32_t *stamp;
This one is easy.
I plan to push it - hopefully today. I don't feel qualified to review the SBC and swap event handling patches, so hopefully someone else can take a look...
PATCH 2/4 dri3: Track full 64-bit SBC numbers, instead of just 32-bits
In reply to Keith PackardTracking the full 64-bit SBC values makes it clearer how those values are being used, and simplifies the wait_msc code. The only trick is in re-constructing the full 64-bit value from Present's 32-bit serial number that we use to pass the SBC value from request to event.
--- src/glx/dri3_glx.c | 34 +++++++++++++++++++++------------- src/glx/dri3_priv.h | 16 +++++++++------- 2 files changed, 30 insertions(+), 20 deletions(-)
src/glx/dri3_glx.c +21 -13
@@ -364,10 +364,17 @@ dri3_handle_present_event(struct dri3_drawable *priv, xcb_present_generic_event_case XCB_PRESENT_COMPLETE_NOTIFY : {xcb_present_complete_notify_event_t *ce = (void *) ge; -if (ce->kind ==XCB_PRESENT_COMPLETE_KIND_PIXMAP ) - priv->present_event_serial = ce->serial; -else - priv->present_msc_event_serial = ce->serial; +/* Compute the processed SBC number from the received 32-bit serial number merged +* with the upper 32-bits of the sent 64-bit serial number while checking for +* wrap +*/ +if (ce->kind ==XCB_PRESENT_COMPLETE_KIND_PIXMAP ) { + priv->recv_sbc = (priv->send_sbc &0xffffffff00000000LL ) | ce->serial; +if (priv->recv_sbc > priv->send_sbc) + priv->recv_sbc -=0x100000000 ; + }else { + priv->recv_msc_serial = ce->serial; + } priv->ust = ce->ust; priv->msc = ce->msc;break ;
@@ -398,12 +405,13 @@ dri3_wait_for_msc(__GLXDRIdrawable *pdraw, int64_t target_msc, int64_t divisor,struct dri3_drawable *priv = (struct dri3_drawable *) pdraw;xcb_generic_event_t *ev;xcb_present_generic_event_t *ge; +uint32_t msc_serial;/* Ask for the an event for the target MSC */ - ++priv->present_msc_request_serial; + msc_serial = ++priv->send_msc_serial;xcb_present_notify_msc (c, priv->base.xDrawable, - priv->present_msc_request_serial, + msc_serial, target_msc, divisor, remainder);
@@ -412,7 +420,7 @@ dri3_wait_for_msc(__GLXDRIdrawable *pdraw, int64_t target_msc, int64_t divisor,/* Wait for the event */ if (priv->special_event) { -while (priv->present_msc_request_serial != priv->present_msc_event_serial) { +while ((int32_t ) (msc_serial - priv->recv_msc_serial) >0 ) { ev =xcb_wait_for_special_event (c, priv->special_event);if (!ev)break ;
@@ -423,7 +431,7 @@ dri3_wait_for_msc(__GLXDRIdrawable *pdraw, int64_t target_msc, int64_t divisor, *ust = priv->ust; *msc = priv->msc; - *sbc = priv->sbc; + *sbc = priv->recv_sbc;return 1 ; }
@@ -450,7 +458,7 @@ dri3_wait_for_sbc(__GLXDRIdrawable *pdraw, int64_t target_sbc, int64_t *ust, {struct dri3_drawable *priv = (struct dri3_drawable *) pdraw; -while (priv->sbc < target_sbc) { +while (priv->send_sbc < target_sbc) {sleep (1 ); }return dri3_wait_for_msc (pdraw,0 ,0 ,0 , ust, msc, sbc);
@@ -1282,15 +1290,15 @@ dri3_swap_buffers(__GLXDRIdrawable *pdraw, int64_t target_msc, int64_t divisor,/* Compute when we want the frame shown by taking the last known successful * MSC and adding in a swap interval for each outstanding swap request */ - ++priv->present_request_serial; + ++priv->send_sbc;if (target_msc ==0 ) - target_msc = priv->msc + priv->swap_interval * (priv->present_request_serial - priv->present_event_serial); + target_msc = priv->msc + priv->swap_interval * (priv->send_sbc - priv->recv_sbc); priv->buffers[buf_id]->busy =1 ; xcb_present_pixmap(c, priv->base.xDrawable, priv->buffers[buf_id]->pixmap, - priv->present_request_serial, + (uint32_t) priv->send_sbc, 0, /* valid */ 0, /* update */ 0, /* x_off */
@@ -1302,7 +1310,7 @@ dri3_swap_buffers(__GLXDRIdrawable *pdraw, int64_t target_msc, int64_t divisor, target_msc, divisor, remainder, 0, NULL); - ret = ++priv->sbc; + ret = (int64_t ) priv->send_sbc;/* If there's a fake front, then copy the source back buffer * to the fake front to keep it up to date. This needs
src/glx/dri3_priv.h +9 -7
@@ -183,16 +183,18 @@ struct dri3_drawable {uint8_t have_fake_front;uint8_t is_pixmap; -uint32_t present_request_serial; -uint32_t present_event_serial; - -uint64_t sbc; +/* SBC numbers are tracked by using the serial numbers +* in the present request and complete events +*/ +uint64_t send_sbc; +uint64_t recv_sbc; +/* Last received UST/MSC values */ uint64_t ust, msc; -/* For WaitMSC */ -uint32_t present_msc_request_serial; -uint32_t present_msc_event_serial; +/* Serial numbers for tracking wait_for_msc events */ +uint32_t send_msc_serial; +uint32_t recv_msc_serial;struct dri3_buffer *buffers[DRI3_NUM_BUFFERS ];int cur_back;
Signature · 1 line
1.8.4.4
PATCH 3/4 dri3: Fix dri3_wait_for_sbc to wait for completion of requested SBC
In reply to Keith PackardEric figured out that glXWaitForSbcOML wanted to block until the requested SBC had been completed, which means to wait until the PresentCompleteNotify event for that SBC had been received.
This replaces the simple sleep(1) loop (which was bogus) with a loop that just checks to see if we've seen the specified SBC value come back in a PresentCompleteNotify event yet.
The change is a bit larger than that as I've broken out a piece of common code to wait for and process a single Present event for the target drawable.
--- src/glx/dri3_glx.c | 55 ++++++++++++++++++++++++++++++++++++++---------------- 1 file changed, 39 insertions(+), 16 deletions(-)
src/glx/dri3_glx.c +39 -16
@@ -397,14 +397,33 @@ dri3_handle_present_event(struct dri3_drawable *priv, xcb_present_generic_event_free (ge); } +static bool +dri3_wait_for_event (__GLXDRIdrawable *pdraw) +{ +xcb_connection_t *c =XGetXCBConnection (pdraw->psc->dpy); +struct dri3_drawable *priv = (struct dri3_drawable *) pdraw; +xcb_generic_event_t *ev; +xcb_present_generic_event_t *ge; + + ev =xcb_wait_for_special_event (c, priv->special_event); +if (!ev) +return false; + ge = (void *) ev; +dri3_handle_present_event (priv, ge); +return true; +} + +/** dri3_wait_for_msc +* +* Get the X server to send an event when the target msc/divisor/remainder is +* reached. +*/ static int dri3_wait_for_msc (__GLXDRIdrawable *pdraw,int64_t target_msc,int64_t divisor,int64_t remainder,int64_t *ust,int64_t *msc,int64_t *sbc) {xcb_connection_t *c =XGetXCBConnection (pdraw->psc->dpy);struct dri3_drawable *priv = (struct dri3_drawable *) pdraw; -xcb_generic_event_t *ev; -xcb_present_generic_event_t *ge;uint32_t msc_serial;/* Ask for the an event for the target MSC */
@@ -421,11 +440,8 @@ dri3_wait_for_msc(__GLXDRIdrawable *pdraw, int64_t target_msc, int64_t divisor,/* Wait for the event */ if (priv->special_event) {while ((int32_t ) (msc_serial - priv->recv_msc_serial) >0 ) { - ev =xcb_wait_for_special_event (c, priv->special_event); -if (!ev) -break ; - ge = (void *) ev; -dri3_handle_present_event (priv, ge); +if (!dri3_wait_for_event (pdraw)) +return 0 ; } }
@@ -436,6 +452,11 @@ dri3_wait_for_msc(__GLXDRIdrawable *pdraw, int64_t target_msc, int64_t divisor,return 1 ; } +/** dri3_drawable_get_msc +* +* Return the current UST/MSC/SBC triplet by asking the server +* for an event +*/ static int dri3_drawable_get_msc (struct glx_screen *psc,__GLXDRIdrawable *pdraw,int64_t *ust,int64_t *msc,int64_t *sbc)
@@ -445,12 +466,9 @@ dri3_drawable_get_msc(struct glx_screen *psc, __GLXDRIdrawable *pdraw,/** dri3_wait_for_sbc * -* Wait for the swap buffer count to increase. The only way this -* can happen is if some other thread is doing swap buffers as -* we no longer share swap buffer counts with other processes. -* -* I'm not sure this is actually useful as such, and so this -* implementation is a kludge that just polls once a second +* Wait for the completed swap buffer count to reach the specified +* target. Presumably the application knows that this will be reached with +* outstanding complete events, or we're going to be here awhile. */ static int dri3_wait_for_sbc(__GLXDRIdrawable *pdraw, int64_t target_sbc, int64_t *ust,
@@ -458,10 +476,15 @@ dri3_wait_for_sbc(__GLXDRIdrawable *pdraw, int64_t target_sbc, int64_t *ust, {struct dri3_drawable *priv = (struct dri3_drawable *) pdraw; -while (priv->send_sbc < target_sbc) { -sleep (1 ); +while (priv->recv_sbc < target_sbc) { +if (!dri3_wait_for_event (pdraw)) +return 0 ; } -return dri3_wait_for_msc (pdraw,0 ,0 ,0 , ust, msc, sbc); + + *ust = priv->ust; + *msc = priv->msc; + *sbc = priv->recv_sbc; +return 1 ; }/**
Signature · 1 line
1.8.4.4
PATCH 4/4 dri3: Enable GLX_INTEL_swap_event
In reply to Keith PackardNow that we're tracking SBC values correctly, and the X server has the ability to send the GLX swap events from a PresentPixmap request, enable this extension.
--- src/glx/dri3_glx.c | 18 +----------------- 1 file changed, 1 insertion(+), 17 deletions(-)
src/glx/dri3_glx.c +1 -17
@@ -1525,23 +1525,7 @@ dri3_bind_extensions(struct dri3_screen *psc, struct glx_display * priv,__glXEnableDirectExtension (&psc->base,"GLX_SGI_swap_control" );__glXEnableDirectExtension (&psc->base,"GLX_MESA_swap_control" );__glXEnableDirectExtension (&psc->base,"GLX_SGI_make_current_read" ); - -/* -* GLX_INTEL_swap_event is broken on the server side, where it's -* currently unconditionally enabled. This completely breaks -* systems running on drivers which don't support that extension. -* There's no way to test for its presence on this side, so instead -* of disabling it unconditionally, just disable it for drivers -* which are known to not support it, or for DDX drivers supporting -* only an older (pre-ScheduleSwap) version of DRI2. -* -* This is a hack which is required until: -* http://lists.x.org/archives/xorg-devel/2013-February/035449.html -* is merged and updated xserver makes it's way into distros: -*/ -// if (pdp->swapAvailable && strcmp(driverName, "vmwgfx") != 0) { -// __glXEnableDirectExtension(&psc->base, "GLX_INTEL_swap_event"); -// } +__glXEnableDirectExtension (&psc->base,"GLX_INTEL_swap_event" ); mask = psc->image_driver->getAPIMask (psc->driScreen);
Signature · 1 line
1.8.4.4