Here we list rules to coalesce by. Given a queue of events to fire, which events can be filtered (removed/ignored)?

Events to coalesce

Some accessible events are subject of coalescence, i.e. events are filtered before delivery to AT. These events can be divided into groups.

Mutation events

There are show, hide and reorder accessible mutation events.

Show event

Show event is fired when accessible object should be created. The accessible object is created when its DOM node is appended to the DOM tree or is shown.

Hide event

Hide event is fired when accessible object is about to destroy. The accessible should be destroyed when its DOM node is removed from DOM or hidden.

Reorder event

Reorder event is fired for accessible which children were changed. Therefore reorder event is tightly related with show/hide events so that reorder event is created for every show/hide event.

However reorder event can be appended to the queue for coalescence without corresponding show event. It happens in the case when DOM node is appended (or shown) is not accessible but it might be accessible after timeout (because the DOM node frame is not created yet).

Text events

There are insert, remove and change text events. The insert event is fired when accessible text is inserted, remove when removed and change when portion of text is changed, i.e. when old text is replaced on new one.

The accessible text can be built from text nodes and DOM elements, for example, HTML br element is treated as caret return character, the same time arbitrary DOM elements within text container accessible are treated as special characters (called as embedded characters) of accessible text, so that, for example, HTML form controls can be a part of accessible text.

The text events are fired when data of text node is changed, text node or element are appended or removed. Text change events should be merged (coalesced) to prevent unnecessary AT processing of these events. For example, if children of HTML p element are removed

  <p>text<h1>heading</h1>text</p>

then only one text remove event should be fired.

Other events

In general other events aren't subject of coalescence from the tree, usually dupe events (i.e. events for the same target) are removed. However no events are expected from the accessible subtree that is destroyed, therefore ideally events should be coalesced with the hide events.

Test area

Test list

• Lazy frame construction insertBefore, bug 570500 (original test, bug 568430).
• Lazy frame construction appendChild, bug 570500, (original test, bug 568430)
• JS Progressive Raytracer, see bug 565452
• Table mutation, see bug 522847
• bug 521973 in attachments (bz said the test is quick with a11y)

Results of tests

All tests are run on my local machine: Intel Core i5, 4Gb, Windows 7 Home extended. Some tests consist of two parts: sync processing and async processing. If "failed" instead a number then I was failed to get results after 2 minutes. Every test run three times, tables present average value. Windows 7 SDK Accessible Event Watcher (AEW) (watching in context events) tool was used as AT.

Additional tests with NVDA were run by Marco on an Intel Core2Duo 6.67 gHz, 3 B of RAM, Windows 7 X64 with NVDA 2010.1.

Reference values table (06 June, trunk)

Performance improvements tracking table

Current implementation

Hidden priority

If a node N is hidden, then any events in the subtree denoted by N are filtered.

Ancestral priority

If a node N has been shown or hidden, then the event is filtered if there is another event in the queue for an ancestor node A that has been shown or hidden.

If a node N has been reordered, then the event is filtered if there is another event in the queue for an ancestor node A that has been reordered.

Siblings

Siblings have the same priority. This could mean for example, that if an event for a node N is to be filtered, then this decision is likely applicable to the same event for all siblings of N.

Bugs/ideas

General performance bugs

These bugs might be split into several bugs while fixing.

1. bug 565452 - Lots of seemingly unnecessary text change events; very slow code to generate them (perf improvement done on bug 575052)
2. bug 568430 - Perf of insertBefore testcase much much slower than test with appendChild
3. bug 522847 - Terrible accessibility performance on this testcase

Bugs tracking (what we did and do)

1. General improvements, get rid unnecessary query interfaces, bug 541618
2. Ignore layout changes that haven't affect on accessible tree, bug 570275.
3. CreateTextChangeEventForNode traverses array twice, bug and patch is coming

Ideas tracking (what we can do)

1. DOMNodeToHyperTextOffset is not performant
2. Coalesce events against the accessible tree.
3. Coalesce reorder events by their related show/hide events.
4. Map accessible tree to ordered set.

Raw brain dump section

Ignorable Cases: For a node N and a descendant node D, can a hide event for D ever come after a hide event for N in gecko?

Fire Hose detection: Would it be useful to detect when the events/time_delta ratio is too large to bother with; after which (when the ratio meets a certain threshold) we could fire the latest event of each type?