168363 2017-02-15 03:35:12 -0800 [GLib] GCActivityCallback::scheduleTimer() keeps pushing dispatch into the future 2017-02-17 01:15:50 -0800 1 1 1 Unclassified WebKit JavaScriptCore WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED P2 Normal --- 1 zan zan annulen bugs-noreply cgarcia commit-queue keith_miller mark.lam mcatanzaro msaboff saam oldest_to_newest 1277148 0 zan 2017-02-15 03:35:12 -0800 GCActivityCallback::scheduleTimer() accepts a delay argument and, in case it's at most half the amount of the current delay, uses this new value to reschedule the internal timer. https://trac.webkit.org/browser/trunk/Source/JavaScriptCore/heap/GCActivityCallback.cpp#L119 Say the GCActivityCallback is scheduled for the first time in 8 seconds. The timer is then set to dispatch 8 seconds from the current time (marked as CT#0). After the JS heap continues to grow, additional scheduleTimer() calls are done, each time decreasing the delay proportional to the amount of memory that's been allocated so far. This is calculated in GCActivityCallback::didAllocate(). https://trac.webkit.org/browser/trunk/Source/JavaScriptCore/heap/GCActivityCallback.cpp#L150 It's possible that the allocations progress in such way that, for example, after CT#0 + 7 seconds the computed delay drops to 4 seconds. At that point the call to scheduleTimer() reschedules the timer, but using the current time as the base, CT#1, which equals to CT#0 + 7, and uses 4 seconds as the delay amount, which means the next dispatch will be at CT#1 + 4 = CT#0 + 11 seconds, three seconds after the time when the first scheduled delay was supposed to dispatch. This isn't how the USE(CF) implementation works. When the delay is set there for the first time, it's set as the latest time when the callback should be fired. Repeating the previous scenario, if the timer is first scheduled to be dispatched after 8 seconds from the current time (CT#0 + 8), and after 7 seconds the delay is dropped to 4 seconds, the new dispatch time will be CT#0 + 4, which is 3 seconds in the past, meaning the timer will dispatch ASAP. The current GLib implementation should probably match that. Note that the current delay computation doesn't mean that GC doesn't get triggered at all, as far as I've tested it just means that the dispatch gets delayed long enough for the delay values to become really small and close enough to the present that the timer gets dispatched in the near-future main loop iteration. The delays here are used to showcase the problem. The initial delays are usually quite large, but then become smaller as the allocations grow. The USE(CF) implementation still sets m_nextFireTime to currentTime() + delay, just like we do, but note that there appears to be no use of the m_nextFireTime member variable or the GCActivityCallback::nextFireTime() getter. 1277149 1 zan 2017-02-15 03:39:12 -0800 Handling this similarly to USE(CF) is a bit hard because we also support disabling the timer completely (via a -1 delay), instead of just scheduling it a decade into the future. This is a bit of a problem because we then treat an infinite delay as a valid one, which results in setting the GSource's ready time to G_MAXINT64. We should probably just simplify this by doing the decade thing. 1277592 2 301736 zan 2017-02-16 03:45:37 -0800 Created attachment 301736 Patch 1277600 3 301736 cgarcia 2017-02-16 04:08:32 -0800 Comment on attachment 301736 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=301736&action=review Thanks! > Source/JavaScriptCore/heap/HeapTimer.cpp:190 > + g_source_set_ready_time(heapTimer.m_timer.get(), g_get_monotonic_time() + HeapTimer::s_decade * G_USEC_PER_SEC); Why don't we do this before calling the callback as we did before? There you have the source already as parameter 1278170 4 301736 zan 2017-02-17 01:13:23 -0800 Comment on attachment 301736 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=301736&action=review >> Source/JavaScriptCore/heap/HeapTimer.cpp:190 >> + g_source_set_ready_time(heapTimer.m_timer.get(), g_get_monotonic_time() + HeapTimer::s_decade * G_USEC_PER_SEC); > > Why don't we do this before calling the callback as we did before? There you have the source already as parameter Because HeapTimer::s_decade isn't accessible from there. heapTimerSourceFunctions could be moved into the HeapTimer class, but that would require bringing in all the GLib headers in HeapTimer.h. So there's different trade-offs. 1278171 5 301736 zan 2017-02-17 01:15:40 -0800 Comment on attachment 301736 Patch Clearing flags on attachment: 301736 Committed r212541: <http://trac.webkit.org/changeset/212541> 1278172 6 zan 2017-02-17 01:15:50 -0800 All reviewed patches have been landed. Closing bug. 301736 2017-02-16 03:45:37 -0800 2017-02-17 01:15:40 -0800 Patch bug-168363-20170216124258.patch text/plain 8025 zan U3VidmVyc2lvbiBSZXZpc2lvbjogMjEyNDIxCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCBk ZjJlMDA2M2U3ZDU3OWFmMmNlNTEzZDQ2MjZmN2Q4ZThjZTNmYmRiLi5hMzkzZjEzYzJmNDk0MTU5 NDI0YjRjNjU4YTVlMDhhZTBlMTEyZmZkIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSw0NSBAQAorMjAxNy0wMi0xNiAgWmFuIERvYmVyc2VrICA8emRvYmVyc2VrQGlnYWxpYS5j b20+CisKKyAgICAgICAgW0dMaWJdIEdDQWN0aXZpdHlDYWxsYmFjazo6c2NoZWR1bGVUaW1lcigp IGtlZXBzIHB1c2hpbmcgZGlzcGF0Y2ggaW50byB0aGUgZnV0dXJlCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNjgzNjMKKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBNaW1pYyB0aGUgVVNFKENGKSBpbXBsZW1l bnRhdGlvbiBvZiBHQ0FjdGl2aXR5Q2FsbGJhY2sgYW5kIEhlYXBUaW1lciBieQorICAgICAgICBz Y2hlZHVsaW5nIHRoZSB0aW1lciBhIGRlY2FkZSBpbnRvIHRoZSBmdXR1cmUgaW5zdGVhZCBvZiBj b21wbGV0ZWx5CisgICAgICAgIGNhbmNlbGxpbmcgaXQuIFRoYXQgd2F5IG5ldyBkaXNwYXRjaCB0 aW1lcyBmb3IgR0NBY3Rpdml0eUNhbGxiYWNrIGNhbiBiZQorICAgICAgICBjb21wdXRlZCBieSBz aW1wbHkgZGVkdWN0aW5nIHRoZSBkaWZmZXJlbmNlIGluIHRoZSBuZXcgYW5kIHByZXZpb3VzCisg ICAgICAgIGRlbGF5IGZyb20gdGhlIEdTb3VyY2UncyBjdXJyZW50IGRpc3BhdGNoIHRpbWUuIFBy ZXZpb3VzbHkgd2UgaGFuZGxlZCBhbgorICAgICAgICBleHRyYSAncGF1c2VkJyBzdGF0ZSAod2hl cmUgbV9kZWxheSB3YXMgLTEpIGFuZCBhbGxvd2VkIGZvciBhIGRlbGF5IG9mCisgICAgICAgIGFu IGluZmluaXRlIHZhbHVlIHRvIGJlIHZhbGlkLCBjb21wbGljYXRpbmcgdGhlIG5leHQgZGlzcGF0 Y2ggdGltZQorICAgICAgICBjb21wdXRhdGlvbi4KKworICAgICAgICBIZWFwVGltZXIgZ2FpbnMg dGhlIHN0YXRpYyBzX2RlY2FkZSB2YXJpYWJsZS4gVGhlIGRpc3BhdGNoIGZ1bmN0aW9uIGluCisg ICAgICAgIGhlYXBUaW1lclNvdXJjZUZ1bmN0aW9ucyBvbmx5IGRpc3BhdGNoZXMgdGhlIGNhbGxi YWNrLCB3aGljaCBub3cgZGVsYXlzCisgICAgICAgIHRoZSBHU291cmNlIGJ5IGEgZGVjYWRlLiBI ZWFwVGltZXI6OnNjaGVkdWxlVGltZXIoKSBzaW1wbHkgc2NoZWR1bGVzIHRoZQorICAgICAgICBz b3VyY2UgdG8gZGlzcGF0Y2ggaW4gdGhlIHNwZWNpZmllZCBhbW91bnQgb2YgdGltZSwgYW5kIGNh bmNlbFRpbWVyKCkKKyAgICAgICAgJ2NhbmNlbHMnIHRoZSBzb3VyY2UgYnkgc2V0dGluZyB0aGUg ZGlzcGF0Y2ggdGltZSB0byBhIGRlY2FkZS4KKworICAgICAgICBHQ0FjdGl2aXR5Q2FsbGJhY2sg Y29uc3RydWN0b3IgaW5pdGlhbGl6ZXMgdGhlIGRlbGF5IHRvIHRoZSBzX2RlY2FkZQorICAgICAg ICB2YWx1ZSBhbmQgaW1tZWRpYXRlbHkgc2V0cyB0aGUgcmVhZHkgdGltZSBmb3IgR1NvdXJjZSBh IGRlY2FkZSBpbnRvIHRoZQorICAgICAgICBmdXR1cmUsIGF2b2lkaW5nIHRoZSBkZWZhdWx0IC0x IHZhbHVlIGFzIHRoZSByZWFkeSB0aW1lIHRoYXQgd291bGQgY2F1c2UKKyAgICAgICAgcHJvYmxl bXMgaW4gc2NoZWR1bGVUaW1lcigpLiBzY2hlZHVsZVRpbWVyKCkgZG9lc24ndCBzcGVjaWFsLWNh c2UgdGhlCisgICAgICAgIHplcm8tZGVsYXkgdmFsdWUgYW55bW9yZSwgaW5zdGVhZCBpdCBqdXN0 IGNvbXB1dGVzIHRoZSBkaWZmZXJlbmNlCisgICAgICAgIGJldHdlZW4gdGhlIG9sZCBhbmQgdGhl IG5ldyBkZWxheSBhbmQgcm9sbHMgYmFjayB0aGUgR1NvdXJjZSdzIHJlYWR5CisgICAgICAgIHRp bWUgZm9yIHRoYXQgYW1vdW50LiBjYW5jZWxUaW1lcigpIHNldHMgbV9kZWxheSB0byB0aGUgZGVj YWRlIHZhbHVlIGFuZAorICAgICAgICBkZWxheXMgdGhlIEdTb3VyY2UgZm9yIHRoYXQgc2FtZSBh bW91bnQuCisKKyAgICAgICAgKiBoZWFwL0dDQWN0aXZpdHlDYWxsYmFjay5jcHA6CisgICAgICAg IChKU0M6OkdDQWN0aXZpdHlDYWxsYmFjazo6R0NBY3Rpdml0eUNhbGxiYWNrKToKKyAgICAgICAg KEpTQzo6R0NBY3Rpdml0eUNhbGxiYWNrOjpzY2hlZHVsZVRpbWVyKToKKyAgICAgICAgKEpTQzo6 R0NBY3Rpdml0eUNhbGxiYWNrOjpjYW5jZWxUaW1lcik6CisgICAgICAgICogaGVhcC9HQ0FjdGl2 aXR5Q2FsbGJhY2suaDoKKyAgICAgICAgKiBoZWFwL0hlYXBUaW1lci5jcHA6CisgICAgICAgIChK U0M6OkhlYXBUaW1lcjo6SGVhcFRpbWVyKToKKyAgICAgICAgKEpTQzo6SGVhcFRpbWVyOjpzY2hl ZHVsZVRpbWVyKToKKyAgICAgICAgKEpTQzo6SGVhcFRpbWVyOjpjYW5jZWxUaW1lcik6CisgICAg ICAgICogaGVhcC9IZWFwVGltZXIuaDoKKwogMjAxNy0wMi0xNSAgR3VpbGxhdW1lIEVtb250ICA8 Z3VpamVtb250QGlnYWxpYS5jb20+CiAKICAgICAgICAgTUlQUzogYWRkIG1pc3NpbmcgaW1wbGVt ZW50YXRpb25zIG9mIGxvYWQ4U2lnbmVkRXh0ZW5kVG8zMigpCmRpZmYgLS1naXQgYS9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvaGVhcC9HQ0FjdGl2aXR5Q2FsbGJhY2suY3BwIGIvU291cmNlL0phdmFT Y3JpcHRDb3JlL2hlYXAvR0NBY3Rpdml0eUNhbGxiYWNrLmNwcAppbmRleCA1OTNiMjBiMWE3YzQ4 ZDc4NjMwZGNkZTA1YmMwNTQwNTAzMTM3MzE5Li40MGRjNThlMGRlMDAwMThhNzQ2NGQzNDExNzRm OTMyN2Q4ODcxYjY4IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvaGVhcC9HQ0Fj dGl2aXR5Q2FsbGJhY2suY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9oZWFwL0dDQWN0 aXZpdHlDYWxsYmFjay5jcHAKQEAgLTYyLDYgKzYyLDcgQEAgR0NBY3Rpdml0eUNhbGxiYWNrOjpH Q0FjdGl2aXR5Q2FsbGJhY2soSGVhcCogaGVhcCkKIEdDQWN0aXZpdHlDYWxsYmFjazo6R0NBY3Rp dml0eUNhbGxiYWNrKEhlYXAqIGhlYXApCiAgICAgOiBHQ0FjdGl2aXR5Q2FsbGJhY2soaGVhcC0+ dm0oKSkKIHsKKyAgICBnX3NvdXJjZV9zZXRfcmVhZHlfdGltZShtX3RpbWVyLmdldCgpLCBnX2dl dF9tb25vdG9uaWNfdGltZSgpICsgc19kZWNhZGUgKiBHX1VTRUNfUEVSX1NFQyk7CiB9CiAjZW5k aWYKIApAQCAtMTE5LDMxICsxMjAsMjIgQEAgdm9pZCBHQ0FjdGl2aXR5Q2FsbGJhY2s6OmNhbmNl bFRpbWVyKCkKIHZvaWQgR0NBY3Rpdml0eUNhbGxiYWNrOjpzY2hlZHVsZVRpbWVyKGRvdWJsZSBu ZXdEZWxheSkKIHsKICAgICBBU1NFUlQobmV3RGVsYXkgPj0gMCk7Ci0gICAgaWYgKG1fZGVsYXkg IT0gLTEgJiYgbmV3RGVsYXkgKiB0aW1lclNsb3AgPiBtX2RlbGF5KQorICAgIGlmIChuZXdEZWxh eSAqIHRpbWVyU2xvcCA+IG1fZGVsYXkpCiAgICAgICAgIHJldHVybjsKIAorICAgIGRvdWJsZSBk ZWx0YSA9IG1fZGVsYXkgLSBuZXdEZWxheTsKICAgICBtX2RlbGF5ID0gbmV3RGVsYXk7CiAgICAg bV9uZXh0RmlyZVRpbWUgPSBXVEY6OmN1cnJlbnRUaW1lKCkgKyBuZXdEZWxheTsKLSAgICBpZiAo IW1fZGVsYXkpIHsKLSAgICAgICAgZ19zb3VyY2Vfc2V0X3JlYWR5X3RpbWUobV90aW1lci5nZXQo KSwgMCk7Ci0gICAgICAgIHJldHVybjsKLSAgICB9CiAKLSAgICBhdXRvIGRlbGF5RHVyYXRpb24g PSBzdGQ6OmNocm9ubzo6ZHVyYXRpb248ZG91YmxlPihtX2RlbGF5KTsKLSAgICBhdXRvIHNhZmVE ZWxheUR1cmF0aW9uID0gc3RkOjpjaHJvbm86Om1pY3Jvc2Vjb25kczo6bWF4KCk7Ci0gICAgaWYg KGRlbGF5RHVyYXRpb24gPCBzYWZlRGVsYXlEdXJhdGlvbikKLSAgICAgICAgc2FmZURlbGF5RHVy YXRpb24gPSBzdGQ6OmNocm9ubzo6ZHVyYXRpb25fY2FzdDxzdGQ6OmNocm9ubzo6bWljcm9zZWNv bmRzPihkZWxheUR1cmF0aW9uKTsKLSAgICBnaW50NjQgY3VycmVudFRpbWUgPSBnX2dldF9tb25v dG9uaWNfdGltZSgpOwotICAgIGdpbnQ2NCB0YXJnZXRUaW1lID0gY3VycmVudFRpbWUgKyBzdGQ6 Om1pbjxnaW50NjQ+KEdfTUFYSU5UNjQgLSBjdXJyZW50VGltZSwgc2FmZURlbGF5RHVyYXRpb24u Y291bnQoKSk7Ci0gICAgQVNTRVJUKHRhcmdldFRpbWUgPj0gY3VycmVudFRpbWUpOwotICAgIGdf c291cmNlX3NldF9yZWFkeV90aW1lKG1fdGltZXIuZ2V0KCksIHRhcmdldFRpbWUpOworICAgIGdp bnQ2NCByZWFkeVRpbWUgPSBnX3NvdXJjZV9nZXRfcmVhZHlfdGltZShtX3RpbWVyLmdldCgpKTsK KyAgICBnX3NvdXJjZV9zZXRfcmVhZHlfdGltZShtX3RpbWVyLmdldCgpLCByZWFkeVRpbWUgLSBk ZWx0YSAqIEdfVVNFQ19QRVJfU0VDKTsKIH0KIAogdm9pZCBHQ0FjdGl2aXR5Q2FsbGJhY2s6OmNh bmNlbFRpbWVyKCkKIHsKLSAgICBtX2RlbGF5ID0gLTE7CisgICAgbV9kZWxheSA9IHNfZGVjYWRl OwogICAgIG1fbmV4dEZpcmVUaW1lID0gMDsKLSAgICBnX3NvdXJjZV9zZXRfcmVhZHlfdGltZSht X3RpbWVyLmdldCgpLCAtMSk7CisgICAgZ19zb3VyY2Vfc2V0X3JlYWR5X3RpbWUobV90aW1lci5n ZXQoKSwgZ19nZXRfbW9ub3RvbmljX3RpbWUoKSArIHNfZGVjYWRlICogR19VU0VDX1BFUl9TRUMp OwogfQogI2VuZGlmCiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9oZWFwL0dD QWN0aXZpdHlDYWxsYmFjay5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL2hlYXAvR0NBY3Rpdml0 eUNhbGxiYWNrLmgKaW5kZXggM2JhYTIxYjdlYTQ3MmVkN2VmMzdhZjVmNGEzOGVhYWNkZDQ0NjQ4 Ny4uYjUyNDJkZDJiYmQ2ZTFlNzRiMDdlZjlhOTQ2ZDUwYzliZmYyODkzZSAxMDA2NDQKLS0tIGEv U291cmNlL0phdmFTY3JpcHRDb3JlL2hlYXAvR0NBY3Rpdml0eUNhbGxiYWNrLmgKKysrIGIvU291 cmNlL0phdmFTY3JpcHRDb3JlL2hlYXAvR0NBY3Rpdml0eUNhbGxiYWNrLmgKQEAgLTg3LDcgKzg3 LDcgQEAgcHJvdGVjdGVkOgogICAgIEdDQWN0aXZpdHlDYWxsYmFjayhWTSogdm0pCiAgICAgICAg IDogSGVhcFRpbWVyKHZtKQogICAgICAgICAsIG1fZW5hYmxlZCh0cnVlKQotICAgICAgICAsIG1f ZGVsYXkoLTEpCisgICAgICAgICwgbV9kZWxheShzX2RlY2FkZSkKICAgICB7CiAgICAgfQogI2Vs c2UKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9oZWFwL0hlYXBUaW1lci5jcHAg Yi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvaGVhcC9IZWFwVGltZXIuY3BwCmluZGV4IDg3MDY5Yjdh NzZjYjNmNmRkYWRmM2QxNGNmZmYyNjU0MzA1MTY4YzMuLmYzODQzMzM1MzAxZmJmNWUyZjkxZDIx NTBjMDJiMWY3ZjU0YmQxODAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9oZWFw L0hlYXBUaW1lci5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL2hlYXAvSGVhcFRpbWVy LmNwcApAQCAtMTY0LDE1ICsxNjQsMTQgQEAgdm9pZCBIZWFwVGltZXI6OmNhbmNlbFRpbWVyKCkK IH0KICNlbGlmIFVTRShHTElCKQogCitjb25zdCBsb25nIEhlYXBUaW1lcjo6c19kZWNhZGUgPSA2 MCAqIDYwICogMjQgKiAzNjUgKiAxMDsKKwogc3RhdGljIEdTb3VyY2VGdW5jcyBoZWFwVGltZXJT b3VyY2VGdW5jdGlvbnMgPSB7CiAgICAgbnVsbHB0ciwgLy8gcHJlcGFyZQogICAgIG51bGxwdHIs IC8vIGNoZWNrCiAgICAgLy8gZGlzcGF0Y2gKLSAgICBbXShHU291cmNlKiBzb3VyY2UsIEdTb3Vy Y2VGdW5jIGNhbGxiYWNrLCBncG9pbnRlciB1c2VyRGF0YSkgLT4gZ2Jvb2xlYW4KKyAgICBbXShH U291cmNlKiwgR1NvdXJjZUZ1bmMgY2FsbGJhY2ssIGdwb2ludGVyIHVzZXJEYXRhKSAtPiBnYm9v bGVhbgogICAgIHsKLSAgICAgICAgaWYgKGdfc291cmNlX2dldF9yZWFkeV90aW1lKHNvdXJjZSkg PT0gLTEpCi0gICAgICAgICAgICByZXR1cm4gR19TT1VSQ0VfQ09OVElOVUU7Ci0gICAgICAgIGdf c291cmNlX3NldF9yZWFkeV90aW1lKHNvdXJjZSwgLTEpOwogICAgICAgICByZXR1cm4gY2FsbGJh Y2sodXNlckRhdGEpOwogICAgIH0sCiAgICAgbnVsbHB0ciwgLy8gZmluYWxpemUKQEAgLTE4Nyw3 ICsxODYsOSBAQCBIZWFwVGltZXI6OkhlYXBUaW1lcihWTSogdm0pCiB7CiAgICAgZ19zb3VyY2Vf c2V0X25hbWUobV90aW1lci5nZXQoKSwgIltKYXZhU2NyaXB0Q29yZV0gSGVhcFRpbWVyIik7CiAg ICAgZ19zb3VyY2Vfc2V0X2NhbGxiYWNrKG1fdGltZXIuZ2V0KCksIFtdKGdwb2ludGVyIHVzZXJE YXRhKSAtPiBnYm9vbGVhbiB7Ci0gICAgICAgIHN0YXRpY19jYXN0PEhlYXBUaW1lcio+KHVzZXJE YXRhKS0+dGltZXJEaWRGaXJlKCk7CisgICAgICAgIGF1dG8mIGhlYXBUaW1lciA9ICpzdGF0aWNf Y2FzdDxIZWFwVGltZXIqPih1c2VyRGF0YSk7CisgICAgICAgIGdfc291cmNlX3NldF9yZWFkeV90 aW1lKGhlYXBUaW1lci5tX3RpbWVyLmdldCgpLCBnX2dldF9tb25vdG9uaWNfdGltZSgpICsgSGVh cFRpbWVyOjpzX2RlY2FkZSAqIEdfVVNFQ19QRVJfU0VDKTsKKyAgICAgICAgaGVhcFRpbWVyLnRp bWVyRGlkRmlyZSgpOwogICAgICAgICByZXR1cm4gR19TT1VSQ0VfQ09OVElOVUU7CiAgICAgfSwg dGhpcywgbnVsbHB0cik7CiAgICAgZ19zb3VyY2VfYXR0YWNoKG1fdGltZXIuZ2V0KCksIGdfbWFp bl9jb250ZXh0X2dldF90aHJlYWRfZGVmYXVsdCgpKTsKQEAgLTIxOCwxNyArMjE5LDEzIEBAIHZv aWQgSGVhcFRpbWVyOjp0aW1lckRpZEZpcmUoKQogCiB2b2lkIEhlYXBUaW1lcjo6c2NoZWR1bGVU aW1lcihkb3VibGUgaW50ZXJ2YWxJblNlY29uZHMpCiB7Ci0gICAgYXV0byBkZWxheUR1cmF0aW9u ID0gc3RkOjpjaHJvbm86OmR1cmF0aW9uX2Nhc3Q8c3RkOjpjaHJvbm86Om1pY3Jvc2Vjb25kcz4o c3RkOjpjaHJvbm86OmR1cmF0aW9uPGRvdWJsZT4oaW50ZXJ2YWxJblNlY29uZHMpKTsKLSAgICBn aW50NjQgY3VycmVudFRpbWUgPSBnX2dldF9tb25vdG9uaWNfdGltZSgpOwotICAgIGdpbnQ2NCB0 YXJnZXRUaW1lID0gY3VycmVudFRpbWUgKyBzdGQ6Om1pbjxnaW50NjQ+KEdfTUFYSU5UNjQgLSBj dXJyZW50VGltZSwgZGVsYXlEdXJhdGlvbi5jb3VudCgpKTsKLSAgICBBU1NFUlQodGFyZ2V0VGlt ZSA+PSBjdXJyZW50VGltZSk7Ci0gICAgZ19zb3VyY2Vfc2V0X3JlYWR5X3RpbWUobV90aW1lci5n ZXQoKSwgdGFyZ2V0VGltZSk7CisgICAgZ19zb3VyY2Vfc2V0X3JlYWR5X3RpbWUobV90aW1lci5n ZXQoKSwgZ19nZXRfbW9ub3RvbmljX3RpbWUoKSArIGludGVydmFsSW5TZWNvbmRzICogR19VU0VD X1BFUl9TRUMpOwogICAgIG1faXNTY2hlZHVsZWQgPSB0cnVlOwogfQogCiB2b2lkIEhlYXBUaW1l cjo6Y2FuY2VsVGltZXIoKQogewotICAgIGdfc291cmNlX3NldF9yZWFkeV90aW1lKG1fdGltZXIu Z2V0KCksIC0xKTsKKyAgICBnX3NvdXJjZV9zZXRfcmVhZHlfdGltZShtX3RpbWVyLmdldCgpLCBn X2dldF9tb25vdG9uaWNfdGltZSgpICsgc19kZWNhZGUgKiBHX1VTRUNfUEVSX1NFQyk7CiAgICAg bV9pc1NjaGVkdWxlZCA9IGZhbHNlOwogfQogI2Vsc2UKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS9oZWFwL0hlYXBUaW1lci5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL2hlYXAv SGVhcFRpbWVyLmgKaW5kZXggYjQ3MGYzYTRkYTZjM2ZjNTk4YmE1ZWZiNDNkOGE2YTJjZTMzODVj Mi4uMjNlNmY2NDE4ZjYxZjQ0NWJiODE0MjRkZWJlY2EzYjk5NWEwNDEzMiAxMDA2NDQKLS0tIGEv U291cmNlL0phdmFTY3JpcHRDb3JlL2hlYXAvSGVhcFRpbWVyLmgKKysrIGIvU291cmNlL0phdmFT Y3JpcHRDb3JlL2hlYXAvSGVhcFRpbWVyLmgKQEAgLTgyLDYgKzgyLDcgQEAgcHJvdGVjdGVkOgog ICAgIHZvaWQgc3RvcCgpOwogICAgIEVjb3JlX1RpbWVyKiBtX3RpbWVyOwogI2VsaWYgVVNFKEdM SUIpCisgICAgc3RhdGljIGNvbnN0IGxvbmcgc19kZWNhZGU7CiAgICAgdm9pZCB0aW1lckRpZEZp cmUoKTsKICAgICBHUmVmUHRyPEdTb3VyY2U+IG1fdGltZXI7CiAjZW5kaWYK