211279 2020-04-30 23:04:32 -0700 Merge putLength() into setLength() 2020-08-26 18:56:18 -0700 1 1 1 Unclassified WebKit JavaScriptCore WebKit Nightly Build All All RESOLVED FIXED https://bugs.webkit.org/show_bug.cgi?id=211205 InRadar P2 Enhancement --- 1 saam ashvayka ashvayka benjamin darin fpizlo ggaren gskachkov guijemont keith_miller mark.lam msaboff rmorisset ross.kirsling ticaiolima tzagallo webkit-bug-importer ysuzuki oldest_to_newest 1647773 0 saam 2020-04-30 23:04:32 -0700 Seems superfluous and costly to do the method table dispatch. 1682959 1 407289 ashvayka 2020-08-26 04:03:22 -0700 Created attachment 407289 Patch 1682960 2 ashvayka 2020-08-26 04:05:19 -0700 (In reply to Alexey Shvayka from comment #1) > Created attachment 407289 [details] > Patch Warmed-up runs, --outer 50: r266157 patch array-shift-unshift-empty 64.8823+-1.0893 ^ 45.5567+-1.4411 ^ definitely 1.4242x faster 1682982 3 407289 saam 2020-08-26 08:37:35 -0700 Comment on attachment 407289 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=407289&action=review > Source/JavaScriptCore/runtime/ArrayPrototype.cpp:874 > + JSValue result = thisObj->get(globalObject, index); Isn’t the whole point of the previous code that we need the Identifier when at the MAX_ARRAY_INDEX boundary? 1683066 4 407289 darin 2020-08-26 11:53:08 -0700 Comment on attachment 407289 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=407289&action=review Ah, the runtime. One area of JavaScriptCore that I still have enough expertise in that I can review. > Source/JavaScriptCore/runtime/ArrayPrototype.cpp:166 > + if (LIKELY(isJSArray(obj))) { Obviously this *is* likely, but I do like to follow the principle of only adding these when we know they’re beneficial so not 100% sure I would have added it. Hard to argue against it strongly, though. >> Source/JavaScriptCore/runtime/ArrayPrototype.cpp:874 >> + JSValue result = thisObj->get(globalObject, index); > > Isn’t the whole point of the previous code that we need the Identifier when at the MAX_ARRAY_INDEX boundary? Perhaps, but since Object::get(JSObject*, uint64_t) takes care of creating the identifier when it’s needed, this code will work properly without separate branches for valid array index values and other values. Object::deleteProperty(JSGlobalObject*, uint64_t) also does. A bit unfortunate that the two functions will do the work to make the Identifier string twice, but I suppose it’s an exotic case that we don’t need to optimize carefully. Similarly, we will end up calling jsNumber on the same number repeatedly, which would waste a bit of heap, but again only in exotic cases. 1683082 5 407289 saam 2020-08-26 12:43:31 -0700 Comment on attachment 407289 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=407289&action=review r=me too >>> Source/JavaScriptCore/runtime/ArrayPrototype.cpp:874 >>> + JSValue result = thisObj->get(globalObject, index); >> >> Isn’t the whole point of the previous code that we need the Identifier when at the MAX_ARRAY_INDEX boundary? > > Perhaps, but since Object::get(JSObject*, uint64_t) takes care of creating the identifier when it’s needed, this code will work properly without separate branches for valid array index values and other values. Object::deleteProperty(JSGlobalObject*, uint64_t) also does. A bit unfortunate that the two functions will do the work to make the Identifier string twice, but I suppose it’s an exotic case that we don’t need to optimize carefully. Similarly, we will end up calling jsNumber on the same number repeatedly, which would waste a bit of heap, but again only in exotic cases. Ah! I forgot I added the uint64_t version of this method. I thought we were implicit casting to the uint32_t version and was worried. jsNumber on the same number repeatedly is cheap, and doesn't allocate anything in the heap. 1683132 6 407289 darin 2020-08-26 14:14:03 -0700 Comment on attachment 407289 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=407289&action=review >>>> Source/JavaScriptCore/runtime/ArrayPrototype.cpp:874 >>>> + JSValue result = thisObj->get(globalObject, index); >>> >>> Isn’t the whole point of the previous code that we need the Identifier when at the MAX_ARRAY_INDEX boundary? >> >> Perhaps, but since Object::get(JSObject*, uint64_t) takes care of creating the identifier when it’s needed, this code will work properly without separate branches for valid array index values and other values. Object::deleteProperty(JSGlobalObject*, uint64_t) also does. A bit unfortunate that the two functions will do the work to make the Identifier string twice, but I suppose it’s an exotic case that we don’t need to optimize carefully. Similarly, we will end up calling jsNumber on the same number repeatedly, which would waste a bit of heap, but again only in exotic cases. > > Ah! I forgot I added the uint64_t version of this method. I thought we were implicit casting to the uint32_t version and was worried. > > jsNumber on the same number repeatedly is cheap, and doesn't allocate anything in the heap. Oh, right, they all get converted to double, and a double always fits in a double. Some values lose precision but they all fit. When we added the uint64_t version it did create one subtle poor design thing. The 32-bit version has a required precondition that the number is an array index; you must not pass it the value 0xFFFFFFFF. The 64-bit version does not have that precondition, nor do other overloads. Although maybe there is an Identifier one that you must not call with a string that just happens to be a serialized array index. Requiring one number be avoided a strange difference to based only on the passed integer’s width. So I might have introduced a difference in name by renaming the 32-bit integer functions. 1683143 7 saam 2020-08-26 14:44:57 -0700 (In reply to Darin Adler from comment #6) > Comment on attachment 407289 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=407289&action=review > > >>>> Source/JavaScriptCore/runtime/ArrayPrototype.cpp:874 > >>>> + JSValue result = thisObj->get(globalObject, index); > >>> > >>> Isn’t the whole point of the previous code that we need the Identifier when at the MAX_ARRAY_INDEX boundary? > >> > >> Perhaps, but since Object::get(JSObject*, uint64_t) takes care of creating the identifier when it’s needed, this code will work properly without separate branches for valid array index values and other values. Object::deleteProperty(JSGlobalObject*, uint64_t) also does. A bit unfortunate that the two functions will do the work to make the Identifier string twice, but I suppose it’s an exotic case that we don’t need to optimize carefully. Similarly, we will end up calling jsNumber on the same number repeatedly, which would waste a bit of heap, but again only in exotic cases. > > > > Ah! I forgot I added the uint64_t version of this method. I thought we were implicit casting to the uint32_t version and was worried. > > > > jsNumber on the same number repeatedly is cheap, and doesn't allocate anything in the heap. > > Oh, right, they all get converted to double, and a double always fits in a > double. Some values lose precision but they all fit. > > When we added the uint64_t version it did create one subtle poor design > thing. The 32-bit version has a required precondition that the number is an > array index; you must not pass it the value 0xFFFFFFFF. The 64-bit version > does not have that precondition, nor do other overloads. Although maybe > there is an Identifier one that you must not call with a string that just > happens to be a serialized array index. Requiring one number be avoided a > strange difference to based only on the passed integer’s width. So I might > have introduced a difference in name by renaming the 32-bit integer > functions. We could rename them. Or invent a new type to pass in as a wrapper to the index. Something like ArrayIndex, and it asserts the value is in range, and it's not implicitly constructible. 1683151 8 darin 2020-08-26 14:50:23 -0700 (In reply to Saam Barati from comment #7) > We could rename them. Or invent a new type to pass in as a wrapper to the > index. Something like ArrayIndex, and it asserts the value is in range, and > it's not implicitly constructible. We are thinking similarly: I literally considered that option too when writing the comment above, but thought it was too complicated to explain so left it out. 1683155 9 saam 2020-08-26 14:53:43 -0700 (In reply to Darin Adler from comment #8) > (In reply to Saam Barati from comment #7) > > We could rename them. Or invent a new type to pass in as a wrapper to the > > index. Something like ArrayIndex, and it asserts the value is in range, and > > it's not implicitly constructible. > > We are thinking similarly: I literally considered that option too when > writing the comment above, but thought it was too complicated to explain so > left it out. I think the right way to do this is to change those helper methods, but also to change the method table methods of: - putByIndex - deletePropertyByIndex - getOwnPropertySlotByIndex 1683156 10 saam 2020-08-26 14:55:40 -0700 (In reply to Saam Barati from comment #9) > (In reply to Darin Adler from comment #8) > > (In reply to Saam Barati from comment #7) > > > We could rename them. Or invent a new type to pass in as a wrapper to the > > > index. Something like ArrayIndex, and it asserts the value is in range, and > > > it's not implicitly constructible. > > > > We are thinking similarly: I literally considered that option too when > > writing the comment above, but thought it was too complicated to explain so > > left it out. > > I think the right way to do this is to change those helper methods, but also > to change the method table methods of: > - putByIndex > - deletePropertyByIndex > - getOwnPropertySlotByIndex I might actually be wrong. Reading some more code. 1683159 11 saam 2020-08-26 15:01:54 -0700 (In reply to Darin Adler from comment #6) > Comment on attachment 407289 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=407289&action=review > > >>>> Source/JavaScriptCore/runtime/ArrayPrototype.cpp:874 > >>>> + JSValue result = thisObj->get(globalObject, index); > >>> > >>> Isn’t the whole point of the previous code that we need the Identifier when at the MAX_ARRAY_INDEX boundary? > >> > >> Perhaps, but since Object::get(JSObject*, uint64_t) takes care of creating the identifier when it’s needed, this code will work properly without separate branches for valid array index values and other values. Object::deleteProperty(JSGlobalObject*, uint64_t) also does. A bit unfortunate that the two functions will do the work to make the Identifier string twice, but I suppose it’s an exotic case that we don’t need to optimize carefully. Similarly, we will end up calling jsNumber on the same number repeatedly, which would waste a bit of heap, but again only in exotic cases. > > > > Ah! I forgot I added the uint64_t version of this method. I thought we were implicit casting to the uint32_t version and was worried. > > > > jsNumber on the same number repeatedly is cheap, and doesn't allocate anything in the heap. > > Oh, right, they all get converted to double, and a double always fits in a > double. Some values lose precision but they all fit. > > When we added the uint64_t version it did create one subtle poor design > thing. The 32-bit version has a required precondition that the number is an > array index; you must not pass it the value 0xFFFFFFFF. The 64-bit version > does not have that precondition, nor do other overloads. Although maybe > there is an Identifier one that you must not call with a string that just > happens to be a serialized array index. Requiring one number be avoided a > strange difference to based only on the passed integer’s width. So I might > have introduced a difference in name by renaming the 32-bit integer > functions. After reading some code, it doesn't appear that there are restrictions on the range of the unsigned passed into these methods. For example, 0xFFFFFFFF should be handled just fine: ``` ALWAYS_INLINE bool putByIndexInline(JSGlobalObject* globalObject, unsigned propertyName, JSValue value, bool shouldThrow) { VM& vm = getVM(globalObject); if (canSetIndexQuickly(propertyName, value)) { setIndexQuickly(vm, propertyName, value); return true; } return methodTable(vm)->putByIndex(this, globalObject, propertyName, value, shouldThrow); } ``` canSetIndexQuickly for 0xFFFFFFFF should return false. This will lead us to taking the putByIndex path. Let's look at one example implementation: ``` bool JSObject::putByIndex(JSCell* cell, JSGlobalObject* globalObject, unsigned propertyName, JSValue value, bool shouldThrow) { VM& vm = globalObject->vm(); JSObject* thisObject = jsCast<JSObject*>(cell); if (propertyName > MAX_ARRAY_INDEX) { PutPropertySlot slot(cell, shouldThrow); return thisObject->methodTable(vm)->put(thisObject, globalObject, Identifier::from(vm, propertyName), value, slot); } ... ... ``` So it's expected that the various method table methods I listed properly handle all ranges of values passed into the various byIndex MethodTable methods. 1683161 12 darin 2020-08-26 15:09:11 -0700 (In reply to Saam Barati from comment #11) > it doesn't appear that there are restrictions on > the range of the unsigned passed into these methods OK, glad to hear it. Guess I remembered wrong. I’m pretty sure I’m the one who created these separate overloads so that integers could pass through the runtime without being converted to and from Identifier strings, but I must have forgotten some of the details over the years. 1683166 13 saam 2020-08-26 15:17:31 -0700 (In reply to Darin Adler from comment #12) > (In reply to Saam Barati from comment #11) > > it doesn't appear that there are restrictions on > > the range of the unsigned passed into these methods > > OK, glad to hear it. Guess I remembered wrong. I’m pretty sure I’m the one > who created these separate overloads so that integers could pass through the > runtime without being converted to and from Identifier strings, but I must > have forgotten some of the details over the years. Yeah, the code itself is a bit subtle, and I have to re-read the code to convince myself of its correctness. It took me a second, just now, to realize that our "isIndex" function and MAX_ARRAY_INDEX are indeed in sync. One nit I have with the code base is to rewrite isIndex in terms of MAX_ARRAY_INDEX, since we have code that relies on > MAX_ARRAY_INDEX having "isIndex" return false. Currently, we just hard code numbers in two different places. 1683170 14 darin 2020-08-26 15:27:14 -0700 (In reply to Saam Barati from comment #13) > One nit I have with the code base is to rewrite isIndex in terms of > MAX_ARRAY_INDEX, since we have code that relies on > MAX_ARRAY_INDEX having > "isIndex" return false. Currently, we just hard code numbers in two > different places. Compared to MAX_ARRAY_INDEX, isIndex is new. Yusuke added it in 2015: https://trac.webkit.org/changeset/182452 MAX_ARRAY_INDEX is many years older and used many more places. 1683185 15 saam 2020-08-26 16:16:10 -0700 (In reply to Darin Adler from comment #14) > (In reply to Saam Barati from comment #13) > > One nit I have with the code base is to rewrite isIndex in terms of > > MAX_ARRAY_INDEX, since we have code that relies on > MAX_ARRAY_INDEX having > > "isIndex" return false. Currently, we just hard code numbers in two > > different places. > > Compared to MAX_ARRAY_INDEX, isIndex is new. Yusuke added it in 2015: > > https://trac.webkit.org/changeset/182452 > > MAX_ARRAY_INDEX is many years older and used many more places. Will do a small cleanup in: https://bugs.webkit.org/show_bug.cgi?id=215872 1683251 16 ashvayka 2020-08-26 18:55:12 -0700 Committed r266215: <https://trac.webkit.org/changeset/266215> 1683254 17 webkit-bug-importer 2020-08-26 18:56:18 -0700 <rdar://problem/67843783> 407289 2020-08-26 04:03:22 -0700 2020-08-26 11:53:08 -0700 Patch bug-211279-20200826140321.patch text/plain 9928 ashvayka U3VidmVyc2lvbiBSZXZpc2lvbjogMjY2MTUxCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCAw M2FiZTlhMzhjZGJkZDM4MjFkMWM4OTM4ZjE3NTUzMWY3Y2Q5OWJhLi5mYWZkNzNhYTJmZjcxMDBm YjRiYmNmMDNhNWM0MjhjYWQyNWY5ZjQzIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwzMyBAQAorMjAyMC0wOC0yNiAgQWxleGV5IFNodmF5a2EgIDxzaHZhaWthbGVzaEBnbWFp bC5jb20+CisKKyAgICAgICAgTWVyZ2UgcHV0TGVuZ3RoKCkgaW50byBzZXRMZW5ndGgoKQorICAg ICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjExMjc5CisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVGhpcyBwYXRjaDoK KworICAgICAgICAxLiBSZXBsYWNlcyBhbGwgcHV0TGVuZ3RoKCkgY2FsbCBzaXRlcyB3aXRoIHNl dExlbmd0aCgpLCBzYXZpbmcgdHdvIEpTVmFsdWUKKyAgICAgICAgICAgaW5zdGFudGlhdGlvbnMg aW4gYXJyYXlQcm90b0Z1bmNQb3AoKSBhbmQgdHdvIGluIGFycmF5UHJvdG9GdW5jU2hpZnQoKS4K KworICAgICAgICAyLiBNZXJnZXMgcHV0TGVuZ3RoKCkgaW50byBzZXRMZW5ndGgoKSwgcmVtb3Zp bmcgc3VwZXJmbHVvdXMgcHV0KCkgY2FsbCBmb3IKKyAgICAgICAgICAgSlNBcnJheS4gQWxzbywg cGVyZm9ybXMgcHV0KCkgaW4gc3RyaWN0IG1vZGUgdG8gcHJlc2VydmUgdGhlIG9yaWdpbmFsCisg ICAgICAgICAgIGVycm9yIG1lc3NhZ2VzLCBsaWtlIG9uZXMgaW4gUHJveHlPYmplY3Q6OnBlcmZv cm1QdXQoKS4KKworICAgICAgICAzLiBJbmxpbmVzIHBlcmZvcm1Qb3AoKSwgd2hpY2ggYXZvaWRl ZCBhbiBleHRyYSBpbmRleCBjaGVjayBhbmQgSWRlbnRpZmllcgorICAgICAgICAgICBjcmVhdGlv biwgYXMgaXQgd2FzIG9uIHRoZSBzbG93IHBhdGggYW55d2F5IChub3RlIEpTQXJyYXk6OnBvcCgp IGNhbGwpLgorCisgICAgICAgIFRoaXMgY2hhbmdlIGFkdmFuY2VzIHByb3ZpZGVkIHNldExlbmd0 aCgpLWhlYXZ5IG1pY3JvYmVuY2htYXJrIGJ5IH40MCUsCisgICAgICAgIHdoaWxlIGV4aXN0aW5n IEFycmF5IHRlc3RzIGFyZSBuZXV0cmFsLgorCisgICAgICAgICogcnVudGltZS9BcnJheVByb3Rv dHlwZS5jcHA6CisgICAgICAgIChKU0M6OnNldExlbmd0aCk6CisgICAgICAgIChKU0M6OmFycmF5 UHJvdG9GdW5jUG9wKToKKyAgICAgICAgKEpTQzo6YXJyYXlQcm90b0Z1bmNQdXNoKToKKyAgICAg ICAgKEpTQzo6YXJyYXlQcm90b0Z1bmNTaGlmdCk6CisgICAgICAgIChKU0M6OmFycmF5UHJvdG9G dW5jVW5TaGlmdCk6CisgICAgICAgIChKU0M6OnB1dExlbmd0aCk6IERlbGV0ZWQuCisKIDIwMjAt MDgtMjUgIERldmluIFJvdXNzbyAgPGRyb3Vzc29AYXBwbGUuY29tPgogCiAgICAgICAgIFdlYiBJ bnNwZWN0b3I6IGJyZWFrcG9pbnQgY29uZGl0aW9uIHNob3VsZCBiZSBldmFsdWF0ZWQgYmVmb3Jl IHRoZSBpZ25vcmUgY291bnQKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50 aW1lL0FycmF5UHJvdG90eXBlLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0Fy cmF5UHJvdG90eXBlLmNwcAppbmRleCA3MTkwOTA0ZWUwNDlhODA3NDU3YTdiOTZjZjE5ZGI5NWI4 MDM3YjgzLi5lMjliODI4ZDVjNTk1YTY4NjA3ODFiMTNmODNhNzZhNGI4MDYxN2RlIDEwMDY0NAot LS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9BcnJheVByb3RvdHlwZS5jcHAKKysr IGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvQXJyYXlQcm90b3R5cGUuY3BwCkBAIC0x NjAsMjcgKzE2MCwxNiBAQCBzdGF0aWMgQUxXQVlTX0lOTElORSBKU1ZhbHVlIGdldFByb3BlcnR5 KEpTR2xvYmFsT2JqZWN0KiBnbG9iYWxPYmplY3QsIEpTT2JqZWN0KgogICAgIFJFTEVBU0VfQU5E X1JFVFVSTihzY29wZSwgc2xvdC5nZXRWYWx1ZShnbG9iYWxPYmplY3QsIGluZGV4KSk7CiB9CiAK LXN0YXRpYyBBTFdBWVNfSU5MSU5FIHZvaWQgcHV0TGVuZ3RoKEpTR2xvYmFsT2JqZWN0KiBnbG9i YWxPYmplY3QsIFZNJiB2bSwgSlNPYmplY3QqIG9iaiwgSlNWYWx1ZSB2YWx1ZSkKLXsKLSAgICBh dXRvIHNjb3BlID0gREVDTEFSRV9USFJPV19TQ09QRSh2bSk7Ci0gICAgUHV0UHJvcGVydHlTbG90 IHNsb3Qob2JqKTsKLSAgICBib29sIHN1Y2Nlc3MgPSBvYmotPm1ldGhvZFRhYmxlKHZtKS0+cHV0 KG9iaiwgZ2xvYmFsT2JqZWN0LCB2bS5wcm9wZXJ0eU5hbWVzLT5sZW5ndGgsIHZhbHVlLCBzbG90 KTsKLSAgICBSRVRVUk5fSUZfRVhDRVBUSU9OKHNjb3BlLCB2b2lkKCkpOwotICAgIGlmIChVTkxJ S0VMWSghc3VjY2VzcykpCi0gICAgICAgIHRocm93VHlwZUVycm9yKGdsb2JhbE9iamVjdCwgc2Nv cGUsIFJlYWRvbmx5UHJvcGVydHlXcml0ZUVycm9yKTsKLX0KLQogc3RhdGljIEFMV0FZU19JTkxJ TkUgdm9pZCBzZXRMZW5ndGgoSlNHbG9iYWxPYmplY3QqIGdsb2JhbE9iamVjdCwgVk0mIHZtLCBK U09iamVjdCogb2JqLCB1aW50NjRfdCB2YWx1ZSkKIHsKLSAgICBhdXRvIHNjb3BlID0gREVDTEFS RV9USFJPV19TQ09QRSh2bSk7CiAgICAgc3RhdGljIGNvbnN0ZXhwciBib29sIHRocm93RXhjZXB0 aW9uID0gdHJ1ZTsKLSAgICBpZiAoaXNKU0FycmF5KG9iaikpIHsKKyAgICBpZiAoTElLRUxZKGlz SlNBcnJheShvYmopKSkgewogICAgICAgICBBU1NFUlQoc3RhdGljX2Nhc3Q8dWludDMyX3Q+KHZh bHVlKSA9PSB2YWx1ZSk7CiAgICAgICAgIGpzQ2FzdDxKU0FycmF5Kj4ob2JqKS0+c2V0TGVuZ3Ro KGdsb2JhbE9iamVjdCwgc3RhdGljX2Nhc3Q8dWludDMyX3Q+KHZhbHVlKSwgdGhyb3dFeGNlcHRp b24pOwotICAgICAgICBSRVRVUk5fSUZfRVhDRVBUSU9OKHNjb3BlLCB2b2lkKCkpOworICAgIH0g ZWxzZSB7CisgICAgICAgIFB1dFByb3BlcnR5U2xvdCBzbG90KG9iaiwgdGhyb3dFeGNlcHRpb24p OworICAgICAgICBvYmotPm1ldGhvZFRhYmxlKHZtKS0+cHV0KG9iaiwgZ2xvYmFsT2JqZWN0LCB2 bS5wcm9wZXJ0eU5hbWVzLT5sZW5ndGgsIGpzTnVtYmVyKHZhbHVlKSwgc2xvdCk7CiAgICAgfQot ICAgIHNjb3BlLnJlbGVhc2UoKTsKLSAgICBwdXRMZW5ndGgoZ2xvYmFsT2JqZWN0LCB2bSwgb2Jq LCBqc051bWJlcih2YWx1ZSkpOwogfQogCiBuYW1lc3BhY2UgQXJyYXlQcm90b3R5cGVJbnRlcm5h bCB7CkBAIC04NzYsMjggKzg2NSwyNCBAQCBFbmNvZGVkSlNWYWx1ZSBKU0NfSE9TVF9DQUxMIGFy cmF5UHJvdG9GdW5jUG9wKEpTR2xvYmFsT2JqZWN0KiBnbG9iYWxPYmplY3QsIENhbAogCiAgICAg aWYgKGxlbmd0aCA9PSAwKSB7CiAgICAgICAgIHNjb3BlLnJlbGVhc2UoKTsKLSAgICAgICAgcHV0 TGVuZ3RoKGdsb2JhbE9iamVjdCwgdm0sIHRoaXNPYmosIGpzTnVtYmVyKGxlbmd0aCkpOworICAg ICAgICBzZXRMZW5ndGgoZ2xvYmFsT2JqZWN0LCB2bSwgdGhpc09iaiwgbGVuZ3RoKTsKICAgICAg ICAgcmV0dXJuIEpTVmFsdWU6OmVuY29kZShqc1VuZGVmaW5lZCgpKTsKICAgICB9CiAKLSAgICBh dXRvIHBlcmZvcm1Qb3AgPSBbJl0gKGF1dG8gaW5kZXgsIEpTVmFsdWUgaW5kZXhWYWx1ZSkgewot ICAgICAgICBKU1ZhbHVlIHJlc3VsdCA9IHRoaXNPYmotPmdldChnbG9iYWxPYmplY3QsIGluZGV4 KTsKLSAgICAgICAgUkVUVVJOX0lGX0VYQ0VQVElPTihzY29wZSwgZW5jb2RlZEpTVmFsdWUoKSk7 Ci0gICAgICAgIGJvb2wgc3VjY2VzcyA9IHRoaXNPYmotPmRlbGV0ZVByb3BlcnR5KGdsb2JhbE9i amVjdCwgaW5kZXgpOwotICAgICAgICBSRVRVUk5fSUZfRVhDRVBUSU9OKHNjb3BlLCBlbmNvZGVk SlNWYWx1ZSgpKTsKLSAgICAgICAgaWYgKFVOTElLRUxZKCFzdWNjZXNzKSkgewotICAgICAgICAg ICAgdGhyb3dUeXBlRXJyb3IoZ2xvYmFsT2JqZWN0LCBzY29wZSwgVW5hYmxlVG9EZWxldGVQcm9w ZXJ0eUVycm9yKTsKLSAgICAgICAgICAgIHJldHVybiBlbmNvZGVkSlNWYWx1ZSgpOwotICAgICAg ICB9Ci0gICAgICAgIHNjb3BlLnJlbGVhc2UoKTsKLSAgICAgICAgcHV0TGVuZ3RoKGdsb2JhbE9i amVjdCwgdm0sIHRoaXNPYmosIGluZGV4VmFsdWUpOwotICAgICAgICByZXR1cm4gSlNWYWx1ZTo6 ZW5jb2RlKHJlc3VsdCk7Ci0gICAgfTsKLQogICAgIHN0YXRpY19hc3NlcnQoTUFYX0FSUkFZX0lO REVYICsgMSA+IE1BWF9BUlJBWV9JTkRFWCk7Ci0gICAgaWYgKExJS0VMWShsZW5ndGggPD0gTUFY X0FSUkFZX0lOREVYICsgMSkpCi0gICAgICAgIHJldHVybiBwZXJmb3JtUG9wKHN0YXRpY19jYXN0 PHVpbnQzMl90PihsZW5ndGggLSAxKSwganNOdW1iZXIoc3RhdGljX2Nhc3Q8dWludDMyX3Q+KGxl bmd0aCAtIDEpKSk7Ci0gICAgcmV0dXJuIHBlcmZvcm1Qb3AoSWRlbnRpZmllcjo6ZnJvbSh2bSwg bGVuZ3RoIC0gMSksIGpzTnVtYmVyKGxlbmd0aCAtIDEpKTsKKyAgICB1aW50NjRfdCBpbmRleCA9 IGxlbmd0aCAtIDE7CisgICAgSlNWYWx1ZSByZXN1bHQgPSB0aGlzT2JqLT5nZXQoZ2xvYmFsT2Jq ZWN0LCBpbmRleCk7CisgICAgUkVUVVJOX0lGX0VYQ0VQVElPTihzY29wZSwgeyB9KTsKKyAgICBi b29sIHN1Y2Nlc3MgPSB0aGlzT2JqLT5kZWxldGVQcm9wZXJ0eShnbG9iYWxPYmplY3QsIGluZGV4 KTsKKyAgICBSRVRVUk5fSUZfRVhDRVBUSU9OKHNjb3BlLCB7IH0pOworICAgIGlmIChVTkxJS0VM WSghc3VjY2VzcykpIHsKKyAgICAgICAgdGhyb3dUeXBlRXJyb3IoZ2xvYmFsT2JqZWN0LCBzY29w ZSwgVW5hYmxlVG9EZWxldGVQcm9wZXJ0eUVycm9yKTsKKyAgICAgICAgcmV0dXJuIHsgfTsKKyAg ICB9CisKKyAgICBzY29wZS5yZWxlYXNlKCk7CisgICAgc2V0TGVuZ3RoKGdsb2JhbE9iamVjdCwg dm0sIHRoaXNPYmosIGluZGV4KTsKKyAgICByZXR1cm4gSlNWYWx1ZTo6ZW5jb2RlKHJlc3VsdCk7 CiB9CiAKIEVuY29kZWRKU1ZhbHVlIEpTQ19IT1NUX0NBTEwgYXJyYXlQcm90b0Z1bmNQdXNoKEpT R2xvYmFsT2JqZWN0KiBnbG9iYWxPYmplY3QsIENhbGxGcmFtZSogY2FsbEZyYW1lKQpAQCAtOTM1 LDEwICs5MjAsMTAgQEAgRW5jb2RlZEpTVmFsdWUgSlNDX0hPU1RfQ0FMTCBhcnJheVByb3RvRnVu Y1B1c2goSlNHbG9iYWxPYmplY3QqIGdsb2JhbE9iamVjdCwgQ2EKICAgICAgICAgUkVUVVJOX0lG X0VYQ0VQVElPTihzY29wZSwgZW5jb2RlZEpTVmFsdWUoKSk7CiAgICAgfQogICAgIAotICAgIEpT VmFsdWUgbmV3TGVuZ3RoKHN0YXRpY19jYXN0PGludDY0X3Q+KGxlbmd0aCkgKyBzdGF0aWNfY2Fz dDxpbnQ2NF90PihjYWxsRnJhbWUtPmFyZ3VtZW50Q291bnQoKSkpOworICAgIHVpbnQ2NF90IG5l d0xlbmd0aCA9IGxlbmd0aCArIGFyZ0NvdW50OwogICAgIHNjb3BlLnJlbGVhc2UoKTsKLSAgICBw dXRMZW5ndGgoZ2xvYmFsT2JqZWN0LCB2bSwgdGhpc09iaiwgbmV3TGVuZ3RoKTsKLSAgICByZXR1 cm4gSlNWYWx1ZTo6ZW5jb2RlKG5ld0xlbmd0aCk7CisgICAgc2V0TGVuZ3RoKGdsb2JhbE9iamVj dCwgdm0sIHRoaXNPYmosIG5ld0xlbmd0aCk7CisgICAgcmV0dXJuIEpTVmFsdWU6OmVuY29kZShq c051bWJlcihuZXdMZW5ndGgpKTsKIH0KIAogRW5jb2RlZEpTVmFsdWUgSlNDX0hPU1RfQ0FMTCBh cnJheVByb3RvRnVuY1JldmVyc2UoSlNHbG9iYWxPYmplY3QqIGdsb2JhbE9iamVjdCwgQ2FsbEZy YW1lKiBjYWxsRnJhbWUpCkBAIC0xMDU3LDcgKzEwNDIsNyBAQCBFbmNvZGVkSlNWYWx1ZSBKU0Nf SE9TVF9DQUxMIGFycmF5UHJvdG9GdW5jU2hpZnQoSlNHbG9iYWxPYmplY3QqIGdsb2JhbE9iamVj dCwgQwogCiAgICAgaWYgKGxlbmd0aCA9PSAwKSB7CiAgICAgICAgIHNjb3BlLnJlbGVhc2UoKTsK LSAgICAgICAgcHV0TGVuZ3RoKGdsb2JhbE9iamVjdCwgdm0sIHRoaXNPYmosIGpzTnVtYmVyKGxl bmd0aCkpOworICAgICAgICBzZXRMZW5ndGgoZ2xvYmFsT2JqZWN0LCB2bSwgdGhpc09iaiwgbGVu Z3RoKTsKICAgICAgICAgcmV0dXJuIEpTVmFsdWU6OmVuY29kZShqc1VuZGVmaW5lZCgpKTsKICAg ICB9CiAKQEAgLTEwNjYsNyArMTA1MSw3IEBAIEVuY29kZWRKU1ZhbHVlIEpTQ19IT1NUX0NBTEwg YXJyYXlQcm90b0Z1bmNTaGlmdChKU0dsb2JhbE9iamVjdCogZ2xvYmFsT2JqZWN0LCBDCiAgICAg c2hpZnQ8SlNBcnJheTo6U2hpZnRDb3VudEZvclNoaWZ0PihnbG9iYWxPYmplY3QsIHRoaXNPYmos IDAsIDEsIDAsIGxlbmd0aCk7CiAgICAgUkVUVVJOX0lGX0VYQ0VQVElPTihzY29wZSwgZW5jb2Rl ZEpTVmFsdWUoKSk7CiAgICAgc2NvcGUucmVsZWFzZSgpOwotICAgIHB1dExlbmd0aChnbG9iYWxP YmplY3QsIHZtLCB0aGlzT2JqLCBqc051bWJlcihsZW5ndGggLSAxKSk7CisgICAgc2V0TGVuZ3Ro KGdsb2JhbE9iamVjdCwgdm0sIHRoaXNPYmosIGxlbmd0aCAtIDEpOwogICAgIHJldHVybiBKU1Zh bHVlOjplbmNvZGUocmVzdWx0KTsKIH0KIApAQCAtMTI2MywxMCArMTI0OCwxMCBAQCBFbmNvZGVk SlNWYWx1ZSBKU0NfSE9TVF9DQUxMIGFycmF5UHJvdG9GdW5jVW5TaGlmdChKU0dsb2JhbE9iamVj dCogZ2xvYmFsT2JqZWN0LAogICAgICAgICB0aGlzT2JqLT5wdXRCeUluZGV4SW5saW5lKGdsb2Jh bE9iamVjdCwgaywgY2FsbEZyYW1lLT51bmNoZWNrZWRBcmd1bWVudChrKSwgdHJ1ZSk7CiAgICAg ICAgIFJFVFVSTl9JRl9FWENFUFRJT04oc2NvcGUsIGVuY29kZWRKU1ZhbHVlKCkpOwogICAgIH0K LSAgICBKU1ZhbHVlIHJlc3VsdCA9IGpzTnVtYmVyKGxlbmd0aCArIG5yQXJncyk7CisgICAgdWlu dDY0X3QgbmV3TGVuZ3RoID0gbGVuZ3RoICsgbnJBcmdzOwogICAgIHNjb3BlLnJlbGVhc2UoKTsK LSAgICBwdXRMZW5ndGgoZ2xvYmFsT2JqZWN0LCB2bSwgdGhpc09iaiwgcmVzdWx0KTsKLSAgICBy ZXR1cm4gSlNWYWx1ZTo6ZW5jb2RlKHJlc3VsdCk7CisgICAgc2V0TGVuZ3RoKGdsb2JhbE9iamVj dCwgdm0sIHRoaXNPYmosIG5ld0xlbmd0aCk7CisgICAgcmV0dXJuIEpTVmFsdWU6OmVuY29kZShq c051bWJlcihuZXdMZW5ndGgpKTsKIH0KIAogZW51bSBjbGFzcyBJbmRleE9mRGlyZWN0aW9uIHsg Rm9yd2FyZCwgQmFja3dhcmQgfTsKZGlmZiAtLWdpdCBhL0pTVGVzdHMvQ2hhbmdlTG9nIGIvSlNU ZXN0cy9DaGFuZ2VMb2cKaW5kZXggOGE0ZjliZTIxYzVhYWI2ZDFhYWJkMDA1ZDgyZmY3MzQwYTJj YTBhZS4uODJlZDdiYmNkZmYxZjRiMDFjZTAzOGE3ZjFkZTYwZTdiNjRjYzA0YSAxMDA2NDQKLS0t IGEvSlNUZXN0cy9DaGFuZ2VMb2cKKysrIGIvSlNUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwx MyBAQAorMjAyMC0wOC0yNiAgQWxleGV5IFNodmF5a2EgIDxzaHZhaWthbGVzaEBnbWFpbC5jb20+ CisKKyAgICAgICAgTWVyZ2UgcHV0TGVuZ3RoKCkgaW50byBzZXRMZW5ndGgoKQorICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjExMjc5CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBtaWNyb2JlbmNobWFya3Mv YXJyYXktc2hpZnQtdW5zaGlmdC1lbXB0eS5qczogQWRkZWQuCisgICAgICAgICogc3RyZXNzL2Fy cmF5LXNldExlbmd0aC1vbi1wcm94eS1lcnJvci5qczogQWRkZWQuCisKIDIwMjAtMDgtMjUgIEFs ZXhleSBTaHZheWthICA8c2h2YWlrYWxlc2hAZ21haWwuY29tPgogCiAgICAgICAgIEludmFsaWQg ZWFybHkgZXJyb3IgZm9yIG9iamVjdCBsaXRlcmFsIG1ldGhvZCBuYW1lZCAiX19wcm90b19fIgpk aWZmIC0tZ2l0IGEvSlNUZXN0cy9taWNyb2JlbmNobWFya3MvYXJyYXktc2hpZnQtdW5zaGlmdC1l bXB0eS5qcyBiL0pTVGVzdHMvbWljcm9iZW5jaG1hcmtzL2FycmF5LXNoaWZ0LXVuc2hpZnQtZW1w dHkuanMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uYzJkOWU0YWIyZWYzMWUxYmMyMmYyZDI2YzRkM2Y1ZGRjNjZmODky MAotLS0gL2Rldi9udWxsCisrKyBiL0pTVGVzdHMvbWljcm9iZW5jaG1hcmtzL2FycmF5LXNoaWZ0 LXVuc2hpZnQtZW1wdHkuanMKQEAgLTAsMCArMSw4IEBACitub0lubGluZShBcnJheS5wcm90b3R5 cGUuc2hpZnQpOworbm9JbmxpbmUoQXJyYXkucHJvdG90eXBlLnVuc2hpZnQpOworCitmb3IgKHZh ciBpID0gMDsgaSA8IDFlNjsgKytpKSB7CisgICAgdmFyIGFyciA9IFtdOworICAgIGFyci5zaGlm dCgpOworICAgIGFyci51bnNoaWZ0KCk7Cit9CmRpZmYgLS1naXQgYS9KU1Rlc3RzL3N0cmVzcy9h cnJheS1zZXRMZW5ndGgtb24tcHJveHktZXJyb3IuanMgYi9KU1Rlc3RzL3N0cmVzcy9hcnJheS1z ZXRMZW5ndGgtb24tcHJveHktZXJyb3IuanMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMGMxMzdhNDM2Yzg2M2MzMWFh MGE2ZTkyYWY0NDYwODdhZGU5MzMyNgotLS0gL2Rldi9udWxsCisrKyBiL0pTVGVzdHMvc3RyZXNz L2FycmF5LXNldExlbmd0aC1vbi1wcm94eS1lcnJvci5qcwpAQCAtMCwwICsxLDQ3IEBACitmdW5j dGlvbiBzaG91bGRUaHJvdyhmdW5jLCBlcnJvck1lc3NhZ2UpIHsKKyAgICB2YXIgZXJyb3JUaHJv d24gPSBmYWxzZTsKKyAgICB0cnkgeworICAgICAgICBmdW5jKCk7CisgICAgfSBjYXRjaCAoZXJy b3IpIHsKKyAgICAgICAgZXJyb3JUaHJvd24gPSB0cnVlOworICAgICAgICBpZiAoU3RyaW5nKGVy cm9yKSAhPT0gZXJyb3JNZXNzYWdlKQorICAgICAgICAgICAgdGhyb3cgbmV3IEVycm9yKGBiYWQg ZXJyb3I6ICR7ZXJyb3J9YCk7CisgICAgfQorICAgIGlmICghZXJyb3JUaHJvd24pCisgICAgICAg IHRocm93IG5ldyBFcnJvcignbm90IHRocm93bicpOworfQorCit2YXIgcHJveHkxID0gbmV3IFBy b3h5KHt9LCB7CisgICAgc2V0OiAoXywga2V5KSA9PiBrZXkgIT09ICJsZW5ndGgiLAorfSk7CisK K3Nob3VsZFRocm93KCgpID0+IHsKKyAgICBBcnJheS5wcm90b3R5cGUudW5zaGlmdC5jYWxsKHBy b3h5MSk7Cit9LCAiVHlwZUVycm9yOiBQcm94eSBvYmplY3QncyAnc2V0JyB0cmFwIHJldHVybmVk IGZhbHN5IHZhbHVlIGZvciBwcm9wZXJ0eSAnbGVuZ3RoJyIpOworCit2YXIgb2JqMiA9IE9iamVj dC5kZWZpbmVQcm9wZXJ0eSh7fSwgImxlbmd0aCIsIHsKKyAgICB2YWx1ZTogMjIsCisgICAgd3Jp dGFibGU6IGZhbHNlLAorICAgIGNvbmZpZ3VyYWJsZTogZmFsc2UsCit9KTsKKwordmFyIHByb3h5 MiA9IG5ldyBQcm94eShvYmoyLCB7CisgICAgc2V0OiAoKSA9PiB0cnVlLAorfSk7CisKK3Nob3Vs ZFRocm93KCgpID0+IHsKKyAgICBBcnJheS5wcm90b3R5cGUuc2hpZnQuY2FsbChwcm94eTIpOwor fSwgIlR5cGVFcnJvcjogUHJveHkgaGFuZGxlcidzICdzZXQnIG9uIGEgbm9uLWNvbmZpZ3VyYWJs ZSBhbmQgbm9uLXdyaXRhYmxlIHByb3BlcnR5IG9uICd0YXJnZXQnIHNob3VsZCBlaXRoZXIgcmV0 dXJuIGZhbHNlIG9yIGJlIHRoZSBzYW1lIHZhbHVlIGFscmVhZHkgb24gdGhlICd0YXJnZXQnIik7 CisKK3ZhciBvYmozID0gT2JqZWN0LmRlZmluZVByb3BlcnR5KHt9LCAibGVuZ3RoIiwgeworICAg IGdldDogKCkgPT4gMzMsCisgICAgY29uZmlndXJhYmxlOiBmYWxzZSwKK30pOworCit2YXIgcHJv eHkzID0gbmV3IFByb3h5KG9iajMsIHsKKyAgICBzZXQ6ICgpID0+IHRydWUsCit9KTsKKworc2hv dWxkVGhyb3coKCkgPT4geworICAgIEFycmF5LnByb3RvdHlwZS5wb3AuY2FsbChwcm94eTMpOwor fSwgIlR5cGVFcnJvcjogUHJveHkgaGFuZGxlcidzICdzZXQnIG1ldGhvZCBvbiBhIG5vbi1jb25m aWd1cmFibGUgYWNjZXNzb3IgcHJvcGVydHkgd2l0aG91dCBhIHNldHRlciBzaG91bGQgcmV0dXJu IGZhbHNlIik7Cg==