Received: from malur.postgresql.org ([217.196.149.56]) by arkaria.postgresql.org with esmtps (TLS1.3:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.92) (envelope-from ) id 1m1Xcd-0000jk-Ao for pgsql-hackers@arkaria.postgresql.org; Thu, 08 Jul 2021 17:15:35 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.92) (envelope-from ) id 1m1Xcc-0000xO-0u for pgsql-hackers@arkaria.postgresql.org; Thu, 08 Jul 2021 17:15:34 +0000 Received: from makus.postgresql.org ([2001:4800:3e1:1::229]) by malur.postgresql.org with esmtps (TLS1.3:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.92) (envelope-from ) id 1m1Xcb-0000xG-H8 for pgsql-hackers@lists.postgresql.org; Thu, 08 Jul 2021 17:15:33 +0000 Received: from sfr-1.cri.mines-paristech.fr ([77.158.180.225] helo=smtp.cri.ensmp.fr) by makus.postgresql.org with esmtps (TLS1.3:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.92) (envelope-from ) id 1m1XcW-00083M-Va for pgsql-hackers@postgresql.org; Thu, 08 Jul 2021 17:15:32 +0000 Received: from pseudo (185.141.6.84.rev.sfr.net [84.6.141.185]) by smtp.cri.ensmp.fr (Postfix) with ESMTPSA id 90231C017B; Thu, 8 Jul 2021 19:17:26 +0200 (CEST) Date: Thu, 8 Jul 2021 19:15:24 +0200 (CEST) From: Fabien COELHO X-X-Sender: fabien@pseudo To: Thomas Munro cc: Michael Paquier , Andrew Dunstan , Alvaro Herrera , Gregory Smith , PostgreSQL-development , david.christensen@crunchydata.com Subject: Re: pgbench logging broken by time logic changes In-Reply-To: Message-ID: References: <202106231308.lxr26cahwxuc@alvherre.pgsql> User-Agent: Alpine 2.22 (DEB 394 2020-01-19) MIME-Version: 1.0 Content-Type: multipart/mixed; BOUNDARY="2056645051-542076898-1625764291=:233209" Content-ID: List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk This message is in MIME format. The first part should be readable text, while the remaining parts are likely unreadable without MIME-aware tools. --2056645051-542076898-1625764291=:233209 Content-Type: text/plain; CHARSET=US-ASCII; format=flowed Content-ID: Hello Thomas, > Thanks! This doesn't seem to address the complaint, though. Don't > you need to do something like this? (See also attached.) > > + initStats(&aggs, start - (start + epoch_shift) % 1000000); ISTM that this is: (start + epoch_shift) / 1000000 * 1000000 > That should reproduce what pgbench 13 does implicitly when it uses > time(NULL). I understand that you are shifting the aggregate internal start time to epoch, however ISTM that other points in the program are not shifted consistently with this, eg the while comparison in doLog? Also if start time is log shifted, then it should not be shifted again when printed (in logAgg). Attached version tries to be consistent. > Namely, it rewinds to the start of the current *wall clock* second, so > that all future aggregates also start at round number wall clock times, > at the cost of making the first aggregate miss out on a fraction of a > second. ISTM that it was already wall clock time, but not epoch wall clock. I'm okay with realigning aggregates on full seconds. > I wonder if some of the confusion on the other thread about the final > aggregate[1] was due to this difference. Dunno. The parallel execution with thread is a pain when handling details. > By rounding down, we get a "head start" (because the first aggregate is > short), so we usually manage to record the expected number of aggregates > before time runs out. Fine with me if everything is consistent. > It's a race though. Your non-rounding version was more likely > to lose the race and finish before the final expected aggregate was > logged, so you added code to force a final aggregate to be logged. ISTM that we always want to force because some modes can have low tps, and the aggregates should be "full". > Do I have this right? I'm not entirely sure how useful a partial final > aggregate is If you ask for 10 seconds run with 1 aggregate per second, you expect to see (at least, about) 10 lines, and I want to ensure that, otherwise people will ask questions, tools will have to look for special cases, missing rows, whatever, and it will be a pain there. We want to produce something simple, consistent, reliable, that tools can depend on. > (it's probably one you have to throw away, like the first one, no? > Isn't it better if we only have to throw away the first one?). This should be the user decision to drop it or not, not the tool producing it, IMO. > I'm not sure, but if we keep that change, a couple of very minor nits: > I found the "tx" parameter name a little confusing. Do you think it's > clearer if we change it to "final" (with inverted sense)? I agree that tx is not a very good name, but the inversion does not look right to me. The "normal" behavior is > For the final aggregate, shouldn't we call doLog() only if agg->cnt > 0? No, I think that we should want to have all aggregates, even with zeros, so that the user can expect a deterministic number of lines. > I think I'd be inclined to take that change back out though, making this > patch very small and net behaviour like pgbench 13, if you agree with my > explanation for why you had to add it and why it's not actually > necessary with the fixed rounding shown above. (And perhaps in v15 we > might consider other ideas like using hi-res times in the log and not > rounding, etc, a topic for later.) I think that I'm moslty okay. > I don't really see the value in the test that checks that $delay falls > in the range 1.5s - 2.5s and then ignores the result. If it hangs > forever, we'll find out about it, and otherwise no human or machine > will ever care about that test. I removed it from this version. Were > you really attached to it? YES, REALLY! It would just have caught quite a few of the regressions we are trying to address here. I want it there even if ignored because I'll look for it to avoid regressions in the future. If the test is actually removed, recreating it is a pain. If you really want to disactivate it, use if(0) but PLEASE let it there so that it can ne reactivated for tests very simply, not bad maintaining some test outside of the tree. Also, if farm logs show that it is okay on all animals, it can be switched on by removing the ignore trick. > I made some very minor language tweaks in comments (we don't usually > shorten "benchmark" to "bench" in English, "series" keeps the -s in > singular (blame the Romans), etc). Thanks! My English is kind of fuzzy in the details:-) > I think we should make it clear when we mean the *Unix* epoch (a > comment "switch to epoch" isn't meaningful on its own, to me at > least), so I changed that in a few places. Ok. Attached v16: - tries to be consistent wrt epoch & aggregates, aligning to Unix epoch as you suggested. - renames tx as accumulate, but does not invert it. - always shows aggregates so that the user can depend on the output, even if stats are zero, because ISTM that clever must be avoided. - put tests back, even if ignored, because I really want them available easily. When/if you get to commit this patch, eventually, do not forget that I'm pushing forward fixes contributed by others, including Kyotaro Horiguchi and Yugo Nagata. -- Fabien. --2056645051-542076898-1625764291=:233209 Content-Type: text/x-diff; NAME=pgbench-log-fix-16.patch Content-Transfer-Encoding: BASE64 Content-ID: Content-Description: Content-Disposition: attachment; FILENAME=pgbench-log-fix-16.patch ZGlmZiAtLWdpdCBhL3NyYy9iaW4vcGdiZW5jaC9wZ2JlbmNoLmMgYi9zcmMv YmluL3BnYmVuY2gvcGdiZW5jaC5jDQppbmRleCA0YWVjY2Q5M2FmLi41N2Mx OTNkNDQ1IDEwMDY0NA0KLS0tIGEvc3JjL2Jpbi9wZ2JlbmNoL3BnYmVuY2gu Yw0KKysrIGIvc3JjL2Jpbi9wZ2JlbmNoL3BnYmVuY2guYw0KQEAgLTM0Myw2 ICszNDMsMTIgQEAgdHlwZWRlZiBzdHJ1Y3QgU3RhdHNEYXRhDQogCVNpbXBs ZVN0YXRzIGxhZzsNCiB9IFN0YXRzRGF0YTsNCiANCisvKg0KKyAqIEZvciBk aXNwbGF5aW5nIFVuaXggZXBvY2ggdGltZXN0YW1wcywgYXMgc29tZSB0aW1l IGZ1bmN0aW9ucyBtYXkgaGF2ZQ0KKyAqIGFub3RoZXIgcmVmZXJlbmNlLg0K KyAqLw0KK3BnX3RpbWVfdXNlY190IGVwb2NoX3NoaWZ0Ow0KKw0KIC8qDQog ICogU3RydWN0IHRvIGtlZXAgcmFuZG9tIHN0YXRlLg0KICAqLw0KQEAgLTY0 OSw3ICs2NTUsNyBAQCBzdGF0aWMgdm9pZCBzZXREb3VibGVWYWx1ZShQZ0Jl bmNoVmFsdWUgKnB2LCBkb3VibGUgZHZhbCk7DQogc3RhdGljIGJvb2wgZXZh bHVhdGVFeHByKENTdGF0ZSAqc3QsIFBnQmVuY2hFeHByICpleHByLA0KIAkJ CQkJCSBQZ0JlbmNoVmFsdWUgKnJldHZhbCk7DQogc3RhdGljIENvbm5lY3Rp b25TdGF0ZUVudW0gZXhlY3V0ZU1ldGFDb21tYW5kKENTdGF0ZSAqc3QsIHBn X3RpbWVfdXNlY190ICpub3cpOw0KLXN0YXRpYyB2b2lkIGRvTG9nKFRTdGF0 ZSAqdGhyZWFkLCBDU3RhdGUgKnN0LA0KK3N0YXRpYyB2b2lkIGRvTG9nKFRT dGF0ZSAqdGhyZWFkLCBDU3RhdGUgKnN0LCBib29sIGFjY3VtdWxhdGUsDQog CQkJCSAgU3RhdHNEYXRhICphZ2csIGJvb2wgc2tpcHBlZCwgZG91YmxlIGxh dGVuY3ksIGRvdWJsZSBsYWcpOw0KIHN0YXRpYyB2b2lkIHByb2Nlc3NYYWN0 U3RhdHMoVFN0YXRlICp0aHJlYWQsIENTdGF0ZSAqc3QsIHBnX3RpbWVfdXNl Y190ICpub3csDQogCQkJCQkJCSBib29sIHNraXBwZWQsIFN0YXRzRGF0YSAq YWdnKTsNCkBAIC0zNzY4LDIwICszNzc0LDUwIEBAIGV4ZWN1dGVNZXRhQ29t bWFuZChDU3RhdGUgKnN0LCBwZ190aW1lX3VzZWNfdCAqbm93KQ0KIAlyZXR1 cm4gQ1NUQVRFX0VORF9DT01NQU5EOw0KIH0NCiANCisvKiBwcmludCBhZ2dy ZWdhdGVkIHJlcG9ydCB0byBsb2dmaWxlICovDQorc3RhdGljIHZvaWQNCits b2dBZ2coRklMRSAqbG9nZmlsZSwgU3RhdHNEYXRhICphZ2cpDQorew0KKwlm cHJpbnRmKGxvZ2ZpbGUsIElOVDY0X0ZPUk1BVCAiICIgSU5UNjRfRk9STUFU ICIgJS4wZiAlLjBmICUuMGYgJS4wZiIsDQorCQkJYWdnLT5zdGFydF90aW1l IC8gMTAwMDAwMCwgLyogdGhpcyBpcyBlcG9jaCB0aW1lICovDQorCQkJYWdn LT5jbnQsDQorCQkJYWdnLT5sYXRlbmN5LnN1bSwNCisJCQlhZ2ctPmxhdGVu Y3kuc3VtMiwNCisJCQlhZ2ctPmxhdGVuY3kubWluLA0KKwkJCWFnZy0+bGF0 ZW5jeS5tYXgpOw0KKwlpZiAodGhyb3R0bGVfZGVsYXkpDQorCXsNCisJCWZw cmludGYobG9nZmlsZSwgIiAlLjBmICUuMGYgJS4wZiAlLjBmIiwNCisJCQkJ YWdnLT5sYWcuc3VtLA0KKwkJCQlhZ2ctPmxhZy5zdW0yLA0KKwkJCQlhZ2ct PmxhZy5taW4sDQorCQkJCWFnZy0+bGFnLm1heCk7DQorCQlpZiAobGF0ZW5j eV9saW1pdCkNCisJCQlmcHJpbnRmKGxvZ2ZpbGUsICIgIiBJTlQ2NF9GT1JN QVQsIGFnZy0+c2tpcHBlZCk7DQorCX0NCisJZnB1dGMoJ1xuJywgbG9nZmls ZSk7DQorfQ0KKw0KIC8qDQogICogUHJpbnQgbG9nIGVudHJ5IGFmdGVyIGNv bXBsZXRpbmcgb25lIHRyYW5zYWN0aW9uLg0KICAqDQotICogV2UgcHJpbnQg VW5peC1lcG9jaCB0aW1lc3RhbXBzIGluIHRoZSBsb2csIHNvIHRoYXQgZW50 cmllcyBjYW4gYmUNCisgKiBUaGUgZnVuY3Rpb24gYmVoYXZpb3IgY2hhbmdl cyBkZXBlbmRpbmcgb24gc2FtcGxlX3JhdGUgKGEgZnJhY3Rpb24gb2YNCisg KiB0cmFuc2FjdGlvbiBpcyByZXBvcnRlZCkgYW5kIGFnZ19pbnRlcnZhbCAo dHJhbnNhY3Rpb25zIGFyZSBhZ2dyZWdhdGVkDQorICogYW5kIHJlcG9ydGVk IG9uY2UgZXZlcnkgYWdnX2ludGVydmFsIHNlY29uZHMpLiAgRm9yIGFnZ3Jl Z2F0aW9uLA0KKyAqICJhY2N1bXVsYXRlIiBpbmRpY2F0ZXMgdGhhdCB3ZSBh cmUgcmVjb3JkaW5nIGEgdHJhbnNhY3Rpb24sIG90aGVyd2lzZSBpdA0KKyAq IGlzIGEgaGludCB0aGF0IHRoZSBmaW5hbCBhZ2dyZWdhdGUgc2hvdWxkIGJl IGxvZ2dlZC4NCisgKg0KKyAqIFdlIHVzZSBVbml4LWVwb2NoIHRpbWVzdGFt cHMgaW4gdGhlIGxvZywgc28gdGhhdCBlbnRyaWVzIGNhbiBiZQ0KICAqIGNv cnJlbGF0ZWQgYWdhaW5zdCBvdGhlciBsb2dzLiAgT24gc29tZSBwbGF0Zm9y bXMgdGhpcyBjb3VsZCBiZSBvYnRhaW5lZA0KICAqIGZyb20gdGhlIGNhbGxl ciwgYnV0IHJhdGhlciB0aGFuIGdldCBlbnRhbmdsZWQgd2l0aCB0aGF0LCB3 ZSBqdXN0IGVhdA0KICAqIHRoZSBjb3N0IG9mIGFuIGV4dHJhIHN5c2NhbGwg aW4gYWxsIGNhc2VzLg0KICAqLw0KIHN0YXRpYyB2b2lkDQotZG9Mb2coVFN0 YXRlICp0aHJlYWQsIENTdGF0ZSAqc3QsDQorZG9Mb2coVFN0YXRlICp0aHJl YWQsIENTdGF0ZSAqc3QsIGJvb2wgYWNjdW11bGF0ZSwNCiAJICBTdGF0c0Rh dGEgKmFnZywgYm9vbCBza2lwcGVkLCBkb3VibGUgbGF0ZW5jeSwgZG91Ymxl IGxhZykNCiB7DQogCUZJTEUJICAgKmxvZ2ZpbGUgPSB0aHJlYWQtPmxvZ2Zp bGU7DQotCXBnX3RpbWVfdXNlY190IG5vdyA9IHBnX3RpbWVfbm93KCk7DQor CXBnX3RpbWVfdXNlY190IG5vdyA9IHBnX3RpbWVfbm93KCkgKyBlcG9jaF9z aGlmdDsNCiANCiAJQXNzZXJ0KHVzZV9sb2cpOw0KIA0KQEAgLTM3OTYsNDMg KzM4MzIsMzMgQEAgZG9Mb2coVFN0YXRlICp0aHJlYWQsIENTdGF0ZSAqc3Qs DQogCS8qIHNob3VsZCB3ZSBhZ2dyZWdhdGUgdGhlIHJlc3VsdHMgb3Igbm90 PyAqLw0KIAlpZiAoYWdnX2ludGVydmFsID4gMCkNCiAJew0KKwkJcGdfdGlt ZV91c2VjX3QJbmV4dDsNCisNCiAJCS8qDQogCQkgKiBMb29wIHVudGlsIHdl IHJlYWNoIHRoZSBpbnRlcnZhbCBvZiB0aGUgY3VycmVudCBtb21lbnQsIGFu ZCBwcmludA0KIAkJICogYW55IGVtcHR5IGludGVydmFscyBpbiBiZXR3ZWVu ICh0aGlzIG1heSBoYXBwZW4gd2l0aCB2ZXJ5IGxvdyB0cHMsDQogCQkgKiBl LmcuIC0tcmF0ZT0wLjEpLg0KIAkJICovDQotDQotCQl3aGlsZSAoYWdnLT5z dGFydF90aW1lICsgYWdnX2ludGVydmFsIDw9IG5vdykNCisJCXdoaWxlICgo bmV4dCA9IGFnZy0+c3RhcnRfdGltZSArIGFnZ19pbnRlcnZhbCAqIElOVDY0 Q09OU1QoMTAwMDAwMCkpIDw9IG5vdykNCiAJCXsNCi0JCQkvKiBwcmludCBh Z2dyZWdhdGVkIHJlcG9ydCB0byBsb2dmaWxlICovDQotCQkJZnByaW50Zihs b2dmaWxlLCBJTlQ2NF9GT1JNQVQgIiAiIElOVDY0X0ZPUk1BVCAiICUuMGYg JS4wZiAlLjBmICUuMGYiLA0KLQkJCQkJYWdnLT5zdGFydF90aW1lLA0KLQkJ CQkJYWdnLT5jbnQsDQotCQkJCQlhZ2ctPmxhdGVuY3kuc3VtLA0KLQkJCQkJ YWdnLT5sYXRlbmN5LnN1bTIsDQotCQkJCQlhZ2ctPmxhdGVuY3kubWluLA0K LQkJCQkJYWdnLT5sYXRlbmN5Lm1heCk7DQotCQkJaWYgKHRocm90dGxlX2Rl bGF5KQ0KLQkJCXsNCi0JCQkJZnByaW50Zihsb2dmaWxlLCAiICUuMGYgJS4w ZiAlLjBmICUuMGYiLA0KLQkJCQkJCWFnZy0+bGFnLnN1bSwNCi0JCQkJCQlh Z2ctPmxhZy5zdW0yLA0KLQkJCQkJCWFnZy0+bGFnLm1pbiwNCi0JCQkJCQlh Z2ctPmxhZy5tYXgpOw0KLQkJCQlpZiAobGF0ZW5jeV9saW1pdCkNCi0JCQkJ CWZwcmludGYobG9nZmlsZSwgIiAiIElOVDY0X0ZPUk1BVCwgYWdnLT5za2lw cGVkKTsNCi0JCQl9DQotCQkJZnB1dGMoJ1xuJywgbG9nZmlsZSk7DQorCQkJ bG9nQWdnKGxvZ2ZpbGUsIGFnZyk7DQogDQogCQkJLyogcmVzZXQgZGF0YSBh bmQgbW92ZSB0byBuZXh0IGludGVydmFsICovDQotCQkJaW5pdFN0YXRzKGFn ZywgYWdnLT5zdGFydF90aW1lICsgYWdnX2ludGVydmFsKTsNCisJCQlpbml0 U3RhdHMoYWdnLCBuZXh0KTsNCiAJCX0NCiANCi0JCS8qIGFjY3VtdWxhdGUg dGhlIGN1cnJlbnQgdHJhbnNhY3Rpb24gKi8NCi0JCWFjY3VtU3RhdHMoYWdn LCBza2lwcGVkLCBsYXRlbmN5LCBsYWcpOw0KKwkJaWYgKGFjY3VtdWxhdGUp DQorCQkJLyogYWNjdW11bGF0ZSB0aGUgY3VycmVudCB0cmFuc2FjdGlvbiAq Lw0KKwkJCWFjY3VtU3RhdHMoYWdnLCBza2lwcGVkLCBsYXRlbmN5LCBsYWcp Ow0KKwkJZWxzZQ0KKwkJCS8qIGZpbmFsIGNhbGwgdG8gc2hvdyB0aGUgbGFz dCBhZ2dyZWdhdGUgKi8NCisJCQlsb2dBZ2cobG9nZmlsZSwgYWdnKTsNCiAJ fQ0KIAllbHNlDQogCXsNCisJCS8qIGFjY3VtdWxhdGUgYXMgZmFsc2UgaXMg b25seSB1c2VkIGZvciBhZ2dyZWdhdGVkIGRhdGEgKi8NCisJCUFzc2VydChh Y2N1bXVsYXRlKTsNCisNCiAJCS8qIG5vLCBwcmludCByYXcgdHJhbnNhY3Rp b25zICovDQogCQlpZiAoc2tpcHBlZCkNCiAJCQlmcHJpbnRmKGxvZ2ZpbGUs ICIlZCAiIElOVDY0X0ZPUk1BVCAiIHNraXBwZWQgJWQgIiBJTlQ2NF9GT1JN QVQgIiAiDQpAQCAtMzg5Miw3ICszOTE4LDcgQEAgcHJvY2Vzc1hhY3RTdGF0 cyhUU3RhdGUgKnRocmVhZCwgQ1N0YXRlICpzdCwgcGdfdGltZV91c2VjX3Qg Km5vdywNCiAJc3QtPmNudCsrOw0KIA0KIAlpZiAodXNlX2xvZykNCi0JCWRv TG9nKHRocmVhZCwgc3QsIGFnZywgc2tpcHBlZCwgbGF0ZW5jeSwgbGFnKTsN CisJCWRvTG9nKHRocmVhZCwgc3QsIHRydWUsIGFnZywgc2tpcHBlZCwgbGF0 ZW5jeSwgbGFnKTsNCiANCiAJLyogWFhYIGNvdWxkIHVzZSBhIG11dGV4IGhl cmUsIGJ1dCB3ZSBjaG9vc2Ugbm90IHRvICovDQogCWlmIChwZXJfc2NyaXB0 X3N0YXRzKQ0KQEAgLTU0NTgsNyArNTQ4NCw4IEBAIHByaW50UHJvZ3Jlc3NS ZXBvcnQoVFN0YXRlICp0aHJlYWRzLCBpbnQ2NCB0ZXN0X3N0YXJ0LCBwZ190 aW1lX3VzZWNfdCBub3csDQogDQogCWlmIChwcm9ncmVzc190aW1lc3RhbXAp DQogCXsNCi0JCXNucHJpbnRmKHRidWYsIHNpemVvZih0YnVmKSwgIiUuM2Yg cyIsIFBHX1RJTUVfR0VUX0RPVUJMRShub3cpKTsNCisJCXNucHJpbnRmKHRi dWYsIHNpemVvZih0YnVmKSwgIiUuM2YgcyIsDQorCQkJCSBQR19USU1FX0dF VF9ET1VCTEUobm93ICsgZXBvY2hfc2hpZnQpKTsNCiAJfQ0KIAllbHNlDQog CXsNCkBAIC01Nzg5LDggKzU4MTYsOCBAQCBtYWluKGludCBhcmdjLCBjaGFy ICoqYXJndikNCiAJVFN0YXRlCSAgICp0aHJlYWRzOwkJLyogYXJyYXkgb2Yg dGhyZWFkICovDQogDQogCXBnX3RpbWVfdXNlY190DQotCQkJCXN0YXJ0X3Rp bWUsCQkvKiBzdGFydCB1cCB0aW1lICovDQotCQkJCWJlbmNoX3N0YXJ0ID0g MCwJLyogZmlyc3QgcmVjb3JkZWQgYmVuY2htYXJraW5nIHRpbWUgKi8NCisJ CQkJc3RhcnRfdGltZSwJCQkJLyogb3ZlcmFsbCBzdGFydCB0aW1lICovDQor CQkJCWJlbmNoX3N0YXJ0ID0gMCwJCS8qIGZpcnN0IHJlY29yZGVkIGJlbmNo bWFya2luZyB0aW1lICovDQogCQkJCWNvbm5fdG90YWxfZHVyYXRpb247CS8q IGN1bXVsYXRlZCBjb25uZWN0aW9uIHRpbWUgaW4NCiAJCQkJCQkJCQkJICog dGhyZWFkcyAqLw0KIAlpbnQ2NAkJbGF0ZW5jeV9sYXRlID0gMDsNCkBAIC01 ODA4LDYgKzU4MzUsMTEgQEAgbWFpbihpbnQgYXJnYywgY2hhciAqKmFyZ3Yp DQogCWNoYXIJICAgKmVudjsNCiANCiAJaW50CQkJZXhpdF9jb2RlID0gMDsN CisJc3RydWN0IHRpbWV2YWwgdHY7DQorDQorCS8qIHJlY29yZCBzaGlmdCBi ZXR3ZWVuIFVuaXggZXBvY2ggYW5kIG5vdygpICovDQorCWdldHRpbWVvZmRh eSgmdHYsIE5VTEwpOw0KKwllcG9jaF9zaGlmdCA9IHR2LnR2X3NlYyAqIElO VDY0Q09OU1QoMTAwMDAwMCkgKyB0di50dl91c2VjIC0gcGdfdGltZV9ub3co KTsNCiANCiAJcGdfbG9nZ2luZ19pbml0KGFyZ3ZbMF0pOw0KIAlwcm9nbmFt ZSA9IGdldF9wcm9nbmFtZShhcmd2WzBdKTsNCkBAIC02NjM3LDcgKzY2Njks MTQgQEAgdGhyZWFkUnVuKHZvaWQgKmFyZykNCiAJdGhyZWFkLT5iZW5jaF9z dGFydCA9IHN0YXJ0Ow0KIAl0aHJlYWQtPnRocm90dGxlX3RyaWdnZXIgPSBz dGFydDsNCiANCi0JaW5pdFN0YXRzKCZhZ2dzLCBzdGFydCk7DQorCS8qDQor CSAqIFRoZSBsb2cgZm9ybWF0IGN1cnJlbnRseSBoYXMgVW5peCBlcG9jaCB0 aW1lc3RhbXBzIHdpdGggd2hvbGUgbnVtYmVycyBvZg0KKwkgKiBzZWNvbmRz LiAgUm91bmQgdGhlIGZpcnN0IGFnZ3JlZ2F0ZSdzIHN0YXJ0IHRpbWUgZG93 biB0byB0aGUgbmVhcmVzdA0KKwkgKiBVbml4IGVwb2NoIHNlY29uZCAodGhl IHZlcnkgZmlyc3QgYWdncmVnYXRlIG1pZ2h0IHJlYWxseSBoYXZlIHN0YXJ0 ZWQgYQ0KKwkgKiBmcmFjdGlvbiBvZiBhIHNlY29uZCBsYXRlciwgYnV0IGxh dGVyIGFnZ3JlZ2F0ZXMgYXJlIG1lYXN1cmVkIGZyb20gdGhlDQorCSAqIHdo b2xlIG51bWJlciB0aW1lIHRoYXQgaXMgYWN0dWFsbHkgbG9nZ2VkKS4NCisJ ICovDQorCWluaXRTdGF0cygmYWdncywgKHN0YXJ0ICsgZXBvY2hfc2hpZnQp IC8gMTAwMDAwMCAqIDEwMDAwMDApOw0KIAlsYXN0ID0gYWdnczsNCiANCiAJ LyogbG9vcCB0aWxsIGFsbCBjbGllbnRzIGhhdmUgdGVybWluYXRlZCAqLw0K QEAgLTY4MzAsOCArNjg2OSw5IEBAIGRvbmU6DQogCQlpZiAoYWdnX2ludGVy dmFsID4gMCkNCiAJCXsNCiAJCQkvKiBsb2cgYWdncmVnYXRlZCBidXQgbm90 IHlldCByZXBvcnRlZCB0cmFuc2FjdGlvbnMgKi8NCi0JCQlkb0xvZyh0aHJl YWQsIHN0YXRlLCAmYWdncywgZmFsc2UsIDAsIDApOw0KKwkJCWRvTG9nKHRo cmVhZCwgc3RhdGUsIGZhbHNlLCAmYWdncywgZmFsc2UsIDAuMCwgMC4wKTsN CiAJCX0NCisNCiAJCWZjbG9zZSh0aHJlYWQtPmxvZ2ZpbGUpOw0KIAkJdGhy ZWFkLT5sb2dmaWxlID0gTlVMTDsNCiAJfQ0KZGlmZiAtLWdpdCBhL3NyYy9i aW4vcGdiZW5jaC90LzAwMV9wZ2JlbmNoX3dpdGhfc2VydmVyLnBsIGIvc3Jj L2Jpbi9wZ2JlbmNoL3QvMDAxX3BnYmVuY2hfd2l0aF9zZXJ2ZXIucGwNCmlu ZGV4IDNhYTlkNWQ3NTMuLjQxMjUwYmY5MWQgMTAwNjQ0DQotLS0gYS9zcmMv YmluL3BnYmVuY2gvdC8wMDFfcGdiZW5jaF93aXRoX3NlcnZlci5wbA0KKysr IGIvc3JjL2Jpbi9wZ2JlbmNoL3QvMDAxX3BnYmVuY2hfd2l0aF9zZXJ2ZXIu cGwNCkBAIC04LDYgKzgsNyBAQCB1c2UgUG9zdGdyZXNOb2RlOw0KIHVzZSBU ZXN0TGliOw0KIHVzZSBUZXN0OjpNb3JlOw0KIHVzZSBDb25maWc7DQordXNl IFRpbWU6OkhpUmVzIHF3KCB0aW1lICk7DQogDQogIyBzdGFydCBhIHBnYmVu Y2ggc3BlY2lmaWMgc2VydmVyDQogbXkgJG5vZGUgPSBnZXRfbmV3X25vZGUo J21haW4nKTsNCkBAIC01NCwxMiArNTUsMTQgQEAgc3ViIHBnYmVuY2gNCiAN CiAJcHVzaCBAY21kLCBAYXJnczsNCiANCisJbXkgJHN0YXJ0ID0gdGltZSgp Ow0KIAkkbm9kZS0+Y29tbWFuZF9jaGVja3NfYWxsKFxAY21kLCAkc3RhdCwg JG91dCwgJGVyciwgJG5hbWUpOw0KKwlteSAkc3RvcCA9IHRpbWUoKTsNCiAN CiAJIyBjbGVhbnVwPw0KIAkjdW5saW5rIEBmaWxlbmFtZXMgb3IgZGllICJj YW5ub3QgdW5saW5rIGZpbGVzIChAZmlsZW5hbWVzKTogJCEiOw0KIA0KLQly ZXR1cm47DQorCXJldHVybiAkc3RvcCAtICRzdGFydDsNCiB9DQogDQogIyB0 YWJsZXNwYWNlIGZvciB0ZXN0aW5nLCBiZWNhdXNlIHBhcnRpdGlvbmVkIHRh YmxlcyBjYW5ub3QgdXNlIHBnX2RlZmF1bHQNCkBAIC0xMTg3LDcgKzExOTAs NyBAQCBzdWIgY2hlY2tfcGdiZW5jaF9sb2dzDQogDQogCSMgJHByZWZpeCBp cyBzaW1wbGUgZW5vdWdoLCB0aHVzIGRvZXMgbm90IG5lZWQgZXNjYXBpbmcN CiAJbXkgQGxvZ3MgPSBsaXN0X2ZpbGVzKCRkaXIsIHFye14kcHJlZml4XC4u KiR9KTsNCi0Jb2soQGxvZ3MgPT0gJG5iLCAibnVtYmVyIG9mIGxvZyBmaWxl cyIpOw0KKwlvayhAbG9ncyA9PSAkbmIsICJudW1iZXIgb2YgbG9nIGZpbGVz IChAbG9ncykiKTsNCiAJb2soZ3JlcCgvXC8kcHJlZml4XC5cZCsoXC5cZCsp PyQvLCBAbG9ncykgPT0gJG5iLCAiZmlsZSBuYW1lIGZvcm1hdCIpOw0KIA0K IAlteSAkbG9nX251bWJlciA9IDA7DQpAQCAtMTIyMCw2ICsxMjIzLDU4IEBA IHN1YiBjaGVja19wZ2JlbmNoX2xvZ3MNCiBteSAkYmRpciA9ICRub2RlLT5i YXNlZGlyOw0KIA0KICMgUnVuIHdpdGggc2FtcGxpbmcgcmF0ZSwgMiBjbGll bnRzIHdpdGggNTAgdHJhbnNhY3Rpb25zIGVhY2guDQorIw0KKyMgVGVzdCB0 aW1lLXNlbnNpdGl2ZSBmZWF0dXJlcyBvbiBhIGxpZ2h0IHJlYWQtb25seSB0 cmFuc2FjdGlvbjoNCisjDQorIyAgIC1UOiBiZW5jaCBkdXJhdGlvbiwgMiBz ZWNvbmRzIHRvIGV4ZXJjaXNlIHByb2dyZXNzICYgbG9ncw0KKyMgICAtUDog cHJvZ3Jlc3MgcmVwb3J0DQorIyAgIC0tYWdncmVnYXRlLWludGVydmFsOiBw ZXJpb2RpYyBhZ2dyZWdhdGVkIGxvZ3MNCisjICAgLS1yYXRlOiBzY2hlZHVs ZSBsb2FkDQorIyAgIC0tbGF0ZW5jeS1saW1pdDogbWF4IGRlbGF5LCBub3Qg ZGVlcGx5IGV4ZXJjaWNlDQorIw0KKyMgbm90ZTogdGhlIC0tcmF0ZSBiZWhh dmlvciBpcyBwcm9iYWJpbGlzdGljIGluIG5hdHVyZS4NCisjIG5vdGU6IC0t cHJvZ3Jlc3MtdGltZXN0YW1wIGlzIG5vdCB0ZXN0ZWQuDQorbXkgJGRlbGF5 ID0gcGdiZW5jaCgNCisJJy1UIDIgLVAgMSAtbCAtLWFnZ3JlZ2F0ZS1pbnRl cnZhbD0xIC1TIC1iIHNlQDInDQorCS4gJyAtLXJhdGU9MjAgLS1sYXRlbmN5 LWxpbWl0PTEwMDAgLWogJyAuICRudGhyZWFkcw0KKwkuICcgLWMgMyAtcics DQorCTAsDQorCVsgICBxcnt0eXBlOiBtdWx0aXBsZX0sDQorCQlxcntjbGll bnRzOiAzfSwNCisJCXFye3RocmVhZHM6ICRudGhyZWFkc30sDQorCQlxcntk dXJhdGlvbjogMiBzfSwNCisJCXFye3NjcmlwdCAxOiAuKiBzZWxlY3Qgb25s eX0sDQorCQlxcntzY3JpcHQgMjogLiogc2VsZWN0IG9ubHl9LA0KKwkJcXJ7 c3RhdGVtZW50IGxhdGVuY2llcyBpbiBtaWxsaXNlY29uZHN9LA0KKwkJcXJ7 RlJPTSBwZ2JlbmNoX2FjY291bnRzfSBdLA0KKwlbIHFye3ZhY3V1bX0sIHFy e3Byb2dyZXNzOiAxXGJ9IF0sDQorCSdwZ2JlbmNoIHByb2dyZXNzJywgdW5k ZWYsDQorCSItLWxvZy1wcmVmaXg9JGJkaXIvMDAxX3BnYmVuY2hfbG9nXzEi KTsNCisNCisjIGNvb2wgY2hlY2sgdGhhdCB3ZSBhcmUgYXJvdW5kIDIgc2Vj b25kcw0KKw0KK1RPRE86IHsNCisJbG9jYWwgJFRPRE8gPSAicG9zc2libHkg dW5yZWxpYWJsZSBvbiBzbG93IGhvc3RzIG9yIHVubHVja3kgcnVucyI7DQor DQorCSMgVGhlIHJhdGUgbWF5IHJlc3VsdHMgaW4gYW4gdW5sdWNreSBzY2hl ZHVsZSB3aGljaCB0cmlnZ2Vycw0KKwkjIGFuIGVhcmx5IGV4aXQsIGhlbmNl IHRoZSBsb29zZSBib3VuZC4NCisNCisJIyBhbHNvLCB0aGUgZGVsYXkgbWF5 IHRvdGFsbHkgZmFpbCBvbiB2ZXJ5IHNsb3cgb3Igb3ZlcmxvYXJkIGhvc3Rz LA0KKwkjIHZhbGdyaW5kIHJ1bnMuLi4NCisNCisJb2soMS41IDwgJGRlbGF5 ICYmICRkZWxheSA8IDIuNSwgIi1UIDIgcnVuIGFyb3VuZCAyIHNlY29uZHMi KTsNCit9DQorDQorIyAkbnRocmVhZHMgdGhyZWFkcywgMiBzZWNvbmRzLCBi dXQgZHVlIHRvIHRpbWluZyBpbXByZWNpc2lvbiB3ZSBtaWdodCBnZXQNCisj IG9ubHkgMSBvciBhcyBtYW55IGFzIDMgcHJvZ3Jlc3MgcmVwb3J0cyBwZXIg dGhyZWFkLg0KKyMgYWdncmVnYXRlIGxvZyBmb3JtYXQgaXM6DQorIyAgIGVw b2NoICN0eCBzdW0gc3VtMiBtaW4gbWF4IFtzdW0gc3VtMiBtaW4gbWF4IFtz a2lwcGVkXV0NCisjIGZpcnN0IHNlcmllIGFib3V0IGxhdGVuY3kgOyBzZWNv bmQgYWJvdXQgbGFnICgtLXJhdGUpIDsNCisjIHNraXBwZWQgb25seSBpZiAt LWxhdGVuY3ktbGltaXQgaXMgc2V0Lg0KK2NoZWNrX3BnYmVuY2hfbG9ncygk YmRpciwgJzAwMV9wZ2JlbmNoX2xvZ18xJywgJG50aHJlYWRzLCAxLCAzLA0K KwlxcnteXGR7MTAsfSBcZHsxLDJ9IFxkKyBcZCsgXGQrIFxkKyBcZCsgXGQr IFxkKyBcZCsgXGQrJH0pOw0KKw0KKyMgd2l0aCBzYW1wbGluZyByYXRlLCAy IGNsaWVudHMgd2l0aCA1MCB0eCBlYWNoDQogcGdiZW5jaCgNCiAJIi1uIC1T IC10IDUwIC1jIDIgLS1sb2cgLS1zYW1wbGluZy1yYXRlPTAuNSIsIDAsDQog CVsgcXJ7c2VsZWN0IG9ubHl9LCBxcntwcm9jZXNzZWQ6IDEwMC8xMDB9IF0s IFtxcnteJH1dLA0K --2056645051-542076898-1625764291=:233209--