Merge lp:~om26er/ubuntu/oneiric/compiz/perf-sru into lp:ubuntu/oneiric-proposed/compiz

[Omer Akram]

merged Daniel's lp:~vanvugt/ubuntu/oneiric/compiz/fix-763005-oneiric with my branch for the fix of bug 764330

[Daniel van Vugt (vanvugt)]

This hasn't been merged at all. How do we fix the status?

[Martin Pitt (pitti)]

Set back to "needs review"

[Sebastien Bacher (seb128)]

it has been "merged":
https://launchpad.net/ubuntu/oneiric/+queue?queue_state=1&queue_text=compiz

I didn't bother using the vcs because launchpad import the package diffs when they packages are accepted by soyuz, but technically that has been uploaded and just need to be reviewed

=== modified file 'debian/changelog'
--- debian/changelog	2012-01-17 15:08:38 +0000
+++ debian/changelog	2012-02-10 11:28:19 +0000
@@ -1,3 +1,15 @@
+compiz (1:0.9.6+bzr20110929-0ubuntu6.2) oneiric-proposed; urgency=low
+
+  [ Daniel van Vugt ]
+  * Fix slow/stuttering display with fglrx (LP: #763005)
+
+  [ Omer Akram ]
+  * debian/patches/fix-764330.patch:
+    - Moving windows lags behind the mouse by 1-2 seconds;
+      appear to freeze when dragging. (LP: #764330)
+
+ -- Omer Akram <[e-mail]>  Fri, 10 Feb 2012 16:11:19 +0500
+
 compiz (1:0.9.6+bzr20110929-0ubuntu6.1) oneiric-proposed; urgency=low
 
   * debian/patches/fix_890947_synthetic_notifications.patch:

=== added file 'debian/patches/fix-764330.patch'
--- debian/patches/fix-764330.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/fix-764330.patch	2012-02-10 11:28:19 +0000
@@ -0,0 +1,92 @@
+=== modified file 'plugins/move/src/move.cpp'
+--- a/plugins/move/src/move.cpp	2011-10-12 10:44:49 +0000
++++ b/plugins/move/src/move.cpp	2012-02-08 05:06:13 +0000
+@@ -487,20 +487,8 @@
+ 	    w->move (wX + dx - w->geometry ().x (),
+ 		     wY + dy - w->geometry ().y (), false);
+ 
+-	    if (ms->optionGetLazyPositioning () &&
+-		ms->hasCompositing &&
+-		!MoveWindow::get (ms->w)->mLocked)
+-	    {
+-		/* FIXME: This form of lazy positioning is broken and should
+-		   be replaced asap. Current code exists just to avoid a
+-		   major performance regression in the 0.5.2 release. */
+-		w->serverGeometry ().setX (w->geometry ().x ());
+-		w->serverGeometry ().setY (w->geometry ().y ());
+-	    }
+-	    else
+-	    {
++	    if (!ms->optionGetLazyPositioning ())
+ 		w->syncPosition ();
+-	    }
+ 
+ 	    ms->x -= dx;
+ 	    ms->y -= dy;
+@@ -508,32 +496,6 @@
+     }
+ }
+ 
+-/* FIXME: This is a hack to prevent a race condition
+- * when core is processing ConfigureNotify events. It
+- * MUST be removed after 0.9.6 when we can break ABI
+- * and do lazy positioning correctly ! */
+-
+-void
+-MoveScreen::handleCompizEvent (const char *plugin, const char *event, CompOption::Vector &options)
+-{
+-    if (w)
+-    {
+-	if (std::string ("core") == std::string (plugin))
+-	{
+-	    if (std::string ("lock_position") == std::string (event))
+-	    {
+-		Window xid = CompOption::getIntOptionNamed (options, "window", 0);
+-		int    lock = CompOption::getIntOptionNamed (options, "active", 0);
+-
+-		if (xid == ROOTPARENT (w))
+-		    MoveWindow::get (w)->mLocked = lock ? true : false;
+-	    }
+-	}
+-    }
+-
+-    screen->handleCompizEvent (plugin, event, options);
+-}
+-
+ void
+ MoveScreen::handleEvent (XEvent *event)
+ {
+
+=== modified file 'plugins/move/src/move.h'
+--- a/plugins/move/src/move.h	2011-09-28 14:15:21 +0000
++++ b/plugins/move/src/move.h	2012-02-08 05:06:13 +0000
+@@ -61,9 +61,6 @@
+ 	void updateOpacity ();
+ 
+ 	void handleEvent (XEvent *);
+-	void handleCompizEvent (const char *plugin,
+-				const char *event,
+-				CompOption::Vector &options);
+ 
+ 	CompWindow *w;
+ 	int        savedX;
+@@ -101,8 +98,7 @@
+ 	    PluginClassHandler<MoveWindow,CompWindow> (window),
+ 	    window (window),
+ 	    gWindow (GLWindow::get (window)),
+-	    cWindow (CompositeWindow::get (window)),
+-	    mLocked (false)
++	    cWindow (CompositeWindow::get (window))
+ 	{
+ 	    if (gWindow)
+ 		GLWindowInterface::setHandler (gWindow, false);
+@@ -114,8 +110,6 @@
+ 	CompWindow      *window;
+ 	GLWindow        *gWindow;
+ 	CompositeWindow *cWindow;
+-
+-	bool            mLocked;
+ };
+ 
+ #define MOVE_SCREEN(s) \
+

=== added file 'debian/patches/fix_slow_vsync_lp763005.patch'
--- debian/patches/fix_slow_vsync_lp763005.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/fix_slow_vsync_lp763005.patch	2012-02-10 11:28:19 +0000
@@ -0,0 +1,145 @@
+Description: Fix slow/stuttering display when sync to Vblank is enabled.
+ For fglrx the cause appears to be an ATI/AMD driver bug where
+ glXGetVideoSyncSGI and glXWaitVideoSyncSGI are particularly slow, so we
+ can't afford to call both on every redraw or we end up with 1/3-1/2 framerate.
+ For intel and really all drivers, another cause appears to be excessive
+ waiting in the compiz architecture not allowing enough CPU time to draw the
+ full frame before the next vertical refresh.
+ This patch addresses both possible problems, providing optimal framerates
+ with sync-to-vblank support, most of the time.
+Author: Daniel van Vugt <[e-mail]>
+Bug-Ubuntu: https://launchpad.net/bugs/763005
+
+===================================================================
+--- old/plugins/opengl/src/screen.cpp	2011-09-12 08:09:46 +0000
++++ new/plugins/opengl/src/screen.cpp	2011-09-30 06:19:53 +0000
+@@ -36,6 +36,9 @@
+ #include <math.h>
+ 
+ namespace GL {
++    typedef int (*GLXSwapIntervalProc) (int interval);
++
++    GLXSwapIntervalProc      swapInterval = NULL;
+     GLXBindTexImageProc      bindTexImage = NULL;
+     GLXReleaseTexImageProc   releaseTexImage = NULL;
+     GLXQueryDrawableProc     queryDrawable = NULL;
+@@ -234,6 +237,12 @@
+ 	    getProcAddress ("glXWaitVideoSyncSGI");
+     }
+ 
++    if (strstr (glxExtensions, "GLX_SGI_swap_control"))
++    {
++	GL::swapInterval = (GL::GLXSwapIntervalProc)
++	    getProcAddress ("glXSwapIntervalSGI");
++    }
++
+     glXMakeCurrent (dpy, CompositeScreen::get (s)->output (), priv->ctx);
+ 
+     glExtensions = (const char *) glGetString (GL_EXTENSIONS);
+@@ -999,21 +1008,41 @@
+ 		priv->lastViewport.height);
+ }
+ 
++namespace GL
++{
++
++void
++waitForVideoSync ()
++{
++    if (GL::waitVideoSync)
++    {
++	// Don't wait twice. Just in case.
++	if (GL::swapInterval)
++	    (*GL::swapInterval) (0);
++
++	// Docs: http://www.opengl.org/registry/specs/SGI/video_sync.txt
++	unsigned int frameno;
++	(*GL::waitVideoSync) (1, 0, &frameno);
++    }
++}
++
++void
++controlSwapVideoSync (bool sync)
++{
++    // Docs: http://www.opengl.org/registry/specs/SGI/swap_control.txt
++    if (GL::swapInterval)
++	(*GL::swapInterval) (sync ? 1 : 0);
++    else if (sync)
++	waitForVideoSync ();
++}
++
++} // namespace GL
++
+ void
+ PrivateGLScreen::waitForVideoSync ()
+ {
+-    unsigned int sync;
+-
+-    if (!optionGetSyncToVblank ())
+-	return;
+-
+-    if (GL::getVideoSync)
+-    {
+-	glFlush ();
+-
+-	(*GL::getVideoSync) (&sync);
+-	(*GL::waitVideoSync) (2, (sync + 1) % 2, &sync);
+-    }
++    if (optionGetSyncToVblank ())
++        GL::waitForVideoSync ();
+ }
+ 
+ void
+@@ -1085,10 +1114,23 @@
+ 
+     targetOutput = &screen->outputDevs ()[0];
+ 
+-    waitForVideoSync ();
++    glFlush ();
+ 
++    //
++    // FIXME: Actually fix the composite plugin to be more efficient;
++    // If GL::swapInterval == NULL && GL::waitVideoSync != NULL then the
++    // composite plugin should not be imposing any framerate restriction
++    // (ie. blocking the CPU) at all. Because the framerate will be controlled
++    // and optimized here:
++    //
+     if (mask & COMPOSITE_SCREEN_DAMAGE_ALL_MASK)
+     {
++	//
++	// controlSwapVideoSync is much faster than waitForVideoSync because
++	// it won't block the CPU. The waiting is offloaded to the GPU.
++	// Unfortunately it only works with glXSwapBuffers in most drivers.
++	//
++	GL::controlSwapVideoSync (optionGetSyncToVblank ());
+ 	glXSwapBuffers (screen->dpy (), cScreen->output ());
+     }
+     else
+@@ -1096,6 +1138,7 @@
+ 	BoxPtr pBox;
+ 	int    nBox, y;
+ 
++	waitForVideoSync ();
+ 	pBox = const_cast <Region> (tmpRegion.handle ())->rects;
+ 	nBox = const_cast <Region> (tmpRegion.handle ())->numRects;
+ 
+@@ -1151,7 +1194,7 @@
+ bool
+ PrivateGLScreen::hasVSync ()
+ {
+-   return (GL::getVideoSync && optionGetSyncToVblank ());
++   return (GL::waitVideoSync && optionGetSyncToVblank ());
+ }
+ 
+ void
+@@ -1159,7 +1202,8 @@
+ {
+     if (pendingCommands)
+     {
+-	glFinish ();
++	// glFlush! glFinish would block the CPU, which is bad.
++	glFlush ();
+ 	pendingCommands = false;
+     }
+ }
+

=== modified file 'debian/patches/series'
--- debian/patches/series	2012-01-17 15:08:38 +0000
+++ debian/patches/series	2012-02-10 11:28:19 +0000
@@ -21,3 +21,5 @@
 fix_890947_synthetic_notifications.patch
 fix_focus_on_wrong_window_896762.patch
 java_offset_frame_extents_878934.patch
+fix_slow_vsync_lp763005.patch
+fix-764330.patch