Version 5 (modified by Jon Davis, 7 years ago) (diff)


Display Lists

2015 Display List Experiment

  • Recording GraphicsContext calls, and playing them back later
  • Drive GraphicsContext cleanup
  • Perf gains
  • Per-compositing layer
  • Logging


  • Display list mutation (some CSS animations, GIFs, scrolling)
  • Repaint
  • Occlusion detection, state change optimization
  • Shared display list segments
  • Paint-to-paint caching
    • Text

Display List Rendering

What is display list rendering?

  • Reduces expensive traversal of the render tree for each tile
  • Converts some paints to pure display-list operations, such as:

GIF animation, CSS animations, scrolling

  • We can also potentially use display lists to paint off the main thread

What can we gain from display lists?

  • Many optimizations we can fit in to our existing code as one-off optimizations, but display lists provide a common way of reasoning about these optimizations
  • Make WK code more efficient by eliminating useless repaints, using precomputed display lists

Better culling (accurate extent information): we can use the display list to compute the exact bounds of what needs to be repainted, allowing us to tighten the repaint rect Can optimize noops out of the painting code Occlusion detection and clipping Can reorder operations for better batching

  • Reuse display lists in a single painting pass (e.g. SVG images, <use>)
  • Can keep display lists around between painting passes (e.g. across different tiles)
  • We have opportunities to cache display lists

Text rendering: don’t have to recompute kerning, glyphs (?)

  • We can log all the painting commands that happen

Developer tools implications: can use display list logs to tell which elements are the most costly to render, or perhaps scrub through the painting of a page Can also use display lists to help layout testing

What are the biggest challenges?

  • For painting off the main thread: CA doesn’t play well with this, GraphicsContext is non-threadsafe
  • Map of RenderObject -> DisplayItem could use a lot of memory
  • Measuring performance gain: often run into unexpected perf issues, weird/unexpected CG behaviors
  • Testing: make sure the switch to display lists doesn’t introduce regressions

The prototype

  • For a particular call into GraphicsContext, we record what the GraphicsContext does
  • Packages up params of calls to GraphicsContext
  • updateItemExtent(DrawingItem): This gets the local bounds of the item and maps into global coordinates taking transforms/shadows into account

Performance data

  • Perf relative to non-display-list mode is similar on iPad and iMac
  • Text is strange – should be much faster, but we seem to spend a lot of time waiting for CG
  • In cases where perf goes down, we spend less time in web code – we seem to get throttled by CG
  • Paint time dwarfs record time
  • Even if we don’t see a performance gain, we might be using fewer CPU cycles, so less power

Next steps

  • Contact other teams (e.g. CA). Maybe get a way from CA to draw from another thread?
  • Continue investigating perf regressions vs. normal rendering
  • Consider cleaning up GraphicsContext
  • Form controls currently grab the platform context out of the context, so they need to be optimized to work with display lists

Other comments

  • Renderer knows about the display lists it generates
  • Geoff: if we can fix the 2 bugs with display lists, it would give us matching and/or better perf across the board
  • Sam: may want to consider a tree structure for when we want to mutate display list operations efficiently
  • Simon: maybe lower the level of diplay list recording to the platform context