Merge lp:~vanvugt/unity/regionalDamage into lp:unity

[Daniel van Vugt]

*PROTOTYPE*

Stop Unity from redrawing on every frame (ie. when it doesn't need to). It has a severe performance impact on graphics performance (LP: #988079)

For me, this branch eliminates the 25-30% slowdown experienced when unity is running with a single monitor. With 2 monitors, this branch eliminates the 75%(!) slowdown experienced when unity is running. Extrapolate and hypothesize as you like.

This also fixes bug 967112 and bug 992516. Probably more...

[Sam Spilsbury (smspillaz)]

Approve the concept, been wanting to do this for some time ;-)

[Sam Spilsbury (smspillaz)]

FYI, this is going to have pretty giant conflict with:

https://code.launchpad.net/~smspillaz/unity/unity.less-paint-insanity/+merge/110267

Since the "should we repaint" logic was moved into a separate file.

You should be able to get away with:

12 + /*
13 + * TODO: Figure out if we can ask compiz when:
14 + * output->containsFullscreenWindows();
15 + * and if true, then force doShellRepaint=false here.
16 + */
           bool doShellRepaint = wt->GetDrawList().size() > 0 ||
18 + BackgroundEffectHelper::HasDirtyHelpers() ||
19 + switcher_controller_->Visible() ||
20 + launcher_controller_->IsOverlayOpen() ||
21 + (mask & (PAINT_SCREEN_TRANSFORMED_MASK |
22 + PAINT_SCREEN_FULL_MASK |
23 + PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS_MASK));
24 +

if (doShellRepaint)
  ShellRepaintRequired ();

25 + /* Warning: ^ checking for PAINT_SCREEN_FULL_MASK is necessary right now
26 + * to avoid flickering. However it will nullify our performance
27 + * optimizations for people who have enabled "Force full screen
28 + * redraws" in the Workarounds plugin.
29 + */

A small note - it would certainly be nice if we had a method to get a collection of all the nux base windows.

[Daniel van Vugt (vanvugt)]

Rev 2405 is way out of date. Ignore it. Still in progress.

[Daniel van Vugt (vanvugt)]

I will fix conflicts as they arise :)

[Sam Spilsbury (smspillaz)]

Of course, just a heads up :)

[Sam Spilsbury (smspillaz)]

Tip on detecting if the shell is hidden (I did this once myself).

It might make more sense to use core's built in occlusion detection to figure this out. I think in that case when you get a redraw on a nux window, region will be empty in glPaint. That's worth double checking. (Also worth noting is that this only works if you disable removing the nux windows from the paint list, which should hopefully be done in the future)

[Daniel van Vugt (vanvugt)]

Well, the current method of detecting if the shell is occluded is working perfectly. It's also simple and fast. But there's still more testing to go and I'm open to any reasonable changes.

[Andrea Azzarone (azzar1)]

Fix bug 992516 for me too.
Regression: when I try to expand/collapse a dash category Unity freezes (not a crash).

[Sam Spilsbury (smspillaz)]

Sure, just using cores occlusion detection will be faster and less breakable. this will only work wehnwe arent removing nux windows from the paint list.

[Andrea Azzarone (azzar1)]

> Fix bug 992516 for me too.
> Regression: when I try to expand/collapse a dash category Unity freezes (not a
> crash).

Nvm. The freeze no longer happens.

[Sam Spilsbury (smspillaz)]

I've noticed that on multiple monitors there is definitely a feedback effect, where compizDamageNux causes something on the second screen to redraw, and then that redraw region is fed right back to us in glPaintOutput which causes that thing to be queued for redraw again.

I'll let you come to your own ideas on this, but one "solution" I've found (and I say "solution" because it has known problems which I think are fixable, more on that on a bit) is to use damageRegion to compute the dirty regions that need redrawing so that we can use the wrap handlers to avoid feedback. For example:

=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp 2012-06-17 14:17:45 +0000
+++ plugins/unityshell/src/unityshell.cpp 2012-06-17 14:18:38 +0000
@@ -1306,34 +1306,35 @@
 {
   bool ret;
+
+ bool requiring_repaint = false;
+
   // A few cases where we want to force the shell to be painted
- if (forcePaintOnTop() ||
- PluginAdapter::Default()->IsExpoActive() ||
+ if ((GetProhibitedPaintMasks () & ShellPaintRequestorInterface::WindowPaintRequestor) ||
+ PluginAdapter::Default ()->IsExpoActive() ||
       (mask & (PAINT_SCREEN_TRANSFORMED_MASK |
                PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS_MASK)))
   {
- compizDamageNux(region);
- doShellRepaint = true;
+ requiring_repaint = true;
   }
   else if (shellIsHidden(*output))
   {
     // Don't ever waste GPU and CPU rendering the shell in games/benchmarks!
- doShellRepaint = false;
+ requiring_repaint = false;
   }
   else
   {
- compizDamageNux(region);
- doShellRepaint = wt->GetDrawList().size() > 0 ||
- BackgroundEffectHelper::HasDirtyHelpers();
+ bool isDamaged = RegionIsNuxDamaged (CompRegion (*output));
+ requiring_repaint = isDamaged &&
+ (wt->GetDrawList().size() > 0 ||
+ BackgroundEffectHelper::HasDirtyHelpers());
   }

   /* glPaintOutput is part of the opengl plugin, so we need the GLScreen base class. */
@@ -1419,6 +1416,19 @@

 }

+bool UnityScreen::RegionIsNuxDamaged (const CompRegion &r)
+{
+ static CompRegion tmp = emptyRegion;
+
+ tmp &= emptyRegion;
+ tmp |= r;
+ tmp &= nux_damage_;
+
+ nux_damage_ -= tmp;
+
+ return !tmp.isEmpty ();
+}
+

^ Checks if a particular output region has damaged nux regions intersecting the output region that came from damageRegion

 void UnityScreen::donePaint()
 {
   std::list <ShowdesktopHandlerWindowInterface *> remove_windows;
@@ -1491,8 +1501,6 @@
 /* Grab changed nux regions and add damage rects for them */
 void UnityScreen::nuxDamageCompiz()
 {
- CompRegion nux_damage;
-
   if (damaged)
     return;

@@ -1503,7 +1511,7 @@
        it != end; ++it)
   {
     nux::Geometry const& geo = *it;
- nux_damage += CompRegion(geo.x, geo.y, geo.width, geo.height);
+ nux_damage_ += CompRegion(geo.x, geo.y, geo.width, geo.height);
   }

   // launcher_controller_ will still be null on startup
@@ -1518,22 +1526,22 @@
         if (!tooltip.IsNull())
         {
           const nux::Geometry &g = tooltip->GetAbsoluteGeometry();
- nux_damage += CompRegion(g.x, g.y, g.width, g.height)...

[Sam Spilsbury (smspillaz)]

(These feedback problems make it good to think about testing too...)

[Daniel van Vugt (vanvugt)]

I haven't even begun multi-monitor testing. Will do this week. Please wait...

[Sam Spilsbury (smspillaz)]

On Mon, 18 Jun 2012, Daniel van Vugt wrote:

> I haven't even begun multi-monitor testing. Will do this week. Please wait...

No problem, I've just been playing around with the branch because I want
faster rendering :P

> --
> https://code.launchpad.net/~vanvugt/unity/regionalDamage/+merge/109809
> Your team DX Unity Bugs is subscribed to branch lp:unity.
>

[Sam Spilsbury (smspillaz)]

(Small update, moving wt->ClearDrawList () to donePaint instead of glPaintOutput fixes most of the annoyances to do with flicking. No nux patching needed)

[Daniel van Vugt (vanvugt)]

Looks like this fix now depends on bug 1014610 being resolved for Nux :(

=== modified file 'launcher/AbstractLauncherIcon.h'
--- launcher/AbstractLauncherIcon.h	2012-06-06 15:40:19 +0000
+++ launcher/AbstractLauncherIcon.h	2012-06-19 09:18:19 +0000
@@ -218,6 +218,7 @@
 
   sigc::signal<void, AbstractLauncherIcon::Ptr> needs_redraw;
   sigc::signal<void, AbstractLauncherIcon::Ptr> remove;
+  sigc::signal<void, nux::ObjectPtr<nux::View>> tooltip_visible;
   sigc::signal<void> visibility_changed;
 
   sigc::connection needs_redraw_connection;

=== modified file 'launcher/Launcher.cpp'
--- launcher/Launcher.cpp	2012-06-15 02:03:31 +0000
+++ launcher/Launcher.cpp	2012-06-19 09:18:19 +0000
@@ -1520,6 +1520,11 @@
   }
 }
 
+nux::ObjectPtr<nux::View> Launcher::GetActiveTooltip() const
+{
+  return _active_tooltip;
+}
+
 void Launcher::SetActionState(LauncherActionState actionstate)
 {
   if (_launcher_action_state == actionstate)
@@ -1681,6 +1686,7 @@
   EnsureAnimation();
 
   icon->needs_redraw.connect(sigc::mem_fun(this, &Launcher::OnIconNeedsRedraw));
+  icon->tooltip_visible.connect(sigc::mem_fun(this, &Launcher::OnTooltipVisible));
 }
 
 void Launcher::OnIconRemoved(AbstractLauncherIcon::Ptr icon)
@@ -1757,6 +1763,11 @@
   EnsureAnimation();
 }
 
+void Launcher::OnTooltipVisible(nux::ObjectPtr<nux::View> view)
+{
+  _active_tooltip = view;
+}
+
 void Launcher::Draw(nux::GraphicsEngine& GfxContext, bool force_draw)
 {
 

=== modified file 'launcher/Launcher.h'
--- launcher/Launcher.h	2012-06-15 02:03:31 +0000
+++ launcher/Launcher.h	2012-06-19 09:18:19 +0000
@@ -96,6 +96,8 @@
     return _parent;
   };
 
+  nux::ObjectPtr<nux::View> GetActiveTooltip() const;  // nullptr = no tooltip
+
   virtual void RecvMouseUp(int x, int y, unsigned long button_flags, unsigned long key_flags);
   virtual void RecvMouseDown(int x, int y, unsigned long button_flags, unsigned long key_flags);
   virtual void RecvMouseDrag(int x, int y, int dx, int dy, unsigned long button_flags, unsigned long key_flags);
@@ -269,6 +271,7 @@
   void OnOrderChanged();
 
   void OnIconNeedsRedraw(AbstractLauncherIcon::Ptr icon);
+  void OnTooltipVisible(nux::ObjectPtr<nux::View> view);
 
   void OnOverlayHidden(GVariant* data);
   void OnOverlayShown(GVariant* data);
@@ -311,6 +314,7 @@
 
   LauncherModel::Ptr _model;
   nux::BaseWindow* _parent;
+  nux::ObjectPtr<nux::View> _active_tooltip;
   QuicklistView* _active_quicklist;
 
   nux::HLayout* m_Layout;

=== modified file 'launcher/LauncherIcon.cpp'
--- launcher/LauncherIcon.cpp	2012-06-19 01:00:36 +0000
+++ launcher/LauncherIcon.cpp	2012-06-19 09:18:19 +0000
@@ -513,6 +513,7 @@
     LoadTooltip();
   _tooltip->ShowTooltipWithTipAt(tip_x, tip_y);
   _tooltip->ShowWindow(!tooltip_text().empty());
+  tooltip_visible.emit(_tooltip);
 }
 
 void
@@ -534,6 +535,7 @@
 
   if (_tooltip)
     _tooltip->ShowWindow(false);
+  tooltip_visible.emit(nux::ObjectPtr<nux::View>(nullptr));
 }
 
 bool LauncherIcon::OpenQuicklist(bool select_first_item, int monitor)
@@ -653,6 +655,7 @@
 {
   if (_tooltip)
     _tooltip->ShowWindow(false);
+  tooltip_visible.emit(nux::ObjectPtr<nux::View>(nullptr));
 }
 
 bool

=== modified file 'panel/PanelController.cpp'
--- panel/PanelController.cpp	2012-06-15 02:03:31 +0000
+++ panel/PanelController.cpp	2012-06-19 09:18:19 +0000
@@ -49,6 +49,7 @@
   void QueueRedraw();
 
   std::vector<Window> GetTrayXids() const;
+  std::vector<nux::View*> GetPanelViews() const;
   std::vector<nux::Geometry> GetGeometries() const;
 
   // NOTE: nux::Property maybe?
@@ -106,6 +107,15 @@
   return xids;
 }
 
+std::vector<nux::View*> Controller::Impl::GetPanelViews() const
+{
+  std::vector<nux::View*> views;
+  views.reserve(windows_.size());
+  for (auto window: windows_)
+    views.push_back(ViewForWindow(window));
+  return views;
+}
+
 std::vector<nux::Geometry> Controller::Impl::GetGeometries() const
 {
   std::vector<nux::Geometry> geometries;
@@ -325,6 +335,11 @@
   return pimpl->GetTrayXids();
 }
 
+std::vector<nux::View*> Controller::GetPanelViews() const
+{
+  return pimpl->GetPanelViews();
+}
+
 std::vector<nux::Geometry> Controller::GetGeometries() const
 {
   return pimpl->GetGeometries();

=== modified file 'panel/PanelController.h'
--- panel/PanelController.h	2012-05-06 23:48:38 +0000
+++ panel/PanelController.h	2012-06-19 09:18:19 +0000
@@ -41,6 +41,7 @@
   void QueueRedraw();
 
   std::vector<Window> GetTrayXids() const;
+  std::vector<nux::View*> GetPanelViews() const;
   std::vector<nux::Geometry> GetGeometries() const;
 
   // NOTE: nux::Property maybe?

=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2012-06-15 02:03:31 +0000
+++ plugins/unityshell/src/unityshell.cpp	2012-06-19 09:18:19 +0000
@@ -1204,7 +1204,20 @@
 {
   bool ret;
 
-  doShellRepaint = true;
+  /*
+   * Very important!
+   * Don't waste GPU and CPU rendering the shell on every frame if you don't
+   * need to. Doing so on every frame causes Nux to hog the GPU and slow down
+   * all other OpenGL apps (LP: #988079)
+   */
+  if (forcePaintOnTop() || PluginAdapter::Default()->IsExpoActive())
+    doShellRepaint = true;
+  else if (region.isEmpty() || shellIsHidden(*output))
+    doShellRepaint = false;
+  else
+    doShellRepaint = wt->GetDrawList().size() > 0 ||
+                     BackgroundEffectHelper::HasDirtyHelpers();
+
   allowWindowPaint = true;
   _last_output = output;
   paint_panel_ = false;
@@ -1220,7 +1233,8 @@
    *   attempts to bind it will only increment
    *   its bind reference so make sure that
    *   you always unbind as much as you bind */
-  _fbo->bind (nux::Geometry (output->x (), output->y (), output->width (), output->height ()));
+  if (doShellRepaint)
+    _fbo->bind (nux::Geometry (output->x (), output->y (), output->width (), output->height ()));
 #endif
 
   /* glPaintOutput is part of the opengl plugin, so we need the GLScreen base class. */
@@ -1279,16 +1293,20 @@
   for (ShowdesktopHandlerWindowInterface *wi : ShowdesktopHandler::animating_windows)
     wi->HandleAnimations (ms);
 
+  // Workaround Nux bug LP: #1014610:
   if (damaged)
   {
     damaged = false;
-    damageNuxRegions();
+    nuxDamageCompiz();
   }
 
+  compizDamageNux(cScreen->currentDamage());
 }
 
 void UnityScreen::donePaint()
 {
+  wt->ClearDrawList();
+
   std::list <ShowdesktopHandlerWindowInterface *> remove_windows;
 
   for (ShowdesktopHandlerWindowInterface *wi : ShowdesktopHandler::animating_windows)
@@ -1309,11 +1327,94 @@
   cScreen->donePaint ();
 }
 
+bool UnityScreen::shellIsHidden(const CompOutput &output)
+{
+  bool hidden = false;
+  const std::vector<Window> &nuxwins(nux::XInputWindow::NativeHandleList());
+
+  // Loop through windows from back to front
+  for (CompWindow *w : screen->windows ())
+  {
+    /*
+     * The shell is hidden if there exists any window that fully covers
+     * the output and is in front of all Nux windows on that output.
+     * We could also check CompositeWindow::opacity() but that would be slower
+     * and almost always pointless.
+     */
+    if (w->isMapped() &&
+        w->isViewable() &&
+        !w->inShowDesktopMode() &&  // Why must this != isViewable?
+        w->geometry().contains(output))
+    {
+      hidden = true;
+    }
+    else if (hidden)
+    {
+      for (Window n : nuxwins)
+      {
+        if (w->id() == n && output.intersects(w->geometry()))
+        {
+          hidden = false;
+          break;
+        }
+      }
+    }
+  }
+
+  return hidden;
+}
+
+void UnityScreen::compizDamageNux(const CompRegion &damage)
+{
+  auto launchers = launcher_controller_->launchers();
+  for (auto launcher : launchers)
+  {
+    if (!launcher->Hidden())
+    {
+      nux::Geometry geo = launcher->GetAbsoluteGeometry();
+      CompRegion launcher_region(geo.x, geo.y, geo.width, geo.height);
+      if (damage.intersects(launcher_region))
+        launcher->QueueDraw();
+      nux::ObjectPtr<nux::View> tooltip = launcher->GetActiveTooltip();
+      if (!tooltip.IsNull())
+      {
+        nux::Geometry tip = tooltip->GetAbsoluteGeometry();
+        CompRegion tip_region(tip.x, tip.y, tip.width, tip.height);
+        if (damage.intersects(tip_region))
+          tooltip->QueueDraw();
+      }
+    }
+  }
+
+  const std::vector<nux::View*> &panels(panel_controller_->GetPanelViews());
+  for (nux::View *view : panels)
+  {
+    nux::Geometry geo = view->GetAbsoluteGeometry();
+    CompRegion panel_region(geo.x, geo.y, geo.width, geo.height);
+    if (damage.intersects(panel_region))
+      view->QueueDraw();
+  }
+
+  QuicklistManager *qm = QuicklistManager::Default();
+  if (qm)
+  {
+    QuicklistView *view = qm->Current();
+    if (view)
+    {
+      nux::Geometry geo = view->GetAbsoluteGeometry();
+      CompRegion quicklist_region(geo.x, geo.y, geo.width, geo.height);
+      if (damage.intersects(quicklist_region))
+        view->QueueDraw();
+    }
+  }
+}
+
 /* Grab changed nux regions and add damage rects for them */
-void UnityScreen::damageNuxRegions()
+void UnityScreen::nuxDamageCompiz()
 {
   CompRegion nux_damage;
 
+  // Workaround Nux bug LP: #1014610 (unbounded DrawList growth)
   if (damaged)
     return;
 
@@ -1327,12 +1428,23 @@
     nux_damage += CompRegion(geo.x, geo.y, geo.width, geo.height);
   }
 
-  nux::Geometry geo = wt->GetWindowCompositor().GetTooltipMainWindowGeometry();
-  nux_damage += CompRegion(geo.x, geo.y, geo.width, geo.height);
-
-  geo = lastTooltipArea;
-  nux_damage += CompRegion(lastTooltipArea.x, lastTooltipArea.y,
-                         lastTooltipArea.width, lastTooltipArea.height);
+  // launcher_controller_ will still be null on startup
+  if (launcher_controller_.get())
+  {
+    auto launchers = launcher_controller_->launchers();
+    for (auto launcher : launchers)
+    {
+      if (!launcher->Hidden())
+      {
+        nux::ObjectPtr<nux::View> tooltip = launcher->GetActiveTooltip();
+        if (!tooltip.IsNull())
+        {
+          const nux::Geometry &g = tooltip->GetAbsoluteGeometry();
+          nux_damage += CompRegion(g.x, g.y, g.width, g.height);
+        }
+      }
+    }
+  }
 
   /*
    * Avoid Nux damaging Nux as recommended by smspillaz. Though I don't
@@ -1341,10 +1453,6 @@
   cScreen->damageRegionSetEnabled(this, false);
   cScreen->damageRegion(nux_damage);
   cScreen->damageRegionSetEnabled(this, true);
-
-  wt->ClearDrawList();
-
-  lastTooltipArea = geo;
 }
 
 /* handle X Events */
@@ -1511,6 +1619,8 @@
     BackgroundEffectHelper::ProcessDamage(geo);
   }
 
+  compizDamageNux(region);
+
   cScreen->damageRegion(region);
 }
 
@@ -2527,25 +2637,7 @@
 
 void UnityScreen::onRedrawRequested()
 {
-  // disable blur updates so we dont waste perf. This can stall the blur during animations
-  // but ensures a smooth animation.
-  if (_in_paint)
-  {
-    if (!sources_.GetSource(local::REDRAW_IDLE))
-    {
-      auto redraw_idle(std::make_shared<glib::Idle>(glib::Source::Priority::DEFAULT));
-      sources_.Add(redraw_idle, local::REDRAW_IDLE);
-
-      redraw_idle->Run([&]() {
-        onRedrawRequested();
-        return false;
-      });
-    }
-  }
-  else
-  {
-    damageNuxRegions();
-  }
+  nuxDamageCompiz();
 }
 
 /* Handle option changes and plug that into nux windows */

=== modified file 'plugins/unityshell/src/unityshell.h'
--- plugins/unityshell/src/unityshell.h	2012-06-15 02:03:31 +0000
+++ plugins/unityshell/src/unityshell.h	2012-06-19 09:18:19 +0000
@@ -212,7 +212,12 @@
 
   bool initPluginActions();
   void initLauncher();
-  void damageNuxRegions();
+
+  void compizDamageNux(const CompRegion &region);
+  void nuxDamageCompiz();
+
+  bool shellIsHidden(const CompOutput &output);
+
   void onRedrawRequested();
   void Relayout();
 
@@ -255,7 +260,6 @@
   bool enable_shortcut_overlay_;
 
   GestureEngine                         gesture_engine_;
-  nux::Geometry                         lastTooltipArea;
   bool                                  needsRelayout;
   bool                                  _in_paint;
   bool                                  super_keypressed_;