237861 2022-03-14 18:00:28 -0700 [WebGPU] Repeated calls to wgpuDeviceGetQueue() are supposed to return the same pointer 2022-03-15 23:10:01 -0700 1 1 1 Unclassified WebKit New Bugs WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 237583 237864 1 mmaxfield mmaxfield dino djg kkinnunen webkit-bug-importer oldest_to_newest 1851099 0 mmaxfield 2022-03-14 18:00:28 -0700 [WebGPU] Repeated calls to wgpuDeviceGetQueue() are supposed to return the same pointer 1851100 1 454644 mmaxfield 2022-03-14 18:02:08 -0700 Created attachment 454644 Patch 1851215 2 454644 kkinnunen 2022-03-15 03:22:43 -0700 Comment on attachment 454644 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=454644&action=review > Source/WebGPU/WebGPU/Adapter.mm:123 > // See the comment in Device::setLabel() about why we're not setting the label here. I think you can remove this comment. For all intents and purposes, passing label to the device constructor counts as initialising, e.g setting, the label for the device. > Source/WebGPU/WebGPU/Device.mm:56 > + if (deviceLabel && strlen(deviceLabel)) nit: we calculate the length of the label for the purpose of "isempty" 1851253 3 454644 kkinnunen 2022-03-15 06:14:17 -0700 Comment on attachment 454644 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=454644&action=review > Source/WebGPU/WebGPU/Adapter.mm:171 > + callback(status, new WGPUDeviceImpl { device.releaseNonNull(), { queue } }, message); btw: Is there a reason for this pattern where we create new wrapper objects every time we communicate with another layer in the sw stack? I think it's employed here (invoking the wgpu client callback) as well as internally ? 1851491 4 454644 mmaxfield 2022-03-15 14:03:26 -0700 Comment on attachment 454644 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=454644&action=review >> Source/WebGPU/WebGPU/Adapter.mm:123 >> // See the comment in Device::setLabel() about why we're not setting the label here. > > I think you can remove this comment. > For all intents and purposes, passing label to the device constructor counts as initialising, e.g setting, the label for the device. Good point. >> Source/WebGPU/WebGPU/Adapter.mm:171 >> + callback(status, new WGPUDeviceImpl { device.releaseNonNull(), { queue } }, message); > > btw: Is there a reason for this pattern where we create new wrapper objects every time we communicate with another layer in the sw stack? > > I think it's employed here (invoking the wgpu client callback) as well as internally ? There's a (bad) reason. Ideas for improvements are welcome. The reason is that the shared WebGPU.h header has: typedef struct WGPUDeviceImpl* WGPUDevice; However, it would be convenient if we could have our own names like this: namespace WebGPU { class Device { ... id<MTLDevice> m_device; ... } } I thought of 3 possible solutions: 1. Use reinterpret_cast<>() to freely convert between WGPUDeviceImpl* and WebGPU::Device*. This breaks C++'s type system, and is technically UB (I think) so I was hoping to avoid this option. 2. Don't have nice names, and don't use "namespace WebGPU": struct WGPUDeviceImpl { ... id<MTLDevice> m_device; ... } This is unfortunate because it foregoes C++'s built-in namespace support in favor of prefixes, and isn't the pattern we use for the rest of WebKit 3. Do a double-pointer-indirection: struct WGPUDeviceImpl { Ref<WebGPU::Device> device; }; This isn't great for performance (though it's probably negligible) and has a somewhat bad smell about having two types which mean the same thing. For the initial implementation, I chose option 3, under the assumption that it would be easy/mechanical to change later if a better option presents itself. 1851500 5 mmaxfield 2022-03-15 14:30:25 -0700 Committed r291315 (248454@trunk): <https://commits.webkit.org/248454@trunk> 1851502 6 454644 mmaxfield 2022-03-15 14:30:48 -0700 Comment on attachment 454644 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=454644&action=review >>> Source/WebGPU/WebGPU/Adapter.mm:171 >>> + callback(status, new WGPUDeviceImpl { device.releaseNonNull(), { queue } }, message); >> >> btw: Is there a reason for this pattern where we create new wrapper objects every time we communicate with another layer in the sw stack? >> >> I think it's employed here (invoking the wgpu client callback) as well as internally ? > > There's a (bad) reason. Ideas for improvements are welcome. > > The reason is that the shared WebGPU.h header has: > > typedef struct WGPUDeviceImpl* WGPUDevice; > > However, it would be convenient if we could have our own names like this: > > namespace WebGPU { > class Device { > ... > id<MTLDevice> m_device; > ... > } > } > > I thought of 3 possible solutions: > > 1. Use reinterpret_cast<>() to freely convert between WGPUDeviceImpl* and WebGPU::Device*. This breaks C++'s type system, and is technically UB (I think) so I was hoping to avoid this option. > > 2. Don't have nice names, and don't use "namespace WebGPU": > > struct WGPUDeviceImpl { > ... > id<MTLDevice> m_device; > ... > } > > This is unfortunate because it foregoes C++'s built-in namespace support in favor of prefixes, and isn't the pattern we use for the rest of WebKit > > 3. Do a double-pointer-indirection: > > struct WGPUDeviceImpl { > Ref<WebGPU::Device> device; > }; > > This isn't great for performance (though it's probably negligible) and has a somewhat bad smell about having two types which mean the same thing. > > For the initial implementation, I chose option 3, under the assumption that it would be easy/mechanical to change later if a better option presents itself. I filed https://bugs.webkit.org/show_bug.cgi?id=237921 about it. 1851504 7 webkit-bug-importer 2022-03-15 14:31:16 -0700 <rdar://problem/90330891> 1851663 8 454644 djg 2022-03-15 23:09:59 -0700 Comment on attachment 454644 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=454644&action=review >>>> Source/WebGPU/WebGPU/Adapter.mm:171 >>>> + callback(status, new WGPUDeviceImpl { device.releaseNonNull(), { queue } }, message); >>> >>> btw: Is there a reason for this pattern where we create new wrapper objects every time we communicate with another layer in the sw stack? >>> >>> I think it's employed here (invoking the wgpu client callback) as well as internally ? >> >> There's a (bad) reason. Ideas for improvements are welcome. >> >> The reason is that the shared WebGPU.h header has: >> >> typedef struct WGPUDeviceImpl* WGPUDevice; >> >> However, it would be convenient if we could have our own names like this: >> >> namespace WebGPU { >> class Device { >> ... >> id<MTLDevice> m_device; >> ... >> } >> } >> >> I thought of 3 possible solutions: >> >> 1. Use reinterpret_cast<>() to freely convert between WGPUDeviceImpl* and WebGPU::Device*. This breaks C++'s type system, and is technically UB (I think) so I was hoping to avoid this option. >> >> 2. Don't have nice names, and don't use "namespace WebGPU": >> >> struct WGPUDeviceImpl { >> ... >> id<MTLDevice> m_device; >> ... >> } >> >> This is unfortunate because it foregoes C++'s built-in namespace support in favor of prefixes, and isn't the pattern we use for the rest of WebKit >> >> 3. Do a double-pointer-indirection: >> >> struct WGPUDeviceImpl { >> Ref<WebGPU::Device> device; >> }; >> >> This isn't great for performance (though it's probably negligible) and has a somewhat bad smell about having two types which mean the same thing. >> >> For the initial implementation, I chose option 3, under the assumption that it would be easy/mechanical to change later if a better option presents itself. > > I filed https://bugs.webkit.org/show_bug.cgi?id=237921 about it. Can you forward decl the namespaced type? eg: namespace WebGPU { class Device; } typedef WebGPU::Device* WGPUDevice; 1851664 9 454644 djg 2022-03-15 23:10:01 -0700 Comment on attachment 454644 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=454644&action=review >>>> Source/WebGPU/WebGPU/Adapter.mm:171 >>>> + callback(status, new WGPUDeviceImpl { device.releaseNonNull(), { queue } }, message); >>> >>> btw: Is there a reason for this pattern where we create new wrapper objects every time we communicate with another layer in the sw stack? >>> >>> I think it's employed here (invoking the wgpu client callback) as well as internally ? >> >> There's a (bad) reason. Ideas for improvements are welcome. >> >> The reason is that the shared WebGPU.h header has: >> >> typedef struct WGPUDeviceImpl* WGPUDevice; >> >> However, it would be convenient if we could have our own names like this: >> >> namespace WebGPU { >> class Device { >> ... >> id<MTLDevice> m_device; >> ... >> } >> } >> >> I thought of 3 possible solutions: >> >> 1. Use reinterpret_cast<>() to freely convert between WGPUDeviceImpl* and WebGPU::Device*. This breaks C++'s type system, and is technically UB (I think) so I was hoping to avoid this option. >> >> 2. Don't have nice names, and don't use "namespace WebGPU": >> >> struct WGPUDeviceImpl { >> ... >> id<MTLDevice> m_device; >> ... >> } >> >> This is unfortunate because it foregoes C++'s built-in namespace support in favor of prefixes, and isn't the pattern we use for the rest of WebKit >> >> 3. Do a double-pointer-indirection: >> >> struct WGPUDeviceImpl { >> Ref<WebGPU::Device> device; >> }; >> >> This isn't great for performance (though it's probably negligible) and has a somewhat bad smell about having two types which mean the same thing. >> >> For the initial implementation, I chose option 3, under the assumption that it would be easy/mechanical to change later if a better option presents itself. > > I filed https://bugs.webkit.org/show_bug.cgi?id=237921 about it. Can you forward decl the namespaced type? eg: namespace WebGPU { class Device; } typedef WebGPU::Device* WGPUDevice; 454644 2022-03-14 18:02:08 -0700 2022-03-15 03:34:43 -0700 Patch bug-237861-20220314180207.patch text/plain 5912 mmaxfield U3VidmVyc2lvbiBSZXZpc2lvbjogMjkxMjU1CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViR1BVL0No YW5nZUxvZyBiL1NvdXJjZS9XZWJHUFUvQ2hhbmdlTG9nCmluZGV4IGYxYjYyM2RjYTVkNzQ2ZGFi YWZlMzg2MzJmMWYwZmZmNWQ5MGQ5ODMuLjE0ZDIyYTg1MTQyMzQ3ZjllNzZjNzkxY2M4M2ZhM2Ez MGQ4OTAxOWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJHUFUvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJHUFUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjMgQEAKKzIwMjItMDMtMTQgIE15bGVzIEMu IE1heGZpZWxkICA8bW1heGZpZWxkQGFwcGxlLmNvbT4KKworICAgICAgICBbV2ViR1BVXSBSZXBl YXRlZCBjYWxscyB0byB3Z3B1RGV2aWNlR2V0UXVldWUoKSBhcmUgc3VwcG9zZWQgdG8gcmV0dXJu IHRoZSBzYW1lIHBvaW50ZXIKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTIzNzg2MQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIFByZXZpb3VzbHksIHdncHVEZXZpY2VHZXRRdWV1ZSgpIGhhZCAibmV3IFdHUFVR dWV1ZUltcGwgeyAuLi4gfSIgYnV0IHRoaXMgaXMgd3JvbmcgYmVjYXVzZQorICAgICAgICB0aGUg ZGVmYXVsdCBxdWV1ZSBkb2Vzbid0IGNoYW5nZSBmcm9tIG9uZSBjYWxsIHRvIHRoZSBuZXh0Lgor CisgICAgICAgICogV2ViR1BVL0FkYXB0ZXIubW06CisgICAgICAgIChXZWJHUFU6OkFkYXB0ZXI6 OnJlcXVlc3REZXZpY2UpOgorICAgICAgICAod2dwdUFkYXB0ZXJSZXF1ZXN0RGV2aWNlKToKKyAg ICAgICAgKHdncHVBZGFwdGVyUmVxdWVzdERldmljZVdpdGhCbG9jayk6CisgICAgICAgICogV2Vi R1BVL0RldmljZS5oOgorICAgICAgICAqIFdlYkdQVS9EZXZpY2UubW06CisgICAgICAgIChXZWJH UFU6OkRldmljZTo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkdQVTo6RGV2aWNlOjpnZXRRdWV1ZSk6 CisgICAgICAgICh3Z3B1RGV2aWNlR2V0UXVldWUpOgorCiAyMDIyLTAzLTEyICBUaW0gSG9ydG9u ICA8dGltb3RoeV9ob3J0b25AYXBwbGUuY29tPgogCiAgICAgICAgIEFkb3B0IEZBTExCQUNLX1BM QVRGT1JNX05BTUUgaW4gcGxhY2Ugb2YgRkFMTEJBQ0tfUExBVEZPUk0KZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJHUFUvV2ViR1BVL0FkYXB0ZXIubW0gYi9Tb3VyY2UvV2ViR1BVL1dlYkdQVS9BZGFw dGVyLm1tCmluZGV4IGZjYTNiMGRmNjFmODkyZGU5ZjY5ZmIzODlkZmMwZDdkNDNlYmJiNDUuLmJh ZGFmYzU2OGE4MmQ1Nzk0ZWFjY2VhNmZjYjQzODI1MmNhY2IyZGEgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJHUFUvV2ViR1BVL0FkYXB0ZXIubW0KKysrIGIvU291cmNlL1dlYkdQVS9XZWJHUFUvQWRh cHRlci5tbQpAQCAtMTIyLDcgKzEyMiw3IEBAIHZvaWQgQWRhcHRlcjo6cmVxdWVzdERldmljZShj b25zdCBXR1BVRGV2aWNlRGVzY3JpcHRvciYgZGVzY3JpcHRvciwgV1RGOjpGdW5jdGlvCiAKICAg ICAvLyBTZWUgdGhlIGNvbW1lbnQgaW4gRGV2aWNlOjpzZXRMYWJlbCgpIGFib3V0IHdoeSB3ZSdy ZSBub3Qgc2V0dGluZyB0aGUgbGFiZWwgaGVyZS4KIAotICAgIGNhbGxiYWNrKFdHUFVSZXF1ZXN0 RGV2aWNlU3RhdHVzX1N1Y2Nlc3MsIERldmljZTo6Y3JlYXRlKG1fZGV2aWNlKSwgbnVsbHB0cik7 CisgICAgY2FsbGJhY2soV0dQVVJlcXVlc3REZXZpY2VTdGF0dXNfU3VjY2VzcywgRGV2aWNlOjpj cmVhdGUobV9kZXZpY2UsIGRlc2NyaXB0b3IubGFiZWwpLCBudWxscHRyKTsKIH0KIAogfSAvLyBu YW1lc3BhY2UgV2ViR1BVCkBAIC0xNTUsMTMgKzE1NSwyMSBAQCBib29sIHdncHVBZGFwdGVySGFz RmVhdHVyZShXR1BVQWRhcHRlciBhZGFwdGVyLCBXR1BVRmVhdHVyZU5hbWUgZmVhdHVyZSkKIHZv aWQgd2dwdUFkYXB0ZXJSZXF1ZXN0RGV2aWNlKFdHUFVBZGFwdGVyIGFkYXB0ZXIsIGNvbnN0IFdH UFVEZXZpY2VEZXNjcmlwdG9yKiBkZXNjcmlwdG9yLCBXR1BVUmVxdWVzdERldmljZUNhbGxiYWNr IGNhbGxiYWNrLCB2b2lkKiB1c2VyZGF0YSkKIHsKICAgICBhZGFwdGVyLT5hZGFwdGVyLT5yZXF1 ZXN0RGV2aWNlKCpkZXNjcmlwdG9yLCBbY2FsbGJhY2ssIHVzZXJkYXRhXSAoV0dQVVJlcXVlc3RE ZXZpY2VTdGF0dXMgc3RhdHVzLCBSZWZQdHI8V2ViR1BVOjpEZXZpY2U+JiYgZGV2aWNlLCBjb25z dCBjaGFyKiBtZXNzYWdlKSB7Ci0gICAgICAgIGNhbGxiYWNrKHN0YXR1cywgZGV2aWNlID8gbmV3 IFdHUFVEZXZpY2VJbXBsIHsgZGV2aWNlLnJlbGVhc2VOb25OdWxsKCkgfSA6IG51bGxwdHIsIG1l c3NhZ2UsIHVzZXJkYXRhKTsKKyAgICAgICAgaWYgKGRldmljZSkgeworICAgICAgICAgICAgYXV0 byYgcXVldWUgPSBkZXZpY2UtPmdldFF1ZXVlKCk7CisgICAgICAgICAgICBjYWxsYmFjayhzdGF0 dXMsIG5ldyBXR1BVRGV2aWNlSW1wbCB7IGRldmljZS5yZWxlYXNlTm9uTnVsbCgpLCB7IHF1ZXVl IH0gfSwgbWVzc2FnZSwgdXNlcmRhdGEpOworICAgICAgICB9IGVsc2UKKyAgICAgICAgICAgIGNh bGxiYWNrKHN0YXR1cywgbnVsbHB0ciwgbWVzc2FnZSwgdXNlcmRhdGEpOwogICAgIH0pOwogfQog CiB2b2lkIHdncHVBZGFwdGVyUmVxdWVzdERldmljZVdpdGhCbG9jayhXR1BVQWRhcHRlciBhZGFw dGVyLCBXR1BVRGV2aWNlRGVzY3JpcHRvciBjb25zdCAqIGRlc2NyaXB0b3IsIFdHUFVSZXF1ZXN0 RGV2aWNlQmxvY2tDYWxsYmFjayBjYWxsYmFjaykKIHsKICAgICBhZGFwdGVyLT5hZGFwdGVyLT5y ZXF1ZXN0RGV2aWNlKCpkZXNjcmlwdG9yLCBbY2FsbGJhY2tdIChXR1BVUmVxdWVzdERldmljZVN0 YXR1cyBzdGF0dXMsIFJlZlB0cjxXZWJHUFU6OkRldmljZT4mJiBkZXZpY2UsIGNvbnN0IGNoYXIq IG1lc3NhZ2UpIHsKLSAgICAgICAgY2FsbGJhY2soc3RhdHVzLCBkZXZpY2UgPyBuZXcgV0dQVURl dmljZUltcGwgeyBkZXZpY2UucmVsZWFzZU5vbk51bGwoKSB9IDogbnVsbHB0ciwgbWVzc2FnZSk7 CisgICAgICAgIGlmIChkZXZpY2UpIHsKKyAgICAgICAgICAgIGF1dG8mIHF1ZXVlID0gZGV2aWNl LT5nZXRRdWV1ZSgpOworICAgICAgICAgICAgY2FsbGJhY2soc3RhdHVzLCBuZXcgV0dQVURldmlj ZUltcGwgeyBkZXZpY2UucmVsZWFzZU5vbk51bGwoKSwgeyBxdWV1ZSB9IH0sIG1lc3NhZ2UpOwor ICAgICAgICB9IGVsc2UKKyAgICAgICAgICAgIGNhbGxiYWNrKHN0YXR1cywgbnVsbHB0ciwgbWVz c2FnZSk7CiAgICAgfSk7CiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViR1BVL1dlYkdQVS9EZXZp Y2UuaCBiL1NvdXJjZS9XZWJHUFUvV2ViR1BVL0RldmljZS5oCmluZGV4IDM4NzVlMzEyM2M3NzEw ZjYxZDBhMzY5MWQwOGMxYjAwZWY1ZWU4NTAuLmQ4MDVkYzBmODgyNDE4ODc5MjhhM2QzOTlhY2Jl Yjk3YWUzOTY5ZDAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJHUFUvV2ViR1BVL0RldmljZS5oCisr KyBiL1NvdXJjZS9XZWJHUFUvV2ViR1BVL0RldmljZS5oCkBAIC0yNSw2ICsyNSw3IEBACiAKICNw cmFnbWEgb25jZQogCisjaW1wb3J0ICJRdWV1ZS5oIgogI2ltcG9ydCA8d3RmL0Zhc3RNYWxsb2Mu aD4KICNpbXBvcnQgPHd0Zi9GdW5jdGlvbi5oPgogI2ltcG9ydCA8d3RmL1JlZi5oPgpAQCAtNDcs MTIgKzQ4LDExIEBAIGNsYXNzIFNoYWRlck1vZHVsZTsKIGNsYXNzIFN1cmZhY2U7CiBjbGFzcyBT d2FwQ2hhaW47CiBjbGFzcyBUZXh0dXJlOwotY2xhc3MgUXVldWU7CiAKIGNsYXNzIERldmljZSA6 IHB1YmxpYyBSZWZDb3VudGVkPERldmljZT4gewogICAgIFdURl9NQUtFX0ZBU1RfQUxMT0NBVEVE OwogcHVibGljOgotICAgIHN0YXRpYyBSZWZQdHI8RGV2aWNlPiBjcmVhdGUoaWQ8TVRMRGV2aWNl Pik7CisgICAgc3RhdGljIFJlZlB0cjxEZXZpY2U+IGNyZWF0ZShpZDxNVExEZXZpY2U+LCBjb25z dCBjaGFyKiBkZXZpY2VMYWJlbCk7CiAKICAgICB+RGV2aWNlKCk7CiAKQEAgLTc0LDcgKzc0LDcg QEAgcHVibGljOgogICAgIHZvaWQgZGVzdHJveSgpOwogICAgIHNpemVfdCBlbnVtZXJhdGVGZWF0 dXJlcyhXR1BVRmVhdHVyZU5hbWUqIGZlYXR1cmVzKTsKICAgICBib29sIGdldExpbWl0cyhXR1BV U3VwcG9ydGVkTGltaXRzJik7Ci0gICAgUmVmUHRyPFF1ZXVlPiBnZXRRdWV1ZSgpOworICAgIFF1 ZXVlJiBnZXRRdWV1ZSgpOwogICAgIGJvb2wgaGFzRmVhdHVyZShXR1BVRmVhdHVyZU5hbWUpOwog ICAgIGJvb2wgcG9wRXJyb3JTY29wZShXVEY6OkZ1bmN0aW9uPHZvaWQoV0dQVUVycm9yVHlwZSwg Y29uc3QgY2hhciopPiYmIGNhbGxiYWNrKTsKICAgICB2b2lkIHB1c2hFcnJvclNjb3BlKFdHUFVF cnJvckZpbHRlcik7CkBAIC05Myw0ICs5Myw1IEBAIHByaXZhdGU6CiAKIHN0cnVjdCBXR1BVRGV2 aWNlSW1wbCB7CiAgICAgUmVmPFdlYkdQVTo6RGV2aWNlPiBkZXZpY2U7CisgICAgV0dQVVF1ZXVl SW1wbCBkZWZhdWx0UXVldWU7CiB9OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkdQVS9XZWJHUFUv RGV2aWNlLm1tIGIvU291cmNlL1dlYkdQVS9XZWJHUFUvRGV2aWNlLm1tCmluZGV4IGM4M2Y4NDNj MjY0N2Y3OWFmMTY2MjExMTc1NTQ5YzhjMmMzN2RiYmEuLjFhNGM1ZmQ4NDk0YWU3NzUxMjg0YWJh NTkwMWUzZjljZGM3YmRmOWMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJHUFUvV2ViR1BVL0Rldmlj ZS5tbQorKysgYi9Tb3VyY2UvV2ViR1BVL1dlYkdQVS9EZXZpY2UubW0KQEAgLTQ1LDEzICs0NSwx NyBAQAogCiBuYW1lc3BhY2UgV2ViR1BVIHsKIAotUmVmUHRyPERldmljZT4gRGV2aWNlOjpjcmVh dGUoaWQ8TVRMRGV2aWNlPiBkZXZpY2UpCitSZWZQdHI8RGV2aWNlPiBEZXZpY2U6OmNyZWF0ZShp ZDxNVExEZXZpY2U+IGRldmljZSwgY29uc3QgY2hhciogZGV2aWNlTGFiZWwpCiB7CiAgICAgaWQ8 TVRMQ29tbWFuZFF1ZXVlPiBjb21tYW5kUXVldWUgPSBbZGV2aWNlIG5ld0NvbW1hbmRRdWV1ZV07 CiAgICAgaWYgKCFjb21tYW5kUXVldWUpCiAgICAgICAgIHJldHVybiBudWxscHRyOwogICAgIGF1 dG8gcXVldWUgPSBRdWV1ZTo6Y3JlYXRlKGNvbW1hbmRRdWV1ZSk7CiAKKyAgICBjb21tYW5kUXVl dWUubGFiZWwgPSBAIkRlZmF1bHQgcXVldWUiOworICAgIGlmIChkZXZpY2VMYWJlbCAmJiBzdHJs ZW4oZGV2aWNlTGFiZWwpKQorICAgICAgICBjb21tYW5kUXVldWUubGFiZWwgPSBbTlNTdHJpbmcg c3RyaW5nV2l0aEZvcm1hdDpAIkRlZmF1bHQgcXVldWUgZm9yIGRldmljZSAlcyIsIGRldmljZUxh YmVsXTsKKwogICAgIHJldHVybiBhZG9wdFJlZigqbmV3IERldmljZShkZXZpY2UsIFdURk1vdmUo cXVldWUpKSk7CiB9CiAKQEAgLTg0LDkgKzg4LDkgQEAgYm9vbCBEZXZpY2U6OmdldExpbWl0cyhX R1BVU3VwcG9ydGVkTGltaXRzJiBsaW1pdHMpCiAgICAgcmV0dXJuIHRydWU7CiB9CiAKLVJlZlB0 cjxRdWV1ZT4gRGV2aWNlOjpnZXRRdWV1ZSgpCitRdWV1ZSYgRGV2aWNlOjpnZXRRdWV1ZSgpCiB7 Ci0gICAgcmV0dXJuIG1fZGVmYXVsdFF1ZXVlLmNvcHlSZWYoKTsKKyAgICByZXR1cm4gbV9kZWZh dWx0UXVldWU7CiB9CiAKIGJvb2wgRGV2aWNlOjpoYXNGZWF0dXJlKFdHUFVGZWF0dXJlTmFtZSkK QEAgLTI1NSw4ICsyNTksNyBAQCBib29sIHdncHVEZXZpY2VHZXRMaW1pdHMoV0dQVURldmljZSBk ZXZpY2UsIFdHUFVTdXBwb3J0ZWRMaW1pdHMqIGxpbWl0cykKIAogV0dQVVF1ZXVlIHdncHVEZXZp Y2VHZXRRdWV1ZShXR1BVRGV2aWNlIGRldmljZSkKIHsKLSAgICBhdXRvIHJlc3VsdCA9IGRldmlj ZS0+ZGV2aWNlLT5nZXRRdWV1ZSgpOwotICAgIHJldHVybiByZXN1bHQgPyBuZXcgV0dQVVF1ZXVl SW1wbCB7IHJlc3VsdC5yZWxlYXNlTm9uTnVsbCgpIH0gOiBudWxscHRyOworICAgIHJldHVybiAm ZGV2aWNlLT5kZWZhdWx0UXVldWU7CiB9CiAKIGJvb2wgd2dwdURldmljZUhhc0ZlYXR1cmUoV0dQ VURldmljZSBkZXZpY2UsIFdHUFVGZWF0dXJlTmFtZSBmZWF0dXJlKQo=