From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 95382 invoked by alias); 21 Feb 2017 14:47:53 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Received: (qmail 95319 invoked by uid 89); 21 Feb 2017 14:47:52 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-23.9 required=5.0 tests=AWL,BAYES_00,FREEMAIL_FROM,GIT_PATCH_0,GIT_PATCH_1,GIT_PATCH_2,GIT_PATCH_3,RCVD_IN_DNSWL_NONE,RCVD_IN_SORBS_SPAM,SPF_PASS autolearn=ham version=3.3.2 spammy=H*f:sk:jb-kag@, Attachment X-HELO: mail-vk0-f42.google.com Received: from mail-vk0-f42.google.com (HELO mail-vk0-f42.google.com) (209.85.213.42) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Tue, 21 Feb 2017 14:47:49 +0000 Received: by mail-vk0-f42.google.com with SMTP id t8so80372223vke.3 for ; Tue, 21 Feb 2017 06:47:49 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:in-reply-to:references:from:date :message-id:subject:to:cc; bh=6xYzuGkrixRYlRRW/rWmetcBBLCYd0nfHUr/qkdMRS4=; b=IlVhxPOFyVN01V4KNOCZqsYiEdgFChVVaDsM3D4Zo21sRKRuRt1EY13fzwzfE/EL5y jo1R+NXXGhA3YCIkueNn4U7bfnxZPZ5lZZgg545hE9TpjZuuY27DoihWqH+ktAt3rskw q+hI5uHpuvPM6/Du70PXmDI0gWsldWH558CIb13i1vGPsWOyMX2Zo4QUhrGnbLVtVbaO eevyr1NDA1W6S0dDFXN2PGA572w1homXgyMhKJNWjDVA6kfFZ9XVZuI4+77MwjItoIZW Jytg3xVB7ndlap/1WTSwpmI7fXpZhLVp1p31yo/q7E+cWGiM6rn5usXXLx0yAZd3luQE lYCQ== X-Gm-Message-State: AMke39ksKSLA5hD6UZubXg6XbboAMaMgKwm4NIii69yKd2XUfGynFQ0yb8lP7Mv5K83dF5ZwzxLrqk8NoDi8Iw== X-Received: by 10.31.82.65 with SMTP id g62mr6730919vkb.150.1487688467460; Tue, 21 Feb 2017 06:47:47 -0800 (PST) MIME-Version: 1.0 Received: by 10.103.72.157 with HTTP; Tue, 21 Feb 2017 06:47:46 -0800 (PST) In-Reply-To: <20170220160509.GA2669@kam.mff.cuni.cz> References: <20170220140210.GA2932@kam.mff.cuni.cz> <20170220151705.GA29965@kam.mff.cuni.cz> <20170220160509.GA2669@kam.mff.cuni.cz> From: "Bin.Cheng" Date: Tue, 21 Feb 2017 14:48:00 -0000 Message-ID: Subject: Re: [PATCH PR77536]Generate correct profiling information for vectorized loop To: Jan Hubicka Cc: Richard Biener , "gcc-patches@gcc.gnu.org" , "pthaugen@linux.vnet.ibm.com" Content-Type: multipart/mixed; boundary=001a114e56eca3d8e705490b76e8 X-IsSubscribed: yes X-SW-Source: 2017-02/txt/msg01291.txt.bz2 --001a114e56eca3d8e705490b76e8 Content-Type: text/plain; charset=UTF-8 Content-length: 5590 On Mon, Feb 20, 2017 at 4:05 PM, Jan Hubicka wrote: >> BTW, if we use gcov_type in calculation from expected_loop_iterations_unbounded, >> how should we adjust the number for calling scale_loop_frequencies >> which has int type? In extreme case, gcov_type could be out of int's >> range, we have to cap the value anyway. But yes, 10000 in >> expect_loop_iterations is too small. > > What I usually do is to use fixed point math in this case (based on REG_BR_PROB_BASE). > Just pass REG_BR_PROB_BASE as den and calculate the adjustment in gcov_type converting > to int. Because you should be just decreasing the counts, it won't overflow and because > the decarese will be in range, say 2...256 times, it should also be sufficiently > precise. > > Be careful to avoid overflow of gcov type - it is not safe to multiply two > counts in 64bit math because each count can be more than 2^32. (next stage1 I > plan to switch most of this to sreals that will make this easier) > >> >> > But I guess here it is sort of safe because vectorized loops are simple. >> >> > You can't just scale down the existing counts/frequencies by vf, because the >> >> > entry edge frequency was adjusted. >> >> I am not 100% follow here, it looks the code avoids changing frequency >> >> counter for preheader/exit edge, otherwise we would need to change all >> >> counters dominated by them? >> > >> > I was just wondering what is wrong with taking the existing frequencies/counts >> > the loop body has and dividing them all by the unroll factor. This is correct >> > if you ignore the versioning. With versioning I guess you want to scale by >> > the unroll factor and also subtract frequencies/counts that was acocunted to >> > the other versions of the loop, right? >> IIUC, for (vectorized) loop header, it's frequency is calculated by: >> freq_header = freq_preheader + freq_latch >> and freq_latch = (niter * freq_preheader). Simply scaling it by VF gives: >> freq_header = (freq_preheader + freq_latch) / VF >> which is wrong. Especially if the loop is vectorized by large VF >> (=16) and we normally assume niter (=10) without profiling >> information, it results not only mismatch, but also >> (loop->header->frequency < loop->preheader->frequency). In fact, if >> we have accurate niter information, the counter should be: >> freq_header = freq_preheader + niter * freq_preheader > > You are right. We need to compensate for the change of probability of the loop > exit edge. >> >> >> > >> >> > Also niter_for_unrolled_loop depends on sanity of the profile, so perhaps you >> >> > need to compute it before you start chanigng the CFG by peeling proplogue? >> >> Peeling for prologue doesn't change profiling information of >> >> vect_loop, it is the skip edge from before loop to preferred epilogue >> >> loop that will change profile counters. I guess here exists a dilemma >> >> that niter_for_unrolled_loop is for loop after peeling for prologue? >> > >> > expected_loop_iterations_unbounded calculates number of iteations by computing >> > sum of frequencies of edges entering the loop and comparing it to the frequency >> > of loop header. While peeling the prologue, you split the preheader edge and >> > adjust frequency of the new preheader BB of the loop to be vectorized. I think >> > that will adjust the #of iterations estimate. >> It's not the case now I think. one motivation of new vect_do_peeling >> is to avoid niter checks between prologue and vector loop. Once >> prologue loop is entered or checked, the vector loop must be executed >> unconditionally. So the preheaderof vector loop has consistent >> frequency counters now. The niter check on whether vector loop should >> be executed is now merged with cost check before prologue, and in the >> future I think this can be further merged if loop versioning is >> needed. > > Originally you have > > loop_preheader > | > v > loop_header > > and the ratio of the two BB frequencies is the loop iteration count. Then you > do something like: > > orig_loop_preheader > | > v > loop_prologue -----> scalar_version_of_loop > | > v > new_loop_preheader > | > v > loop_header > > At some point, you need to update new_loop_preheader frequency/count > to reflect the fact that with some probability the loop_prologue avoids > the vectorized loop. Once you do it and if you don't scale frequency of > loop_header you will make expect_loop_iterations to return higher value > than previously. > > So at the time you are calling it, you need to be sure that the loop_header > and its preheader frequences was both adjusted by same factor. Or you need > to call it early before you start hacking on the CFG and its profile. > > Pehaps currently it is safe, because your peeling code is also scaling > the loop profiles. Hi Honza, Attachment is the updated patch. Bootstrap and test ongoing, any comments? Thanks, bin 2017-02-21 Bin Cheng PR tree-optimization/77536 * tree-ssa-loop-manip.c (niter_for_unrolled_loop): New function. (tree_transform_and_unroll_loop): Use above function to compute the estimated niter of unrolled loop and use it when scaling profile. * tree-ssa-loop-manip.h niter_for_unrolled_loop(): New declaration. * tree-vect-loop.c (scale_profile_for_vect_loop): New function. (vect_transform_loop): Call above function. gcc/testsuite/ChangeLog 2017-02-21 Bin Cheng PR tree-optimization/77536 * gcc.dg/vect/pr79347.c: Revise testing string. --001a114e56eca3d8e705490b76e8 Content-Type: text/plain; charset=US-ASCII; name="pr77536-20170217.txt" Content-Disposition: attachment; filename="pr77536-20170217.txt" Content-Transfer-Encoding: base64 X-Attachment-Id: f_izfna17p0 Content-length: 10366 ZGlmZiAtLWdpdCBhL2djYy90ZXN0c3VpdGUvZ2NjLmRnL3ZlY3QvcHI3OTM0 Ny5jIGIvZ2NjL3Rlc3RzdWl0ZS9nY2MuZGcvdmVjdC9wcjc5MzQ3LmMKaW5k ZXggNTg2YzYzOC4uNjgyNTQyMCAxMDA2NDQKLS0tIGEvZ2NjL3Rlc3RzdWl0 ZS9nY2MuZGcvdmVjdC9wcjc5MzQ3LmMKKysrIGIvZ2NjL3Rlc3RzdWl0ZS9n Y2MuZGcvdmVjdC9wcjc5MzQ3LmMKQEAgLTEwLDQgKzEwLDQgQEAgdm9pZCBu KHZvaWQpCiAgICAgYVtpXSsrOwogfQogCi0vKiB7IGRnLWZpbmFsIHsgc2Nh bi10cmVlLWR1bXAtdGltZXMgIkludmFsaWQgc3VtIG9mICIgMiAidmVjdCIg fSB9ICovCisvKiB7IGRnLWZpbmFsIHsgc2Nhbi10cmVlLWR1bXAtbm90ICJJ bnZhbGlkIHN1bSBvZiAiICJ2ZWN0IiB9IH0gKi8KZGlmZiAtLWdpdCBhL2dj Yy90cmVlLXNzYS1sb29wLW1hbmlwLmMgYi9nY2MvdHJlZS1zc2EtbG9vcC1t YW5pcC5jCmluZGV4IDQzZGYyOWMuLmNmMmNkNDggMTAwNjQ0Ci0tLSBhL2dj Yy90cmVlLXNzYS1sb29wLW1hbmlwLmMKKysrIGIvZ2NjL3RyZWUtc3NhLWxv b3AtbWFuaXAuYwpAQCAtMTA5Myw2ICsxMDkzLDMzIEBAIHNjYWxlX2RvbWlu YXRlZF9ibG9ja3NfaW5fbG9vcCAoc3RydWN0IGxvb3AgKmxvb3AsIGJhc2lj X2Jsb2NrIGJiLAogICAgIH0KIH0KIAorLyogUmV0dXJuIGVzdGltYXRlZCBu aXRlciBmb3IgTE9PUCBhZnRlciB1bnJvbGxpbmcgYnkgRkFDVE9SIHRpbWVz LiAgKi8KKworZ2Nvdl90eXBlCituaXRlcl9mb3JfdW5yb2xsZWRfbG9vcCAo c3RydWN0IGxvb3AgKmxvb3AsIHVuc2lnbmVkIGZhY3RvcikKK3sKKyAgZ2Nj X2Fzc2VydCAoZmFjdG9yICE9IDApOworICBib29sIHByb2ZpbGVfcCA9IGZh bHNlOworICBnY292X3R5cGUgZXN0X25pdGVyID0gZXhwZWN0ZWRfbG9vcF9p dGVyYXRpb25zX3VuYm91bmRlZCAobG9vcCwgJnByb2ZpbGVfcCk7CisgIGdj b3ZfdHlwZSBuZXdfZXN0X25pdGVyID0gZXN0X25pdGVyIC8gZmFjdG9yOwor CisgIC8qIFdpdGhvdXQgcHJvZmlsZSBmZWVkYmFjaywgbG9vcHMgZm9yIHdo aWNoIHdlIGRvIG5vdCBrbm93IGEgYmV0dGVyIGVzdGltYXRlCisgICAgIGFy ZSBhc3N1bWVkIHRvIHJvbGwgMTAgdGltZXMuICBXaGVuIHdlIHVucm9sbCBz dWNoIGxvb3AsIGl0IGFwcGVhcnMgdG8KKyAgICAgcm9sbCB0b28gbGl0dGxl LCBhbmQgaXQgbWF5IGV2ZW4gc2VlbSB0byBiZSBjb2xkLiAgVG8gYXZvaWQg dGhpcywgd2UKKyAgICAgZW5zdXJlIHRoYXQgdGhlIGNyZWF0ZWQgbG9vcCBh cHBlYXJzIHRvIHJvbGwgYXQgbGVhc3QgNSB0aW1lcyAoYnV0IGF0CisgICAg IG1vc3QgYXMgbWFueSB0aW1lcyBhcyBiZWZvcmUgdW5yb2xsaW5nKS4gIERv bid0IGRvIGFkanVzdG1lbnQgaWYgcHJvZmlsZQorICAgICBmZWVkYmFjayBp cyBwcmVzZW50LiAgKi8KKyAgaWYgKG5ld19lc3Rfbml0ZXIgPCA1ICYmICFw cm9maWxlX3ApCisgICAgeworICAgICAgaWYgKGVzdF9uaXRlciA8IDUpCisJ bmV3X2VzdF9uaXRlciA9IGVzdF9uaXRlcjsKKyAgICAgIGVsc2UKKwluZXdf ZXN0X25pdGVyID0gNTsKKyAgICB9CisKKyAgcmV0dXJuIG5ld19lc3Rfbml0 ZXI7Cit9CisKIC8qIFVucm9sbCBMT09QIEZBQ1RPUiB0aW1lcy4gIERFU0Mg ZGVzY3JpYmVzIG51bWJlciBvZiBpdGVyYXRpb25zIG9mIExPT1AuCiAgICBF WElUIGlzIHRoZSBleGl0IG9mIHRoZSBsb29wIHRvIHRoYXQgREVTQyBjb3Jy ZXNwb25kcy4KIApAQCAtMTE3MCwxMiArMTE5NywxMSBAQCB0cmVlX3RyYW5z Zm9ybV9hbmRfdW5yb2xsX2xvb3AgKHN0cnVjdCBsb29wICpsb29wLCB1bnNp Z25lZCBmYWN0b3IsCiAgIGdpbXBsZV9zdG10X2l0ZXJhdG9yIGJzaTsKICAg dXNlX29wZXJhbmRfcCBvcDsKICAgYm9vbCBvazsKLSAgdW5zaWduZWQgZXN0 X25pdGVyLCBwcm9iX2VudHJ5LCBzY2FsZV91bnJvbGxlZCwgc2NhbGVfcmVz dCwgZnJlcV9lLCBmcmVxX2g7Ci0gIHVuc2lnbmVkIG5ld19lc3Rfbml0ZXIs IGksIHByb2I7CisgIHVuc2lnbmVkIGksIHByb2IsIHByb2JfZW50cnksIHNj YWxlX3Vucm9sbGVkLCBzY2FsZV9yZXN0LCBmcmVxX2UsIGZyZXFfaDsKKyAg Z2Nvdl90eXBlIG5ld19lc3Rfbml0ZXIgPSBuaXRlcl9mb3JfdW5yb2xsZWRf bG9vcCAobG9vcCwgZmFjdG9yKTsKICAgdW5zaWduZWQgaXJyID0gbG9vcF9w cmVoZWFkZXJfZWRnZSAobG9vcCktPmZsYWdzICYgRURHRV9JUlJFRFVDSUJM RV9MT09QOwogICBhdXRvX3ZlYzxlZGdlPiB0b19yZW1vdmU7CiAKLSAgZXN0 X25pdGVyID0gZXhwZWN0ZWRfbG9vcF9pdGVyYXRpb25zIChsb29wKTsKICAg ZGV0ZXJtaW5lX2V4aXRfY29uZGl0aW9ucyAobG9vcCwgZGVzYywgZmFjdG9y LAogCQkJICAgICAmZW50ZXJfbWFpbl9jb25kLCAmZXhpdF9iYXNlLCAmZXhp dF9zdGVwLAogCQkJICAgICAmZXhpdF9jbXAsICZleGl0X2JvdW5kKTsKQEAg LTEyMDcsMjIgKzEyMzMsNiBAQCB0cmVlX3RyYW5zZm9ybV9hbmRfdW5yb2xs X2xvb3AgKHN0cnVjdCBsb29wICpsb29wLCB1bnNpZ25lZCBmYWN0b3IsCiAg IGdjY19hc3NlcnQgKG5ld19sb29wICE9IE5VTEwpOwogICB1cGRhdGVfc3Nh IChUT0RPX3VwZGF0ZV9zc2EpOwogCi0gIC8qIERldGVybWluZSB0aGUgcHJv YmFiaWxpdHkgb2YgdGhlIGV4aXQgZWRnZSBvZiB0aGUgdW5yb2xsZWQgbG9v cC4gICovCi0gIG5ld19lc3Rfbml0ZXIgPSBlc3Rfbml0ZXIgLyBmYWN0b3I7 Ci0KLSAgLyogV2l0aG91dCBwcm9maWxlIGZlZWRiYWNrLCBsb29wcyBmb3Ig dGhhdCB3ZSBkbyBub3Qga25vdyBhIGJldHRlciBlc3RpbWF0ZQotICAgICBh cmUgYXNzdW1lZCB0byByb2xsIDEwIHRpbWVzLiAgV2hlbiB3ZSB1bnJvbGwg c3VjaCBsb29wLCBpdCBhcHBlYXJzIHRvCi0gICAgIHJvbGwgdG9vIGxpdHRs ZSwgYW5kIGl0IG1heSBldmVuIHNlZW0gdG8gYmUgY29sZC4gIFRvIGF2b2lk IHRoaXMsIHdlCi0gICAgIGVuc3VyZSB0aGF0IHRoZSBjcmVhdGVkIGxvb3Ag YXBwZWFycyB0byByb2xsIGF0IGxlYXN0IDUgdGltZXMgKGJ1dCBhdAotICAg ICBtb3N0IGFzIG1hbnkgdGltZXMgYXMgYmVmb3JlIHVucm9sbGluZykuICAq LwotICBpZiAobmV3X2VzdF9uaXRlciA8IDUpCi0gICAgewotICAgICAgaWYg KGVzdF9uaXRlciA8IDUpCi0JbmV3X2VzdF9uaXRlciA9IGVzdF9uaXRlcjsK LSAgICAgIGVsc2UKLQluZXdfZXN0X25pdGVyID0gNTsKLSAgICB9Ci0KICAg LyogUHJlcGFyZSB0aGUgY2ZnIGFuZCB1cGRhdGUgdGhlIHBoaSBub2Rlcy4g IE1vdmUgdGhlIGxvb3AgZXhpdCB0byB0aGUKICAgICAgbG9vcCBsYXRjaCAo YW5kIG1ha2UgaXRzIGNvbmRpdGlvbiBkdW1teSwgZm9yIHRoZSBtb21lbnQp LiAgKi8KICAgcmVzdCA9IGxvb3BfcHJlaGVhZGVyX2VkZ2UgKG5ld19sb29w KS0+c3JjOwpAQCAtMTMyOSw3ICsxMzM5LDEyIEBAIHRyZWVfdHJhbnNmb3Jt X2FuZF91bnJvbGxfbG9vcCAoc3RydWN0IGxvb3AgKmxvb3AsIHVuc2lnbmVk IGZhY3RvciwKICAgZnJlcV9oID0gbG9vcC0+aGVhZGVyLT5mcmVxdWVuY3k7 CiAgIGZyZXFfZSA9IEVER0VfRlJFUVVFTkNZIChsb29wX3ByZWhlYWRlcl9l ZGdlIChsb29wKSk7CiAgIGlmIChmcmVxX2ggIT0gMCkKLSAgICBzY2FsZV9s b29wX2ZyZXF1ZW5jaWVzIChsb29wLCBmcmVxX2UgKiAobmV3X2VzdF9uaXRl ciArIDEpLCBmcmVxX2gpOworICAgIHsKKyAgICAgIGdjb3ZfdHlwZSBzY2Fs ZTsKKyAgICAgIC8qIFRoaXMgc2hvdWxkIG5vdCBvdmVyZmxvdy4gICovCisg ICAgICBzY2FsZSA9IEdDT1ZfQ09NUFVURV9TQ0FMRSAoZnJlcV9lICogKG5l d19lc3Rfbml0ZXIgKyAxKSwgZnJlcV9oKTsKKyAgICAgIHNjYWxlX2xvb3Bf ZnJlcXVlbmNpZXMgKGxvb3AsIHNjYWxlLCBSRUdfQlJfUFJPQl9CQVNFKTsK KyAgICB9CiAKICAgZXhpdF9iYiA9IHNpbmdsZV9wcmVkIChsb29wLT5sYXRj aCk7CiAgIG5ld19leGl0ID0gZmluZF9lZGdlIChleGl0X2JiLCByZXN0KTsK ZGlmZiAtLWdpdCBhL2djYy90cmVlLXNzYS1sb29wLW1hbmlwLmggYi9nY2Mv dHJlZS1zc2EtbG9vcC1tYW5pcC5oCmluZGV4IDFlNzUzMWYuLmExMzkwNTAg MTAwNjQ0Ci0tLSBhL2djYy90cmVlLXNzYS1sb29wLW1hbmlwLmgKKysrIGIv Z2NjL3RyZWUtc3NhLWxvb3AtbWFuaXAuaApAQCAtNDgsNiArNDgsNyBAQCBl eHRlcm4gYm9vbCBnaW1wbGVfZHVwbGljYXRlX2xvb3BfdG9faGVhZGVyX2Vk Z2UgKHN0cnVjdCBsb29wICosIGVkZ2UsCiAJCQkJCQkgIGludCk7CiBleHRl cm4gYm9vbCBjYW5fdW5yb2xsX2xvb3BfcCAoc3RydWN0IGxvb3AgKmxvb3As IHVuc2lnbmVkIGZhY3RvciwKIAkJCSAgICAgICBzdHJ1Y3QgdHJlZV9uaXRl cl9kZXNjICpuaXRlcik7CitleHRlcm4gZ2Nvdl90eXBlIG5pdGVyX2Zvcl91 bnJvbGxlZF9sb29wIChzdHJ1Y3QgbG9vcCAqLCB1bnNpZ25lZCk7CiBleHRl cm4gdm9pZCB0cmVlX3RyYW5zZm9ybV9hbmRfdW5yb2xsX2xvb3AgKHN0cnVj dCBsb29wICosIHVuc2lnbmVkLAogCQkJCQkgICAgZWRnZSwgc3RydWN0IHRy ZWVfbml0ZXJfZGVzYyAqLAogCQkJCQkgICAgdHJhbnNmb3JtX2NhbGxiYWNr LCB2b2lkICopOwpkaWZmIC0tZ2l0IGEvZ2NjL3RyZWUtdmVjdC1sb29wLmMg Yi9nY2MvdHJlZS12ZWN0LWxvb3AuYwppbmRleCBjNWExNjI3Li4yY2EwM2M1 IDEwMDY0NAotLS0gYS9nY2MvdHJlZS12ZWN0LWxvb3AuYworKysgYi9nY2Mv dHJlZS12ZWN0LWxvb3AuYwpAQCAtNjcxOCw2ICs2NzE4LDQ4IEBAIGxvb3Bf bml0ZXJzX25vX292ZXJmbG93IChsb29wX3ZlY19pbmZvIGxvb3BfdmluZm8p CiAgIHJldHVybiBmYWxzZTsKIH0KIAorLyogU2NhbGUgcHJvZmlsaW5nIGNv dW50ZXJzIGJ5IGVzdGltYXRpb24gZm9yIExPT1Agd2hpY2ggaXMgdmVjdG9y aXplZAorICAgYnkgZmFjdG9yIFZGLiAgKi8KKworc3RhdGljIHZvaWQKK3Nj YWxlX3Byb2ZpbGVfZm9yX3ZlY3RfbG9vcCAoc3RydWN0IGxvb3AgKmxvb3As IHVuc2lnbmVkIHZmKQoreworICBlZGdlIHByZWhlYWRlciA9IGxvb3BfcHJl aGVhZGVyX2VkZ2UgKGxvb3ApOworICB1bnNpZ25lZCBmcmVxX2ggPSBsb29w LT5oZWFkZXItPmZyZXF1ZW5jeTsKKyAgdW5zaWduZWQgZnJlcV9lID0gRURH RV9GUkVRVUVOQ1kgKHByZWhlYWRlcik7CisgIC8qIFJlZHVjZSBsb29wIGl0 ZXJhdGlvbnMgYnkgdGhlIHZlY3Rvcml6YXRpb24gZmFjdG9yLiAgKi8KKyAg Z2Nvdl90eXBlIG5ld19lc3Rfbml0ZXIgPSBuaXRlcl9mb3JfdW5yb2xsZWRf bG9vcCAobG9vcCwgdmYpOworCisgIC8qIFVzZSBwcm9maWxpbmcgY291bnQg aW5mb3JtYXRpb24gaWYgZnJlcXVlbmNpZXMgYXJlIHplcm8uICAqLworICBp ZiAoZnJlcV9oID09IDAgfHwgZnJlcV9lID09IDApCisgICAgeworICAgICAg ZnJlcV9lID0gcHJlaGVhZGVyLT5jb3VudDsKKyAgICAgIGZyZXFfaCA9IGxv b3AtPmhlYWRlci0+Y291bnQ7CisgICAgfQorCisgIGlmIChmcmVxX2ggIT0g MCkKKyAgICB7CisgICAgICBnY292X3R5cGUgc2NhbGU7CisgICAgICAvKiBU aGlzIHNob3VsZCBub3Qgb3ZlcmZsb3cuICAqLworICAgICAgc2NhbGUgPSBH Q09WX0NPTVBVVEVfU0NBTEUgKGZyZXFfZSAqIChuZXdfZXN0X25pdGVyICsg MSksIGZyZXFfaCk7CisgICAgICBzY2FsZV9sb29wX2ZyZXF1ZW5jaWVzIChs b29wLCBzY2FsZSwgUkVHX0JSX1BST0JfQkFTRSk7CisgICAgfQorCisgIGJh c2ljX2Jsb2NrIGV4aXRfYmIgPSBzaW5nbGVfcHJlZCAobG9vcC0+bGF0Y2gp OworICBlZGdlIGV4aXRfZSA9IHNpbmdsZV9leGl0IChsb29wKTsKKyAgZXhp dF9lLT5jb3VudCA9IGxvb3BfcHJlaGVhZGVyX2VkZ2UgKGxvb3ApLT5jb3Vu dDsKKyAgZXhpdF9lLT5wcm9iYWJpbGl0eSA9IFJFR19CUl9QUk9CX0JBU0Ug LyAobmV3X2VzdF9uaXRlciArIDEpOworCisgIGVkZ2UgZXhpdF9sID0gc2lu Z2xlX3ByZWRfZWRnZSAobG9vcC0+bGF0Y2gpOworICBpbnQgcHJvYiA9IGV4 aXRfbC0+cHJvYmFiaWxpdHk7CisgIGV4aXRfbC0+cHJvYmFiaWxpdHkgPSBS RUdfQlJfUFJPQl9CQVNFIC0gZXhpdF9lLT5wcm9iYWJpbGl0eTsKKyAgZXhp dF9sLT5jb3VudCA9IGV4aXRfYmItPmNvdW50IC0gZXhpdF9lLT5jb3VudDsK KyAgaWYgKGV4aXRfbC0+Y291bnQgPCAwKQorICAgIGV4aXRfbC0+Y291bnQg PSAwOworICBpZiAocHJvYiA+IDApCisgICAgc2NhbGVfYmJzX2ZyZXF1ZW5j aWVzX2ludCAoJmxvb3AtPmxhdGNoLCAxLCBleGl0X2wtPnByb2JhYmlsaXR5 LCBwcm9iKTsKK30KKwogLyogRnVuY3Rpb24gdmVjdF90cmFuc2Zvcm1fbG9v cC4KIAogICAgVGhlIGFuYWx5c2lzIHBoYXNlIGhhcyBkZXRlcm1pbmVkIHRo YXQgdGhlIGxvb3AgaXMgdmVjdG9yaXphYmxlLgpAQCAtNjc0MywxNiArNjc4 NSwxMCBAQCB2ZWN0X3RyYW5zZm9ybV9sb29wIChsb29wX3ZlY19pbmZvIGxv b3BfdmluZm8pCiAgIGJvb2wgdHJhbnNmb3JtX3BhdHRlcm5fc3RtdCA9IGZh bHNlOwogICBib29sIGNoZWNrX3Byb2ZpdGFiaWxpdHkgPSBmYWxzZTsKICAg aW50IHRoOwotICAvKiBSZWNvcmQgbnVtYmVyIG9mIGl0ZXJhdGlvbnMgYmVm b3JlIHdlIHN0YXJ0ZWQgdGFtcGVyaW5nIHdpdGggdGhlIHByb2ZpbGUuICov Ci0gIGdjb3ZfdHlwZSBleHBlY3RlZF9pdGVyYXRpb25zID0gZXhwZWN0ZWRf bG9vcF9pdGVyYXRpb25zX3VuYm91bmRlZCAobG9vcCk7CiAKICAgaWYgKGR1 bXBfZW5hYmxlZF9wICgpKQogICAgIGR1bXBfcHJpbnRmX2xvYyAoTVNHX05P VEUsIHZlY3RfbG9jYXRpb24sICI9PT0gdmVjX3RyYW5zZm9ybV9sb29wID09 PVxuIik7CiAKLSAgLyogSWYgcHJvZmlsZSBpcyBpbnByZWNpc2UsIHdlIGhh dmUgY2hhbmNlIHRvIGZpeCBpdCB1cC4gICovCi0gIGlmIChMT09QX1ZJTkZP X05JVEVSU19LTk9XTl9QIChsb29wX3ZpbmZvKSkKLSAgICBleHBlY3RlZF9p dGVyYXRpb25zID0gTE9PUF9WSU5GT19JTlRfTklURVJTIChsb29wX3ZpbmZv KTsKLQogICAvKiBVc2UgdGhlIG1vcmUgY29uc2VydmF0aXZlIHZlY3Rvcml6 YXRpb24gdGhyZXNob2xkLiAgSWYgdGhlIG51bWJlcgogICAgICBvZiBpdGVy YXRpb25zIGlzIGNvbnN0YW50IGFzc3VtZSB0aGUgY29zdCBjaGVjayBoYXMg YmVlbiBwZXJmb3JtZWQKICAgICAgYnkgb3VyIGNhbGxlci4gIElmIHRoZSB0 aHJlc2hvbGQgbWFrZXMgYWxsIGxvb3BzIHByb2ZpdGFibGUgdGhhdApAQCAt NzA2OCw5ICs3MTA0LDggQEAgdmVjdF90cmFuc2Zvcm1fbG9vcCAobG9vcF92 ZWNfaW5mbyBsb29wX3ZpbmZvKQogCiAgIHNscGVlbF9tYWtlX2xvb3BfaXRl cmF0ZV9udGltZXMgKGxvb3AsIG5pdGVyc192ZWN0b3IpOwogCi0gIC8qIFJl ZHVjZSBsb29wIGl0ZXJhdGlvbnMgYnkgdGhlIHZlY3Rvcml6YXRpb24gZmFj dG9yLiAgKi8KLSAgc2NhbGVfbG9vcF9wcm9maWxlIChsb29wLCBHQ09WX0NP TVBVVEVfU0NBTEUgKDEsIHZmKSwKLQkJICAgICAgZXhwZWN0ZWRfaXRlcmF0 aW9ucyAvIHZmKTsKKyAgc2NhbGVfcHJvZmlsZV9mb3JfdmVjdF9sb29wIChs b29wLCB2Zik7CisKICAgLyogVGhlIG1pbmltdW0gbnVtYmVyIG9mIGl0ZXJh dGlvbnMgcGVyZm9ybWVkIGJ5IHRoZSBlcGlsb2d1ZS4gIFRoaXMKICAgICAg aXMgMSB3aGVuIHBlZWxpbmcgZm9yIGdhcHMgYmVjYXVzZSB3ZSBhbHdheXMg bmVlZCBhIGZpbmFsIHNjYWxhcgogICAgICBpdGVyYXRpb24uICAqLwo= --001a114e56eca3d8e705490b76e8--