tree 88d000299ae6131cd2caae3940bc4f08eadea649
parent 2393b88311845fe3fb7bfbab15322e22d102d79e
author Brian Osman <brianosman@google.com> 1646871943 +0000
committer SkCQ <skcq-be@skia-corp.google.com.iam.gserviceaccount.com> 1646872144 +0000

Revert "Convert PatchWriter to trait-oriented template"

This reverts commit 2393b88311845fe3fb7bfbab15322e22d102d79e.

Reason for revert: Asserts on ASAN bots.

Original change's description:
> Convert PatchWriter to trait-oriented template
>
> This allows the different variations to have compile-time optimizations
> for certain features related to stroking, curve-filling, or wedges.
> Additionally, it extends the attrib writing system to let graphite take
> advantage of compile-time-only attribute configs and avoid using
> VertexWriter::If per patch.
>
> Benchmark                              Orig   ->   ToT    ->   CL
> StrokeFixedCountTessellator_motionmark 845us  ->  904us   ->  871us
> StrokeFixedCountTessellator_one_chop   3.03ms ->  3.29ms  ->  2.89ms
> StrokeFixedCountTessellator            2.15ms ->  2.21ms  ->  1.93ms
> StrokeHardwareTessellator_motionmark   560us  ->  601us   ->  551us
> StrokeHardwareTessellator_one_chop     2.45ms ->  4.23ms  ->  3.89ms
> StrokeHardwareTessellator              395us  ->  478us   ->  399us
> PathWedgeTessellator                   313us  ->  407us   ->  367us
> PathCurveTessellator                   278us  ->  335us   ->  331us
>
> With these results from my workstation, we nearly recovered the
> regression on the SFCT_motionmark benchmark and exceeded original perf
> on the SFCT_on_chop and SFCT benchmarks. SHT_motionmark and SHT have
> returned to original, and SHT_one_chop has improved. I'm less concerned
> about bringing that back down since SHT is on the chopping block. We see
> some improvements on the PWT and PCT benches.
>
> Change-Id: Id76d34089dbaa50fe7d5f82fe54ee3cf605d0c24
> Reviewed-on: https://skia-review.googlesource.com/c/skia/+/512577
> Reviewed-by: Robert Phillips <robertphillips@google.com>
> Commit-Queue: Michael Ludwig <michaelludwig@google.com>

Change-Id: Ief826c4e489742df98dbe7a38165dd72537ece3d
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/519076
Auto-Submit: Brian Osman <brianosman@google.com>
Commit-Queue: Rubber Stamper <rubber-stamper@appspot.gserviceaccount.com>
Bot-Commit: Rubber Stamper <rubber-stamper@appspot.gserviceaccount.com>
