230749 2021-09-24 05:52:48 -0700 REGRESSION (Safari 15): Poor WebGL performance on https://downloads.scirra.com/labs/particles 2022-03-18 16:50:44 -0700 1 1 1 Unclassified WebKit ANGLE Other Unspecified Unspecified RESOLVED FIXED https://bugs.webkit.org/show_bug.cgi?id=232905 InRadar P2 Normal --- 231180 1 ashley kkinnunen ap dino ews-watchlist fielding gman kbr kevin_neal kkinnunen kondapallykalyan kpiddington le.hoang.q osoker008 rdavey tjkoury webkit-bug-importer oldest_to_newest 1796854 0 ashley 2021-09-24 05:52:48 -0700 Safari 15 appears to have a significant performance regression rendering points in WebGL relative to Safari 14. Perhaps this is related to the new Metal backend. Demo URL: https://downloads.scirra.com/labs/particles/ On an iPad Pro with Safari 15, this starts off very slow, around 12 FPS. There are only a few hundred point sprites being rendered, which should be well within the capability of the hardware. It seems to gradually warm up and end up rendering at either 30 FPS or 60 FPS. The CPU measurement (based on timing how long is spent in JS execution) looks very high. Conversely, an iPhone 7 Plus with iOS 14.7.1, and a Pixel 3 running Chrome for Android, both run the same demo at a steady 60 FPS right from the start. Safari 15 clearly has unexpectedly bad performance in this case. In our engine, the particles are drawn with gl.drawArrays(gl.POINTS, ...). The GLSL references both gl_PointSize and gl_PointCoord. We have not found any other performance issues with any of our other WebGL content. I speculate that this points to a performance regression specifically with point rendering in Safari 15's new Metal backend. 1796857 1 ashley 2021-09-24 06:03:15 -0700 Hmm, actually forcing a normal quads rendering path does not seem to improve performance much. So perhaps this is not to do with gl.POINTS after all. I'll leave it up to a browser engineer to profile! 1796863 2 ashley 2021-09-24 06:30:24 -0700 Here's the equivalent demo rendering with quads instead of points: https://downloads.scirra.com/labs/particles-quads/ For unrelated reasons, we already have a quad draw path for particles, so in this test I've just flipped the flag to use that. This will instead use lots of calls to gl.drawElements(gl.TRIANGLES, ...) with an index buffer. It's less efficient with draw calls than our points rendering path, but it still runs at 60 FPS on both the iPhone 7 Plus with iOS 14.7.1 and the Pixel 3, and is still very slow on the iPad Pro with Safari 15. In other words, the same performance characteristics as before. We need both paths to be fast for Construct content, as we use both rendering techniques depending on the content. 1796865 3 ashley 2021-09-24 06:33:17 -0700 One more thing, do let me know if you can identify a workaround - if possible I'm keen to update our engine to avoid the performance cliff for the time being (assuming it will be 6 months until the next Safari update rolls out). 1796889 4 kkinnunen 2021-09-24 08:20:48 -0700 Thanks for the report! I tried recent build, and it seems to work 60fps. If the demo uses index buffers, the root cause might have been bug 230107. If you want to further report observations: - Use Settings->General->Information to check which iPad you have, and report the model name. - Check if "WebGL via Metal" == Off has an effect on the FPS. You find the setting from Settings -> Safari -> Advanced -> Experimental settings -> WebGL via Metal. Remember to turn it back on. 1796932 5 ashley 2021-09-24 10:12:54 -0700 The iPad Pro with Safari 15 that exhibits poor performance is an "iPad Pro (12.9-inch)", model number ML0H2ZP/A. I tried turning off "WebGL via Metal" as advised, but it didn't seem to make much difference. Both samples still run very poorly. I'm not sure if the device needs a reboot in between or something? I'd also point out the first sample uses dl.drawArrays(gl.POINTS) and does not make use of an index buffer. 1797097 6 gman 2021-09-24 17:28:49 -0700 > This will instead use lots of calls to gl.drawElements(gl.TRIANGLES, ...) with an index buffer. It's less efficient with draw calls than our points rendering path, Not a bug fix but you can emulate points with instancing and no extra data (well you need a single unitQuad. You'll get the benefit that there's no limit to their size and their offscreen clipping will be consistent across devices, something you don't get with gl.POINTS https://jsgist.org/?src=535da7687726e14dc26884e085de7629 1797312 7 ap 2021-09-26 14:35:27 -0700 > The iPad Pro with Safari 15 that exhibits poor performance is an "iPad Pro (12.9-inch)", model number ML0H2ZP/A. This is the original iPad Pro from 2015. I have this model with iOS 14.6 installed, and can confirm that it renders at 60 FPS according to what the webpage measures. > If the demo uses index buffers, the root cause might have been bug 230107. I don't think that I can easily get such a build to try out at this point. 1797456 8 ashley 2021-09-27 07:59:51 -0700 @Gregg - is there any evidence instancing actually performs better in Safari 15? The performance pitfall also seems to apply to just quads, and since it's not clear why or when the performance pitfall happens, it seems it could also affect instancing. 1797508 9 webkit-bug-importer 2021-09-27 09:19:40 -0700 <rdar://problem/83576271> 1797696 10 gman 2021-09-27 16:23:57 -0700 Sorry, I didn't mean to imply that solution solves this particular perf issue. Instead I just meant to point out, if you're using points, as the demo linked above shows then (1) lots of your users are having those images disappear when their center hits the edge of the view and others are not. You really shouldn't be using points at all if you want things to run the same across devices. Checking my own devices I can see the particles are disappearing early on my AMD Mac but moving offscreen smoothly on my NVidia PC. (2) emulating points is trivial, solves that issue, and only requires a single draw call, same as POINTS, so whatever overhead there is per draw call should disappear ... separate from any perf bugs in WebKit, ANGLE, the driver. 1797700 11 rdavey 2021-09-27 16:29:52 -0700 We're seeing an inconsistent but significant performance decrease in games made with our library (Phaser 3). Games that run at 60fps solid under iOS14 now struggle to hit 20fps. The inconsistency is that it doesn't impact them all, so it can't be our default shaders. We also don't use GL_POINTS at all, so it's unrelated to that. We have simple quads and index buffers. I will start trying to debug this tomorrow and produce a test case for you but just wanted to add this is a very real issue. It's also not device-specific as we've had reports from across pretty much all modern Apple hardware. It's almost as if something forces Safari into low-power mode, even though that is disabled in the General Settings. 1797706 12 ap 2021-09-27 16:43:25 -0700 > Games that run at 60fps solid under iOS14 now struggle to hit 20fps. Please file a new bug about that, unless you are very certain that it's the same root cause as with https://downloads.scirra.com/labs/particles/ 1797839 13 ashley 2021-09-28 05:21:00 -0700 @Gregg - I tried hacking together code using instancing instead, and it's also still slow. So I don't think instancing has anything to do with the performance issue reported here. I think the issue title might be misleading now - the test case appears to show a serious performance regression in Safari 15 with points rendering, indexed quads, and instancing. 1797862 14 rdavey 2021-09-28 06:20:39 -0700 (In reply to Alexey Proskuryakov from comment #12) > > Games that run at 60fps solid under iOS14 now struggle to hit 20fps. > > Please file a new bug about that, unless you are very certain that it's the > same root cause as with https://downloads.scirra.com/labs/particles/ If it turns out to be different, I will. However, as no one actually knows what causes this in this issue yet, it's too early to say. My guess is that's it's all related. 1797865 15 ashley 2021-09-28 06:26:59 -0700 Edited issue title myself as it does not appear to be specific to gl.POINTS. 1798273 16 kkinnunen 2021-09-29 05:44:21 -0700 Note: the original report is about bad perf on startup, e.g. slow frame rate during first 10 secs or so. I can repro the slowness during startup on said iPad Pro model. Posted the trace to the rdar. 1798311 17 tjkoury 2021-09-29 07:18:16 -0700 Seeing the same kind of performance hit. FPS are cut in half on all platforms (MacBook, iPhone, iPad): https://celestrak.com/cesium/orbit-viz.php?tle=/pub/TLE/catalog.txt&satcat=/pub/satcat.txt&referenceFrame=1 1798422 18 ap 2021-09-29 10:08:47 -0700 > Seeing the same kind of performance hit. FPS are cut in half on all platforms (MacBook, iPhone, iPad): Please file a new bug report about this. Discussing all WebGL issues in one report makes it LESS likely that they will be fixed soon (because of inevitable confusion), not more likely. 1808359 19 kkinnunen 2021-10-25 05:51:38 -0700 This is most likely due to the same root cause as bug 231607. The test case appears to ramp up the amount of vertices drawn with drawArrays. This causes the conversion attribute buffers to be re-allocated for each draw. To work around the issue, you could try to store each vertex attribute in a separate buffer. 1808400 20 ashley 2021-10-25 08:06:02 -0700 IIRC, in the provided demos, each vertex attribute already uses its own separate buffer. So I don't think that suggested workaround will help here. 1808816 21 kkinnunen 2021-10-26 04:15:08 -0700 Thanks for the info. Yes, I can see the root cause is not that. 1808818 22 442478 kkinnunen 2021-10-26 04:25:05 -0700 Created attachment 442478 Patch 1808819 23 ews-watchlist 2021-10-26 04:26:26 -0700 Note that there are important steps to take when updating ANGLE. See https://trac.webkit.org/wiki/UpdatingANGLE 1808821 24 442479 kkinnunen 2021-10-26 04:27:37 -0700 Created attachment 442479 Patch 1808951 25 442479 kbr 2021-10-26 11:19:24 -0700 Comment on attachment 442479 Patch Fantastic diagnosis Kimmo. Let's make sure this gets upstreamed. r+ 1808961 26 kbr 2021-10-26 11:35:05 -0700 Filed: Metal: Upstream index buffer cache mapping performance improvement https://bugs.chromium.org/p/angleproject/issues/detail?id=6620 about upstreaming this patch. 1809146 27 le.hoang.q 2021-10-26 18:59:30 -0700 (In reply to Kimmo Kinnunen from comment #24) > Created attachment 442479 [details] > Patch Hi, I am interested in this finding. Would it be more correct to change this condition: ``` if (!noSync && isCPUReadMemNeedSync()) ``` to: ``` if (!noSync && (isCPUReadMemNeedSync() || !readonly)) ``` ? The synchronization should be done if `noSync` is not requested AND 1. either the buffer's CPU memory needs synchronization due to ongoing GPU modifications. 2. or we are mapping within an intention to WRITE (even if the GPU is not modifying it). * If we don't synchronize in the 2nd case then the buffer would be modified while its old content is being drawn by the GPU -> undefined results. * `isCPUReadMemNeedSync()` flag is only used to indicate that the buffer is being modified by GPU and this modification needs to be made visible to CPU in order for it to read the update-to-date data. 1809151 28 le.hoang.q 2021-10-26 19:05:20 -0700 btw, I didn't notice that ANGLE needs to update the index range every time `drawElements` is called with a new range. Previously I mostly worked with "normal" mode OpenGL of ANGLE. Apparently, ANGLE will always do index range check when it operates in "WebGL compatibility" mode. 1809238 29 442584 kkinnunen 2021-10-27 06:26:01 -0700 Created attachment 442584 Patch for landing 1809239 30 kkinnunen 2021-10-27 06:27:28 -0700 (In reply to Le Hoang Quyen from comment #27) > (In reply to Kimmo Kinnunen from comment #24) > > Created attachment 442479 [details] > > Patch > > Hi, I am interested in this finding. > > Would it be more correct to change this condition: > ``` > if (!noSync && isCPUReadMemNeedSync()) > ``` > to: > ``` > if (!noSync && (isCPUReadMemNeedSync() || !readonly)) > ``` > Yes, exactly! Thanks for review. (I couldn't put you as the reviewer due to tooling, sorry). Taking the liberty to land with Ken's approval and above amends. 1809318 31 ews-feeder 2021-10-27 10:43:45 -0700 Committed r284927 (243598@main): <https://commits.webkit.org/243598@main> All reviewed patches have been landed. Closing bug and clearing flags on attachment 442584. 1817438 32 osoker008 2021-11-23 04:16:52 -0800 How long time does is take for this BugFixed Update in user's iOS Safari 15? 1827704 33 ashley 2022-01-03 06:35:39 -0800 This issue is marked fixed but it still reproduces in Safari 15.2. Is it really fixed? Should I file a new issue again? 1827754 34 ap 2022-01-03 08:38:27 -0800 This fix is not yet included in any Safari release or beta (other than Safari Technology Preview for macOS). We can not comment about future releases. 1827781 35 ashley 2022-01-03 10:14:44 -0800 I know this is probably out of your hands, but it is a pretty developer-hostile policy. It leaves us having to manually test every release that comes out to find out for ourselves as nobody at Apple is allowed to tell us anything about when anything will actually ship. 442478 2021-10-26 04:25:05 -0700 2021-10-26 04:27:31 -0700 Patch bug-230749-20211026142503.patch text/plain 2256 kkinnunen U3VidmVyc2lvbiBSZXZpc2lvbjogMjg0ODU4CmRpZmYgLS1naXQgYS9Tb3VyY2UvVGhpcmRQYXJ0 eS9BTkdMRS9DaGFuZ2VMb2cgYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9DaGFuZ2VMb2cKaW5k ZXggOTU3M2NiMTYwMjM4Mzg3YTQ5YjA2MGNhZDQ2OWJmMjRiYmQ4MDMyMy4uOTcxZjRkYTk0Yzkz ODNlNTZlODg4OWQyMWZhNjBjNTBmYmU2ODgxZCAxMDA2NDQKLS0tIGEvU291cmNlL1RoaXJkUGFy dHkvQU5HTEUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL0NoYW5nZUxv ZwpAQCAtMSwzICsxLDI1IEBACisyMDIxLTEwLTI2ICBLaW1tbyBLaW5udW5lbiAgPGtraW5udW5l bkBhcHBsZS5jb20+CisKKyAgICAgICAgUkVHUkVTU0lPTiAoU2FmYXJpIDE1KTogUG9vciBXZWJH TCBwZXJmb3JtYW5jZSBvbiBodHRwczovL2Rvd25sb2Fkcy5zY2lycmEuY29tL2xhYnMvcGFydGlj bGVzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMzA3 NDkKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzgzNTc2MjcxPgorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoZSBzaXRlIHdvdWxkIGRyYXcgaW5kZXhl ZCBwZXIgZnJhbWUgd2l0aCBlYWNoIGZyYW1lIGluY3JlYXNpbmcgdGhlIHNpemUgb2YgdGhlIGRy YXcuCisgICAgICAgIFRoaXMgd291bGQgY2F1c2UgaW5kZXggYnVmZmVyIHJhbmdlIGNhY2hlIHVw ZGF0ZSBmb3IgZWFjaCBkcmF3LgorICAgICAgICBSYW5nZSBjb21wdXRhdGlvbiBuZWVkcyB0byBs b29rIGluc2lkZSB0aGUgaW5kZXggYnVmZmVyLgorICAgICAgICBNYXBwaW5nIGEgaW5kZXggYnVm ZmVyIGZvciByZWFkIHdvdWxkIGNhdXNlIGNvbW1hbmQgYnVmZmVyIGZsdXNoIGZvciBlYWNoIGNv bXB1dGF0aW9uLAorICAgICAgICBzaW5jZSBwcmV2aW91cyBmcmFtZSB3b3VsZCBoYXZlIHVzZWQg dGhlIGluZGV4IGJ1ZmZlciBmb3IgcmVhZGluZy4gVGhpcyB3b3VsZCBjYXVzZQorICAgICAgICBw ZXJmb3JtYW5jZSBkZWdyYWRhdGlvbiBmb3IgdGhlIGR1cmF0aW9uIHdoZXJlIHRoZSByYW5nZSBj YWNoZSB3b3VsZCBuZWVkIHVwZGF0ZS4KKworICAgICAgICBTaW5jZSB0aGUgYnVmZmVyIGlzIHJl YWQgYnkgdGhlIGRyYXcgYnV0IG5vdCB3cml0dGVuLCB0aGUgbWFwIHNob3VsZCBiZSBhIG5vLW9w LgorICAgICAgICBDb25zdWx0IHRoZSAiQ1BVIG1lbW9yeSBuZWVkcyBzeW5jaHJvbml6aW5nIiBm bGFnIG9mIHRoZSBtdGw6OlJlc291cmNlIHdoZW4KKyAgICAgICAgbWFwcGluZy4gT25seSBzeW5j aHJvbml6ZSB3aXRoIEdQVSBpZiB0aGUgbWVtb3J5IG5lZWRzIHN5bmNocm9uaXppbmcuCisKKyAg ICAgICAgKiBzcmMvbGliQU5HTEUvcmVuZGVyZXIvbWV0YWwvbXRsX3Jlc291cmNlcy5tbToKKyAg ICAgICAgKHJ4OjptdGw6OkJ1ZmZlcjo6bWFwV2l0aE9wdCk6CisKIDIwMjEtMTAtMjUgIEt5bGUg UGlkZGluZ3RvbiAgPGtwaWRkaW5ndG9uQGFwcGxlLmNvbT4KIAogICAgICAgICBSRUdSRVNTSU9O IChpT1MgMTUpLCBzYWZhcmk2MDQuMTogQ291bGQgbm90IGxpbmsgdGhlIHNoYWRlciBwcm9ncmFt CmRpZmYgLS1naXQgYS9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvcmVuZGVy ZXIvbWV0YWwvbXRsX3Jlc291cmNlcy5tbSBiL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9s aWJBTkdMRS9yZW5kZXJlci9tZXRhbC9tdGxfcmVzb3VyY2VzLm1tCmluZGV4IDMzOTY0ZjYxNzMw MWVkNmU2M2Y3NWY3ZGYxYjJjMDY2NzQyODNjZjMuLmI4NmQ5NjQxZmE1ZmFiMGViOWE5Y2VkYjE2 MWQ0MzM2YzU2MTI5OTMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9s aWJBTkdMRS9yZW5kZXJlci9tZXRhbC9tdGxfcmVzb3VyY2VzLm1tCisrKyBiL1NvdXJjZS9UaGly ZFBhcnR5L0FOR0xFL3NyYy9saWJBTkdMRS9yZW5kZXJlci9tZXRhbC9tdGxfcmVzb3VyY2VzLm1t CkBAIC0xMDAwLDcgKzEwMDAsNyBAQCB1aW50OF90ICpCdWZmZXI6Om1hcFdpdGhPcHQoQ29udGV4 dE10bCAqY29udGV4dCwgYm9vbCByZWFkb25seSwgYm9vbCBub1N5bmMpCiB7CiAgICAgbU1hcFJl YWRPbmx5ID0gcmVhZG9ubHk7CiAKLSAgICBpZiAoIW5vU3luYykKKyAgICBpZiAoIW5vU3luYyAm JiBpc0NQVVJlYWRNZW1OZWVkU3luYygpKQogICAgIHsKICAgICAgICAgQ29tbWFuZFF1ZXVlICZj bWRRdWV1ZSA9IGNvbnRleHQtPmNtZFF1ZXVlKCk7CiAK 442479 2021-10-26 04:27:37 -0700 2021-10-27 06:25:54 -0700 Patch bug-230749-20211026142735.patch text/plain 2258 kkinnunen U3VidmVyc2lvbiBSZXZpc2lvbjogMjg0ODU4CmRpZmYgLS1naXQgYS9Tb3VyY2UvVGhpcmRQYXJ0 eS9BTkdMRS9DaGFuZ2VMb2cgYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9DaGFuZ2VMb2cKaW5k ZXggOTU3M2NiMTYwMjM4Mzg3YTQ5YjA2MGNhZDQ2OWJmMjRiYmQ4MDMyMy4uMDU3M2UzNjQ0MzMx MGMwYTdhMWMwNmZkMzVkYTcwNTNjNjQ3NjBiZSAxMDA2NDQKLS0tIGEvU291cmNlL1RoaXJkUGFy dHkvQU5HTEUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL0NoYW5nZUxv ZwpAQCAtMSwzICsxLDI1IEBACisyMDIxLTEwLTI2ICBLaW1tbyBLaW5udW5lbiAgPGtraW5udW5l bkBhcHBsZS5jb20+CisKKyAgICAgICAgUkVHUkVTU0lPTiAoU2FmYXJpIDE1KTogUG9vciBXZWJH TCBwZXJmb3JtYW5jZSBvbiBodHRwczovL2Rvd25sb2Fkcy5zY2lycmEuY29tL2xhYnMvcGFydGlj bGVzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMzA3 NDkKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzgzNTc2MjcxPgorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoZSBzaXRlIHdvdWxkIGRyYXcgaW5kZXhl ZCBwZXIgZnJhbWUgd2l0aCBlYWNoIGZyYW1lIGluY3JlYXNpbmcgdGhlIHNpemUgb2YgdGhlIGRy YXcuCisgICAgICAgIFRoaXMgd291bGQgY2F1c2UgaW5kZXggYnVmZmVyIHJhbmdlIGNhY2hlIHVw ZGF0ZSBmb3IgZWFjaCBkcmF3LgorICAgICAgICBSYW5nZSBjb21wdXRhdGlvbiBuZWVkcyB0byBs b29rIGluc2lkZSB0aGUgaW5kZXggYnVmZmVyLgorICAgICAgICBNYXBwaW5nIHRoZSBpbmRleCBi dWZmZXIgZm9yIHJlYWQgd291bGQgY2F1c2UgY29tbWFuZCBidWZmZXIgZmx1c2ggZm9yIGVhY2gg Y29tcHV0YXRpb24sCisgICAgICAgIHNpbmNlIHByZXZpb3VzIGZyYW1lIHdvdWxkIGhhdmUgdXNl ZCB0aGUgaW5kZXggYnVmZmVyIGZvciByZWFkaW5nLiBUaGlzIHdvdWxkIGNhdXNlCisgICAgICAg IHBlcmZvcm1hbmNlIGRlZ3JhZGF0aW9uIGZvciB0aGUgZHVyYXRpb24gd2hlcmUgdGhlIHJhbmdl IGNhY2hlIHdvdWxkIG5lZWQgdXBkYXRlLgorCisgICAgICAgIFNpbmNlIHRoZSBidWZmZXIgaXMg cmVhZCBieSB0aGUgZHJhdyBidXQgbm90IHdyaXR0ZW4sIHRoZSBtYXAgc2hvdWxkIGJlIGEgbm8t b3AuCisgICAgICAgIENvbnN1bHQgdGhlICJDUFUgbWVtb3J5IG5lZWRzIHN5bmNocm9uaXppbmci IGZsYWcgb2YgdGhlIG10bDo6UmVzb3VyY2Ugd2hlbgorICAgICAgICBtYXBwaW5nLiBPbmx5IHN5 bmNocm9uaXplIHdpdGggR1BVIGlmIHRoZSBtZW1vcnkgbmVlZHMgc3luY2hyb25pemluZy4KKwor ICAgICAgICAqIHNyYy9saWJBTkdMRS9yZW5kZXJlci9tZXRhbC9tdGxfcmVzb3VyY2VzLm1tOgor ICAgICAgICAocng6Om10bDo6QnVmZmVyOjptYXBXaXRoT3B0KToKKwogMjAyMS0xMC0yNSAgS3ls ZSBQaWRkaW5ndG9uICA8a3BpZGRpbmd0b25AYXBwbGUuY29tPgogCiAgICAgICAgIFJFR1JFU1NJ T04gKGlPUyAxNSksIHNhZmFyaTYwNC4xOiBDb3VsZCBub3QgbGluayB0aGUgc2hhZGVyIHByb2dy YW0KZGlmZiAtLWdpdCBhL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9saWJBTkdMRS9yZW5k ZXJlci9tZXRhbC9tdGxfcmVzb3VyY2VzLm1tIGIvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3Jj L2xpYkFOR0xFL3JlbmRlcmVyL21ldGFsL210bF9yZXNvdXJjZXMubW0KaW5kZXggMzM5NjRmNjE3 MzAxZWQ2ZTYzZjc1ZjdkZjFiMmMwNjY3NDI4M2NmMy4uYjg2ZDk2NDFmYTVmYWIwZWI5YTljZWRi MTYxZDQzMzZjNTYxMjk5MyAxMDA2NDQKLS0tIGEvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3Jj L2xpYkFOR0xFL3JlbmRlcmVyL21ldGFsL210bF9yZXNvdXJjZXMubW0KKysrIGIvU291cmNlL1Ro aXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL3JlbmRlcmVyL21ldGFsL210bF9yZXNvdXJjZXMu bW0KQEAgLTEwMDAsNyArMTAwMCw3IEBAIHVpbnQ4X3QgKkJ1ZmZlcjo6bWFwV2l0aE9wdChDb250 ZXh0TXRsICpjb250ZXh0LCBib29sIHJlYWRvbmx5LCBib29sIG5vU3luYykKIHsKICAgICBtTWFw UmVhZE9ubHkgPSByZWFkb25seTsKIAotICAgIGlmICghbm9TeW5jKQorICAgIGlmICghbm9TeW5j ICYmIGlzQ1BVUmVhZE1lbU5lZWRTeW5jKCkpCiAgICAgewogICAgICAgICBDb21tYW5kUXVldWUg JmNtZFF1ZXVlID0gY29udGV4dC0+Y21kUXVldWUoKTsKIAo= 442584 2021-10-27 06:26:01 -0700 2021-10-27 10:43:46 -0700 Patch for landing bug-230749-20211027162600.patch text/plain 2274 kkinnunen U3VidmVyc2lvbiBSZXZpc2lvbjogMjg0ODU4CmRpZmYgLS1naXQgYS9Tb3VyY2UvVGhpcmRQYXJ0 eS9BTkdMRS9DaGFuZ2VMb2cgYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9DaGFuZ2VMb2cKaW5k ZXggOTU3M2NiMTYwMjM4Mzg3YTQ5YjA2MGNhZDQ2OWJmMjRiYmQ4MDMyMy4uMjlmZGViOWY0ZDYx MGM0OTJkMWQxMmZkYjFjNDQ4NGY3MTc3MTJlNSAxMDA2NDQKLS0tIGEvU291cmNlL1RoaXJkUGFy dHkvQU5HTEUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL0NoYW5nZUxv ZwpAQCAtMSwzICsxLDI1IEBACisyMDIxLTEwLTI2ICBLaW1tbyBLaW5udW5lbiAgPGtraW5udW5l bkBhcHBsZS5jb20+CisKKyAgICAgICAgUkVHUkVTU0lPTiAoU2FmYXJpIDE1KTogUG9vciBXZWJH TCBwZXJmb3JtYW5jZSBvbiBodHRwczovL2Rvd25sb2Fkcy5zY2lycmEuY29tL2xhYnMvcGFydGlj bGVzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMzA3 NDkKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzgzNTc2MjcxPgorCisgICAgICAgIFJldmlld2Vk IGJ5IEtlbm5ldGggUnVzc2VsbC4KKworICAgICAgICBUaGUgc2l0ZSB3b3VsZCBkcmF3IGluZGV4 ZWQgcGVyIGZyYW1lIHdpdGggZWFjaCBmcmFtZSBpbmNyZWFzaW5nIHRoZSBzaXplIG9mIHRoZSBk cmF3LgorICAgICAgICBUaGlzIHdvdWxkIGNhdXNlIGluZGV4IGJ1ZmZlciByYW5nZSBjYWNoZSB1 cGRhdGUgZm9yIGVhY2ggZHJhdy4KKyAgICAgICAgUmFuZ2UgY29tcHV0YXRpb24gbmVlZHMgdG8g bG9vayBpbnNpZGUgdGhlIGluZGV4IGJ1ZmZlci4KKyAgICAgICAgTWFwcGluZyB0aGUgaW5kZXgg YnVmZmVyIGZvciByZWFkIHdvdWxkIGNhdXNlIGNvbW1hbmQgYnVmZmVyIGZsdXNoIGZvciBlYWNo IGNvbXB1dGF0aW9uLAorICAgICAgICBzaW5jZSBwcmV2aW91cyBmcmFtZSB3b3VsZCBoYXZlIHVz ZWQgdGhlIGluZGV4IGJ1ZmZlciBmb3IgcmVhZGluZy4gVGhpcyB3b3VsZCBjYXVzZQorICAgICAg ICBwZXJmb3JtYW5jZSBkZWdyYWRhdGlvbiBmb3IgdGhlIGR1cmF0aW9uIHdoZXJlIHRoZSByYW5n ZSBjYWNoZSB3b3VsZCBuZWVkIHVwZGF0ZS4KKworICAgICAgICBTaW5jZSB0aGUgYnVmZmVyIGlz IHJlYWQgYnkgdGhlIGRyYXcgYnV0IG5vdCB3cml0dGVuLCB0aGUgbWFwIHNob3VsZCBiZSBhIG5v LW9wLgorICAgICAgICBDb25zdWx0IHRoZSAiQ1BVIG1lbW9yeSBuZWVkcyBzeW5jaHJvbml6aW5n IiBmbGFnIG9mIHRoZSBtdGw6OlJlc291cmNlIHdoZW4KKyAgICAgICAgbWFwcGluZy4gT25seSBz eW5jaHJvbml6ZSB3aXRoIEdQVSBpZiB0aGUgbWVtb3J5IG5lZWRzIHN5bmNocm9uaXppbmcuCisK KyAgICAgICAgKiBzcmMvbGliQU5HTEUvcmVuZGVyZXIvbWV0YWwvbXRsX3Jlc291cmNlcy5tbToK KyAgICAgICAgKHJ4OjptdGw6OkJ1ZmZlcjo6bWFwV2l0aE9wdCk6CisKIDIwMjEtMTAtMjUgIEt5 bGUgUGlkZGluZ3RvbiAgPGtwaWRkaW5ndG9uQGFwcGxlLmNvbT4KIAogICAgICAgICBSRUdSRVNT SU9OIChpT1MgMTUpLCBzYWZhcmk2MDQuMTogQ291bGQgbm90IGxpbmsgdGhlIHNoYWRlciBwcm9n cmFtCmRpZmYgLS1naXQgYS9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvcmVu ZGVyZXIvbWV0YWwvbXRsX3Jlc291cmNlcy5tbSBiL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL3Ny Yy9saWJBTkdMRS9yZW5kZXJlci9tZXRhbC9tdGxfcmVzb3VyY2VzLm1tCmluZGV4IDMzOTY0ZjYx NzMwMWVkNmU2M2Y3NWY3ZGYxYjJjMDY2NzQyODNjZjMuLmZkODliODZhZDFjZWU1ZGFiNTExYjZh ZDllNjRlYWI5NjI5ZGZlOWMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL3Ny Yy9saWJBTkdMRS9yZW5kZXJlci9tZXRhbC9tdGxfcmVzb3VyY2VzLm1tCisrKyBiL1NvdXJjZS9U aGlyZFBhcnR5L0FOR0xFL3NyYy9saWJBTkdMRS9yZW5kZXJlci9tZXRhbC9tdGxfcmVzb3VyY2Vz Lm1tCkBAIC0xMDAwLDcgKzEwMDAsNyBAQCB1aW50OF90ICpCdWZmZXI6Om1hcFdpdGhPcHQoQ29u dGV4dE10bCAqY29udGV4dCwgYm9vbCByZWFkb25seSwgYm9vbCBub1N5bmMpCiB7CiAgICAgbU1h cFJlYWRPbmx5ID0gcmVhZG9ubHk7CiAKLSAgICBpZiAoIW5vU3luYykKKyAgICBpZiAoIW5vU3lu YyAmJiAoaXNDUFVSZWFkTWVtTmVlZFN5bmMoKSB8fCAhcmVhZG9ubHkpKQogICAgIHsKICAgICAg ICAgQ29tbWFuZFF1ZXVlICZjbWRRdWV1ZSA9IGNvbnRleHQtPmNtZFF1ZXVlKCk7CiAK