ParseHTMLOnMainThread: notify main thread of chunks less frequently

ParseHTMLOnMainThread: notify main thread of chunks less frequently

This patch adds an experiment variant to the
ParseHTMLOnMainThread experiment threaded group. It adds
a group that uses the threaded parser, but coalesces token
chunks in the background parser, notifying the main thread
less often. This can often result in issuing preloads faster
due to not eagerly parsing/scripting when tokens are about to
come in.

Note: this experiment group actually aligns the threaded behavior
closer to the non-threaded behavior. The non-threaded experiment
group also runs the entirety of pumpTokenizer when it is tokenizing,
whereas the threaded parser usually starts parsing at the first call to
notifyPendingTokenizedChunks (if it is idle). This is usually very early
on in pumpTokenizer, because we split up chunks very fine grained.
This experiment group tries not to start the main thread parsing until
we've tokenized a bit more.

TBR=kinuko@chromium.org

BUG=632394
Committed: https://crrev.com/803fb39346006820c009f206dc05dd62b12e82ee
Cr-Commit-Position: refs/heads/master@{#408537}

[Charlie Harrison, 2016-06-15 06:20:42]

csharrison@chromium.org changed reviewers:
+ kouhei@chromium.org

[Charlie Harrison, 2016-06-15 06:20:43]

Kouhei, can you take a look at this approach? It may be a bit too extreme.

[kouhei (in TOK), 2016-06-15 07:09:03]

Thanks for working on this! This is a great find!
I'm ok with trying this experiment, but I want more data on this so that you can
maximize your impact from this work :)
Can we Finch this? Would you provide traces of demonstrative page load w/+w/o
the patch? Would you run PCv2/wptorg?

[Charlie Harrison, 2016-06-15 20:15:21]

On 2016/06/15 at 07:09:03, kouhei wrote:
> Thanks for working on this! This is a great find!
> I'm ok with trying this experiment, but I want more data on this so that you
can maximize your impact from this work :)
> Can we Finch this? Would you provide traces of demonstrative page load w/+w/o
the patch? Would you run PCv2/wptorg?

I wonder if we should finch this in isolation or in conjunction with the changes
to documentElementAvailable? Now that we know that the documentElementAvailable
can cause regressions in some artificial pages
(http://stevesouders.com/cuzillion/?c0=hb0hfff0_2_f&c1=hc1hfff2_0_f&c2=hc1hfff...),
it may make sense to finch it.

Especially considering that this change which fixes that site is a bit more
extreme than the original change.

WDYT?

[Charlie Harrison, 2016-07-22 21:08:39]

I wonder if we can rework this so it doesn't need finch? I'm noticing a lot of
sites hitting this case (first chunks don't have preloads).

I know there have been a lot of hacks added, but I'd like to find a reasonable
solution for the first set of preloads. If we could just defer notifying the
main thread for 25-50 tokens, I think it would drastically improve a lot of
pages (for users with extensions). On my workstation with a few active
extensions, I'm seeing 70ms delays that could be cut down to 0.

[Charlie Harrison, 2016-07-26 21:32:48]

The CQ bit was checked by csharrison@chromium.org to run a CQ dry run

[commit-bot: I haz the power, 2016-07-26 21:33:26]

Dry run: CQ is trying da patch. Follow status at
 
https://chromium-cq-status.appspot.com/v2/patch-status/codereview.chromium.or...

[Charlie Harrison, 2016-07-26 22:42:48]

Ok. I reworked this so that we only change the initial call to pumpTokenizer.
This is where I see idle network the most in traces.

[commit-bot: I haz the power, 2016-07-26 22:45:49]

The CQ bit was unchecked by commit-bot@chromium.org

[commit-bot: I haz the power, 2016-07-26 22:45:50]

Dry run: This issue passed the CQ dry run.

[Charlie Harrison, 2016-07-26 22:47:13]

Note that this doesn't really affect the ParseHTMLOnMainThread experiment as it
currently stands, because we never quit the while loop if it is running on the
main thread (i.e. we always tokenize to the end before starting to parse).

Still, I think this is worthwhile and is very low hanging fruit for a lot of
sites.

[Charlie Harrison, 2016-07-27 19:10:34]

Sorry, I've changed my mind again on this, and think we should go back to PS #1.
Too often the first call to notify the main thread has no preloads, and we don't
actually initialize the preloads for a long time.

[kouhei (in TOK), 2016-07-28 01:28:16]

I have no objections to PS#1 approach, but I really want to have some gating
before we land this optimization.
Can we default-enable this, but have some population disable this so that we can
compare them?

[Charlie Harrison, 2016-07-28 01:30:19]

Yeah SG.

[Charlie Harrison, 2016-07-28 16:57:31]

The CQ bit was checked by csharrison@chromium.org to run a CQ dry run

[commit-bot: I haz the power, 2016-07-28 16:57:49]

Dry run: CQ is trying da patch. Follow status at
 
https://chromium-cq-status.appspot.com/v2/patch-status/codereview.chromium.or...

[Charlie Harrison, 2016-07-28 17:06:00]

Description was changed from

==========
Notify the main thread of parsed chunks less frequently

BUG=
==========

to

==========
Notify the main thread of parsed chunks less frequently

This patch adds an experiment variant to the
ParseHTMLOnMainThread experiment threaded group. It adds
a group that uses the threaded parser, but coalesces token
chunks in the background parser, notifying the main thread
less often. This can often result in issuing preloads faster
due to not eagerly parsing/scripting when tokens are about to
come in.

BUG=632394
==========

[Charlie Harrison, 2016-07-28 17:07:06]

Description was changed from

==========
Notify the main thread of parsed chunks less frequently

This patch adds an experiment variant to the
ParseHTMLOnMainThread experiment threaded group. It adds
a group that uses the threaded parser, but coalesces token
chunks in the background parser, notifying the main thread
less often. This can often result in issuing preloads faster
due to not eagerly parsing/scripting when tokens are about to
come in.

BUG=632394
==========

to

==========
Notify the main thread of parsed chunks less frequently

This patch adds an experiment variant to the
ParseHTMLOnMainThread experiment threaded group. It adds
a group that uses the threaded parser, but coalesces token
chunks in the background parser, notifying the main thread
less often. This can often result in issuing preloads faster
due to not eagerly parsing/scripting when tokens are about to
come in.

TBR=kinuko@chromium.org

BUG=632394
==========

[Charlie Harrison, 2016-07-28 17:08:17]

Alright, I decided to add this group to the ParseHTMLOnMainThread experiment
(for the threaded group). PTAL?

I will also try to get this merged into M53 if all goes well.

+kinuko TBR for comment in //content.

[commit-bot: I haz the power, 2016-07-28 18:17:05]

The CQ bit was unchecked by commit-bot@chromium.org

[commit-bot: I haz the power, 2016-07-28 18:17:06]

Dry run: This issue passed the CQ dry run.

[kouhei (in TOK), 2016-07-29 00:41:16]

On 2016/07/28 17:08:17, csharrison wrote:
> Alright, I decided to add this group to the ParseHTMLOnMainThread experiment
> (for the threaded group). PTAL?
lgtm

[Charlie Harrison, 2016-07-29 00:53:59]

Description was changed from

==========
Notify the main thread of parsed chunks less frequently

This patch adds an experiment variant to the
ParseHTMLOnMainThread experiment threaded group. It adds
a group that uses the threaded parser, but coalesces token
chunks in the background parser, notifying the main thread
less often. This can often result in issuing preloads faster
due to not eagerly parsing/scripting when tokens are about to
come in.

TBR=kinuko@chromium.org

BUG=632394
==========

to

==========
Notify the main thread of parsed chunks less frequently

This patch adds an experiment variant to the
ParseHTMLOnMainThread experiment threaded group. It adds
a group that uses the threaded parser, but coalesces token
chunks in the background parser, notifying the main thread
less often. This can often result in issuing preloads faster
due to not eagerly parsing/scripting when tokens are about to
come in.

Note: this experiment group actually aligns the threaded behavior
closer to the non-threaded behavior. The non-threaded experiment
group has also runs the entirety of pumpTokenizer when it is tokenizing,
whereas the threaded parser usually starts parsing at the first call to
notifyPendingTokenizedChunks (if it is idle). This experiment group tries
not to start the main thread parsing until we've tokenized a bit more.
TBR=kinuko@chromium.org

BUG=632394
==========

[Charlie Harrison, 2016-07-29 00:55:31]

Description was changed from

==========
Notify the main thread of parsed chunks less frequently

This patch adds an experiment variant to the
ParseHTMLOnMainThread experiment threaded group. It adds
a group that uses the threaded parser, but coalesces token
chunks in the background parser, notifying the main thread
less often. This can often result in issuing preloads faster
due to not eagerly parsing/scripting when tokens are about to
come in.

Note: this experiment group actually aligns the threaded behavior
closer to the non-threaded behavior. The non-threaded experiment
group has also runs the entirety of pumpTokenizer when it is tokenizing,
whereas the threaded parser usually starts parsing at the first call to
notifyPendingTokenizedChunks (if it is idle). This experiment group tries
not to start the main thread parsing until we've tokenized a bit more.
TBR=kinuko@chromium.org

BUG=632394
==========

to

==========
Notify the main thread of parsed chunks less frequently

This patch adds an experiment variant to the
ParseHTMLOnMainThread experiment threaded group. It adds
a group that uses the threaded parser, but coalesces token
chunks in the background parser, notifying the main thread
less often. This can often result in issuing preloads faster
due to not eagerly parsing/scripting when tokens are about to
come in.

Note: this experiment group actually aligns the threaded behavior
closer to the non-threaded behavior. The non-threaded experiment
group also runs the entirety of pumpTokenizer when it is tokenizing,
whereas the threaded parser usually starts parsing at the first call to
notifyPendingTokenizedChunks (if it is idle). This is usually very early
on in pumpTokenizer, because we split up chunks very fine grained.
This experiment group tries not to start the main thread parsing until 
we've tokenized a bit more.

TBR=kinuko@chromium.org

BUG=632394
==========

[Charlie Harrison, 2016-07-29 00:56:06]

Thank you. I've updated the description to state a bit clearer why this fits
into the threaded experiment. Landing!

[Charlie Harrison, 2016-07-29 00:56:53]

Description was changed from

==========
Notify the main thread of parsed chunks less frequently

This patch adds an experiment variant to the
ParseHTMLOnMainThread experiment threaded group. It adds
a group that uses the threaded parser, but coalesces token
chunks in the background parser, notifying the main thread
less often. This can often result in issuing preloads faster
due to not eagerly parsing/scripting when tokens are about to
come in.

Note: this experiment group actually aligns the threaded behavior
closer to the non-threaded behavior. The non-threaded experiment
group also runs the entirety of pumpTokenizer when it is tokenizing,
whereas the threaded parser usually starts parsing at the first call to
notifyPendingTokenizedChunks (if it is idle). This is usually very early
on in pumpTokenizer, because we split up chunks very fine grained.
This experiment group tries not to start the main thread parsing until 
we've tokenized a bit more.

TBR=kinuko@chromium.org

BUG=632394
==========

to

==========
ParseHTMLOnMainThread: notify main thread of chunks less frequently

This patch adds an experiment variant to the
ParseHTMLOnMainThread experiment threaded group. It adds
a group that uses the threaded parser, but coalesces token
chunks in the background parser, notifying the main thread
less often. This can often result in issuing preloads faster
due to not eagerly parsing/scripting when tokens are about to
come in.

Note: this experiment group actually aligns the threaded behavior
closer to the non-threaded behavior. The non-threaded experiment
group also runs the entirety of pumpTokenizer when it is tokenizing,
whereas the threaded parser usually starts parsing at the first call to
notifyPendingTokenizedChunks (if it is idle). This is usually very early
on in pumpTokenizer, because we split up chunks very fine grained.
This experiment group tries not to start the main thread parsing until 
we've tokenized a bit more.

TBR=kinuko@chromium.org

BUG=632394
==========

[Charlie Harrison, 2016-07-29 00:57:09]

The CQ bit was checked by csharrison@chromium.org

[commit-bot: I haz the power, 2016-07-29 00:57:22]

CQ is trying da patch. Follow status at
 
https://chromium-cq-status.appspot.com/v2/patch-status/codereview.chromium.or...

[commit-bot: I haz the power, 2016-07-29 01:00:44]

Description was changed from

==========
ParseHTMLOnMainThread: notify main thread of chunks less frequently

This patch adds an experiment variant to the
ParseHTMLOnMainThread experiment threaded group. It adds
a group that uses the threaded parser, but coalesces token
chunks in the background parser, notifying the main thread
less often. This can often result in issuing preloads faster
due to not eagerly parsing/scripting when tokens are about to
come in.

Note: this experiment group actually aligns the threaded behavior
closer to the non-threaded behavior. The non-threaded experiment
group also runs the entirety of pumpTokenizer when it is tokenizing,
whereas the threaded parser usually starts parsing at the first call to
notifyPendingTokenizedChunks (if it is idle). This is usually very early
on in pumpTokenizer, because we split up chunks very fine grained.
This experiment group tries not to start the main thread parsing until 
we've tokenized a bit more.

TBR=kinuko@chromium.org

BUG=632394
==========

to

==========
ParseHTMLOnMainThread: notify main thread of chunks less frequently

This patch adds an experiment variant to the
ParseHTMLOnMainThread experiment threaded group. It adds
a group that uses the threaded parser, but coalesces token
chunks in the background parser, notifying the main thread
less often. This can often result in issuing preloads faster
due to not eagerly parsing/scripting when tokens are about to
come in.

Note: this experiment group actually aligns the threaded behavior
closer to the non-threaded behavior. The non-threaded experiment
group also runs the entirety of pumpTokenizer when it is tokenizing,
whereas the threaded parser usually starts parsing at the first call to
notifyPendingTokenizedChunks (if it is idle). This is usually very early
on in pumpTokenizer, because we split up chunks very fine grained.
This experiment group tries not to start the main thread parsing until 
we've tokenized a bit more.

TBR=kinuko@chromium.org

BUG=632394
==========

[commit-bot: I haz the power, 2016-07-29 01:00:44]

Committed patchset #3 (id:40001)

[commit-bot: I haz the power, 2016-07-29 01:03:12]

Description was changed from

==========
ParseHTMLOnMainThread: notify main thread of chunks less frequently

This patch adds an experiment variant to the
ParseHTMLOnMainThread experiment threaded group. It adds
a group that uses the threaded parser, but coalesces token
chunks in the background parser, notifying the main thread
less often. This can often result in issuing preloads faster
due to not eagerly parsing/scripting when tokens are about to
come in.

Note: this experiment group actually aligns the threaded behavior
closer to the non-threaded behavior. The non-threaded experiment
group also runs the entirety of pumpTokenizer when it is tokenizing,
whereas the threaded parser usually starts parsing at the first call to
notifyPendingTokenizedChunks (if it is idle). This is usually very early
on in pumpTokenizer, because we split up chunks very fine grained.
This experiment group tries not to start the main thread parsing until 
we've tokenized a bit more.

TBR=kinuko@chromium.org

BUG=632394
==========

to

==========
ParseHTMLOnMainThread: notify main thread of chunks less frequently

This patch adds an experiment variant to the
ParseHTMLOnMainThread experiment threaded group. It adds
a group that uses the threaded parser, but coalesces token
chunks in the background parser, notifying the main thread
less often. This can often result in issuing preloads faster
due to not eagerly parsing/scripting when tokens are about to
come in.

Note: this experiment group actually aligns the threaded behavior
closer to the non-threaded behavior. The non-threaded experiment
group also runs the entirety of pumpTokenizer when it is tokenizing,
whereas the threaded parser usually starts parsing at the first call to
notifyPendingTokenizedChunks (if it is idle). This is usually very early
on in pumpTokenizer, because we split up chunks very fine grained.
This experiment group tries not to start the main thread parsing until
we've tokenized a bit more.

TBR=kinuko@chromium.org

BUG=632394

Committed: https://crrev.com/803fb39346006820c009f206dc05dd62b12e82ee
Cr-Commit-Position: refs/heads/master@{#408537}
==========

[commit-bot: I haz the power, 2016-07-29 01:03:13]

Patchset 3 (id:??) landed as
https://crrev.com/803fb39346006820c009f206dc05dd62b12e82ee
Cr-Commit-Position: refs/heads/master@{#408537}