From debbugs-submit-bounces@debbugs.gnu.org Thu Jul 11 10:06:01 2019 Received: (at submit) by debbugs.gnu.org; 11 Jul 2019 14:06:01 +0000 Received: from localhost ([127.0.0.1]:38271 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hlZhx-0001js-0P for submit@debbugs.gnu.org; Thu, 11 Jul 2019 10:06:01 -0400 Received: from lists.gnu.org ([209.51.188.17]:37603) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hlZht-0001jk-TD for submit@debbugs.gnu.org; Thu, 11 Jul 2019 10:05:59 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:55104) by lists.gnu.org with esmtp (Exim 4.86_2) (envelope-from ) id 1hlZhr-000845-Ge for bug-gnu-emacs@gnu.org; Thu, 11 Jul 2019 10:05:57 -0400 X-Spam-Checker-Version: SpamAssassin 3.3.2 (2011-06-06) on eggs.gnu.org X-Spam-Level: X-Spam-Status: No, score=0.8 required=5.0 tests=BAYES_50,FREEMAIL_FROM autolearn=disabled version=3.3.2 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1hlZho-0008P0-12 for bug-gnu-emacs@gnu.org; Thu, 11 Jul 2019 10:05:54 -0400 Received: from mail-ot1-x32c.google.com ([2607:f8b0:4864:20::32c]:42000) by eggs.gnu.org with esmtps (TLS1.0:RSA_AES_128_CBC_SHA1:16) (Exim 4.71) (envelope-from ) id 1hlZhn-0008Nx-GG for bug-gnu-emacs@gnu.org; Thu, 11 Jul 2019 10:05:51 -0400 Received: by mail-ot1-x32c.google.com with SMTP id l15so5950108otn.9 for ; Thu, 11 Jul 2019 07:05:51 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:from:date:message-id:subject:to; bh=ovEVak1eBLBW1iSQJzbXdan5pWh0QbGswETkc8KiVEc=; b=aBsx35gDTvUnIPODhoRlAc8d9JCfqzXML2E3xZ12709Xb6bjt7Pht2ozZRvW5ggFLz AtrUIfKA6w9/XIOLW/BbeNUZiewMfKeXgAAxSe72pN4nBPoL6k1gQlffN+2GCOf7j08Y z7f0pA7HN2y8RLOPnWOmhUKHbt51/4qO7Ta/vBIYbw55t3ab9mq9pwc6DUtI2EKHE1S2 Q69Wd7VV3EGqeqkuPNwOZcYkERhM7WP9tiMXIMUhfzCjM2rKAsQbABHYrL5AT5i208NM vbXfu2OSQ++NVKndafXUHdjqm5c/M8f3OPVQiwXOChotlmsb3Z/QBUEXDXQLl+qOyqRP FoVg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:from:date:message-id:subject:to; bh=ovEVak1eBLBW1iSQJzbXdan5pWh0QbGswETkc8KiVEc=; b=EycjjDTY2Prz2iQ596Z2wKLIZ4YpundLUHMJiE4KzozKbqVIFTKq+f11rVp6wM8FLm SjAkr7ipbHkr5F5O4lon+hsPGY4Cu1ScXe8UG3iYwU8C7z65Bg3FWUNKzx0/aT1zp+Us qyP/eiIp2XmKo12aladRm2hNgFVVCLJ3UXe+QiS1i9FdDeEbwcTsl38Gobb5dPq8/aNq 5paUchybZs5oGD5mNd3zRLFIfpAbpM57L3AmFRawXUn6d1FfDfjGQ6BKpg2cTIpr18sE HaHRMTsh4yeEauDMMey2edgbdtYpV+2dVHJ+Px/XDTbW/8F/TvD+Av19IEAAQncnjvZh nElw== X-Gm-Message-State: APjAAAV9VlXzf6Ksbhvd/jwyZ/kuw8nmP6K3WeJEofdZGBn9IHxdO7Jz gzZiY6SeVLLG2T02bpvZTCRCoHUUAedO9hP76ML9v2Mg X-Google-Smtp-Source: APXvYqxLASWlFOY3gGBFPIEnUl8xm4NZW0VhH0xA9ZbAHFhVv2b3HOCnRxEVzD8b+Nm9Vf1YMgR98CYVWs9BVSxkyAc= X-Received: by 2002:a9d:7284:: with SMTP id t4mr3804844otj.154.1562853950384; Thu, 11 Jul 2019 07:05:50 -0700 (PDT) MIME-Version: 1.0 From: Pip Cet Date: Thu, 11 Jul 2019 14:05:14 +0000 Message-ID: Subject: 27.0.50; rehash hash tables eagerly in pdumper To: bug-gnu-emacs@gnu.org, Daniel Colascione Content-Type: multipart/mixed; boundary="0000000000008cb6d5058d684ade" X-detected-operating-system: by eggs.gnu.org: Genre and OS details not recognized. X-Received-From: 2607:f8b0:4864:20::32c X-Spam-Score: -1.3 (-) X-Debbugs-Envelope-To: submit X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -2.3 (--) --0000000000008cb6d5058d684ade Content-Type: text/plain; charset="UTF-8" This is a follow-up to bug#36447, which has been fixed. Lazy rehashing for hash tables should be removed. This patch does that. Lazy rehashing makes all code that accesses hash tables a little more complicated; in at least one case, we forgot to do that, resulting in bug#36596. The sole benefit of lazy rehashing to be mentioned so far is that start-up time is reduced a little (by less than a millisecond on this system), and that for certain usage patterns (many short Emacs sessions that don't do very much, I think), this might outweigh the negative consequences of lazy rehashing. Lazy rehashing means less maintainable code, more code, and, at run-time, slightly slower code. In particular, it means that we have to have a comment in lisp.h which distracts from the code and has to be marked as "IMPORTANT!!!!!!!", which I think is nearly as annoying as having to jump through special hoops before accessing a hash table. I'm posting this as a separate bug so we can have a, hopefully, brief discussion about it and then either move away from lazy rehashing or continue using it; if we decide to continue using it, it should be documented in much more detail. (We should keep in mind that conditional branches, even ones that are well-predicted and don't cause cache misses, aren't free: they use execution units, and preparing their arguments in registers increases register pressure, and of course they increase code size.) --0000000000008cb6d5058d684ade Content-Type: text/x-patch; charset="US-ASCII"; name="0001-Rehash-hash-tables-eagerly-after-loading-a-portable-.patch" Content-Disposition: attachment; filename="0001-Rehash-hash-tables-eagerly-after-loading-a-portable-.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_jxyqt0420 RnJvbSAyZGIzOTY0ZjJkODI5MGI5MDViMmQyMGUyYTYyZmIwNzNmZWMxMzgyIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBQaXAgQ2V0IDxwaXBjZXRAZ21haWwuY29tPgpEYXRlOiBUaHUs IDExIEp1bCAyMDE5IDEyOjA2OjU5ICswMDAwClN1YmplY3Q6IFtQQVRDSF0gUmVoYXNoIGhhc2gg dGFibGVzIGVhZ2VybHkgYWZ0ZXIgbG9hZGluZyBhIHBvcnRhYmxlIGR1bXAKCiogc3JjL2xpc3Au aCAoaGFzaF9yZWhhc2hfbmVlZGVkX3ApOiBSZW1vdmUuICBBbGwgdXNlcyByZW1vdmVkLgooaGFz aF9yZWhhc2hfaWZfbmVlZGVkKTogUmVtb3ZlLiAgQWxsIHVzZXMgcmVtb3ZlZC4KKHN0cnVjdCBM aXNwX0hhc2hfVGFibGUpOiBSZW1vdmUgY29tbWVudCBhYm91dCByZWhhc2hpbmcgaGFzaCB0YWJs ZXMuCiogc3JjL3BkdW1wZXIuYyAodGhhd19oYXNoX3RhYmxlcyk6IE5ldyBmdW5jdGlvbi4KKGhh c2hfdGFibGVfdGhhdyk6IE5ldyBmdW5jdGlvbi4KKGhhc2hfdGFibGVfZnJlZXplKTogTmV3IGZ1 bmN0aW9uLgooZHVtcF9oYXNoX3RhYmxlKTogU2ltcGxpZnkuCihkdW1wX2hhc2hfdGFibGVfbGlz dCk6IE5ldyBmdW5jdGlvbi4KKGhhc2hfdGFibGVfY29udGVudHMpOiBOZXcgZnVuY3Rpb24uCihG ZHVtcF9lbWFjc19wb3J0YWJsZSk6IEhhbmRsZSBoYXNoIHRhYmxlcyBieSBlYWdlciByZWhhc2hp bmcuCihwZHVtcGVyX2xvYWQpOiBSZXN0b3JlIGhhc2ggdGFibGVzLgooaW5pdF9wZHVtcGVyX29u Y2UpOiBOZXcgZnVuY3Rpb24uCi0tLQogc3JjL2J5dGVjb2RlLmMgIHwgICAxIC0KIHNyYy9jb21w b3NpdGUuYyB8ICAgMSAtCiBzcmMvZW1hY3MuYyAgICAgfCAgIDEgKwogc3JjL2Zucy5jICAgICAg IHwgIDUzICsrKystLS0tLS0tLS0tLQogc3JjL2xpc3AuaCAgICAgIHwgIDE5ICstLS0tLQogc3Jj L21pbmlidWYuYyAgIHwgICAzIC0KIHNyYy9wZHVtcGVyLmMgICB8IDE3NyArKysrKysrKysrKysr KysrKysrKysrKysrLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIHNyYy9wZHVtcGVyLmggICB8ICAg MSArCiA4IGZpbGVzIGNoYW5nZWQsIDEwOCBpbnNlcnRpb25zKCspLCAxNDggZGVsZXRpb25zKC0p CgpkaWZmIC0tZ2l0IGEvc3JjL2J5dGVjb2RlLmMgYi9zcmMvYnl0ZWNvZGUuYwppbmRleCAyOWRm ZjQ0ZjAwLi45YzcyNDI5ZTBjIDEwMDY0NAotLS0gYS9zcmMvYnl0ZWNvZGUuYworKysgYi9zcmMv Ynl0ZWNvZGUuYwpAQCAtMTQwMiw3ICsxNDAyLDYgQEAgI2RlZmluZSBERUZJTkUobmFtZSwgdmFs dWUpIExBQkVMIChuYW1lKSAsCiAgICAgICAgICAgICBMaXNwX09iamVjdCB2MSA9IFBPUDsKICAg ICAgICAgICAgIHB0cmRpZmZfdCBpOwogICAgICAgICAgICAgc3RydWN0IExpc3BfSGFzaF9UYWJs ZSAqaCA9IFhIQVNIX1RBQkxFIChqbXBfdGFibGUpOwotICAgICAgICAgICAgaGFzaF9yZWhhc2hf aWZfbmVlZGVkIChoKTsKIAogICAgICAgICAgICAgLyogaC0+Y291bnQgaXMgYSBmYXN0ZXIgYXBw cm94aW1hdGlvbiBmb3IgSEFTSF9UQUJMRV9TSVpFIChoKQogICAgICAgICAgICAgICAgaGVyZS4g Ki8KZGlmZiAtLWdpdCBhL3NyYy9jb21wb3NpdGUuYyBiL3NyYy9jb21wb3NpdGUuYwppbmRleCAx ODMwNjJkZTQ2Li40OWEyODVjZmYwIDEwMDY0NAotLS0gYS9zcmMvY29tcG9zaXRlLmMKKysrIGIv c3JjL2NvbXBvc2l0ZS5jCkBAIC02NTQsNyArNjU0LDYgQEAgZ3N0cmluZ19sb29rdXBfY2FjaGUg KExpc3BfT2JqZWN0IGhlYWRlcikKIGNvbXBvc2l0aW9uX2dzdHJpbmdfcHV0X2NhY2hlIChMaXNw X09iamVjdCBnc3RyaW5nLCBwdHJkaWZmX3QgbGVuKQogewogICBzdHJ1Y3QgTGlzcF9IYXNoX1Rh YmxlICpoID0gWEhBU0hfVEFCTEUgKGdzdHJpbmdfaGFzaF90YWJsZSk7Ci0gIGhhc2hfcmVoYXNo X2lmX25lZWRlZCAoaCk7CiAgIExpc3BfT2JqZWN0IGhlYWRlciA9IExHU1RSSU5HX0hFQURFUiAo Z3N0cmluZyk7CiAgIEVNQUNTX1VJTlQgaGFzaCA9IGgtPnRlc3QuaGFzaGZuICgmaC0+dGVzdCwg aGVhZGVyKTsKICAgaWYgKGxlbiA8IDApCmRpZmYgLS1naXQgYS9zcmMvZW1hY3MuYyBiL3NyYy9l bWFjcy5jCmluZGV4IDljOTM3NDhhMGYuLjEzNjIzNmViMzUgMTAwNjQ0Ci0tLSBhL3NyYy9lbWFj cy5jCisrKyBiL3NyYy9lbWFjcy5jCkBAIC0xNTYwLDYgKzE1NjAsNyBAQCBtYWluIChpbnQgYXJn YywgY2hhciAqKmFyZ3YpCiAgIGlmICghaW5pdGlhbGl6ZWQpCiAgICAgewogICAgICAgaW5pdF9h bGxvY19vbmNlICgpOworICAgICAgaW5pdF9wZHVtcGVyX29uY2UgKCk7CiAgICAgICBpbml0X29i YXJyYXlfb25jZSAoKTsKICAgICAgIGluaXRfZXZhbF9vbmNlICgpOwogICAgICAgaW5pdF9jaGFy c2V0X29uY2UgKCk7CmRpZmYgLS1naXQgYS9zcmMvZm5zLmMgYi9zcmMvZm5zLmMKaW5kZXggNzM0 MzU1NmFjMi4uNDIwZDg5OGIyNiAxMDA2NDQKLS0tIGEvc3JjL2Zucy5jCisrKyBiL3NyYy9mbnMu YwpAQCAtNDIyNCw0MyArNDIyNCwyNCBAQCBoYXNoX3RhYmxlX3JlaGFzaCAoc3RydWN0IExpc3Bf SGFzaF9UYWJsZSAqaCkKIHsKICAgcHRyZGlmZl90IHNpemUgPSBIQVNIX1RBQkxFX1NJWkUgKGgp OwogCi0gIC8qIFRoZXNlIHN0cnVjdHVyZXMgbWF5IGhhdmUgYmVlbiBwdXJlY29waWVkIGFuZCBz aGFyZWQKLSAgICAgKGJ1ZyMzNjQ0NykuICAqLwotICBoLT5uZXh0ID0gRmNvcHlfc2VxdWVuY2Ug KGgtPm5leHQpOwotICBoLT5pbmRleCA9IEZjb3B5X3NlcXVlbmNlIChoLT5pbmRleCk7Ci0gIGgt Pmhhc2ggPSBGY29weV9zZXF1ZW5jZSAoaC0+aGFzaCk7Ci0KICAgLyogUmVjb21wdXRlIHRoZSBh Y3R1YWwgaGFzaCBjb2RlcyBmb3IgZWFjaCBlbnRyeSBpbiB0aGUgdGFibGUuCiAgICAgIE9yZGVy IGlzIHN0aWxsIGludmFsaWQuICAqLwogICBmb3IgKHB0cmRpZmZfdCBpID0gMDsgaSA8IHNpemU7 ICsraSkKLSAgICBpZiAoIU5JTFAgKEhBU0hfSEFTSCAoaCwgaSkpKQotICAgICAgewotICAgICAg ICBMaXNwX09iamVjdCBrZXkgPSBIQVNIX0tFWSAoaCwgaSk7Ci0gICAgICAgIEVNQUNTX1VJTlQg aGFzaF9jb2RlID0gaC0+dGVzdC5oYXNoZm4gKCZoLT50ZXN0LCBrZXkpOwotICAgICAgICBzZXRf aGFzaF9oYXNoX3Nsb3QgKGgsIGksIG1ha2VfZml4bnVtIChoYXNoX2NvZGUpKTsKLSAgICAgIH0K LQotICAvKiBSZXNldCB0aGUgaW5kZXggc28gdGhhdCBhbnkgc2xvdCB3ZSBkb24ndCBmaWxsIGJl bG93IGlzIG1hcmtlZAotICAgICBpbnZhbGlkLiAgKi8KLSAgRmZpbGxhcnJheSAoaC0+aW5kZXgs IG1ha2VfZml4bnVtICgtMSkpOworICAgIHsKKyAgICAgIExpc3BfT2JqZWN0IGtleSA9IEhBU0hf S0VZIChoLCBpKTsKKyAgICAgIEVNQUNTX1VJTlQgaGFzaF9jb2RlID0gaC0+dGVzdC5oYXNoZm4g KCZoLT50ZXN0LCBrZXkpOworICAgICAgc2V0X2hhc2hfaGFzaF9zbG90IChoLCBpLCBtYWtlX2Zp eG51bSAoaGFzaF9jb2RlKSk7CisgICAgfQogCiAgIC8qIFJlYnVpbGQgdGhlIGNvbGxpc2lvbiBj aGFpbnMuICAqLwogICBmb3IgKHB0cmRpZmZfdCBpID0gMDsgaSA8IHNpemU7ICsraSkKLSAgICBp ZiAoIU5JTFAgKEhBU0hfSEFTSCAoaCwgaSkpKQotICAgICAgewotICAgICAgICBFTUFDU19VSU5U IGhhc2hfY29kZSA9IFhVRklYTlVNIChIQVNIX0hBU0ggKGgsIGkpKTsKLSAgICAgICAgcHRyZGlm Zl90IHN0YXJ0X29mX2J1Y2tldCA9IGhhc2hfY29kZSAlIEFTSVpFIChoLT5pbmRleCk7Ci0gICAg ICAgIHNldF9oYXNoX25leHRfc2xvdCAoaCwgaSwgSEFTSF9JTkRFWCAoaCwgc3RhcnRfb2ZfYnVj a2V0KSk7Ci0gICAgICAgIHNldF9oYXNoX2luZGV4X3Nsb3QgKGgsIHN0YXJ0X29mX2J1Y2tldCwg aSk7Ci0gICAgICAgIGVhc3NlcnQgKEhBU0hfTkVYVCAoaCwgaSkgIT0gaSk7IC8qIFN0b3AgbG9v cHMuICAqLwotICAgICAgfQotCi0gIC8qIEZpbmFsbHksIG1hcmsgdGhlIGhhc2ggdGFibGUgYXMg aGF2aW5nIGEgdmFsaWQgaGFzaCBvcmRlci4KLSAgICAgRG8gdGhpcyBsYXN0IHNvIHRoYXQgaWYg d2UncmUgaW50ZXJydXB0ZWQsIHdlIHJldHJ5IG9uIG5leHQKLSAgICAgYWNjZXNzLiAqLwotICBl YXNzZXJ0IChoLT5jb3VudCA8IDApOwotICBoLT5jb3VudCA9IC1oLT5jb3VudDsKLSAgZWFzc2Vy dCAoIWhhc2hfcmVoYXNoX25lZWRlZF9wIChoKSk7CisgICAgeworICAgICAgRU1BQ1NfVUlOVCBo YXNoX2NvZGUgPSBYVUZJWE5VTSAoSEFTSF9IQVNIIChoLCBpKSk7CisgICAgICBwdHJkaWZmX3Qg c3RhcnRfb2ZfYnVja2V0ID0gaGFzaF9jb2RlICUgQVNJWkUgKGgtPmluZGV4KTsKKyAgICAgIHNl dF9oYXNoX25leHRfc2xvdCAoaCwgaSwgSEFTSF9JTkRFWCAoaCwgc3RhcnRfb2ZfYnVja2V0KSk7 CisgICAgICBzZXRfaGFzaF9pbmRleF9zbG90IChoLCBzdGFydF9vZl9idWNrZXQsIGkpOworICAg ICAgZWFzc2VydCAoSEFTSF9ORVhUIChoLCBpKSAhPSBpKTsgLyogU3RvcCBsb29wcy4gICovCisg ICAgfQogfQogCiAvKiBMb29rdXAgS0VZIGluIGhhc2ggdGFibGUgSC4gIElmIEhBU0ggaXMgbm9u LW51bGwsIHJldHVybiBpbiAqSEFTSApAQCAtNDI3Myw4ICs0MjU0LDYgQEAgaGFzaF9sb29rdXAg KHN0cnVjdCBMaXNwX0hhc2hfVGFibGUgKmgsIExpc3BfT2JqZWN0IGtleSwgRU1BQ1NfVUlOVCAq aGFzaCkKICAgRU1BQ1NfVUlOVCBoYXNoX2NvZGU7CiAgIHB0cmRpZmZfdCBzdGFydF9vZl9idWNr ZXQsIGk7CiAKLSAgaGFzaF9yZWhhc2hfaWZfbmVlZGVkIChoKTsKLQogICBoYXNoX2NvZGUgPSBo LT50ZXN0Lmhhc2hmbiAoJmgtPnRlc3QsIGtleSk7CiAgIGVhc3NlcnQgKChoYXNoX2NvZGUgJiB+ SU5UTUFTSykgPT0gMCk7CiAgIGlmIChoYXNoKQpAQCAtNDMwMyw4ICs0MjgyLDYgQEAgaGFzaF9w dXQgKHN0cnVjdCBMaXNwX0hhc2hfVGFibGUgKmgsIExpc3BfT2JqZWN0IGtleSwgTGlzcF9PYmpl Y3QgdmFsdWUsCiB7CiAgIHB0cmRpZmZfdCBzdGFydF9vZl9idWNrZXQsIGk7CiAKLSAgaGFzaF9y ZWhhc2hfaWZfbmVlZGVkIChoKTsKLQogICBlYXNzZXJ0ICgoaGFzaCAmIH5JTlRNQVNLKSA9PSAw KTsKIAogICAvKiBJbmNyZW1lbnQgY291bnQgYWZ0ZXIgcmVzaXppbmcgYmVjYXVzZSByZXNpemlu ZyBtYXkgZmFpbC4gICovCkBAIC00MzM4LDggKzQzMTUsNiBAQCBoYXNoX3JlbW92ZV9mcm9tX3Rh YmxlIChzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICpoLCBMaXNwX09iamVjdCBrZXkpCiAgIHB0cmRp ZmZfdCBzdGFydF9vZl9idWNrZXQgPSBoYXNoX2NvZGUgJSBBU0laRSAoaC0+aW5kZXgpOwogICBw dHJkaWZmX3QgcHJldiA9IC0xOwogCi0gIGhhc2hfcmVoYXNoX2lmX25lZWRlZCAoaCk7Ci0KICAg Zm9yIChwdHJkaWZmX3QgaSA9IEhBU0hfSU5ERVggKGgsIHN0YXJ0X29mX2J1Y2tldCk7CiAgICAg ICAgMCA8PSBpOwogICAgICAgIGkgPSBIQVNIX05FWFQgKGgsIGkpKQpAQCAtNDQxNyw5ICs0Mzky LDcgQEAgc3dlZXBfd2Vha190YWJsZSAoc3RydWN0IExpc3BfSGFzaF9UYWJsZSAqaCwgYm9vbCBy ZW1vdmVfZW50cmllc19wKQogICBmb3IgKHB0cmRpZmZfdCBidWNrZXQgPSAwOyBidWNrZXQgPCBu OyArK2J1Y2tldCkKICAgICB7CiAgICAgICAvKiBGb2xsb3cgY29sbGlzaW9uIGNoYWluLCByZW1v dmluZyBlbnRyaWVzIHRoYXQgZG9uJ3Qgc3Vydml2ZQotICAgICAgICAgdGhpcyBnYXJiYWdlIGNv bGxlY3Rpb24uICBJdCdzIG9rYXkgaWYgaGFzaF9yZWhhc2hfbmVlZGVkX3AKLSAgICAgICAgICho KSBpcyB0cnVlLCBzaW5jZSB3ZSdyZSBvcGVyYXRpbmcgZW50aXJlbHkgb24gdGhlIGNhY2hlZAot ICAgICAgICAgaGFzaCB2YWx1ZXMuICovCisgICAgICAgICB0aGlzIGdhcmJhZ2UgY29sbGVjdGlv bi4gICovCiAgICAgICBwdHJkaWZmX3QgcHJldiA9IC0xOwogICAgICAgcHRyZGlmZl90IG5leHQ7 CiAgICAgICBmb3IgKHB0cmRpZmZfdCBpID0gSEFTSF9JTkRFWCAoaCwgYnVja2V0KTsgMCA8PSBp OyBpID0gbmV4dCkKZGlmZiAtLWdpdCBhL3NyYy9saXNwLmggYi9zcmMvbGlzcC5oCmluZGV4IGZh NTdjYWQ4YTYuLmNjMGUxYmNlNTEgMTAwNjQ0Ci0tLSBhL3NyYy9saXNwLmgKKysrIGIvc3JjL2xp c3AuaApAQCAtMjIzNiwxMSArMjIzNiw3IEBAICNkZWZpbmUgREVGU1lNKHN5bSwgbmFtZSkgLyog ZW1wdHkgKi8KIAogc3RydWN0IExpc3BfSGFzaF9UYWJsZQogewotICAvKiBDaGFuZ2UgcGR1bXBl ci5jIGlmIHlvdSBjaGFuZ2UgdGhlIGZpZWxkcyBoZXJlLgotCi0gICAgIElNUE9SVEFOVCEhISEh ISEKLQotICAgICBDYWxsIGhhc2hfcmVoYXNoX2lmX25lZWRlZCgpIGJlZm9yZSBhY2Nlc3Npbmcu ICAqLworICAvKiBDaGFuZ2UgcGR1bXBlci5jIGlmIHlvdSBjaGFuZ2UgdGhlIGZpZWxkcyBoZXJl LiAgKi8KIAogICAvKiBUaGlzIGlzIGZvciBMaXNwOyB0aGUgaGFzaCB0YWJsZSBjb2RlIGRvZXMg bm90IHJlZmVyIHRvIGl0LiAgKi8KICAgdW5pb24gdmVjdG9ybGlrZV9oZWFkZXIgaGVhZGVyOwpA QCAtMjM1MywxOSArMjM0OSw2IEBAIEhBU0hfVEFCTEVfU0laRSAoY29uc3Qgc3RydWN0IExpc3Bf SGFzaF9UYWJsZSAqaCkKIAogdm9pZCBoYXNoX3RhYmxlX3JlaGFzaCAoc3RydWN0IExpc3BfSGFz aF9UYWJsZSAqaCk7CiAKLUlOTElORSBib29sCi1oYXNoX3JlaGFzaF9uZWVkZWRfcCAoY29uc3Qg c3RydWN0IExpc3BfSGFzaF9UYWJsZSAqaCkKLXsKLSAgcmV0dXJuIGgtPmNvdW50IDwgMDsKLX0K LQotSU5MSU5FIHZvaWQKLWhhc2hfcmVoYXNoX2lmX25lZWRlZCAoc3RydWN0IExpc3BfSGFzaF9U YWJsZSAqaCkKLXsKLSAgaWYgKGhhc2hfcmVoYXNoX25lZWRlZF9wIChoKSkKLSAgICBoYXNoX3Rh YmxlX3JlaGFzaCAoaCk7Ci19Ci0KIC8qIERlZmF1bHQgc2l6ZSBmb3IgaGFzaCB0YWJsZXMgaWYg bm90IHNwZWNpZmllZC4gICovCiAKIGVudW0gREVGQVVMVF9IQVNIX1NJWkUgeyBERUZBVUxUX0hB U0hfU0laRSA9IDY1IH07CmRpZmYgLS1naXQgYS9zcmMvbWluaWJ1Zi5jIGIvc3JjL21pbmlidWYu YwppbmRleCBkOWE2ZTE1YjA1Li5lOTIzY2UyYTQzIDEwMDY0NAotLS0gYS9zcmMvbWluaWJ1Zi5j CisrKyBiL3NyYy9taW5pYnVmLmMKQEAgLTEyMDMsOSArMTIwMyw2IEBAIERFRlVOICgidHJ5LWNv bXBsZXRpb24iLCBGdHJ5X2NvbXBsZXRpb24sIFN0cnlfY29tcGxldGlvbiwgMiwgMywgMCwKICAg ICAgIGJ1Y2tldCA9IEFSRUYgKGNvbGxlY3Rpb24sIGlkeCk7CiAgICAgfQogCi0gIGlmIChIQVNI X1RBQkxFX1AgKGNvbGxlY3Rpb24pKQotICAgIGhhc2hfcmVoYXNoX2lmX25lZWRlZCAoWEhBU0hf VEFCTEUgKGNvbGxlY3Rpb24pKTsKLQogICB3aGlsZSAoMSkKICAgICB7CiAgICAgICAvKiBHZXQg dGhlIG5leHQgZWxlbWVudCBvZiB0aGUgYWxpc3QsIG9iYXJyYXksIG9yIGhhc2gtdGFibGUuICAq LwpkaWZmIC0tZ2l0IGEvc3JjL3BkdW1wZXIuYyBiL3NyYy9wZHVtcGVyLmMKaW5kZXggM2Q4NTMx YzZhNC4uY2ZkZWI1ZWM5YiAxMDA2NDQKLS0tIGEvc3JjL3BkdW1wZXIuYworKysgYi9zcmMvcGR1 bXBlci5jCkBAIC0zOTIsNiArMzkyLDggQEAgZHVtcF9maW5nZXJwcmludCAoY29uc3QgY2hhciAq bGFiZWwsIHVuc2lnbmVkIGNoYXIgY29uc3QgKnhmaW5nZXJwcmludCkKICAgICAgVGhlIHN0YXJ0 IG9mIHRoZSBjb2xkIHJlZ2lvbiBpcyBhbHdheXMgYWxpZ25lZCBvbiBhIHBhZ2UKICAgICAgYm91 bmRhcnkuICAqLwogICBkdW1wX29mZiBjb2xkX3N0YXJ0OworCisgIGR1bXBfb2ZmIGhhc2hfbGlz dDsKIH07CiAKIC8qIERvdWJsZS1lbmRlZCBzaW5nbHkgbGlua2VkIGxpc3QuICAqLwpAQCAtNTQ5 LDYgKzU1MSw4IEBAIGR1bXBfZmluZ2VycHJpbnQgKGNvbnN0IGNoYXIgKmxhYmVsLCB1bnNpZ25l ZCBjaGFyIGNvbnN0ICp4ZmluZ2VycHJpbnQpCiAgICAgIGhlYXAgb2JqZWN0cy4gICovCiAgIExp c3BfT2JqZWN0IGJpZ251bV9kYXRhOwogCisgIExpc3BfT2JqZWN0IGhhc2hfdGFibGVzOworCiAg IHVuc2lnbmVkIG51bWJlcl9ob3RfcmVsb2NhdGlvbnM7CiAgIHVuc2lnbmVkIG51bWJlcl9kaXNj YXJkYWJsZV9yZWxvY2F0aW9uczsKIH07CkBAIC0yNjIxLDY4ICsyNjI1LDY0IEBAIGR1bXBfdmVj dG9ybGlrZV9nZW5lcmljIChzdHJ1Y3QgZHVtcF9jb250ZXh0ICpjdHgsCiAgIHJldHVybiBvZmZz ZXQ7CiB9CiAKLS8qIERldGVybWluZSB3aGV0aGVyIHRoZSBoYXNoIHRhYmxlJ3MgaGFzaCBvcmRl ciBpcyBzdGFibGUKLSAgIGFjcm9zcyBkdW1wIGFuZCBsb2FkLiAgSWYgaXQgaXMsIHdlIGRvbid0 IGhhdmUgdG8gdHJpZ2dlcgotICAgYSByZWhhc2ggb24gYWNjZXNzLiAgKi8KLXN0YXRpYyBib29s Ci1kdW1wX2hhc2hfdGFibGVfc3RhYmxlX3AgKGNvbnN0IHN0cnVjdCBMaXNwX0hhc2hfVGFibGUg Kmhhc2gpCisvKiBSZXR1cm4gYSBsaXN0IG9mIChLRVkgLiBWQUxVRSkgcGFpcnMgaW4gdGhlIGdp dmVuIGhhc2ggdGFibGUuICAqLworc3RhdGljIExpc3BfT2JqZWN0CitoYXNoX3RhYmxlX2NvbnRl bnRzIChzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICpoKQogewotICBib29sIGlzX2VxbCA9IGhhc2gt PnRlc3QuaGFzaGZuID09IGhhc2hmbl9lcWw7Ci0gIGJvb2wgaXNfZXF1YWwgPSBoYXNoLT50ZXN0 Lmhhc2hmbiA9PSBoYXNoZm5fZXF1YWw7Ci0gIHB0cmRpZmZfdCBzaXplID0gSEFTSF9UQUJMRV9T SVpFIChoYXNoKTsKLSAgZm9yIChwdHJkaWZmX3QgaSA9IDA7IGkgPCBzaXplOyArK2kpCi0gICAg aWYgKCFOSUxQIChIQVNIX0hBU0ggKGhhc2gsIGkpKSkKKyAgTGlzcF9PYmplY3QgY29udGVudHMg PSBRbmlsOworICAvKiBNYWtlIHN1cmUga2V5X2FuZF92YWx1ZSBlbmRzIHVwIGluIHRoZSBzYW1l IG9yZGVyLCBjaGFyc2V0LmMKKyAgICAgcmVsaWVzIG9uIGl0IGJ5IGV4cGVjdGluZyBoYXNoIHRh YmxlIGluZGljZXMgdG8gc3RheSBjb25zdGFudAorICAgICBhY3Jvc3MgdGhlIGR1bXAuICAqLwor ICBmb3IgKHB0cmRpZmZfdCBpID0gSEFTSF9UQUJMRV9TSVpFIChoKSAtIDE7IGkgPj0gMDsgLS1p KQorICAgIGlmICghTklMUCAoSEFTSF9IQVNIIChoLCBpKSkpCiAgICAgICB7Ci0gICAgICAgIExp c3BfT2JqZWN0IGtleSA9ICBIQVNIX0tFWSAoaGFzaCwgaSk7Ci0JYm9vbCBrZXlfc3RhYmxlID0g KGR1bXBfYnVpbHRpbl9zeW1ib2xfcCAoa2V5KQotCQkJICAgfHwgRklYTlVNUCAoa2V5KQotCQkJ ICAgfHwgKGlzX2VxdWFsICYmIFNUUklOR1AgKGtleSkpCi0JCQkgICB8fCAoKGlzX2VxdWFsIHx8 IGlzX2VxbCkgJiYgRkxPQVRQIChrZXkpKSk7Ci0gICAgICAgIGlmICgha2V5X3N0YWJsZSkKLSAg ICAgICAgICByZXR1cm4gZmFsc2U7CisJZHVtcF9wdXNoICgmY29udGVudHMsIEhBU0hfVkFMVUUg KGgsIGkpKTsKKwlkdW1wX3B1c2ggKCZjb250ZW50cywgSEFTSF9LRVkgKGgsIGkpKTsKICAgICAg IH0KKyAgcmV0dXJuIENBTExOIChGYXBwbHksIFF2ZWN0b3IsIGNvbnRlbnRzKTsKK30KIAotICBy ZXR1cm4gdHJ1ZTsKK3N0YXRpYyBkdW1wX29mZgorZHVtcF9oYXNoX3RhYmxlX2xpc3QgKHN0cnVj dCBkdW1wX2NvbnRleHQgKmN0eCkKK3sKKyAgaWYgKENPTlNQIChjdHgtPmhhc2hfdGFibGVzKSkK KyAgICByZXR1cm4gZHVtcF9vYmplY3QgKGN0eCwgQ0FMTE4gKEZhcHBseSwgUXZlY3RvciwgY3R4 LT5oYXNoX3RhYmxlcykpOworICBlbHNlCisgICAgcmV0dXJuIDA7CiB9CiAKLS8qIFJldHVybiBh IGxpc3Qgb2YgKEtFWSAuIFZBTFVFKSBwYWlycyBpbiB0aGUgZ2l2ZW4gaGFzaCB0YWJsZS4gICov Ci1zdGF0aWMgTGlzcF9PYmplY3QKLWhhc2hfdGFibGVfY29udGVudHMgKExpc3BfT2JqZWN0IHRh YmxlKQorc3RhdGljIHZvaWQKK2hhc2hfdGFibGVfZnJlZXplIChzdHJ1Y3QgTGlzcF9IYXNoX1Rh YmxlICpoKQogewotICBMaXNwX09iamVjdCBjb250ZW50cyA9IFFuaWw7Ci0gIHN0cnVjdCBMaXNw X0hhc2hfVGFibGUgKmggPSBYSEFTSF9UQUJMRSAodGFibGUpOwotICBmb3IgKHB0cmRpZmZfdCBp ID0gMDsgaSA8IEhBU0hfVEFCTEVfU0laRSAoaCk7ICsraSkKLSAgICBpZiAoIU5JTFAgKEhBU0hf SEFTSCAoaCwgaSkpKQotICAgICAgZHVtcF9wdXNoICgmY29udGVudHMsIEZjb25zIChIQVNIX0tF WSAoaCwgaSksIEhBU0hfVkFMVUUgKGgsIGkpKSk7Ci0gIHJldHVybiBGbnJldmVyc2UgKGNvbnRl bnRzKTsKKyAgaC0+a2V5X2FuZF92YWx1ZSA9IGhhc2hfdGFibGVfY29udGVudHMgKGgpOworICBw dHJkaWZmX3QgbmtleXMgPSBYRklYTkFUIChGbGVuZ3RoIChoLT5rZXlfYW5kX3ZhbHVlKSkgLyAy OworICBoLT5jb3VudCA9IG5rZXlzOworICBpZiAobmtleXMgPT0gMCkKKyAgICBua2V5cyA9IDE7 CisgIGgtPmluZGV4ID0gaC0+bmV4dCA9IGgtPmhhc2ggPSBtYWtlX2ZpeG51bSAobmtleXMpOwog fQogCi0vKiBDb3B5IHRoZSBnaXZlbiBoYXNoIHRhYmxlLCByZWhhc2ggaXQsIGFuZCBtYWtlIHN1 cmUgdGhhdCB3ZSBjYW4KLSAgIGxvb2sgdXAgYWxsIHRoZSB2YWx1ZXMgaW4gdGhlIG9yaWdpbmFs LiAgKi8KIHN0YXRpYyB2b2lkCi1jaGVja19oYXNoX3RhYmxlX3JlaGFzaCAoTGlzcF9PYmplY3Qg dGFibGVfb3JpZykKLXsKLSAgaGFzaF9yZWhhc2hfaWZfbmVlZGVkIChYSEFTSF9UQUJMRSAodGFi bGVfb3JpZykpOwotICBMaXNwX09iamVjdCB0YWJsZV9yZWhhc2hlZCA9IEZjb3B5X2hhc2hfdGFi bGUgKHRhYmxlX29yaWcpOwotICBlYXNzZXJ0IChYSEFTSF9UQUJMRSAodGFibGVfcmVoYXNoZWQp LT5jb3VudCA+PSAwKTsKLSAgWEhBU0hfVEFCTEUgKHRhYmxlX3JlaGFzaGVkKS0+Y291bnQgKj0g LTE7Ci0gIGVhc3NlcnQgKFhIQVNIX1RBQkxFICh0YWJsZV9yZWhhc2hlZCktPmNvdW50IDw9IDAp OwotICBoYXNoX3JlaGFzaF9pZl9uZWVkZWQgKFhIQVNIX1RBQkxFICh0YWJsZV9yZWhhc2hlZCkp OwotICBlYXNzZXJ0IChYSEFTSF9UQUJMRSAodGFibGVfcmVoYXNoZWQpLT5jb3VudCA+PSAwKTsK LSAgTGlzcF9PYmplY3QgZXhwZWN0ZWRfY29udGVudHMgPSBoYXNoX3RhYmxlX2NvbnRlbnRzICh0 YWJsZV9vcmlnKTsKLSAgd2hpbGUgKCFOSUxQIChleHBlY3RlZF9jb250ZW50cykpCitoYXNoX3Rh YmxlX3RoYXcgKHN0cnVjdCBMaXNwX0hhc2hfVGFibGUgKmgpCit7CisgIExpc3BfT2JqZWN0IGNv dW50ID0gaC0+aW5kZXg7CisgIGgtPmluZGV4ID0gRm1ha2VfdmVjdG9yIChoLT5pbmRleCwgbWFr ZV9maXhudW0gKC0xKSk7CisgIGgtPmhhc2ggPSBGbWFrZV92ZWN0b3IgKGgtPmhhc2gsIFFuaWwp OworICBoLT5uZXh0ID0gRm1ha2VfdmVjdG9yIChoLT5uZXh0LCBtYWtlX2ZpeG51bSAoLTEpKTsK KyAgTGlzcF9PYmplY3Qga2V5X2FuZF92YWx1ZSA9IGgtPmtleV9hbmRfdmFsdWU7CisgIGgtPm5l eHRfZnJlZSA9IC0xOworICBpZiAoWEZJWE5BVCAoY291bnQpIDw9IDEpCiAgICAgewotICAgICAg TGlzcF9PYmplY3Qga2V5X3ZhbHVlX3BhaXIgPSBkdW1wX3BvcCAoJmV4cGVjdGVkX2NvbnRlbnRz KTsKLSAgICAgIExpc3BfT2JqZWN0IGtleSA9IFhDQVIgKGtleV92YWx1ZV9wYWlyKTsKLSAgICAg IExpc3BfT2JqZWN0IGV4cGVjdGVkX3ZhbHVlID0gWENEUiAoa2V5X3ZhbHVlX3BhaXIpOwotICAg ICAgTGlzcF9PYmplY3QgYXJiaXRyYXJ5ID0gUWR1bXBfZW1hY3NfcG9ydGFibGVfX3NvcnRfcHJl ZGljYXRlX2NvcGllZDsKLSAgICAgIExpc3BfT2JqZWN0IGZvdW5kX3ZhbHVlID0gRmdldGhhc2gg KGtleSwgdGFibGVfcmVoYXNoZWQsIGFyYml0cmFyeSk7Ci0gICAgICBlYXNzZXJ0IChFUSAoZXhw ZWN0ZWRfdmFsdWUsIGZvdW5kX3ZhbHVlKSk7Ci0gICAgICBGcmVtaGFzaCAoa2V5LCB0YWJsZV9y ZWhhc2hlZCk7CisgICAgICBoLT5rZXlfYW5kX3ZhbHVlID0gRm1ha2VfdmVjdG9yIChtYWtlX2Zp eG51bSAoMiAqIFhGSVhOQVQgKGNvdW50KSksIFFuaWwpOworICAgICAgcHRyZGlmZl90IGkgPSAw OworICAgICAgd2hpbGUgKGkgPCBBU0laRSAoa2V5X2FuZF92YWx1ZSkpCisJeworCSAgQVNFVCAo aC0+a2V5X2FuZF92YWx1ZSwgaSwgQVJFRiAoa2V5X2FuZF92YWx1ZSwgaSkpOworCSAgaSsrOwor CX0KICAgICB9CiAKLSAgZWFzc2VydCAoRVEgKEZoYXNoX3RhYmxlX2NvdW50ICh0YWJsZV9yZWhh c2hlZCksCi0gICAgICAgICAgICAgICBtYWtlX2ZpeG51bSAoMCkpKTsKKyAgaGFzaF90YWJsZV9y ZWhhc2ggKGgpOwogfQogCiBzdGF0aWMgZHVtcF9vZmYKQEAgLTI2OTQsNDUgKzI2OTQsMTEgQEAg ZHVtcF9oYXNoX3RhYmxlIChzdHJ1Y3QgZHVtcF9jb250ZXh0ICpjdHgsCiAjIGVycm9yICJMaXNw X0hhc2hfVGFibGUgY2hhbmdlZC4gU2VlIENIRUNLX1NUUlVDVFMgY29tbWVudCBpbiBjb25maWcu aC4iCiAjZW5kaWYKICAgY29uc3Qgc3RydWN0IExpc3BfSGFzaF9UYWJsZSAqaGFzaF9pbiA9IFhI QVNIX1RBQkxFIChvYmplY3QpOwotICBib29sIGlzX3N0YWJsZSA9IGR1bXBfaGFzaF90YWJsZV9z dGFibGVfcCAoaGFzaF9pbik7Ci0gIC8qIElmIHRoZSBoYXNoIHRhYmxlIGlzIGxpa2VseSB0byBi ZSBtb2RpZmllZCBpbiBtZW1vcnkgKGVpdGhlcgotICAgICBiZWNhdXNlIHdlIG5lZWQgdG8gcmVo YXNoLCBhbmQgdGh1cyB0b2dnbGUgaGFzaC0+Y291bnQsIG9yCi0gICAgIGJlY2F1c2Ugd2UgbmVl ZCB0byBhc3NlbWJsZSBhIGxpc3Qgb2Ygd2VhayB0YWJsZXMpIHB1bnQgdGhlIGhhc2gKLSAgICAg dGFibGUgdG8gdGhlIGVuZCBvZiB0aGUgZHVtcCwgd2hlcmUgd2UgY2FuIGx1bXAgYWxsIHN1Y2gg aGFzaAotICAgICB0YWJsZXMgdG9nZXRoZXIuICAqLwotICBpZiAoIShpc19zdGFibGUgfHwgIU5J TFAgKGhhc2hfaW4tPndlYWspKQotICAgICAgJiYgY3R4LT5mbGFncy5kZWZlcl9oYXNoX3RhYmxl cykKLSAgICB7Ci0gICAgICBpZiAob2Zmc2V0ICE9IERVTVBfT0JKRUNUX09OX0hBU0hfVEFCTEVf UVVFVUUpCi0gICAgICAgIHsKLQkgIGVhc3NlcnQgKG9mZnNldCA9PSBEVU1QX09CSkVDVF9PTl9O T1JNQUxfUVVFVUUKLQkJICAgfHwgb2Zmc2V0ID09IERVTVBfT0JKRUNUX05PVF9TRUVOKTsKLSAg ICAgICAgICAvKiBXZSBzdGlsbCB3YW50IHRvIGR1bXAgdGhlIGFjdHVhbCBrZXlzIGFuZCB2YWx1 ZXMgbm93LiAgKi8KLSAgICAgICAgICBkdW1wX2VucXVldWVfb2JqZWN0IChjdHgsIGhhc2hfaW4t PmtleV9hbmRfdmFsdWUsIFdFSUdIVF9OT05FKTsKLSAgICAgICAgICAvKiBXZSdsbCBnZXQgdG8g dGhlIHJlc3QgbGF0ZXIuICAqLwotICAgICAgICAgIG9mZnNldCA9IERVTVBfT0JKRUNUX09OX0hB U0hfVEFCTEVfUVVFVUU7Ci0gICAgICAgICAgZHVtcF9yZW1lbWJlcl9vYmplY3QgKGN0eCwgb2Jq ZWN0LCBvZmZzZXQpOwotICAgICAgICAgIGR1bXBfcHVzaCAoJmN0eC0+ZGVmZXJyZWRfaGFzaF90 YWJsZXMsIG9iamVjdCk7Ci0gICAgICAgIH0KLSAgICAgIHJldHVybiBvZmZzZXQ7Ci0gICAgfQot Ci0gIGlmIChQRFVNUEVSX0NIRUNLX1JFSEFTSElORykKLSAgICBjaGVja19oYXNoX3RhYmxlX3Jl aGFzaCAobWFrZV9saXNwX3B0ciAoKHZvaWQgKikgaGFzaF9pbiwgTGlzcF9WZWN0b3JsaWtlKSk7 Ci0KICAgc3RydWN0IExpc3BfSGFzaF9UYWJsZSBoYXNoX211bmdlZCA9ICpoYXNoX2luOwogICBz dHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICpoYXNoID0gJmhhc2hfbXVuZ2VkOwogCi0gIC8qIFJlbWVt YmVyIHRvIHJlaGFzaCB0aGlzIGhhc2ggdGFibGUgb24gZmlyc3QgYWNjZXNzLiAgQWZ0ZXIgYQot ICAgICBkdW1wIHJlbG9hZCwgdGhlIGhhc2ggdGFibGUgdmFsdWVzIHdpbGwgaGF2ZSBjaGFuZ2Vk LCBzbyB3ZSdsbAotICAgICBuZWVkIHRvIHJlYnVpbGQgdGhlIGluZGV4LgotCi0gICAgIFRPRE86 IGZvciBFUSBhbmQgRVFMIGhhc2ggdGFibGVzLCBpdCBzaG91bGQgYmUgcG9zc2libGUgdG8gcmVo YXNoCi0gICAgIGhlcmUgdXNpbmcgdGhlIHByZWZlcnJlZCBsb2FkIGFkZHJlc3Mgb2YgdGhlIGR1 bXAsIGVsaW1pbmF0aW5nCi0gICAgIHRoZSBuZWVkIHRvIHJlaGFzaC1vbi1hY2Nlc3MgaWYgd2Ug Y2FuIGxvYWQgdGhlIGR1bXAgd2hlcmUgd2UKLSAgICAgd2FudC4gICovCi0gIGlmIChoYXNoLT5j b3VudCA+IDAgJiYgIWlzX3N0YWJsZSkKLSAgICBoYXNoLT5jb3VudCA9IC1oYXNoLT5jb3VudDsK KyAgaGFzaF90YWJsZV9mcmVlemUgKGhhc2gpOworICBkdW1wX3B1c2ggKCZjdHgtPmhhc2hfdGFi bGVzLCBvYmplY3QpOwogCiAgIFNUQVJUX0RVTVBfUFZFQyAoY3R4LCAmaGFzaC0+aGVhZGVyLCBz dHJ1Y3QgTGlzcF9IYXNoX1RhYmxlLCBvdXQpOwogICBkdW1wX3BzZXVkb3ZlY3Rvcl9saXNwX2Zp ZWxkcyAoY3R4LCAmb3V0LT5oZWFkZXIsICZoYXNoLT5oZWFkZXIpOwpAQCAtNDE0Miw2ICs0MTA4 LDE5IEBAIERFRlVOICgiZHVtcC1lbWFjcy1wb3J0YWJsZSIsCiAJIHx8ICFOSUxQIChjdHgtPmRl ZmVycmVkX2hhc2hfdGFibGVzKQogCSB8fCAhTklMUCAoY3R4LT5kZWZlcnJlZF9zeW1ib2xzKSk7 CiAKKyAgY3R4LT5oZWFkZXIuaGFzaF9saXN0ID0gY3R4LT5vZmZzZXQ7CisgIGR1bXBfaGFzaF90 YWJsZV9saXN0IChjdHgpOworCisgIGRvCisgICAgeworICAgICAgZHVtcF9kcmFpbl9kZWZlcnJl ZF9oYXNoX3RhYmxlcyAoY3R4KTsKKyAgICAgIGR1bXBfZHJhaW5fZGVmZXJyZWRfc3ltYm9scyAo Y3R4KTsKKyAgICAgIGR1bXBfZHJhaW5fbm9ybWFsX3F1ZXVlIChjdHgpOworICAgIH0KKyAgd2hp bGUgKCFkdW1wX3F1ZXVlX2VtcHR5X3AgKCZjdHgtPmR1bXBfcXVldWUpCisJIHx8ICFOSUxQIChj dHgtPmRlZmVycmVkX2hhc2hfdGFibGVzKQorCSB8fCAhTklMUCAoY3R4LT5kZWZlcnJlZF9zeW1i b2xzKSk7CisKICAgZHVtcF9zb3J0X2NvcGllZF9vYmplY3RzIChjdHgpOwogCiAgIC8qIFdoaWxl IHdlIGNvcHkgYnVpbHQtaW4gc3ltYm9scyBpbnRvIHRoZSBFbWFjcyBpbWFnZSwgdGhlc2UKQEAg LTU0MzMsNiArNTQxMiwxMyBAQCBwZHVtcGVyX2xvYWQgKGNvbnN0IGNoYXIgKmR1bXBfZmlsZW5h bWUpCiAgIGZvciAoaW50IGkgPSAwOyBpIDwgQVJSQVlFTFRTIChzZWN0aW9ucyk7ICsraSkKICAg ICBkdW1wX21tYXBfcmVzZXQgKCZzZWN0aW9uc1tpXSk7CiAKKyAgaWYgKGhlYWRlci0+aGFzaF9s aXN0KQorICAgIHsKKyAgICAgIHN0cnVjdCBMaXNwX1ZlY3RvciAqaGFzaF90YWJsZXMgPQorCSgo c3RydWN0IExpc3BfVmVjdG9yICopKGR1bXBfYmFzZSArIGhlYWRlci0+aGFzaF9saXN0KSk7Cisg ICAgICBYU0VUVkVDVE9SIChWcGR1bXBlcl9oYXNoX3RhYmxlcywgaGFzaF90YWJsZXMpOworICAg IH0KKwogICAvKiBSdW4gdGhlIGZ1bmN0aW9ucyBFbWFjcyByZWdpc3RlcmVkIGZvciBkb2luZyBw b3N0LWR1bXAtbG9hZAogICAgICBpbml0aWFsaXphdGlvbi4gICovCiAgIGZvciAoaW50IGkgPSAw OyBpIDwgbnJfZHVtcF9ob29rczsgKytpKQpAQCAtNTUwNCwxMCArNTQ5MCwzMSBAQCBERUZVTiAo InBkdW1wZXItc3RhdHMiLCBGcGR1bXBlcl9zdGF0cywgU3BkdW1wZXJfc3RhdHMsIDAsIDAsIDAs CiAKIAwKIAorc3RhdGljIHZvaWQgdGhhd19oYXNoX3RhYmxlcyAodm9pZCkKK3sKKyAgTGlzcF9P YmplY3QgaGFzaF90YWJsZXMgPSBWcGR1bXBlcl9oYXNoX3RhYmxlczsKKyAgcHRyZGlmZl90IGkg PSAwOworICB3aGlsZSAoaSA8IEFTSVpFIChoYXNoX3RhYmxlcykpCisgICAgeworICAgICAgaGFz aF90YWJsZV90aGF3IChYSEFTSF9UQUJMRSAoQVJFRiAoaGFzaF90YWJsZXMsIGkpKSk7CisgICAg ICBpKys7CisgICAgfQorICBWcGR1bXBlcl9oYXNoX3RhYmxlcyA9IHplcm9fdmVjdG9yOworfQor Cit2b2lkCitpbml0X3BkdW1wZXJfb25jZSAodm9pZCkKK3sKKyAgVnBkdW1wZXJfaGFzaF90YWJs ZXMgPSB6ZXJvX3ZlY3RvcjsKKyAgcGR1bXBlcl9kb19ub3dfYW5kX2FmdGVyX2xvYWQgKHRoYXdf aGFzaF90YWJsZXMpOworfQorCiB2b2lkCiBzeW1zX29mX3BkdW1wZXIgKHZvaWQpCiB7CiAjaWZk ZWYgSEFWRV9QRFVNUEVSCisgIERFRlZBUl9MSVNQICgicGR1bXBlci1oYXNoLXRhYmxlcyIsIFZw ZHVtcGVyX2hhc2hfdGFibGVzLAorCSAgICAgICBkb2M6IC8qIEEgbGlzdCBvZiBoYXNoIHRhYmxl cyB0aGF0IG5lZWQgdG8gYmUgdGhhd2VkIGFmdGVyIGxvYWRpbmcgdGhlIHBkdW1wLiAgKi8pOwog ICBkZWZzdWJyICgmU2R1bXBfZW1hY3NfcG9ydGFibGUpOwogICBkZWZzdWJyICgmU2R1bXBfZW1h Y3NfcG9ydGFibGVfX3NvcnRfcHJlZGljYXRlKTsKICAgZGVmc3ViciAoJlNkdW1wX2VtYWNzX3Bv cnRhYmxlX19zb3J0X3ByZWRpY2F0ZV9jb3BpZWQpOwpkaWZmIC0tZ2l0IGEvc3JjL3BkdW1wZXIu aCBiL3NyYy9wZHVtcGVyLmgKaW5kZXggYWIyZjQyNmMxZS4uY2ZlYTA2ZDMzZCAxMDA2NDQKLS0t IGEvc3JjL3BkdW1wZXIuaAorKysgYi9zcmMvcGR1bXBlci5oCkBAIC0yNDgsNiArMjQ4LDcgQEAg cGR1bXBlcl9jbGVhcl9tYXJrcyAodm9pZCkKICAgIGZpbGUgd2FzIGxvYWRlZC4gICovCiBleHRl cm4gdm9pZCBwZHVtcGVyX3JlY29yZF93ZCAoY29uc3QgY2hhciAqKTsKIAordm9pZCBpbml0X3Bk dW1wZXJfb25jZSAodm9pZCk7CiB2b2lkIHN5bXNfb2ZfcGR1bXBlciAodm9pZCk7CiAKIElOTElO RV9IRUFERVJfRU5ECi0tIAoyLjIwLjEKCg== --0000000000008cb6d5058d684ade-- From debbugs-submit-bounces@debbugs.gnu.org Sun Jul 14 10:39:20 2019 Received: (at 36597) by debbugs.gnu.org; 14 Jul 2019 14:39:20 +0000 Received: from localhost ([127.0.0.1]:45595 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hmfep-0002sQ-Q9 for submit@debbugs.gnu.org; Sun, 14 Jul 2019 10:39:20 -0400 Received: from zimbra.cs.ucla.edu ([131.179.128.68]:39660) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hmfem-0002sA-WE for 36597@debbugs.gnu.org; Sun, 14 Jul 2019 10:39:18 -0400 Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id B3BD11626AA; Sun, 14 Jul 2019 07:39:10 -0700 (PDT) Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10032) with ESMTP id 1gdu1G9kyYAL; Sun, 14 Jul 2019 07:39:08 -0700 (PDT) Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id DB9041626B9; Sun, 14 Jul 2019 07:39:08 -0700 (PDT) X-Virus-Scanned: amavisd-new at zimbra.cs.ucla.edu Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10026) with ESMTP id ClyIYe2rIFMN; Sun, 14 Jul 2019 07:39:08 -0700 (PDT) Received: from [192.168.1.9] (cpe-23-242-74-103.socal.res.rr.com [23.242.74.103]) by zimbra.cs.ucla.edu (Postfix) with ESMTPSA id A393D1626AA; Sun, 14 Jul 2019 07:39:08 -0700 (PDT) To: Pip Cet From: Paul Eggert Subject: 27.0.50; rehash hash tables eagerly in pdumper Organization: UCLA Computer Science Department Message-ID: <6a260307-a463-bd08-8a10-d7664d0606a2@cs.ucla.edu> Date: Sun, 14 Jul 2019 07:39:08 -0700 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Thunderbird/60.7.2 MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="------------5F0120606C9BF0661B12A340" Content-Language: en-US X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 36597 Cc: 36597@debbugs.gnu.org, Daniel Colascione X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) This is a multi-part message in MIME format. --------------5F0120606C9BF0661B12A340 Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 7bit Although I like the simplicity of eager rehashing, I'm not yet sold on the performance implications. On my usual (cd lisp && make compile-always) benchmark, the patch hurt user+system CPU time performance by 1.5%. Admittedly just one benchmark, but still.... Also, must we expose Vpdumper_hash_tables to Lisp? Surely it'd be better to keep it private to pdumper.c. I'll CC: to Daniel to see whether he has any insights about improvements in this area. PS. I ran that benchmark on my home desktop, an Intel Xeon E3-1225 v2 running Ubunto 18.04.2. To run it, I rebased your patch and also removed the no-longer-used PDUMPER_CHECK_REHASHING macro that my GCC complained about (wonder why that didn't happen for you?), resulting in the attached patch against current master 8ff09154a29a1151afb2902267ca35f89ebda73c. --------------5F0120606C9BF0661B12A340 Content-Type: text/x-patch; name="0001-Rehash-hash-tables-eagerly-after-loading-a-portable-.patch" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename*0="0001-Rehash-hash-tables-eagerly-after-loading-a-portable-.pa"; filename*1="tch" >From 96a36697b2f472f3a6b3138444659babd0d73f32 Mon Sep 17 00:00:00 2001 From: Pip Cet Date: Sun, 14 Jul 2019 07:22:01 -0700 Subject: [PATCH] Rehash hash tables eagerly after loading a portable dump * src/lisp.h (hash_rehash_needed_p): Remove. All uses removed. (hash_rehash_if_needed): Remove. All uses removed. (struct Lisp_Hash_Table): Remove comment about rehashing hash tables. * src/pdumper.c (thaw_hash_tables): New function. (hash_table_thaw): New function. (hash_table_freeze): New function. (dump_hash_table): Simplify. (dump_hash_table_list): New function. (hash_table_contents): New function. (Fdump_emacs_portable): Handle hash tables by eager rehashing. (pdumper_load): Restore hash tables. (init_pdumper_once): New function. (PDUMPER_CHECK_REHASHING): Remove. --- src/bytecode.c | 1 - src/composite.c | 1 - src/emacs.c | 1 + src/fns.c | 54 ++++---------- src/lisp.h | 19 +---- src/minibuf.c | 3 - src/pdumper.c | 188 ++++++++++++++++++++++++------------------------ src/pdumper.h | 1 + 8 files changed, 108 insertions(+), 160 deletions(-) diff --git a/src/bytecode.c b/src/bytecode.c index 29dff44f00..9c72429e0c 100644 --- a/src/bytecode.c +++ b/src/bytecode.c @@ -1402,7 +1402,6 @@ #define DEFINE(name, value) LABEL (name) , Lisp_Object v1 = POP; ptrdiff_t i; struct Lisp_Hash_Table *h = XHASH_TABLE (jmp_table); - hash_rehash_if_needed (h); /* h->count is a faster approximation for HASH_TABLE_SIZE (h) here. */ diff --git a/src/composite.c b/src/composite.c index 183062de46..49a285cff0 100644 --- a/src/composite.c +++ b/src/composite.c @@ -654,7 +654,6 @@ gstring_lookup_cache (Lisp_Object header) composition_gstring_put_cache (Lisp_Object gstring, ptrdiff_t len) { struct Lisp_Hash_Table *h = XHASH_TABLE (gstring_hash_table); - hash_rehash_if_needed (h); Lisp_Object header = LGSTRING_HEADER (gstring); EMACS_UINT hash = h->test.hashfn (&h->test, header); if (len < 0) diff --git a/src/emacs.c b/src/emacs.c index ad661a081b..855b2c6715 100644 --- a/src/emacs.c +++ b/src/emacs.c @@ -1560,6 +1560,7 @@ main (int argc, char **argv) if (!initialized) { init_alloc_once (); + init_pdumper_once (); init_obarray_once (); init_eval_once (); init_charset_once (); diff --git a/src/fns.c b/src/fns.c index 0497588689..b6134a314c 100644 --- a/src/fns.c +++ b/src/fns.c @@ -4241,43 +4241,24 @@ hash_table_rehash (struct Lisp_Hash_Table *h) { ptrdiff_t size = HASH_TABLE_SIZE (h); - /* These structures may have been purecopied and shared - (bug#36447). */ - h->next = Fcopy_sequence (h->next); - h->index = Fcopy_sequence (h->index); - h->hash = Fcopy_sequence (h->hash); - /* Recompute the actual hash codes for each entry in the table. Order is still invalid. */ for (ptrdiff_t i = 0; i < size; ++i) - if (!NILP (HASH_HASH (h, i))) - { - Lisp_Object key = HASH_KEY (h, i); - EMACS_UINT hash_code = h->test.hashfn (&h->test, key); - set_hash_hash_slot (h, i, make_fixnum (hash_code)); - } - - /* Reset the index so that any slot we don't fill below is marked - invalid. */ - Ffillarray (h->index, make_fixnum (-1)); + { + Lisp_Object key = HASH_KEY (h, i); + EMACS_UINT hash_code = h->test.hashfn (&h->test, key); + set_hash_hash_slot (h, i, make_fixnum (hash_code)); + } /* Rebuild the collision chains. */ for (ptrdiff_t i = 0; i < size; ++i) - if (!NILP (HASH_HASH (h, i))) - { - EMACS_UINT hash_code = XUFIXNUM (HASH_HASH (h, i)); - ptrdiff_t start_of_bucket = hash_code % ASIZE (h->index); - set_hash_next_slot (h, i, HASH_INDEX (h, start_of_bucket)); - set_hash_index_slot (h, start_of_bucket, i); - eassert (HASH_NEXT (h, i) != i); /* Stop loops. */ - } - - /* Finally, mark the hash table as having a valid hash order. - Do this last so that if we're interrupted, we retry on next - access. */ - eassert (h->count < 0); - h->count = -h->count; - eassert (!hash_rehash_needed_p (h)); + { + EMACS_UINT hash_code = XUFIXNUM (HASH_HASH (h, i)); + ptrdiff_t start_of_bucket = hash_code % ASIZE (h->index); + set_hash_next_slot (h, i, HASH_INDEX (h, start_of_bucket)); + set_hash_index_slot (h, start_of_bucket, i); + eassert (HASH_NEXT (h, i) != i); /* Stop loops. */ + } } /* Lookup KEY in hash table H. If HASH is non-null, return in *HASH @@ -4290,8 +4271,6 @@ hash_lookup (struct Lisp_Hash_Table *h, Lisp_Object key, EMACS_UINT *hash) EMACS_UINT hash_code; ptrdiff_t start_of_bucket, i; - hash_rehash_if_needed (h); - hash_code = h->test.hashfn (&h->test, key); eassert ((hash_code & ~INTMASK) == 0); if (hash) @@ -4320,8 +4299,6 @@ hash_put (struct Lisp_Hash_Table *h, Lisp_Object key, Lisp_Object value, { ptrdiff_t start_of_bucket, i; - hash_rehash_if_needed (h); - eassert ((hash & ~INTMASK) == 0); /* Increment count after resizing because resizing may fail. */ @@ -4355,8 +4332,6 @@ hash_remove_from_table (struct Lisp_Hash_Table *h, Lisp_Object key) ptrdiff_t start_of_bucket = hash_code % ASIZE (h->index); ptrdiff_t prev = -1; - hash_rehash_if_needed (h); - for (ptrdiff_t i = HASH_INDEX (h, start_of_bucket); 0 <= i; i = HASH_NEXT (h, i)) @@ -4434,9 +4409,7 @@ sweep_weak_table (struct Lisp_Hash_Table *h, bool remove_entries_p) for (ptrdiff_t bucket = 0; bucket < n; ++bucket) { /* Follow collision chain, removing entries that don't survive - this garbage collection. It's okay if hash_rehash_needed_p - (h) is true, since we're operating entirely on the cached - hash values. */ + this garbage collection. */ ptrdiff_t prev = -1; ptrdiff_t next; for (ptrdiff_t i = HASH_INDEX (h, bucket); 0 <= i; i = next) @@ -4881,7 +4854,6 @@ DEFUN ("hash-table-count", Fhash_table_count, Shash_table_count, 1, 1, 0, (Lisp_Object table) { struct Lisp_Hash_Table *h = check_hash_table (table); - hash_rehash_if_needed (h); return make_fixnum (h->count); } diff --git a/src/lisp.h b/src/lisp.h index 13014c82dc..d0e5c43c41 100644 --- a/src/lisp.h +++ b/src/lisp.h @@ -2245,11 +2245,7 @@ #define DEFSYM(sym, name) /* empty */ struct Lisp_Hash_Table { - /* Change pdumper.c if you change the fields here. - - IMPORTANT!!!!!!! - - Call hash_rehash_if_needed() before accessing. */ + /* Change pdumper.c if you change the fields here. */ /* This is for Lisp; the hash table code does not refer to it. */ union vectorlike_header header; @@ -2363,19 +2359,6 @@ HASH_TABLE_SIZE (const struct Lisp_Hash_Table *h) void hash_table_rehash (struct Lisp_Hash_Table *h); -INLINE bool -hash_rehash_needed_p (const struct Lisp_Hash_Table *h) -{ - return h->count < 0; -} - -INLINE void -hash_rehash_if_needed (struct Lisp_Hash_Table *h) -{ - if (hash_rehash_needed_p (h)) - hash_table_rehash (h); -} - /* Default size for hash tables if not specified. */ enum DEFAULT_HASH_SIZE { DEFAULT_HASH_SIZE = 65 }; diff --git a/src/minibuf.c b/src/minibuf.c index d9a6e15b05..e923ce2a43 100644 --- a/src/minibuf.c +++ b/src/minibuf.c @@ -1203,9 +1203,6 @@ DEFUN ("try-completion", Ftry_completion, Stry_completion, 2, 3, 0, bucket = AREF (collection, idx); } - if (HASH_TABLE_P (collection)) - hash_rehash_if_needed (XHASH_TABLE (collection)); - while (1) { /* Get the next element of the alist, obarray, or hash-table. */ diff --git a/src/pdumper.c b/src/pdumper.c index 03c00bf27b..d35d296d32 100644 --- a/src/pdumper.c +++ b/src/pdumper.c @@ -107,17 +107,6 @@ #define VM_MS_WINDOWS 2 #define DANGEROUS 0 -/* PDUMPER_CHECK_REHASHING being true causes the portable dumper to - check, for each hash table it dumps, that the hash table means the - same thing after rehashing. */ -#ifndef PDUMPER_CHECK_REHASHING -# if ENABLE_CHECKING -# define PDUMPER_CHECK_REHASHING 1 -# else -# define PDUMPER_CHECK_REHASHING 0 -# endif -#endif - /* We require an architecture in which all pointers are the same size and have the same layout, where pointers are either 32 or 64 bits long, and where bytes have eight bits --- that is, a @@ -393,6 +382,8 @@ dump_fingerprint (char const *label, The start of the cold region is always aligned on a page boundary. */ dump_off cold_start; + + dump_off hash_list; }; /* Double-ended singly linked list. */ @@ -550,6 +541,8 @@ dump_fingerprint (char const *label, heap objects. */ Lisp_Object bignum_data; + Lisp_Object hash_tables; + unsigned number_hot_relocations; unsigned number_discardable_relocations; }; @@ -2622,68 +2615,64 @@ dump_vectorlike_generic (struct dump_context *ctx, return offset; } -/* Determine whether the hash table's hash order is stable - across dump and load. If it is, we don't have to trigger - a rehash on access. */ -static bool -dump_hash_table_stable_p (const struct Lisp_Hash_Table *hash) +/* Return a list of (KEY . VALUE) pairs in the given hash table. */ +static Lisp_Object +hash_table_contents (struct Lisp_Hash_Table *h) { - bool is_eql = hash->test.hashfn == hashfn_eql; - bool is_equal = hash->test.hashfn == hashfn_equal; - ptrdiff_t size = HASH_TABLE_SIZE (hash); - for (ptrdiff_t i = 0; i < size; ++i) - if (!NILP (HASH_HASH (hash, i))) + Lisp_Object contents = Qnil; + /* Make sure key_and_value ends up in the same order, charset.c + relies on it by expecting hash table indices to stay constant + across the dump. */ + for (ptrdiff_t i = HASH_TABLE_SIZE (h) - 1; i >= 0; --i) + if (!NILP (HASH_HASH (h, i))) { - Lisp_Object key = HASH_KEY (hash, i); - bool key_stable = (dump_builtin_symbol_p (key) - || FIXNUMP (key) - || (is_equal && STRINGP (key)) - || ((is_equal || is_eql) && FLOATP (key))); - if (!key_stable) - return false; + dump_push (&contents, HASH_VALUE (h, i)); + dump_push (&contents, HASH_KEY (h, i)); } + return CALLN (Fapply, Qvector, contents); +} - return true; +static dump_off +dump_hash_table_list (struct dump_context *ctx) +{ + if (CONSP (ctx->hash_tables)) + return dump_object (ctx, CALLN (Fapply, Qvector, ctx->hash_tables)); + else + return 0; } -/* Return a list of (KEY . VALUE) pairs in the given hash table. */ -static Lisp_Object -hash_table_contents (Lisp_Object table) +static void +hash_table_freeze (struct Lisp_Hash_Table *h) { - Lisp_Object contents = Qnil; - struct Lisp_Hash_Table *h = XHASH_TABLE (table); - for (ptrdiff_t i = 0; i < HASH_TABLE_SIZE (h); ++i) - if (!NILP (HASH_HASH (h, i))) - dump_push (&contents, Fcons (HASH_KEY (h, i), HASH_VALUE (h, i))); - return Fnreverse (contents); + h->key_and_value = hash_table_contents (h); + ptrdiff_t nkeys = XFIXNAT (Flength (h->key_and_value)) / 2; + h->count = nkeys; + if (nkeys == 0) + nkeys = 1; + h->index = h->next = h->hash = make_fixnum (nkeys); } -/* Copy the given hash table, rehash it, and make sure that we can - look up all the values in the original. */ static void -check_hash_table_rehash (Lisp_Object table_orig) -{ - hash_rehash_if_needed (XHASH_TABLE (table_orig)); - Lisp_Object table_rehashed = Fcopy_hash_table (table_orig); - eassert (XHASH_TABLE (table_rehashed)->count >= 0); - XHASH_TABLE (table_rehashed)->count *= -1; - eassert (XHASH_TABLE (table_rehashed)->count <= 0); - hash_rehash_if_needed (XHASH_TABLE (table_rehashed)); - eassert (XHASH_TABLE (table_rehashed)->count >= 0); - Lisp_Object expected_contents = hash_table_contents (table_orig); - while (!NILP (expected_contents)) +hash_table_thaw (struct Lisp_Hash_Table *h) +{ + Lisp_Object count = h->index; + h->index = Fmake_vector (h->index, make_fixnum (-1)); + h->hash = Fmake_vector (h->hash, Qnil); + h->next = Fmake_vector (h->next, make_fixnum (-1)); + Lisp_Object key_and_value = h->key_and_value; + h->next_free = -1; + if (XFIXNAT (count) <= 1) { - Lisp_Object key_value_pair = dump_pop (&expected_contents); - Lisp_Object key = XCAR (key_value_pair); - Lisp_Object expected_value = XCDR (key_value_pair); - Lisp_Object arbitrary = Qdump_emacs_portable__sort_predicate_copied; - Lisp_Object found_value = Fgethash (key, table_rehashed, arbitrary); - eassert (EQ (expected_value, found_value)); - Fremhash (key, table_rehashed); + h->key_and_value = Fmake_vector (make_fixnum (2 * XFIXNAT (count)), Qnil); + ptrdiff_t i = 0; + while (i < ASIZE (key_and_value)) + { + ASET (h->key_and_value, i, AREF (key_and_value, i)); + i++; + } } - eassert (EQ (Fhash_table_count (table_rehashed), - make_fixnum (0))); + hash_table_rehash (h); } static dump_off @@ -2695,45 +2684,11 @@ dump_hash_table (struct dump_context *ctx, # error "Lisp_Hash_Table changed. See CHECK_STRUCTS comment in config.h." #endif const struct Lisp_Hash_Table *hash_in = XHASH_TABLE (object); - bool is_stable = dump_hash_table_stable_p (hash_in); - /* If the hash table is likely to be modified in memory (either - because we need to rehash, and thus toggle hash->count, or - because we need to assemble a list of weak tables) punt the hash - table to the end of the dump, where we can lump all such hash - tables together. */ - if (!(is_stable || !NILP (hash_in->weak)) - && ctx->flags.defer_hash_tables) - { - if (offset != DUMP_OBJECT_ON_HASH_TABLE_QUEUE) - { - eassert (offset == DUMP_OBJECT_ON_NORMAL_QUEUE - || offset == DUMP_OBJECT_NOT_SEEN); - /* We still want to dump the actual keys and values now. */ - dump_enqueue_object (ctx, hash_in->key_and_value, WEIGHT_NONE); - /* We'll get to the rest later. */ - offset = DUMP_OBJECT_ON_HASH_TABLE_QUEUE; - dump_remember_object (ctx, object, offset); - dump_push (&ctx->deferred_hash_tables, object); - } - return offset; - } - - if (PDUMPER_CHECK_REHASHING) - check_hash_table_rehash (make_lisp_ptr ((void *) hash_in, Lisp_Vectorlike)); - struct Lisp_Hash_Table hash_munged = *hash_in; struct Lisp_Hash_Table *hash = &hash_munged; - /* Remember to rehash this hash table on first access. After a - dump reload, the hash table values will have changed, so we'll - need to rebuild the index. - - TODO: for EQ and EQL hash tables, it should be possible to rehash - here using the preferred load address of the dump, eliminating - the need to rehash-on-access if we can load the dump where we - want. */ - if (hash->count > 0 && !is_stable) - hash->count = -hash->count; + hash_table_freeze (hash); + dump_push (&ctx->hash_tables, object); START_DUMP_PVEC (ctx, &hash->header, struct Lisp_Hash_Table, out); dump_pseudovector_lisp_fields (ctx, &out->header, &hash->header); @@ -4140,6 +4095,19 @@ DEFUN ("dump-emacs-portable", || !NILP (ctx->deferred_hash_tables) || !NILP (ctx->deferred_symbols)); + ctx->header.hash_list = ctx->offset; + dump_hash_table_list (ctx); + + do + { + dump_drain_deferred_hash_tables (ctx); + dump_drain_deferred_symbols (ctx); + dump_drain_normal_queue (ctx); + } + while (!dump_queue_empty_p (&ctx->dump_queue) + || !NILP (ctx->deferred_hash_tables) + || !NILP (ctx->deferred_symbols)); + dump_sort_copied_objects (ctx); /* While we copy built-in symbols into the Emacs image, these @@ -5431,6 +5399,13 @@ pdumper_load (const char *dump_filename) for (int i = 0; i < ARRAYELTS (sections); ++i) dump_mmap_reset (§ions[i]); + if (header->hash_list) + { + struct Lisp_Vector *hash_tables = + ((struct Lisp_Vector *)(dump_base + header->hash_list)); + XSETVECTOR (Vpdumper_hash_tables, hash_tables); + } + /* Run the functions Emacs registered for doing post-dump-load initialization. */ for (int i = 0; i < nr_dump_hooks; ++i) @@ -5502,10 +5477,31 @@ DEFUN ("pdumper-stats", Fpdumper_stats, Spdumper_stats, 0, 0, 0, +static void thaw_hash_tables (void) +{ + Lisp_Object hash_tables = Vpdumper_hash_tables; + ptrdiff_t i = 0; + while (i < ASIZE (hash_tables)) + { + hash_table_thaw (XHASH_TABLE (AREF (hash_tables, i))); + i++; + } + Vpdumper_hash_tables = zero_vector; +} + +void +init_pdumper_once (void) +{ + Vpdumper_hash_tables = zero_vector; + pdumper_do_now_and_after_load (thaw_hash_tables); +} + void syms_of_pdumper (void) { #ifdef HAVE_PDUMPER + DEFVAR_LISP ("pdumper-hash-tables", Vpdumper_hash_tables, + doc: /* A list of hash tables that need to be thawed after loading the pdump. */); defsubr (&Sdump_emacs_portable); defsubr (&Sdump_emacs_portable__sort_predicate); defsubr (&Sdump_emacs_portable__sort_predicate_copied); diff --git a/src/pdumper.h b/src/pdumper.h index ab2f426c1e..cfea06d33d 100644 --- a/src/pdumper.h +++ b/src/pdumper.h @@ -248,6 +248,7 @@ pdumper_clear_marks (void) file was loaded. */ extern void pdumper_record_wd (const char *); +void init_pdumper_once (void); void syms_of_pdumper (void); INLINE_HEADER_END -- 2.17.1 --------------5F0120606C9BF0661B12A340-- From debbugs-submit-bounces@debbugs.gnu.org Sun Jul 14 11:02:31 2019 Received: (at 36597) by debbugs.gnu.org; 14 Jul 2019 15:02:31 +0000 Received: from localhost ([127.0.0.1]:45641 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hmg1H-0005dj-Cj for submit@debbugs.gnu.org; Sun, 14 Jul 2019 11:02:31 -0400 Received: from mail-ot1-f50.google.com ([209.85.210.50]:38255) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hmg1F-0005dV-4A for 36597@debbugs.gnu.org; Sun, 14 Jul 2019 11:02:29 -0400 Received: by mail-ot1-f50.google.com with SMTP id d17so14295706oth.5 for <36597@debbugs.gnu.org>; Sun, 14 Jul 2019 08:02:29 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc; bh=xwvZZUp+X9cAPDy6VfPJHbkV0flv9zfuGkOavhQYpvQ=; b=W/V9GErEEmNRXcVZBMGc/Rn/vTBDOO5rPduc8B/vqwDDxzpKXGOPXTUj/kA6x98aUG RNzz1HZ+yIy/OMgid3ygrV4CHYJTT3mhnB2fsEDArpbd8Q8oXfbGVjOskdPw61torJJu UZGzE9GEGe1WlM6w/PgWEgK1sCbWOzFak+RuY8o2mc1G7A+A0ETXzcWoX4nfKOv6WZ6p mPSFygHdfRJO5kJ6n8T2/v6K2Xn1rGAA+ITjykU9G+lvOR/ZSffJ1GvwhcraKngctXEp C8A16l27XRPerIeNFKSJdNZYliDsXsLw2kjLXKP1dNEx+TFFuQD/xXmv35axCSMoMYRx et+g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=xwvZZUp+X9cAPDy6VfPJHbkV0flv9zfuGkOavhQYpvQ=; b=Xve18oSO5AWrsAyLPK8KbznM0vWtPb/sI/6TJQd6ELbXUVXxF1h4dgBE4HkanNMdyG tnoWUBjuwU23SsSSENdWp802NFyLJ4J1YYO/AQFPwHvhuYOjaUO9Ck9nH1vgWwFISbJE eDhI8TY29ZkzogTbbhg2sd5VELqP8z7cgycioa5q58vVEo5WNYC2ByJHiV4wOGS6lQpN 0Ob5qP7im/L8V8/HuUf8/cQgIkLnmUVtx80SGqYpDcGLQsXhwxEhR5TJKrV+/bm5CT8N /wcMwZGbbMmj6pj3bwPYBsG5R3US2DVckTxF9fWQf+ECKxHrImBuE0o+JhuMp3P6t59s fIiQ== X-Gm-Message-State: APjAAAV35dVJxTfLclEoFxOfgNmH2r+V7Gj2G0fgUbMJibOefMnhw+9P g2UgUUqYsm+vslEmHIUrXhvOWrbBisqtf1oDZs8= X-Google-Smtp-Source: APXvYqzumsUvVdkiXs5/LPHwSeDU56iDQAB6P1q1OEhqTzRVP1UDwjdIkzuyDu49YnToSqbo7wZGokelaFXWh8Otr3c= X-Received: by 2002:a9d:6014:: with SMTP id h20mr16242774otj.210.1563116543435; Sun, 14 Jul 2019 08:02:23 -0700 (PDT) MIME-Version: 1.0 References: <6a260307-a463-bd08-8a10-d7664d0606a2@cs.ucla.edu> In-Reply-To: <6a260307-a463-bd08-8a10-d7664d0606a2@cs.ucla.edu> From: Pip Cet Date: Sun, 14 Jul 2019 15:01:47 +0000 Message-ID: Subject: Re: bug#36597: 27.0.50; rehash hash tables eagerly in pdumper To: Paul Eggert Content-Type: text/plain; charset="UTF-8" X-Spam-Score: -0.0 (/) X-Debbugs-Envelope-To: 36597 Cc: 36597@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) On Sun, Jul 14, 2019 at 2:40 PM Paul Eggert wrote: > Although I like the simplicity of eager rehashing, I'm not yet sold on the > performance implications. On my usual (cd lisp && make compile-always) > benchmark, the patch hurt user+system CPU time performance by 1.5%. Admittedly > just one benchmark, but still.... Indeed, that's plenty of small Emacs processes not doing very much. It's not the case we ought to be optimizing for, I think, but the performance concerns should be taken seriously. One way to avoid the performance problems entirely is preferred-address loading of hash dumps, but that has security implications... > Also, must we expose Vpdumper_hash_tables to Lisp? Surely it'd be better to keep > it private to pdumper.c. Oops, I agree absolutely. Will remove that. > I'll CC: to Daniel to see whether he has any insights about improvements in this > area. Sure; I sent the original email to Daniel, too, of course. > PS. I ran that benchmark on my home desktop, an Intel Xeon E3-1225 v2 running > Ubunto 18.04.2. To run it, I rebased your patch and also removed the > no-longer-used PDUMPER_CHECK_REHASHING macro that my GCC complained about > (wonder why that didn't happen for you?), resulting in the attached patch > against current master 8ff09154a29a1151afb2902267ca35f89ebda73c. Some GCC versions complain about it, some don't, I think. From debbugs-submit-bounces@debbugs.gnu.org Sun Jul 14 11:49:26 2019 Received: (at 36597) by debbugs.gnu.org; 14 Jul 2019 15:49:26 +0000 Received: from localhost ([127.0.0.1]:45670 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hmgkg-0000UL-0T for submit@debbugs.gnu.org; Sun, 14 Jul 2019 11:49:26 -0400 Received: from zimbra.cs.ucla.edu ([131.179.128.68]:45200) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hmgkd-0000U8-W2 for 36597@debbugs.gnu.org; Sun, 14 Jul 2019 11:49:24 -0400 Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id 49C441626AA; Sun, 14 Jul 2019 08:49:17 -0700 (PDT) Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10032) with ESMTP id CTtXIxU6SQq7; Sun, 14 Jul 2019 08:49:16 -0700 (PDT) Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id 96CFF162704; Sun, 14 Jul 2019 08:49:16 -0700 (PDT) X-Virus-Scanned: amavisd-new at zimbra.cs.ucla.edu Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10026) with ESMTP id 83WIqIEzsBZi; Sun, 14 Jul 2019 08:49:16 -0700 (PDT) Received: from [192.168.1.9] (cpe-23-242-74-103.socal.res.rr.com [23.242.74.103]) by zimbra.cs.ucla.edu (Postfix) with ESMTPSA id 6C63C1626AA; Sun, 14 Jul 2019 08:49:16 -0700 (PDT) Subject: Re: bug#36597: 27.0.50; rehash hash tables eagerly in pdumper To: Pip Cet References: <6a260307-a463-bd08-8a10-d7664d0606a2@cs.ucla.edu> From: Paul Eggert Organization: UCLA Computer Science Department Message-ID: <74235afc-7043-1da7-7c71-07f0ca23b9fd@cs.ucla.edu> Date: Sun, 14 Jul 2019 08:49:16 -0700 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Thunderbird/60.7.2 MIME-Version: 1.0 In-Reply-To: Content-Type: text/plain; charset=utf-8; format=flowed Content-Language: en-US Content-Transfer-Encoding: 7bit X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 36597 Cc: 36597@debbugs.gnu.org, Daniel Colascione X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) Pip Cet wrote: > Indeed, that's plenty of small Emacs processes not doing very much. > It's not the case we ought to be optimizing for, I think, but the > performance concerns should be taken seriously. What's a good benchmark for what we should be optimizing for? Ideally something somewhat-realistic as opposed to a microbenchmark. It doesn't appear to be as simple as plenty of processes not doing very much. This benchmark: cd leim && time make -B ../lisp/leim/ja-dic/ja-dic.el is dominated by a single CPU-intensive Emacs process and takes about 19 CPU seconds on my home desktop. The proposed patch slows this benchmark down by about 0.6%. (I ran the benchmark ten times after a warmup run, and took the average of the ten user+system times.) From debbugs-submit-bounces@debbugs.gnu.org Sun Jul 14 12:55:36 2019 Received: (at 36597) by debbugs.gnu.org; 14 Jul 2019 16:55:36 +0000 Received: from localhost ([127.0.0.1]:45770 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hmhmi-0000OZ-11 for submit@debbugs.gnu.org; Sun, 14 Jul 2019 12:55:36 -0400 Received: from mail-ot1-f44.google.com ([209.85.210.44]:32861) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hmhmg-0000OH-0i for 36597@debbugs.gnu.org; Sun, 14 Jul 2019 12:55:34 -0400 Received: by mail-ot1-f44.google.com with SMTP id q20so14448509otl.0 for <36597@debbugs.gnu.org>; Sun, 14 Jul 2019 09:55:33 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc:content-transfer-encoding; bh=cCPzDfIu142p6zzgvxF0VZKO0dcki4OmxduPw9IHXmY=; b=tIhJQv736XL8oCr2Nm/m/znb9OVuMFLOYz2xfjJwtrNqQlisyqoXTPIzwOrZdOoBjp JGc0q6psbIEDqdUAg9HGJNsNiVhmbkRVrVXDsM+6jCC0ROYzVXztyuubS/RXB0kUhWlE AjECuTrbBVIjC7YBYiP6EaPDvgKHzAylkOVvfWO9MFf+7yqmYfHVjLx1NCXMZfDXvEXe CR/l1Vc0CsJ23Znu19Y1EusA6aaMW4QKqb8zDgV5b1Z8O4dmhQalWNb0UI7H9omnj+FD lCoCDF6wnhEvMa/O2fAsf2PlZC0GLcpudhuAeT+Bk7Rj2HR5G+3yPhDZQV/sQj5jmq7O qPLw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc:content-transfer-encoding; bh=cCPzDfIu142p6zzgvxF0VZKO0dcki4OmxduPw9IHXmY=; b=CBPkP/HVgzIgHbyojvcFRZXVCreC47+RXnaFALA6mtKoA3B26Rb3nYz/qqaocuZZvp klndy9EbOw9OB7feB6iCtwkOcKNL/1QwBowP4rTJv7bhMqniIyXfTM/1N9sRfiD1mf8f 5f53R6n+9yRDs5l3xetYFpStItCLOBerZvjFbgYUhLuHZi82PR/EpQpYFjp4SW4MBFLA olIKZCGum/38hT8TX1bNaKcymNPzzJrFFR401+rDYQH7mnH5LEy9e3nPCHjOVQaqjWeR +nntYVIN94hMNcWu2tyCfXHl/2x5SmeZUVIGj4dYPhzWC+RQvCWtK8fsTQsT4Es+inSu 1G7g== X-Gm-Message-State: APjAAAX6sf0S3bfHFnQpLKUc8rYSC4JnfKBA26iT5F/jhiUTZfZs5aOO 5FvZ+FwiZ5rM2R0Na3xj4hX27lHl1AwoFep582E= X-Google-Smtp-Source: APXvYqyMnwmQaBB6keH+7N6GoTYPAP1AV05z18cHWSyvd3I7LlyyF684J1qCYWRK83aQToRcn8gelB+c+gxZuZmFgNA= X-Received: by 2002:a9d:7352:: with SMTP id l18mr12001687otk.292.1563123328338; Sun, 14 Jul 2019 09:55:28 -0700 (PDT) MIME-Version: 1.0 References: <6a260307-a463-bd08-8a10-d7664d0606a2@cs.ucla.edu> <74235afc-7043-1da7-7c71-07f0ca23b9fd@cs.ucla.edu> In-Reply-To: <74235afc-7043-1da7-7c71-07f0ca23b9fd@cs.ucla.edu> From: Pip Cet Date: Sun, 14 Jul 2019 16:54:52 +0000 Message-ID: Subject: Re: bug#36597: 27.0.50; rehash hash tables eagerly in pdumper To: Paul Eggert Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 36597 Cc: 36597@debbugs.gnu.org, Daniel Colascione X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) On Sun, Jul 14, 2019 at 3:49 PM Paul Eggert wrote: > Pip Cet wrote: > > Indeed, that's plenty of small Emacs processes not doing very much. > > It's not the case we ought to be optimizing for, I think, but the > > performance concerns should be taken seriously. > > What's a good benchmark for what we should be optimizing for? Ideally som= ething > somewhat-realistic as opposed to a microbenchmark. I'd suggest something along the lines of: perf stat -r 10 --table -e cycles:u,instructions:u,branches:u,branch-misses:u make -B ../lisp/leim/ja-dic/ja-dic.el With my patch: 61,136,837,192 cycles:u ( +- 0.42% ) 42,313,912,525 instructions:u # 0.69 insn per cycle ( +- 0.00% ) 12,131,893,779 branches:u ( +- 0.00% ) 47,602,747 branch-misses:u # 0.39% of all branches ( +- 1.11% ) without my patch: 61,460,927,899 cycles:u ( +- 0.44% ) 42,358,289,131 instructions:u # 0.69 insn per cycle ( +- 0.00% ) 12,134,582,441 branches:u ( +- 0.00% ) 48,540,232 branch-misses:u # 0.40% of all branches ( +- 1.09% ) A 0.5% improvement. By comparison, perf stat -r 100 --table -e cycles:u,instructions:u,branches:u,branch-misses:u ~/git/emacs/src/emacs -Q --batch With my patch: 80,749,425 cycles:u ( +- 0.81% ) 146,770,045 instructions:u # 1.82 insn per cycle ( +- 0.00% ) 29,218,226 branches:u ( +- 0.00% ) 450,275 branch-misses:u # 1.54% of all branches ( +- 0.11% ) without my patch: 78,896,395 cycles:u ( +- 0.12% ) 147,059,777 instructions:u # 1.86 insn per cycle ( +- 0.00% ) 29,287,917 branches:u ( +- 0.00% ) 450,194 branch-misses:u # 1.54% of all branches ( +- 0.09% ) About a 2% slowdown. perf stat -r cycles:u,instructions:u,branches:u,missed-branches:u > is dominated by a single CPU-intensive Emacs process and takes about 19 C= PU > seconds on my home desktop. The proposed patch slows this benchmark down = by > about 0.6%. (I ran the benchmark ten times after a warmup run, and took t= he > average of the ten user+system times.) Hmm. I'd like to know the reason for that, but I suspect it may simply be thermal throttling. That's the reason I'm running tests in parallel, though it might be better to compare instruction counts or scheduled =C2=B5-ops rather than cycles... From debbugs-submit-bounces@debbugs.gnu.org Mon Jul 15 10:40:37 2019 Received: (at 36597) by debbugs.gnu.org; 15 Jul 2019 14:40:37 +0000 Received: from localhost ([127.0.0.1]:48693 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hn29c-0000vK-LN for submit@debbugs.gnu.org; Mon, 15 Jul 2019 10:40:36 -0400 Received: from mail-oi1-f170.google.com ([209.85.167.170]:34418) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hn29Y-0000v3-HD for 36597@debbugs.gnu.org; Mon, 15 Jul 2019 10:40:35 -0400 Received: by mail-oi1-f170.google.com with SMTP id l12so12830321oil.1 for <36597@debbugs.gnu.org>; Mon, 15 Jul 2019 07:40:32 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc; bh=hmzGg/srQlD9m0/WzOYg+2UdDlZrkD64OYN86d/e82I=; b=bC2E3Sb0kn2d9mPF/An9fRrAt6K/NqRCNPTjLiqn5L5ksKik0kywI2fncdkitlo7yF 4ijEkjE86m1WzP+S4QnUfx93Qbo0P/XU6IhXnS6xn1z70TCDLd4upTScpIYh/xRipg7J TMUGZ7olgSAqE0cizxbDYpWFskoRywzgUGCnWvaBuk7QkRiaPJcAIZ84mPVm4Owylrzq KIxtz8sNTv1ogXGkQ0adov3TV3KpCWpvto3fOOI1IdOjcoDxXad21gaTl5O8tr0T9qFW AKG3nnARgtlUULeltuXrGpj3Il8AqySVMFpj6R1XA1UZHTN/lcWKNzyWyvgmLjYvsXu4 FyvA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=hmzGg/srQlD9m0/WzOYg+2UdDlZrkD64OYN86d/e82I=; b=l0cAxzVcCNwxIgeYDifPYJb+e+MgEj5ULunmG5bjTUbW41Q+pYI3RBRyrMyTA449BW WpME/dKlLcgq/eUrm3AMSk5Nk4uyifBMbOPRRNAiVB/qX8elZc8sIjYXHiOJMitR31ZW 2pkH/HB3Mrggr4O5BWZsKdimywrbaUvHdTMgdO7njHo0ZLQmkyh/uZ+UfZV9hs/8ES3m p4/A9hyeJ7BzKLpJqq24xwSYU42RyTc7B0Tzui0MTDQ1ZcF/Iz9CKd6ky0i7TZuR9lvM kBhBpVPgklX3jTKm8ybmOLJJSixs06q8qxN4FnoLrVLqjgqs8u6dqaqomM4ws4Gzo6sl m0JA== X-Gm-Message-State: APjAAAXWDG+G7WkIh1y22b/gMZi7dyA3eRTFasqbvwrT/NO8KQgzT6pN +HpB6MRshrud/OSa512YqW9jCaFQk7zRuW4CcbE= X-Google-Smtp-Source: APXvYqzb3dbM5PtC890CVzq5JM0sLtiGVQ57D30WuTP/we1SvH5xHn0g72M5mbg9ZPqSVP3mifDOmEkHcJWibINgC8E= X-Received: by 2002:aca:be88:: with SMTP id o130mr13134250oif.122.1563201626953; Mon, 15 Jul 2019 07:40:26 -0700 (PDT) MIME-Version: 1.0 References: <6a260307-a463-bd08-8a10-d7664d0606a2@cs.ucla.edu> <74235afc-7043-1da7-7c71-07f0ca23b9fd@cs.ucla.edu> In-Reply-To: From: Pip Cet Date: Mon, 15 Jul 2019 14:39:49 +0000 Message-ID: Subject: Re: bug#36597: 27.0.50; rehash hash tables eagerly in pdumper To: Paul Eggert Content-Type: text/plain; charset="UTF-8" X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 36597 Cc: 36597@debbugs.gnu.org, Daniel Colascione X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) On Sun, Jul 14, 2019 at 4:54 PM Pip Cet wrote: > > What's a good benchmark for what we should be optimizing for? Ideally something > > somewhat-realistic as opposed to a microbenchmark. Here are the things I've tried so far (building a full histogram of actual clock cycles per run in all cases): 1. ja-dic.el: my patch is slightly faster: (on the order of 0.5%) 2. emacs -Q --batch: my patch is slightly slower (on the order of ~2%) 3. emacs -Q --eval "(run-with-timer 1 nil #'kill-emacs)": my patch is very slightly faster (on the order of 0.1%) Test 3 was run using a dedicated Xvnc server; all tests were run in parallel with and without the patch. The main advantage of my patch appears to be a reduction in pdumper image size, which somehow leads to the performance improvement. I haven't benchmarked a hypothetical patch which reduces the pdumper image size but continues rehashing lazily. But I noticed that my patch may affect hashes more than it should, because it makes the thawed hash have the same size as the number of hash entries in it. That seems not to hurt performance... From debbugs-submit-bounces@debbugs.gnu.org Thu Jul 18 01:39:38 2019 Received: (at 36597) by debbugs.gnu.org; 18 Jul 2019 05:39:38 +0000 Received: from localhost ([127.0.0.1]:53280 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hnz8j-0005al-JI for submit@debbugs.gnu.org; Thu, 18 Jul 2019 01:39:38 -0400 Received: from eggs.gnu.org ([209.51.188.92]:51601) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hnz8g-0005aT-Ds for 36597@debbugs.gnu.org; Thu, 18 Jul 2019 01:39:35 -0400 Received: from fencepost.gnu.org ([2001:470:142:3::e]:47953) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1hnz8a-0006WA-BW; Thu, 18 Jul 2019 01:39:28 -0400 Received: from [176.228.60.248] (port=2155 helo=home-c4e4a596f7) by fencepost.gnu.org with esmtpsa (TLS1.2:RSA_AES_256_CBC_SHA1:256) (Exim 4.82) (envelope-from ) id 1hnz8Z-00068w-Io; Thu, 18 Jul 2019 01:39:28 -0400 Date: Thu, 18 Jul 2019 08:39:20 +0300 Message-Id: <831rynzyt3.fsf@gnu.org> From: Eli Zaretskii To: Paul Eggert In-reply-to: <6a260307-a463-bd08-8a10-d7664d0606a2@cs.ucla.edu> (message from Paul Eggert on Sun, 14 Jul 2019 07:39:08 -0700) Subject: Re: bug#36597: 27.0.50; rehash hash tables eagerly in pdumper References: <6a260307-a463-bd08-8a10-d7664d0606a2@cs.ucla.edu> X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.2.x-3.x [generic] X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 36597 Cc: 36597@debbugs.gnu.org, Daniel Colascione , pipcet@gmail.com X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) > From: Paul Eggert > Date: Sun, 14 Jul 2019 07:39:08 -0700 > Cc: 36597@debbugs.gnu.org > > Although I like the simplicity of eager rehashing, I'm not yet sold on the > performance implications. On my usual (cd lisp && make compile-always) > benchmark, the patch hurt user+system CPU time performance by 1.5%. Admittedly > just one benchmark, but still.... > > Also, must we expose Vpdumper_hash_tables to Lisp? Surely it'd be better to keep > it private to pdumper.c. > > I'll CC: to Daniel to see whether he has any insights about improvements in this > area. You didn't CC Daniel, AFAICT, so I did that now. > PS. I ran that benchmark on my home desktop, an Intel Xeon E3-1225 v2 running > Ubunto 18.04.2. To run it, I rebased your patch and also removed the > no-longer-used PDUMPER_CHECK_REHASHING macro that my GCC complained about > (wonder why that didn't happen for you?), resulting in the attached patch > against current master 8ff09154a29a1151afb2902267ca35f89ebda73c. > > >From 96a36697b2f472f3a6b3138444659babd0d73f32 Mon Sep 17 00:00:00 2001 > From: Pip Cet > Date: Sun, 14 Jul 2019 07:22:01 -0700 > Subject: [PATCH] Rehash hash tables eagerly after loading a portable dump > > * src/lisp.h (hash_rehash_needed_p): Remove. All uses removed. > (hash_rehash_if_needed): Remove. All uses removed. > (struct Lisp_Hash_Table): Remove comment about rehashing hash tables. > * src/pdumper.c (thaw_hash_tables): New function. > (hash_table_thaw): New function. > (hash_table_freeze): New function. > (dump_hash_table): Simplify. > (dump_hash_table_list): New function. > (hash_table_contents): New function. > (Fdump_emacs_portable): Handle hash tables by eager rehashing. > (pdumper_load): Restore hash tables. > (init_pdumper_once): New function. > (PDUMPER_CHECK_REHASHING): Remove. > --- > src/bytecode.c | 1 - > src/composite.c | 1 - > src/emacs.c | 1 + > src/fns.c | 54 ++++---------- > src/lisp.h | 19 +---- > src/minibuf.c | 3 - > src/pdumper.c | 188 ++++++++++++++++++++++++------------------------ > src/pdumper.h | 1 + > 8 files changed, 108 insertions(+), 160 deletions(-) > > diff --git a/src/bytecode.c b/src/bytecode.c > index 29dff44f00..9c72429e0c 100644 > --- a/src/bytecode.c > +++ b/src/bytecode.c > @@ -1402,7 +1402,6 @@ #define DEFINE(name, value) LABEL (name) , > Lisp_Object v1 = POP; > ptrdiff_t i; > struct Lisp_Hash_Table *h = XHASH_TABLE (jmp_table); > - hash_rehash_if_needed (h); > > /* h->count is a faster approximation for HASH_TABLE_SIZE (h) > here. */ > diff --git a/src/composite.c b/src/composite.c > index 183062de46..49a285cff0 100644 > --- a/src/composite.c > +++ b/src/composite.c > @@ -654,7 +654,6 @@ gstring_lookup_cache (Lisp_Object header) > composition_gstring_put_cache (Lisp_Object gstring, ptrdiff_t len) > { > struct Lisp_Hash_Table *h = XHASH_TABLE (gstring_hash_table); > - hash_rehash_if_needed (h); > Lisp_Object header = LGSTRING_HEADER (gstring); > EMACS_UINT hash = h->test.hashfn (&h->test, header); > if (len < 0) > diff --git a/src/emacs.c b/src/emacs.c > index ad661a081b..855b2c6715 100644 > --- a/src/emacs.c > +++ b/src/emacs.c > @@ -1560,6 +1560,7 @@ main (int argc, char **argv) > if (!initialized) > { > init_alloc_once (); > + init_pdumper_once (); > init_obarray_once (); > init_eval_once (); > init_charset_once (); > diff --git a/src/fns.c b/src/fns.c > index 0497588689..b6134a314c 100644 > --- a/src/fns.c > +++ b/src/fns.c > @@ -4241,43 +4241,24 @@ hash_table_rehash (struct Lisp_Hash_Table *h) > { > ptrdiff_t size = HASH_TABLE_SIZE (h); > > - /* These structures may have been purecopied and shared > - (bug#36447). */ > - h->next = Fcopy_sequence (h->next); > - h->index = Fcopy_sequence (h->index); > - h->hash = Fcopy_sequence (h->hash); > - > /* Recompute the actual hash codes for each entry in the table. > Order is still invalid. */ > for (ptrdiff_t i = 0; i < size; ++i) > - if (!NILP (HASH_HASH (h, i))) > - { > - Lisp_Object key = HASH_KEY (h, i); > - EMACS_UINT hash_code = h->test.hashfn (&h->test, key); > - set_hash_hash_slot (h, i, make_fixnum (hash_code)); > - } > - > - /* Reset the index so that any slot we don't fill below is marked > - invalid. */ > - Ffillarray (h->index, make_fixnum (-1)); > + { > + Lisp_Object key = HASH_KEY (h, i); > + EMACS_UINT hash_code = h->test.hashfn (&h->test, key); > + set_hash_hash_slot (h, i, make_fixnum (hash_code)); > + } > > /* Rebuild the collision chains. */ > for (ptrdiff_t i = 0; i < size; ++i) > - if (!NILP (HASH_HASH (h, i))) > - { > - EMACS_UINT hash_code = XUFIXNUM (HASH_HASH (h, i)); > - ptrdiff_t start_of_bucket = hash_code % ASIZE (h->index); > - set_hash_next_slot (h, i, HASH_INDEX (h, start_of_bucket)); > - set_hash_index_slot (h, start_of_bucket, i); > - eassert (HASH_NEXT (h, i) != i); /* Stop loops. */ > - } > - > - /* Finally, mark the hash table as having a valid hash order. > - Do this last so that if we're interrupted, we retry on next > - access. */ > - eassert (h->count < 0); > - h->count = -h->count; > - eassert (!hash_rehash_needed_p (h)); > + { > + EMACS_UINT hash_code = XUFIXNUM (HASH_HASH (h, i)); > + ptrdiff_t start_of_bucket = hash_code % ASIZE (h->index); > + set_hash_next_slot (h, i, HASH_INDEX (h, start_of_bucket)); > + set_hash_index_slot (h, start_of_bucket, i); > + eassert (HASH_NEXT (h, i) != i); /* Stop loops. */ > + } > } > > /* Lookup KEY in hash table H. If HASH is non-null, return in *HASH > @@ -4290,8 +4271,6 @@ hash_lookup (struct Lisp_Hash_Table *h, Lisp_Object key, EMACS_UINT *hash) > EMACS_UINT hash_code; > ptrdiff_t start_of_bucket, i; > > - hash_rehash_if_needed (h); > - > hash_code = h->test.hashfn (&h->test, key); > eassert ((hash_code & ~INTMASK) == 0); > if (hash) > @@ -4320,8 +4299,6 @@ hash_put (struct Lisp_Hash_Table *h, Lisp_Object key, Lisp_Object value, > { > ptrdiff_t start_of_bucket, i; > > - hash_rehash_if_needed (h); > - > eassert ((hash & ~INTMASK) == 0); > > /* Increment count after resizing because resizing may fail. */ > @@ -4355,8 +4332,6 @@ hash_remove_from_table (struct Lisp_Hash_Table *h, Lisp_Object key) > ptrdiff_t start_of_bucket = hash_code % ASIZE (h->index); > ptrdiff_t prev = -1; > > - hash_rehash_if_needed (h); > - > for (ptrdiff_t i = HASH_INDEX (h, start_of_bucket); > 0 <= i; > i = HASH_NEXT (h, i)) > @@ -4434,9 +4409,7 @@ sweep_weak_table (struct Lisp_Hash_Table *h, bool remove_entries_p) > for (ptrdiff_t bucket = 0; bucket < n; ++bucket) > { > /* Follow collision chain, removing entries that don't survive > - this garbage collection. It's okay if hash_rehash_needed_p > - (h) is true, since we're operating entirely on the cached > - hash values. */ > + this garbage collection. */ > ptrdiff_t prev = -1; > ptrdiff_t next; > for (ptrdiff_t i = HASH_INDEX (h, bucket); 0 <= i; i = next) > @@ -4881,7 +4854,6 @@ DEFUN ("hash-table-count", Fhash_table_count, Shash_table_count, 1, 1, 0, > (Lisp_Object table) > { > struct Lisp_Hash_Table *h = check_hash_table (table); > - hash_rehash_if_needed (h); > return make_fixnum (h->count); > } > > diff --git a/src/lisp.h b/src/lisp.h > index 13014c82dc..d0e5c43c41 100644 > --- a/src/lisp.h > +++ b/src/lisp.h > @@ -2245,11 +2245,7 @@ #define DEFSYM(sym, name) /* empty */ > > struct Lisp_Hash_Table > { > - /* Change pdumper.c if you change the fields here. > - > - IMPORTANT!!!!!!! > - > - Call hash_rehash_if_needed() before accessing. */ > + /* Change pdumper.c if you change the fields here. */ > > /* This is for Lisp; the hash table code does not refer to it. */ > union vectorlike_header header; > @@ -2363,19 +2359,6 @@ HASH_TABLE_SIZE (const struct Lisp_Hash_Table *h) > > void hash_table_rehash (struct Lisp_Hash_Table *h); > > -INLINE bool > -hash_rehash_needed_p (const struct Lisp_Hash_Table *h) > -{ > - return h->count < 0; > -} > - > -INLINE void > -hash_rehash_if_needed (struct Lisp_Hash_Table *h) > -{ > - if (hash_rehash_needed_p (h)) > - hash_table_rehash (h); > -} > - > /* Default size for hash tables if not specified. */ > > enum DEFAULT_HASH_SIZE { DEFAULT_HASH_SIZE = 65 }; > diff --git a/src/minibuf.c b/src/minibuf.c > index d9a6e15b05..e923ce2a43 100644 > --- a/src/minibuf.c > +++ b/src/minibuf.c > @@ -1203,9 +1203,6 @@ DEFUN ("try-completion", Ftry_completion, Stry_completion, 2, 3, 0, > bucket = AREF (collection, idx); > } > > - if (HASH_TABLE_P (collection)) > - hash_rehash_if_needed (XHASH_TABLE (collection)); > - > while (1) > { > /* Get the next element of the alist, obarray, or hash-table. */ > diff --git a/src/pdumper.c b/src/pdumper.c > index 03c00bf27b..d35d296d32 100644 > --- a/src/pdumper.c > +++ b/src/pdumper.c > @@ -107,17 +107,6 @@ #define VM_MS_WINDOWS 2 > > #define DANGEROUS 0 > > -/* PDUMPER_CHECK_REHASHING being true causes the portable dumper to > - check, for each hash table it dumps, that the hash table means the > - same thing after rehashing. */ > -#ifndef PDUMPER_CHECK_REHASHING > -# if ENABLE_CHECKING > -# define PDUMPER_CHECK_REHASHING 1 > -# else > -# define PDUMPER_CHECK_REHASHING 0 > -# endif > -#endif > - > /* We require an architecture in which all pointers are the same size > and have the same layout, where pointers are either 32 or 64 bits > long, and where bytes have eight bits --- that is, a > @@ -393,6 +382,8 @@ dump_fingerprint (char const *label, > The start of the cold region is always aligned on a page > boundary. */ > dump_off cold_start; > + > + dump_off hash_list; > }; > > /* Double-ended singly linked list. */ > @@ -550,6 +541,8 @@ dump_fingerprint (char const *label, > heap objects. */ > Lisp_Object bignum_data; > > + Lisp_Object hash_tables; > + > unsigned number_hot_relocations; > unsigned number_discardable_relocations; > }; > @@ -2622,68 +2615,64 @@ dump_vectorlike_generic (struct dump_context *ctx, > return offset; > } > > -/* Determine whether the hash table's hash order is stable > - across dump and load. If it is, we don't have to trigger > - a rehash on access. */ > -static bool > -dump_hash_table_stable_p (const struct Lisp_Hash_Table *hash) > +/* Return a list of (KEY . VALUE) pairs in the given hash table. */ > +static Lisp_Object > +hash_table_contents (struct Lisp_Hash_Table *h) > { > - bool is_eql = hash->test.hashfn == hashfn_eql; > - bool is_equal = hash->test.hashfn == hashfn_equal; > - ptrdiff_t size = HASH_TABLE_SIZE (hash); > - for (ptrdiff_t i = 0; i < size; ++i) > - if (!NILP (HASH_HASH (hash, i))) > + Lisp_Object contents = Qnil; > + /* Make sure key_and_value ends up in the same order, charset.c > + relies on it by expecting hash table indices to stay constant > + across the dump. */ > + for (ptrdiff_t i = HASH_TABLE_SIZE (h) - 1; i >= 0; --i) > + if (!NILP (HASH_HASH (h, i))) > { > - Lisp_Object key = HASH_KEY (hash, i); > - bool key_stable = (dump_builtin_symbol_p (key) > - || FIXNUMP (key) > - || (is_equal && STRINGP (key)) > - || ((is_equal || is_eql) && FLOATP (key))); > - if (!key_stable) > - return false; > + dump_push (&contents, HASH_VALUE (h, i)); > + dump_push (&contents, HASH_KEY (h, i)); > } > + return CALLN (Fapply, Qvector, contents); > +} > > - return true; > +static dump_off > +dump_hash_table_list (struct dump_context *ctx) > +{ > + if (CONSP (ctx->hash_tables)) > + return dump_object (ctx, CALLN (Fapply, Qvector, ctx->hash_tables)); > + else > + return 0; > } > > -/* Return a list of (KEY . VALUE) pairs in the given hash table. */ > -static Lisp_Object > -hash_table_contents (Lisp_Object table) > +static void > +hash_table_freeze (struct Lisp_Hash_Table *h) > { > - Lisp_Object contents = Qnil; > - struct Lisp_Hash_Table *h = XHASH_TABLE (table); > - for (ptrdiff_t i = 0; i < HASH_TABLE_SIZE (h); ++i) > - if (!NILP (HASH_HASH (h, i))) > - dump_push (&contents, Fcons (HASH_KEY (h, i), HASH_VALUE (h, i))); > - return Fnreverse (contents); > + h->key_and_value = hash_table_contents (h); > + ptrdiff_t nkeys = XFIXNAT (Flength (h->key_and_value)) / 2; > + h->count = nkeys; > + if (nkeys == 0) > + nkeys = 1; > + h->index = h->next = h->hash = make_fixnum (nkeys); > } > > -/* Copy the given hash table, rehash it, and make sure that we can > - look up all the values in the original. */ > static void > -check_hash_table_rehash (Lisp_Object table_orig) > -{ > - hash_rehash_if_needed (XHASH_TABLE (table_orig)); > - Lisp_Object table_rehashed = Fcopy_hash_table (table_orig); > - eassert (XHASH_TABLE (table_rehashed)->count >= 0); > - XHASH_TABLE (table_rehashed)->count *= -1; > - eassert (XHASH_TABLE (table_rehashed)->count <= 0); > - hash_rehash_if_needed (XHASH_TABLE (table_rehashed)); > - eassert (XHASH_TABLE (table_rehashed)->count >= 0); > - Lisp_Object expected_contents = hash_table_contents (table_orig); > - while (!NILP (expected_contents)) > +hash_table_thaw (struct Lisp_Hash_Table *h) > +{ > + Lisp_Object count = h->index; > + h->index = Fmake_vector (h->index, make_fixnum (-1)); > + h->hash = Fmake_vector (h->hash, Qnil); > + h->next = Fmake_vector (h->next, make_fixnum (-1)); > + Lisp_Object key_and_value = h->key_and_value; > + h->next_free = -1; > + if (XFIXNAT (count) <= 1) > { > - Lisp_Object key_value_pair = dump_pop (&expected_contents); > - Lisp_Object key = XCAR (key_value_pair); > - Lisp_Object expected_value = XCDR (key_value_pair); > - Lisp_Object arbitrary = Qdump_emacs_portable__sort_predicate_copied; > - Lisp_Object found_value = Fgethash (key, table_rehashed, arbitrary); > - eassert (EQ (expected_value, found_value)); > - Fremhash (key, table_rehashed); > + h->key_and_value = Fmake_vector (make_fixnum (2 * XFIXNAT (count)), Qnil); > + ptrdiff_t i = 0; > + while (i < ASIZE (key_and_value)) > + { > + ASET (h->key_and_value, i, AREF (key_and_value, i)); > + i++; > + } > } > > - eassert (EQ (Fhash_table_count (table_rehashed), > - make_fixnum (0))); > + hash_table_rehash (h); > } > > static dump_off > @@ -2695,45 +2684,11 @@ dump_hash_table (struct dump_context *ctx, > # error "Lisp_Hash_Table changed. See CHECK_STRUCTS comment in config.h." > #endif > const struct Lisp_Hash_Table *hash_in = XHASH_TABLE (object); > - bool is_stable = dump_hash_table_stable_p (hash_in); > - /* If the hash table is likely to be modified in memory (either > - because we need to rehash, and thus toggle hash->count, or > - because we need to assemble a list of weak tables) punt the hash > - table to the end of the dump, where we can lump all such hash > - tables together. */ > - if (!(is_stable || !NILP (hash_in->weak)) > - && ctx->flags.defer_hash_tables) > - { > - if (offset != DUMP_OBJECT_ON_HASH_TABLE_QUEUE) > - { > - eassert (offset == DUMP_OBJECT_ON_NORMAL_QUEUE > - || offset == DUMP_OBJECT_NOT_SEEN); > - /* We still want to dump the actual keys and values now. */ > - dump_enqueue_object (ctx, hash_in->key_and_value, WEIGHT_NONE); > - /* We'll get to the rest later. */ > - offset = DUMP_OBJECT_ON_HASH_TABLE_QUEUE; > - dump_remember_object (ctx, object, offset); > - dump_push (&ctx->deferred_hash_tables, object); > - } > - return offset; > - } > - > - if (PDUMPER_CHECK_REHASHING) > - check_hash_table_rehash (make_lisp_ptr ((void *) hash_in, Lisp_Vectorlike)); > - > struct Lisp_Hash_Table hash_munged = *hash_in; > struct Lisp_Hash_Table *hash = &hash_munged; > > - /* Remember to rehash this hash table on first access. After a > - dump reload, the hash table values will have changed, so we'll > - need to rebuild the index. > - > - TODO: for EQ and EQL hash tables, it should be possible to rehash > - here using the preferred load address of the dump, eliminating > - the need to rehash-on-access if we can load the dump where we > - want. */ > - if (hash->count > 0 && !is_stable) > - hash->count = -hash->count; > + hash_table_freeze (hash); > + dump_push (&ctx->hash_tables, object); > > START_DUMP_PVEC (ctx, &hash->header, struct Lisp_Hash_Table, out); > dump_pseudovector_lisp_fields (ctx, &out->header, &hash->header); > @@ -4140,6 +4095,19 @@ DEFUN ("dump-emacs-portable", > || !NILP (ctx->deferred_hash_tables) > || !NILP (ctx->deferred_symbols)); > > + ctx->header.hash_list = ctx->offset; > + dump_hash_table_list (ctx); > + > + do > + { > + dump_drain_deferred_hash_tables (ctx); > + dump_drain_deferred_symbols (ctx); > + dump_drain_normal_queue (ctx); > + } > + while (!dump_queue_empty_p (&ctx->dump_queue) > + || !NILP (ctx->deferred_hash_tables) > + || !NILP (ctx->deferred_symbols)); > + > dump_sort_copied_objects (ctx); > > /* While we copy built-in symbols into the Emacs image, these > @@ -5431,6 +5399,13 @@ pdumper_load (const char *dump_filename) > for (int i = 0; i < ARRAYELTS (sections); ++i) > dump_mmap_reset (§ions[i]); > > + if (header->hash_list) > + { > + struct Lisp_Vector *hash_tables = > + ((struct Lisp_Vector *)(dump_base + header->hash_list)); > + XSETVECTOR (Vpdumper_hash_tables, hash_tables); > + } > + > /* Run the functions Emacs registered for doing post-dump-load > initialization. */ > for (int i = 0; i < nr_dump_hooks; ++i) > @@ -5502,10 +5477,31 @@ DEFUN ("pdumper-stats", Fpdumper_stats, Spdumper_stats, 0, 0, 0, > > > > +static void thaw_hash_tables (void) > +{ > + Lisp_Object hash_tables = Vpdumper_hash_tables; > + ptrdiff_t i = 0; > + while (i < ASIZE (hash_tables)) > + { > + hash_table_thaw (XHASH_TABLE (AREF (hash_tables, i))); > + i++; > + } > + Vpdumper_hash_tables = zero_vector; > +} > + > +void > +init_pdumper_once (void) > +{ > + Vpdumper_hash_tables = zero_vector; > + pdumper_do_now_and_after_load (thaw_hash_tables); > +} > + > void > syms_of_pdumper (void) > { > #ifdef HAVE_PDUMPER > + DEFVAR_LISP ("pdumper-hash-tables", Vpdumper_hash_tables, > + doc: /* A list of hash tables that need to be thawed after loading the pdump. */); > defsubr (&Sdump_emacs_portable); > defsubr (&Sdump_emacs_portable__sort_predicate); > defsubr (&Sdump_emacs_portable__sort_predicate_copied); > diff --git a/src/pdumper.h b/src/pdumper.h > index ab2f426c1e..cfea06d33d 100644 > --- a/src/pdumper.h > +++ b/src/pdumper.h > @@ -248,6 +248,7 @@ pdumper_clear_marks (void) > file was loaded. */ > extern void pdumper_record_wd (const char *); > > +void init_pdumper_once (void); > void syms_of_pdumper (void); > > INLINE_HEADER_END > -- > 2.17.1 > From debbugs-submit-bounces@debbugs.gnu.org Fri Jul 19 03:24:35 2019 Received: (at 36597) by debbugs.gnu.org; 19 Jul 2019 07:24:36 +0000 Received: from localhost ([127.0.0.1]:55049 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hoNFr-0001T9-58 for submit@debbugs.gnu.org; Fri, 19 Jul 2019 03:24:35 -0400 Received: from mail-oi1-f170.google.com ([209.85.167.170]:38590) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hoNFo-0001Sw-PA for 36597@debbugs.gnu.org; Fri, 19 Jul 2019 03:24:33 -0400 Received: by mail-oi1-f170.google.com with SMTP id v186so23559109oie.5 for <36597@debbugs.gnu.org>; Fri, 19 Jul 2019 00:24:32 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc; bh=hFplcDCuhvI8eQZhWlWsttkPJU9IDkmxJPJixjF7u98=; b=Ra92w8JpPbsErQO6Da/jCsBMCYNfvk18QZ3cmOKboXhcBmGr+GfN6h+UecWdM6fPC+ nMlpAsC02XegSEiqWzF65vG38XiXFPJmZwBOPn5kEAaYV08G2bbS42fh5vEd5/e8Hkla pax3Ydi8L07Hm+1elEGO4N4LjrLXQhjWugVPl/W+JeIFESwvTXdp1z3l+lPTC1aIv1D1 P63lqDdv9u67fNZ7fJlmFX69kflN3qrW4dQ6vhg7gOSS/OXNU7tmV1YKfY3Ge8l+VL8d mLBjHi6bSP5QtfXZqNVBRzxP6lkmK0n7KmwIF5Jz7QjFGDBR8UICI3f97Q9aw6RS5a+A nhZg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=hFplcDCuhvI8eQZhWlWsttkPJU9IDkmxJPJixjF7u98=; b=fCtB+yodaGkek2KNOk1D7K+RJotwAK1fCQlRny4GTfmaZGBpEXNr7MNTkcnkEo0NYU Ez01UvUPBCBYIFlcujaTO+NdpXtPIpqpKN588u0mDbRtTipvbyURO+uG49HxU/y+D9Nd 7+WptV7iKPuOtwL3DjSAM1oAhILgJbuF6IIau5Bw30ZxFl77B2DQeOR8wvwdQEIz0hwq 2CpFQa0IKhcO2Sh5w7LcL2jmKTDEmRrItWiHTUNfhl1mpsN76dddFtcN9UrsSaIW1cT1 iVA4hoOB0AQGcumG0MbYgT9gAlr1u7n46GstEM+Lghw3IOw1INJ/NTsWwX4CSB1Ka/sp MlNA== X-Gm-Message-State: APjAAAUW2wsnAdyQ6GoT/sCPCDt46nZ1MvEL8oP6fCBcK7dQSKC5CWZB jvClBU7s/nFOM+pq/e4VRTQCwYQYDuZk5eB61tmw+A== X-Google-Smtp-Source: APXvYqyUZjIjew0UjsbCtSYVo8wY6+9/rE3hv4bBNwhoTokE+934GLII0ZJA9UkOsvuus8DI4TRtQH2W+PTscRsA+2I= X-Received: by 2002:aca:be88:: with SMTP id o130mr25028659oif.122.1563521067055; Fri, 19 Jul 2019 00:24:27 -0700 (PDT) MIME-Version: 1.0 References: <6a260307-a463-bd08-8a10-d7664d0606a2@cs.ucla.edu> <74235afc-7043-1da7-7c71-07f0ca23b9fd@cs.ucla.edu> In-Reply-To: From: Pip Cet Date: Fri, 19 Jul 2019 07:23:50 +0000 Message-ID: Subject: Re: bug#36597: 27.0.50; rehash hash tables eagerly in pdumper To: Paul Eggert Content-Type: multipart/mixed; boundary="000000000000cd2240058e039dc6" X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 36597 Cc: 36597@debbugs.gnu.org, Daniel Colascione X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) --000000000000cd2240058e039dc6 Content-Type: text/plain; charset="UTF-8" On Mon, Jul 15, 2019 at 2:39 PM Pip Cet wrote: > But I noticed that my patch may affect hashes more than it should, > because it makes the thawed hash have the same size as the number of > hash entries in it. That seems not to hurt performance... But it should be fixed, anyway. The attached patch has no unexpected performance benefits, as far as I can tell. --000000000000cd2240058e039dc6 Content-Type: text/x-patch; charset="US-ASCII"; name="0001-Rehash-hash-tables-eagerly-after-loading-a-dump.patch" Content-Disposition: attachment; filename="0001-Rehash-hash-tables-eagerly-after-loading-a-dump.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_jy9rq33t0 RnJvbSAyMWVmNWRlZDM3NDE0Mjk4MzdlOTAzZWI5YWRlODhkNTkzYmMwZDhmIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBQaXAgQ2V0IDxwaXBjZXRAZ21haWwuY29tPgpEYXRlOiBGcmks IDE5IEp1bCAyMDE5IDA3OjEyOjQyICswMDAwClN1YmplY3Q6IFtQQVRDSF0gUmVoYXNoIGhhc2gg dGFibGVzIGVhZ2VybHkgYWZ0ZXIgbG9hZGluZyBhIGR1bXAuCgoqIHNyYy9saXNwLmggKGhhc2hf cmVoYXNoX25lZWRlZF9wKTogUmVtb3ZlLiAgQWxsIHVzZXMgcmVtb3ZlZC4KKGhhc2hfcmVoYXNo X2lmX25lZWRlZCk6IFJlbW92ZS4gIEFsbCB1c2VzIHJlbW92ZWQuCihzdHJ1Y3QgTGlzcF9IYXNo X1RhYmxlKTogUmVtb3ZlIGNvbW1lbnQgYWJvdXQgcmVoYXNoaW5nIGhhc2ggdGFibGVzLgoqIHNy Yy9wZHVtcGVyLmMgKHRoYXdfaGFzaF90YWJsZXMpOiBOZXcgZnVuY3Rpb24uCihoYXNoX3RhYmxl X3RoYXcpOiBOZXcgZnVuY3Rpb24uCihoYXNoX3RhYmxlX2ZyZWV6ZSk6IE5ldyBmdW5jdGlvbi4K KGR1bXBfaGFzaF90YWJsZSk6IFNpbXBsaWZ5LgooZHVtcF9oYXNoX3RhYmxlX2xpc3QpOiBOZXcg ZnVuY3Rpb24uCihoYXNoX3RhYmxlX2NvbnRlbnRzKTogTmV3IGZ1bmN0aW9uLgooRmR1bXBfZW1h Y3NfcG9ydGFibGUpOiBIYW5kbGUgaGFzaCB0YWJsZXMgYnkgZWFnZXIgcmVoYXNoaW5nLgoocGR1 bXBlcl9sb2FkKTogUmVzdG9yZSBoYXNoIHRhYmxlcy4KKGluaXRfcGR1bXBlcl9vbmNlKTogTmV3 IGZ1bmN0aW9uLgotLS0KIHNyYy9ieXRlY29kZS5jICB8ICAgMSAtCiBzcmMvY29tcG9zaXRlLmMg fCAgIDEgLQogc3JjL2VtYWNzLmMgICAgIHwgICAxICsKIHNyYy9mbnMuYyAgICAgICB8ICA2NSAr KysrKy0tLS0tLS0tLS0tLQogc3JjL2xpc3AuaCAgICAgIHwgIDE5ICstLS0tCiBzcmMvbWluaWJ1 Zi5jICAgfCAgIDMgLQogc3JjL3BkdW1wZXIuYyAgIHwgMTgyICsrKysrKysrKysrKysrKysrKysr KystLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogc3JjL3BkdW1wZXIuaCAgIHwgICAxICsKIDgg ZmlsZXMgY2hhbmdlZCwgMTAzIGluc2VydGlvbnMoKyksIDE3MCBkZWxldGlvbnMoLSkKCmRpZmYg LS1naXQgYS9zcmMvYnl0ZWNvZGUuYyBiL3NyYy9ieXRlY29kZS5jCmluZGV4IDI5ZGZmNDRmMDAu LjljNzI0MjllMGMgMTAwNjQ0Ci0tLSBhL3NyYy9ieXRlY29kZS5jCisrKyBiL3NyYy9ieXRlY29k ZS5jCkBAIC0xNDAyLDcgKzE0MDIsNiBAQCAjZGVmaW5lIERFRklORShuYW1lLCB2YWx1ZSkgTEFC RUwgKG5hbWUpICwKICAgICAgICAgICAgIExpc3BfT2JqZWN0IHYxID0gUE9QOwogICAgICAgICAg ICAgcHRyZGlmZl90IGk7CiAgICAgICAgICAgICBzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICpoID0g WEhBU0hfVEFCTEUgKGptcF90YWJsZSk7Ci0gICAgICAgICAgICBoYXNoX3JlaGFzaF9pZl9uZWVk ZWQgKGgpOwogCiAgICAgICAgICAgICAvKiBoLT5jb3VudCBpcyBhIGZhc3RlciBhcHByb3hpbWF0 aW9uIGZvciBIQVNIX1RBQkxFX1NJWkUgKGgpCiAgICAgICAgICAgICAgICBoZXJlLiAqLwpkaWZm IC0tZ2l0IGEvc3JjL2NvbXBvc2l0ZS5jIGIvc3JjL2NvbXBvc2l0ZS5jCmluZGV4IDE4MzA2MmRl NDYuLjQ5YTI4NWNmZjAgMTAwNjQ0Ci0tLSBhL3NyYy9jb21wb3NpdGUuYworKysgYi9zcmMvY29t cG9zaXRlLmMKQEAgLTY1NCw3ICs2NTQsNiBAQCBnc3RyaW5nX2xvb2t1cF9jYWNoZSAoTGlzcF9P YmplY3QgaGVhZGVyKQogY29tcG9zaXRpb25fZ3N0cmluZ19wdXRfY2FjaGUgKExpc3BfT2JqZWN0 IGdzdHJpbmcsIHB0cmRpZmZfdCBsZW4pCiB7CiAgIHN0cnVjdCBMaXNwX0hhc2hfVGFibGUgKmgg PSBYSEFTSF9UQUJMRSAoZ3N0cmluZ19oYXNoX3RhYmxlKTsKLSAgaGFzaF9yZWhhc2hfaWZfbmVl ZGVkIChoKTsKICAgTGlzcF9PYmplY3QgaGVhZGVyID0gTEdTVFJJTkdfSEVBREVSIChnc3RyaW5n KTsKICAgRU1BQ1NfVUlOVCBoYXNoID0gaC0+dGVzdC5oYXNoZm4gKCZoLT50ZXN0LCBoZWFkZXIp OwogICBpZiAobGVuIDwgMCkKZGlmZiAtLWdpdCBhL3NyYy9lbWFjcy5jIGIvc3JjL2VtYWNzLmMK aW5kZXggYWQ2NjFhMDgxYi4uODU1YjJjNjcxNSAxMDA2NDQKLS0tIGEvc3JjL2VtYWNzLmMKKysr IGIvc3JjL2VtYWNzLmMKQEAgLTE1NjAsNiArMTU2MCw3IEBAIG1haW4gKGludCBhcmdjLCBjaGFy ICoqYXJndikKICAgaWYgKCFpbml0aWFsaXplZCkKICAgICB7CiAgICAgICBpbml0X2FsbG9jX29u Y2UgKCk7CisgICAgICBpbml0X3BkdW1wZXJfb25jZSAoKTsKICAgICAgIGluaXRfb2JhcnJheV9v bmNlICgpOwogICAgICAgaW5pdF9ldmFsX29uY2UgKCk7CiAgICAgICBpbml0X2NoYXJzZXRfb25j ZSAoKTsKZGlmZiAtLWdpdCBhL3NyYy9mbnMuYyBiL3NyYy9mbnMuYwppbmRleCAwNDk3NTg4Njg5 Li42Zjg2ZDdmMzE0IDEwMDY0NAotLS0gYS9zcmMvZm5zLmMKKysrIGIvc3JjL2Zucy5jCkBAIC00 MjMzLDUxICs0MjMzLDI3IEBAIG1heWJlX3Jlc2l6ZV9oYXNoX3RhYmxlIChzdHJ1Y3QgTGlzcF9I YXNoX1RhYmxlICpoKQogCiAvKiBSZWNvbXB1dGUgdGhlIGhhc2hlcyAoYW5kIGhlbmNlIGFsc28g dGhlICJuZXh0IiBwb2ludGVycykuCiAgICBOb3JtYWxseSB0aGVyZSdzIG5ldmVyIGEgbmVlZCB0 byByZWNvbXB1dGUgaGFzaGVzLgotICAgVGhpcyBpcyBkb25lIG9ubHkgb24gZmlyc3QtYWNjZXNz IHRvIGEgaGFzaC10YWJsZSBsb2FkZWQgZnJvbQotICAgdGhlICJwZHVtcCIsIGJlY2F1c2UgdGhl IG9iamVjdCdzIGFkZHJlc3NlcyBtYXkgaGF2ZSBjaGFuZ2VkLCB0aHVzCisgICBUaGlzIGlzIGRv bmUgb25seSBvbiBmaXJzdCBhY2Nlc3MgdG8gYSBoYXNoLXRhYmxlIGxvYWRlZCBmcm9tCisgICB0 aGUgInBkdW1wIiwgYmVjYXVzZSB0aGUgb2JqZWN0cycgYWRkcmVzc2VzIG1heSBoYXZlIGNoYW5n ZWQsIHRodXMKICAgIGFmZmVjdGluZyB0aGVpciBoYXNoLiAgKi8KIHZvaWQKIGhhc2hfdGFibGVf cmVoYXNoIChzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICpoKQogewotICBwdHJkaWZmX3Qgc2l6ZSA9 IEhBU0hfVEFCTEVfU0laRSAoaCk7Ci0KLSAgLyogVGhlc2Ugc3RydWN0dXJlcyBtYXkgaGF2ZSBi ZWVuIHB1cmVjb3BpZWQgYW5kIHNoYXJlZAotICAgICAoYnVnIzM2NDQ3KS4gICovCi0gIGgtPm5l eHQgPSBGY29weV9zZXF1ZW5jZSAoaC0+bmV4dCk7Ci0gIGgtPmluZGV4ID0gRmNvcHlfc2VxdWVu Y2UgKGgtPmluZGV4KTsKLSAgaC0+aGFzaCA9IEZjb3B5X3NlcXVlbmNlIChoLT5oYXNoKTsKLQog ICAvKiBSZWNvbXB1dGUgdGhlIGFjdHVhbCBoYXNoIGNvZGVzIGZvciBlYWNoIGVudHJ5IGluIHRo ZSB0YWJsZS4KICAgICAgT3JkZXIgaXMgc3RpbGwgaW52YWxpZC4gICovCi0gIGZvciAocHRyZGlm Zl90IGkgPSAwOyBpIDwgc2l6ZTsgKytpKQotICAgIGlmICghTklMUCAoSEFTSF9IQVNIIChoLCBp KSkpCi0gICAgICB7Ci0gICAgICAgIExpc3BfT2JqZWN0IGtleSA9IEhBU0hfS0VZIChoLCBpKTsK LSAgICAgICAgRU1BQ1NfVUlOVCBoYXNoX2NvZGUgPSBoLT50ZXN0Lmhhc2hmbiAoJmgtPnRlc3Qs IGtleSk7Ci0gICAgICAgIHNldF9oYXNoX2hhc2hfc2xvdCAoaCwgaSwgbWFrZV9maXhudW0gKGhh c2hfY29kZSkpOwotICAgICAgfQotCi0gIC8qIFJlc2V0IHRoZSBpbmRleCBzbyB0aGF0IGFueSBz bG90IHdlIGRvbid0IGZpbGwgYmVsb3cgaXMgbWFya2VkCi0gICAgIGludmFsaWQuICAqLwotICBG ZmlsbGFycmF5IChoLT5pbmRleCwgbWFrZV9maXhudW0gKC0xKSk7Ci0KLSAgLyogUmVidWlsZCB0 aGUgY29sbGlzaW9uIGNoYWlucy4gICovCi0gIGZvciAocHRyZGlmZl90IGkgPSAwOyBpIDwgc2l6 ZTsgKytpKQotICAgIGlmICghTklMUCAoSEFTSF9IQVNIIChoLCBpKSkpCi0gICAgICB7Ci0gICAg ICAgIEVNQUNTX1VJTlQgaGFzaF9jb2RlID0gWFVGSVhOVU0gKEhBU0hfSEFTSCAoaCwgaSkpOwot ICAgICAgICBwdHJkaWZmX3Qgc3RhcnRfb2ZfYnVja2V0ID0gaGFzaF9jb2RlICUgQVNJWkUgKGgt PmluZGV4KTsKLSAgICAgICAgc2V0X2hhc2hfbmV4dF9zbG90IChoLCBpLCBIQVNIX0lOREVYICho LCBzdGFydF9vZl9idWNrZXQpKTsKLSAgICAgICAgc2V0X2hhc2hfaW5kZXhfc2xvdCAoaCwgc3Rh cnRfb2ZfYnVja2V0LCBpKTsKLSAgICAgICAgZWFzc2VydCAoSEFTSF9ORVhUIChoLCBpKSAhPSBp KTsgLyogU3RvcCBsb29wcy4gICovCi0gICAgICB9CisgIGZvciAocHRyZGlmZl90IGkgPSAwOyBp IDwgaC0+Y291bnQ7ICsraSkKKyAgICB7CisgICAgICBMaXNwX09iamVjdCBrZXkgPSBIQVNIX0tF WSAoaCwgaSk7CisgICAgICBFTUFDU19VSU5UIGhhc2hfY29kZSA9IGgtPnRlc3QuaGFzaGZuICgm aC0+dGVzdCwga2V5KTsKKyAgICAgIHB0cmRpZmZfdCBzdGFydF9vZl9idWNrZXQgPSBoYXNoX2Nv ZGUgJSBBU0laRSAoaC0+aW5kZXgpOworICAgICAgc2V0X2hhc2hfaGFzaF9zbG90IChoLCBpLCBt YWtlX2ZpeG51bSAoaGFzaF9jb2RlKSk7CisgICAgICBzZXRfaGFzaF9uZXh0X3Nsb3QgKGgsIGks IEhBU0hfSU5ERVggKGgsIHN0YXJ0X29mX2J1Y2tldCkpOworICAgICAgc2V0X2hhc2hfaW5kZXhf c2xvdCAoaCwgc3RhcnRfb2ZfYnVja2V0LCBpKTsKKyAgICAgIGVhc3NlcnQgKEhBU0hfTkVYVCAo aCwgaSkgIT0gaSk7IC8qIFN0b3AgbG9vcHMuICAqLworICAgIH0KIAotICAvKiBGaW5hbGx5LCBt YXJrIHRoZSBoYXNoIHRhYmxlIGFzIGhhdmluZyBhIHZhbGlkIGhhc2ggb3JkZXIuCi0gICAgIERv IHRoaXMgbGFzdCBzbyB0aGF0IGlmIHdlJ3JlIGludGVycnVwdGVkLCB3ZSByZXRyeSBvbiBuZXh0 Ci0gICAgIGFjY2Vzcy4gKi8KLSAgZWFzc2VydCAoaC0+Y291bnQgPCAwKTsKLSAgaC0+Y291bnQg PSAtaC0+Y291bnQ7Ci0gIGVhc3NlcnQgKCFoYXNoX3JlaGFzaF9uZWVkZWRfcCAoaCkpOworICBm b3IgKHB0cmRpZmZfdCBpID0gaC0+Y291bnQ7IGkgPCBBU0laRSAoaC0+bmV4dCkgLSAxOyBpKysp CisgICAgc2V0X2hhc2hfbmV4dF9zbG90IChoLCBpLCBpICsgMSk7CiB9CiAKIC8qIExvb2t1cCBL RVkgaW4gaGFzaCB0YWJsZSBILiAgSWYgSEFTSCBpcyBub24tbnVsbCwgcmV0dXJuIGluICpIQVNI CkBAIC00MjkwLDggKzQyNjYsNiBAQCBoYXNoX2xvb2t1cCAoc3RydWN0IExpc3BfSGFzaF9UYWJs ZSAqaCwgTGlzcF9PYmplY3Qga2V5LCBFTUFDU19VSU5UICpoYXNoKQogICBFTUFDU19VSU5UIGhh c2hfY29kZTsKICAgcHRyZGlmZl90IHN0YXJ0X29mX2J1Y2tldCwgaTsKIAotICBoYXNoX3JlaGFz aF9pZl9uZWVkZWQgKGgpOwotCiAgIGhhc2hfY29kZSA9IGgtPnRlc3QuaGFzaGZuICgmaC0+dGVz dCwga2V5KTsKICAgZWFzc2VydCAoKGhhc2hfY29kZSAmIH5JTlRNQVNLKSA9PSAwKTsKICAgaWYg KGhhc2gpCkBAIC00MzIwLDggKzQyOTQsNiBAQCBoYXNoX3B1dCAoc3RydWN0IExpc3BfSGFzaF9U YWJsZSAqaCwgTGlzcF9PYmplY3Qga2V5LCBMaXNwX09iamVjdCB2YWx1ZSwKIHsKICAgcHRyZGlm Zl90IHN0YXJ0X29mX2J1Y2tldCwgaTsKIAotICBoYXNoX3JlaGFzaF9pZl9uZWVkZWQgKGgpOwot CiAgIGVhc3NlcnQgKChoYXNoICYgfklOVE1BU0spID09IDApOwogCiAgIC8qIEluY3JlbWVudCBj b3VudCBhZnRlciByZXNpemluZyBiZWNhdXNlIHJlc2l6aW5nIG1heSBmYWlsLiAgKi8KQEAgLTQz NTUsOCArNDMyNyw2IEBAIGhhc2hfcmVtb3ZlX2Zyb21fdGFibGUgKHN0cnVjdCBMaXNwX0hhc2hf VGFibGUgKmgsIExpc3BfT2JqZWN0IGtleSkKICAgcHRyZGlmZl90IHN0YXJ0X29mX2J1Y2tldCA9 IGhhc2hfY29kZSAlIEFTSVpFIChoLT5pbmRleCk7CiAgIHB0cmRpZmZfdCBwcmV2ID0gLTE7CiAK LSAgaGFzaF9yZWhhc2hfaWZfbmVlZGVkIChoKTsKLQogICBmb3IgKHB0cmRpZmZfdCBpID0gSEFT SF9JTkRFWCAoaCwgc3RhcnRfb2ZfYnVja2V0KTsKICAgICAgICAwIDw9IGk7CiAgICAgICAgaSA9 IEhBU0hfTkVYVCAoaCwgaSkpCkBAIC00NDM0LDkgKzQ0MDQsNyBAQCBzd2VlcF93ZWFrX3RhYmxl IChzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICpoLCBib29sIHJlbW92ZV9lbnRyaWVzX3ApCiAgIGZv ciAocHRyZGlmZl90IGJ1Y2tldCA9IDA7IGJ1Y2tldCA8IG47ICsrYnVja2V0KQogICAgIHsKICAg ICAgIC8qIEZvbGxvdyBjb2xsaXNpb24gY2hhaW4sIHJlbW92aW5nIGVudHJpZXMgdGhhdCBkb24n dCBzdXJ2aXZlCi0gICAgICAgICB0aGlzIGdhcmJhZ2UgY29sbGVjdGlvbi4gIEl0J3Mgb2theSBp ZiBoYXNoX3JlaGFzaF9uZWVkZWRfcAotICAgICAgICAgKGgpIGlzIHRydWUsIHNpbmNlIHdlJ3Jl IG9wZXJhdGluZyBlbnRpcmVseSBvbiB0aGUgY2FjaGVkCi0gICAgICAgICBoYXNoIHZhbHVlcy4g Ki8KKyAgICAgICAgIHRoaXMgZ2FyYmFnZSBjb2xsZWN0aW9uLiAgKi8KICAgICAgIHB0cmRpZmZf dCBwcmV2ID0gLTE7CiAgICAgICBwdHJkaWZmX3QgbmV4dDsKICAgICAgIGZvciAocHRyZGlmZl90 IGkgPSBIQVNIX0lOREVYIChoLCBidWNrZXQpOyAwIDw9IGk7IGkgPSBuZXh0KQpAQCAtNDQ3OCw3 ICs0NDQ2LDcgQEAgc3dlZXBfd2Vha190YWJsZSAoc3RydWN0IExpc3BfSGFzaF9UYWJsZSAqaCwg Ym9vbCByZW1vdmVfZW50cmllc19wKQogICAgICAgICAgICAgICAgICAgc2V0X2hhc2hfaGFzaF9z bG90IChoLCBpLCBRbmlsKTsKIAogICAgICAgICAgICAgICAgICAgZWFzc2VydCAoaC0+Y291bnQg IT0gMCk7Ci0gICAgICAgICAgICAgICAgICBoLT5jb3VudCArPSBoLT5jb3VudCA+IDAgPyAtMSA6 IDE7CisgICAgICAgICAgICAgICAgICBoLT5jb3VudC0tOwogICAgICAgICAgICAgICAgIH0KIAkg ICAgICBlbHNlCiAJCXsKQEAgLTQ4ODEsNyArNDg0OSw2IEBAIERFRlVOICgiaGFzaC10YWJsZS1j b3VudCIsIEZoYXNoX3RhYmxlX2NvdW50LCBTaGFzaF90YWJsZV9jb3VudCwgMSwgMSwgMCwKICAg KExpc3BfT2JqZWN0IHRhYmxlKQogewogICBzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICpoID0gY2hl Y2tfaGFzaF90YWJsZSAodGFibGUpOwotICBoYXNoX3JlaGFzaF9pZl9uZWVkZWQgKGgpOwogICBy ZXR1cm4gbWFrZV9maXhudW0gKGgtPmNvdW50KTsKIH0KIApkaWZmIC0tZ2l0IGEvc3JjL2xpc3Au aCBiL3NyYy9saXNwLmgKaW5kZXggMTMwMTRjODJkYy4uZDBlNWM0M2M0MSAxMDA2NDQKLS0tIGEv c3JjL2xpc3AuaAorKysgYi9zcmMvbGlzcC5oCkBAIC0yMjQ1LDExICsyMjQ1LDcgQEAgI2RlZmlu ZSBERUZTWU0oc3ltLCBuYW1lKSAvKiBlbXB0eSAqLwogCiBzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxl CiB7Ci0gIC8qIENoYW5nZSBwZHVtcGVyLmMgaWYgeW91IGNoYW5nZSB0aGUgZmllbGRzIGhlcmUu Ci0KLSAgICAgSU1QT1JUQU5UISEhISEhIQotCi0gICAgIENhbGwgaGFzaF9yZWhhc2hfaWZfbmVl ZGVkKCkgYmVmb3JlIGFjY2Vzc2luZy4gICovCisgIC8qIENoYW5nZSBwZHVtcGVyLmMgaWYgeW91 IGNoYW5nZSB0aGUgZmllbGRzIGhlcmUuICAqLwogCiAgIC8qIFRoaXMgaXMgZm9yIExpc3A7IHRo ZSBoYXNoIHRhYmxlIGNvZGUgZG9lcyBub3QgcmVmZXIgdG8gaXQuICAqLwogICB1bmlvbiB2ZWN0 b3JsaWtlX2hlYWRlciBoZWFkZXI7CkBAIC0yMzYzLDE5ICsyMzU5LDYgQEAgSEFTSF9UQUJMRV9T SVpFIChjb25zdCBzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICpoKQogCiB2b2lkIGhhc2hfdGFibGVf cmVoYXNoIChzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICpoKTsKIAotSU5MSU5FIGJvb2wKLWhhc2hf cmVoYXNoX25lZWRlZF9wIChjb25zdCBzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICpoKQotewotICBy ZXR1cm4gaC0+Y291bnQgPCAwOwotfQotCi1JTkxJTkUgdm9pZAotaGFzaF9yZWhhc2hfaWZfbmVl ZGVkIChzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICpoKQotewotICBpZiAoaGFzaF9yZWhhc2hfbmVl ZGVkX3AgKGgpKQotICAgIGhhc2hfdGFibGVfcmVoYXNoIChoKTsKLX0KLQogLyogRGVmYXVsdCBz aXplIGZvciBoYXNoIHRhYmxlcyBpZiBub3Qgc3BlY2lmaWVkLiAgKi8KIAogZW51bSBERUZBVUxU X0hBU0hfU0laRSB7IERFRkFVTFRfSEFTSF9TSVpFID0gNjUgfTsKZGlmZiAtLWdpdCBhL3NyYy9t aW5pYnVmLmMgYi9zcmMvbWluaWJ1Zi5jCmluZGV4IGQ5YTZlMTViMDUuLmU5MjNjZTJhNDMgMTAw NjQ0Ci0tLSBhL3NyYy9taW5pYnVmLmMKKysrIGIvc3JjL21pbmlidWYuYwpAQCAtMTIwMyw5ICsx MjAzLDYgQEAgREVGVU4gKCJ0cnktY29tcGxldGlvbiIsIEZ0cnlfY29tcGxldGlvbiwgU3RyeV9j b21wbGV0aW9uLCAyLCAzLCAwLAogICAgICAgYnVja2V0ID0gQVJFRiAoY29sbGVjdGlvbiwgaWR4 KTsKICAgICB9CiAKLSAgaWYgKEhBU0hfVEFCTEVfUCAoY29sbGVjdGlvbikpCi0gICAgaGFzaF9y ZWhhc2hfaWZfbmVlZGVkIChYSEFTSF9UQUJMRSAoY29sbGVjdGlvbikpOwotCiAgIHdoaWxlICgx KQogICAgIHsKICAgICAgIC8qIEdldCB0aGUgbmV4dCBlbGVtZW50IG9mIHRoZSBhbGlzdCwgb2Jh cnJheSwgb3IgaGFzaC10YWJsZS4gICovCmRpZmYgLS1naXQgYS9zcmMvcGR1bXBlci5jIGIvc3Jj L3BkdW1wZXIuYwppbmRleCAwM2MwMGJmMjdiLi5lMWJlNjk2NzQ4IDEwMDY0NAotLS0gYS9zcmMv cGR1bXBlci5jCisrKyBiL3NyYy9wZHVtcGVyLmMKQEAgLTEwNywxNyArMTA3LDYgQEAgI2RlZmlu ZSBWTV9NU19XSU5ET1dTIDIKIAogI2RlZmluZSBEQU5HRVJPVVMgMAogCi0vKiBQRFVNUEVSX0NI RUNLX1JFSEFTSElORyBiZWluZyB0cnVlIGNhdXNlcyB0aGUgcG9ydGFibGUgZHVtcGVyIHRvCi0g ICBjaGVjaywgZm9yIGVhY2ggaGFzaCB0YWJsZSBpdCBkdW1wcywgdGhhdCB0aGUgaGFzaCB0YWJs ZSBtZWFucyB0aGUKLSAgIHNhbWUgdGhpbmcgYWZ0ZXIgcmVoYXNoaW5nLiAgKi8KLSNpZm5kZWYg UERVTVBFUl9DSEVDS19SRUhBU0hJTkcKLSMgaWYgRU5BQkxFX0NIRUNLSU5HCi0jICBkZWZpbmUg UERVTVBFUl9DSEVDS19SRUhBU0hJTkcgMQotIyBlbHNlCi0jICBkZWZpbmUgUERVTVBFUl9DSEVD S19SRUhBU0hJTkcgMAotIyBlbmRpZgotI2VuZGlmCi0KIC8qIFdlIHJlcXVpcmUgYW4gYXJjaGl0 ZWN0dXJlIGluIHdoaWNoIGFsbCBwb2ludGVycyBhcmUgdGhlIHNhbWUgc2l6ZQogICAgYW5kIGhh dmUgdGhlIHNhbWUgbGF5b3V0LCB3aGVyZSBwb2ludGVycyBhcmUgZWl0aGVyIDMyIG9yIDY0IGJp dHMKICAgIGxvbmcsIGFuZCB3aGVyZSBieXRlcyBoYXZlIGVpZ2h0IGJpdHMgLS0tIHRoYXQgaXMs IGEKQEAgLTM5Myw2ICszODIsOCBAQCBkdW1wX2ZpbmdlcnByaW50IChjaGFyIGNvbnN0ICpsYWJl bCwKICAgICAgVGhlIHN0YXJ0IG9mIHRoZSBjb2xkIHJlZ2lvbiBpcyBhbHdheXMgYWxpZ25lZCBv biBhIHBhZ2UKICAgICAgYm91bmRhcnkuICAqLwogICBkdW1wX29mZiBjb2xkX3N0YXJ0OworCisg IGR1bXBfb2ZmIGhhc2hfbGlzdDsKIH07CiAKIC8qIERvdWJsZS1lbmRlZCBzaW5nbHkgbGlua2Vk IGxpc3QuICAqLwpAQCAtNTUwLDYgKzU0MSw4IEBAIGR1bXBfZmluZ2VycHJpbnQgKGNoYXIgY29u c3QgKmxhYmVsLAogICAgICBoZWFwIG9iamVjdHMuICAqLwogICBMaXNwX09iamVjdCBiaWdudW1f ZGF0YTsKIAorICBMaXNwX09iamVjdCBoYXNoX3RhYmxlczsKKwogICB1bnNpZ25lZCBudW1iZXJf aG90X3JlbG9jYXRpb25zOwogICB1bnNpZ25lZCBudW1iZXJfZGlzY2FyZGFibGVfcmVsb2NhdGlv bnM7CiB9OwpAQCAtMjYyMiw2OCArMjYxNSw1OCBAQCBkdW1wX3ZlY3Rvcmxpa2VfZ2VuZXJpYyAo c3RydWN0IGR1bXBfY29udGV4dCAqY3R4LAogICByZXR1cm4gb2Zmc2V0OwogfQogCi0vKiBEZXRl cm1pbmUgd2hldGhlciB0aGUgaGFzaCB0YWJsZSdzIGhhc2ggb3JkZXIgaXMgc3RhYmxlCi0gICBh Y3Jvc3MgZHVtcCBhbmQgbG9hZC4gIElmIGl0IGlzLCB3ZSBkb24ndCBoYXZlIHRvIHRyaWdnZXIK LSAgIGEgcmVoYXNoIG9uIGFjY2Vzcy4gICovCi1zdGF0aWMgYm9vbAotZHVtcF9oYXNoX3RhYmxl X3N0YWJsZV9wIChjb25zdCBzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICpoYXNoKQorLyogUmV0dXJu IGEgdmVjdG9yIG9mIEtFWSwgVkFMVUUgcGFpcnMgaW4gdGhlIGdpdmVuIGhhc2ggdGFibGUgSC4g IFRoZQorICAgZmlyc3QgSC0+Y291bnQgcGFpcnMgYXJlIHZhbGlkLCB0aGUgcmVzdCBpcyBsZWZ0 IGFzIG5pbC4gICovCitzdGF0aWMgTGlzcF9PYmplY3QKK2hhc2hfdGFibGVfY29udGVudHMgKHN0 cnVjdCBMaXNwX0hhc2hfVGFibGUgKmgpCiB7Ci0gIGJvb2wgaXNfZXFsID0gaGFzaC0+dGVzdC5o YXNoZm4gPT0gaGFzaGZuX2VxbDsKLSAgYm9vbCBpc19lcXVhbCA9IGhhc2gtPnRlc3QuaGFzaGZu ID09IGhhc2hmbl9lcXVhbDsKLSAgcHRyZGlmZl90IHNpemUgPSBIQVNIX1RBQkxFX1NJWkUgKGhh c2gpOwotICBmb3IgKHB0cmRpZmZfdCBpID0gMDsgaSA8IHNpemU7ICsraSkKLSAgICBpZiAoIU5J TFAgKEhBU0hfSEFTSCAoaGFzaCwgaSkpKQorICBMaXNwX09iamVjdCBjb250ZW50cyA9IFFuaWw7 CisgIC8qIE1ha2Ugc3VyZSBrZXlfYW5kX3ZhbHVlIGVuZHMgdXAgaW4gdGhlIHNhbWUgb3JkZXIs IGNoYXJzZXQuYworICAgICByZWxpZXMgb24gaXQgYnkgZXhwZWN0aW5nIGhhc2ggdGFibGUgaW5k aWNlcyB0byBzdGF5IGNvbnN0YW50CisgICAgIGFjcm9zcyB0aGUgZHVtcC4gICovCisgIGZvciAo cHRyZGlmZl90IGkgPSAwOyBpIDwgSEFTSF9UQUJMRV9TSVpFIChoKSAtIGgtPmNvdW50OyBpKysp CisgICAgeworICAgICAgZHVtcF9wdXNoICgmY29udGVudHMsIFFuaWwpOworICAgICAgZHVtcF9w dXNoICgmY29udGVudHMsIFFuaWwpOworICAgIH0KKworICBmb3IgKHB0cmRpZmZfdCBpID0gSEFT SF9UQUJMRV9TSVpFIChoKSAtIDE7IGkgPj0gMDsgLS1pKQorICAgIGlmICghTklMUCAoSEFTSF9I QVNIIChoLCBpKSkpCiAgICAgICB7Ci0gICAgICAgIExpc3BfT2JqZWN0IGtleSA9ICBIQVNIX0tF WSAoaGFzaCwgaSk7Ci0JYm9vbCBrZXlfc3RhYmxlID0gKGR1bXBfYnVpbHRpbl9zeW1ib2xfcCAo a2V5KQotCQkJICAgfHwgRklYTlVNUCAoa2V5KQotCQkJICAgfHwgKGlzX2VxdWFsICYmIFNUUklO R1AgKGtleSkpCi0JCQkgICB8fCAoKGlzX2VxdWFsIHx8IGlzX2VxbCkgJiYgRkxPQVRQIChrZXkp KSk7Ci0gICAgICAgIGlmICgha2V5X3N0YWJsZSkKLSAgICAgICAgICByZXR1cm4gZmFsc2U7CisJ ZHVtcF9wdXNoICgmY29udGVudHMsIEhBU0hfVkFMVUUgKGgsIGkpKTsKKwlkdW1wX3B1c2ggKCZj b250ZW50cywgSEFTSF9LRVkgKGgsIGkpKTsKICAgICAgIH0KIAotICByZXR1cm4gdHJ1ZTsKKyAg cmV0dXJuIENBTExOIChGYXBwbHksIFF2ZWN0b3IsIGNvbnRlbnRzKTsKIH0KIAotLyogUmV0dXJu IGEgbGlzdCBvZiAoS0VZIC4gVkFMVUUpIHBhaXJzIGluIHRoZSBnaXZlbiBoYXNoIHRhYmxlLiAg Ki8KLXN0YXRpYyBMaXNwX09iamVjdAotaGFzaF90YWJsZV9jb250ZW50cyAoTGlzcF9PYmplY3Qg dGFibGUpCitzdGF0aWMgZHVtcF9vZmYKK2R1bXBfaGFzaF90YWJsZV9saXN0IChzdHJ1Y3QgZHVt cF9jb250ZXh0ICpjdHgpCiB7Ci0gIExpc3BfT2JqZWN0IGNvbnRlbnRzID0gUW5pbDsKLSAgc3Ry dWN0IExpc3BfSGFzaF9UYWJsZSAqaCA9IFhIQVNIX1RBQkxFICh0YWJsZSk7Ci0gIGZvciAocHRy ZGlmZl90IGkgPSAwOyBpIDwgSEFTSF9UQUJMRV9TSVpFIChoKTsgKytpKQotICAgIGlmICghTklM UCAoSEFTSF9IQVNIIChoLCBpKSkpCi0gICAgICBkdW1wX3B1c2ggKCZjb250ZW50cywgRmNvbnMg KEhBU0hfS0VZIChoLCBpKSwgSEFTSF9WQUxVRSAoaCwgaSkpKTsKLSAgcmV0dXJuIEZucmV2ZXJz ZSAoY29udGVudHMpOworICBpZiAoQ09OU1AgKGN0eC0+aGFzaF90YWJsZXMpKQorICAgIHJldHVy biBkdW1wX29iamVjdCAoY3R4LCBDQUxMTiAoRmFwcGx5LCBRdmVjdG9yLCBjdHgtPmhhc2hfdGFi bGVzKSk7CisgIGVsc2UKKyAgICByZXR1cm4gMDsKIH0KIAotLyogQ29weSB0aGUgZ2l2ZW4gaGFz aCB0YWJsZSwgcmVoYXNoIGl0LCBhbmQgbWFrZSBzdXJlIHRoYXQgd2UgY2FuCi0gICBsb29rIHVw IGFsbCB0aGUgdmFsdWVzIGluIHRoZSBvcmlnaW5hbC4gICovCiBzdGF0aWMgdm9pZAotY2hlY2tf aGFzaF90YWJsZV9yZWhhc2ggKExpc3BfT2JqZWN0IHRhYmxlX29yaWcpCi17Ci0gIGhhc2hfcmVo YXNoX2lmX25lZWRlZCAoWEhBU0hfVEFCTEUgKHRhYmxlX29yaWcpKTsKLSAgTGlzcF9PYmplY3Qg dGFibGVfcmVoYXNoZWQgPSBGY29weV9oYXNoX3RhYmxlICh0YWJsZV9vcmlnKTsKLSAgZWFzc2Vy dCAoWEhBU0hfVEFCTEUgKHRhYmxlX3JlaGFzaGVkKS0+Y291bnQgPj0gMCk7Ci0gIFhIQVNIX1RB QkxFICh0YWJsZV9yZWhhc2hlZCktPmNvdW50ICo9IC0xOwotICBlYXNzZXJ0IChYSEFTSF9UQUJM RSAodGFibGVfcmVoYXNoZWQpLT5jb3VudCA8PSAwKTsKLSAgaGFzaF9yZWhhc2hfaWZfbmVlZGVk IChYSEFTSF9UQUJMRSAodGFibGVfcmVoYXNoZWQpKTsKLSAgZWFzc2VydCAoWEhBU0hfVEFCTEUg KHRhYmxlX3JlaGFzaGVkKS0+Y291bnQgPj0gMCk7Ci0gIExpc3BfT2JqZWN0IGV4cGVjdGVkX2Nv bnRlbnRzID0gaGFzaF90YWJsZV9jb250ZW50cyAodGFibGVfb3JpZyk7Ci0gIHdoaWxlICghTklM UCAoZXhwZWN0ZWRfY29udGVudHMpKQotICAgIHsKLSAgICAgIExpc3BfT2JqZWN0IGtleV92YWx1 ZV9wYWlyID0gZHVtcF9wb3AgKCZleHBlY3RlZF9jb250ZW50cyk7Ci0gICAgICBMaXNwX09iamVj dCBrZXkgPSBYQ0FSIChrZXlfdmFsdWVfcGFpcik7Ci0gICAgICBMaXNwX09iamVjdCBleHBlY3Rl ZF92YWx1ZSA9IFhDRFIgKGtleV92YWx1ZV9wYWlyKTsKLSAgICAgIExpc3BfT2JqZWN0IGFyYml0 cmFyeSA9IFFkdW1wX2VtYWNzX3BvcnRhYmxlX19zb3J0X3ByZWRpY2F0ZV9jb3BpZWQ7Ci0gICAg ICBMaXNwX09iamVjdCBmb3VuZF92YWx1ZSA9IEZnZXRoYXNoIChrZXksIHRhYmxlX3JlaGFzaGVk LCBhcmJpdHJhcnkpOwotICAgICAgZWFzc2VydCAoRVEgKGV4cGVjdGVkX3ZhbHVlLCBmb3VuZF92 YWx1ZSkpOwotICAgICAgRnJlbWhhc2ggKGtleSwgdGFibGVfcmVoYXNoZWQpOwotICAgIH0KK2hh c2hfdGFibGVfZnJlZXplIChzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICpoKQoreworICBwdHJkaWZm X3QgbmtleXMgPSBYRklYTkFUIChGbGVuZ3RoIChoLT5rZXlfYW5kX3ZhbHVlKSkgLyAyOworICBo LT5rZXlfYW5kX3ZhbHVlID0gaGFzaF90YWJsZV9jb250ZW50cyAoaCk7CisgIGgtPm5leHRfZnJl ZSA9IChua2V5cyA9PSBoLT5jb3VudCA/IC0xIDogaC0+Y291bnQpOworICBoLT5pbmRleCA9IEZs ZW5ndGggKGgtPmluZGV4KTsKKyAgaC0+bmV4dCA9IGgtPmhhc2ggPSBtYWtlX2ZpeG51bSAobmtl eXMpOworfQorCitzdGF0aWMgdm9pZAoraGFzaF90YWJsZV90aGF3IChzdHJ1Y3QgTGlzcF9IYXNo X1RhYmxlICpoKQoreworICBoLT5pbmRleCA9IEZtYWtlX3ZlY3RvciAoaC0+aW5kZXgsIG1ha2Vf Zml4bnVtICgtMSkpOworICBoLT5oYXNoID0gRm1ha2VfdmVjdG9yIChoLT5oYXNoLCBRbmlsKTsK KyAgaC0+bmV4dCA9IEZtYWtlX3ZlY3RvciAoaC0+bmV4dCwgbWFrZV9maXhudW0gKC0xKSk7CiAK LSAgZWFzc2VydCAoRVEgKEZoYXNoX3RhYmxlX2NvdW50ICh0YWJsZV9yZWhhc2hlZCksCi0gICAg ICAgICAgICAgICBtYWtlX2ZpeG51bSAoMCkpKTsKKyAgaGFzaF90YWJsZV9yZWhhc2ggKGgpOwog fQogCiBzdGF0aWMgZHVtcF9vZmYKQEAgLTI2OTUsNDUgKzI2NzgsMTEgQEAgZHVtcF9oYXNoX3Rh YmxlIChzdHJ1Y3QgZHVtcF9jb250ZXh0ICpjdHgsCiAjIGVycm9yICJMaXNwX0hhc2hfVGFibGUg Y2hhbmdlZC4gU2VlIENIRUNLX1NUUlVDVFMgY29tbWVudCBpbiBjb25maWcuaC4iCiAjZW5kaWYK ICAgY29uc3Qgc3RydWN0IExpc3BfSGFzaF9UYWJsZSAqaGFzaF9pbiA9IFhIQVNIX1RBQkxFIChv YmplY3QpOwotICBib29sIGlzX3N0YWJsZSA9IGR1bXBfaGFzaF90YWJsZV9zdGFibGVfcCAoaGFz aF9pbik7Ci0gIC8qIElmIHRoZSBoYXNoIHRhYmxlIGlzIGxpa2VseSB0byBiZSBtb2RpZmllZCBp biBtZW1vcnkgKGVpdGhlcgotICAgICBiZWNhdXNlIHdlIG5lZWQgdG8gcmVoYXNoLCBhbmQgdGh1 cyB0b2dnbGUgaGFzaC0+Y291bnQsIG9yCi0gICAgIGJlY2F1c2Ugd2UgbmVlZCB0byBhc3NlbWJs ZSBhIGxpc3Qgb2Ygd2VhayB0YWJsZXMpIHB1bnQgdGhlIGhhc2gKLSAgICAgdGFibGUgdG8gdGhl IGVuZCBvZiB0aGUgZHVtcCwgd2hlcmUgd2UgY2FuIGx1bXAgYWxsIHN1Y2ggaGFzaAotICAgICB0 YWJsZXMgdG9nZXRoZXIuICAqLwotICBpZiAoIShpc19zdGFibGUgfHwgIU5JTFAgKGhhc2hfaW4t PndlYWspKQotICAgICAgJiYgY3R4LT5mbGFncy5kZWZlcl9oYXNoX3RhYmxlcykKLSAgICB7Ci0g ICAgICBpZiAob2Zmc2V0ICE9IERVTVBfT0JKRUNUX09OX0hBU0hfVEFCTEVfUVVFVUUpCi0gICAg ICAgIHsKLQkgIGVhc3NlcnQgKG9mZnNldCA9PSBEVU1QX09CSkVDVF9PTl9OT1JNQUxfUVVFVUUK LQkJICAgfHwgb2Zmc2V0ID09IERVTVBfT0JKRUNUX05PVF9TRUVOKTsKLSAgICAgICAgICAvKiBX ZSBzdGlsbCB3YW50IHRvIGR1bXAgdGhlIGFjdHVhbCBrZXlzIGFuZCB2YWx1ZXMgbm93LiAgKi8K LSAgICAgICAgICBkdW1wX2VucXVldWVfb2JqZWN0IChjdHgsIGhhc2hfaW4tPmtleV9hbmRfdmFs dWUsIFdFSUdIVF9OT05FKTsKLSAgICAgICAgICAvKiBXZSdsbCBnZXQgdG8gdGhlIHJlc3QgbGF0 ZXIuICAqLwotICAgICAgICAgIG9mZnNldCA9IERVTVBfT0JKRUNUX09OX0hBU0hfVEFCTEVfUVVF VUU7Ci0gICAgICAgICAgZHVtcF9yZW1lbWJlcl9vYmplY3QgKGN0eCwgb2JqZWN0LCBvZmZzZXQp OwotICAgICAgICAgIGR1bXBfcHVzaCAoJmN0eC0+ZGVmZXJyZWRfaGFzaF90YWJsZXMsIG9iamVj dCk7Ci0gICAgICAgIH0KLSAgICAgIHJldHVybiBvZmZzZXQ7Ci0gICAgfQotCi0gIGlmIChQRFVN UEVSX0NIRUNLX1JFSEFTSElORykKLSAgICBjaGVja19oYXNoX3RhYmxlX3JlaGFzaCAobWFrZV9s aXNwX3B0ciAoKHZvaWQgKikgaGFzaF9pbiwgTGlzcF9WZWN0b3JsaWtlKSk7Ci0KICAgc3RydWN0 IExpc3BfSGFzaF9UYWJsZSBoYXNoX211bmdlZCA9ICpoYXNoX2luOwogICBzdHJ1Y3QgTGlzcF9I YXNoX1RhYmxlICpoYXNoID0gJmhhc2hfbXVuZ2VkOwogCi0gIC8qIFJlbWVtYmVyIHRvIHJlaGFz aCB0aGlzIGhhc2ggdGFibGUgb24gZmlyc3QgYWNjZXNzLiAgQWZ0ZXIgYQotICAgICBkdW1wIHJl bG9hZCwgdGhlIGhhc2ggdGFibGUgdmFsdWVzIHdpbGwgaGF2ZSBjaGFuZ2VkLCBzbyB3ZSdsbAot ICAgICBuZWVkIHRvIHJlYnVpbGQgdGhlIGluZGV4LgotCi0gICAgIFRPRE86IGZvciBFUSBhbmQg RVFMIGhhc2ggdGFibGVzLCBpdCBzaG91bGQgYmUgcG9zc2libGUgdG8gcmVoYXNoCi0gICAgIGhl cmUgdXNpbmcgdGhlIHByZWZlcnJlZCBsb2FkIGFkZHJlc3Mgb2YgdGhlIGR1bXAsIGVsaW1pbmF0 aW5nCi0gICAgIHRoZSBuZWVkIHRvIHJlaGFzaC1vbi1hY2Nlc3MgaWYgd2UgY2FuIGxvYWQgdGhl IGR1bXAgd2hlcmUgd2UKLSAgICAgd2FudC4gICovCi0gIGlmIChoYXNoLT5jb3VudCA+IDAgJiYg IWlzX3N0YWJsZSkKLSAgICBoYXNoLT5jb3VudCA9IC1oYXNoLT5jb3VudDsKKyAgaGFzaF90YWJs ZV9mcmVlemUgKGhhc2gpOworICBkdW1wX3B1c2ggKCZjdHgtPmhhc2hfdGFibGVzLCBvYmplY3Qp OwogCiAgIFNUQVJUX0RVTVBfUFZFQyAoY3R4LCAmaGFzaC0+aGVhZGVyLCBzdHJ1Y3QgTGlzcF9I YXNoX1RhYmxlLCBvdXQpOwogICBkdW1wX3BzZXVkb3ZlY3Rvcl9saXNwX2ZpZWxkcyAoY3R4LCAm b3V0LT5oZWFkZXIsICZoYXNoLT5oZWFkZXIpOwpAQCAtNDE0MCw2ICs0MDg5LDE5IEBAIERFRlVO ICgiZHVtcC1lbWFjcy1wb3J0YWJsZSIsCiAJIHx8ICFOSUxQIChjdHgtPmRlZmVycmVkX2hhc2hf dGFibGVzKQogCSB8fCAhTklMUCAoY3R4LT5kZWZlcnJlZF9zeW1ib2xzKSk7CiAKKyAgY3R4LT5o ZWFkZXIuaGFzaF9saXN0ID0gY3R4LT5vZmZzZXQ7CisgIGR1bXBfaGFzaF90YWJsZV9saXN0IChj dHgpOworCisgIGRvCisgICAgeworICAgICAgZHVtcF9kcmFpbl9kZWZlcnJlZF9oYXNoX3RhYmxl cyAoY3R4KTsKKyAgICAgIGR1bXBfZHJhaW5fZGVmZXJyZWRfc3ltYm9scyAoY3R4KTsKKyAgICAg IGR1bXBfZHJhaW5fbm9ybWFsX3F1ZXVlIChjdHgpOworICAgIH0KKyAgd2hpbGUgKCFkdW1wX3F1 ZXVlX2VtcHR5X3AgKCZjdHgtPmR1bXBfcXVldWUpCisJIHx8ICFOSUxQIChjdHgtPmRlZmVycmVk X2hhc2hfdGFibGVzKQorCSB8fCAhTklMUCAoY3R4LT5kZWZlcnJlZF9zeW1ib2xzKSk7CisKICAg ZHVtcF9zb3J0X2NvcGllZF9vYmplY3RzIChjdHgpOwogCiAgIC8qIFdoaWxlIHdlIGNvcHkgYnVp bHQtaW4gc3ltYm9scyBpbnRvIHRoZSBFbWFjcyBpbWFnZSwgdGhlc2UKQEAgLTUyOTAsNiArNTI1 Miw5IEBAIGR1bXBfZG9fYWxsX2VtYWNzX3JlbG9jYXRpb25zIChjb25zdCBzdHJ1Y3QgZHVtcF9o ZWFkZXIgKmNvbnN0IGhlYWRlciwKICAgIE5VTUJFUl9EVU1QX1NFQ1RJT05TLAogICB9OwogCisv KiBQb2ludGVyIHRvIGEgc3RhY2sgdmFyaWFibGUgdG8gYXZvaWQgaGF2aW5nIHRvIHN0YXRpY3By byBpdC4gICovCitzdGF0aWMgTGlzcF9PYmplY3QgKnBkdW1wZXJfaGFzaGVzID0gJnplcm9fdmVj dG9yOworCiAvKiBMb2FkIGEgZHVtcCBmcm9tIERVTVBfRklMRU5BTUUuICBSZXR1cm4gYW4gZXJy b3IgY29kZS4KIAogICAgTi5CLiBXZSBydW4gdmVyeSBlYXJseSBpbiBpbml0aWFsaXphdGlvbiwg c28gd2UgY2FuJ3QgdXNlIGxpc3AsCkBAIC01NDMxLDYgKzUzOTYsMTUgQEAgcGR1bXBlcl9sb2Fk IChjb25zdCBjaGFyICpkdW1wX2ZpbGVuYW1lKQogICBmb3IgKGludCBpID0gMDsgaSA8IEFSUkFZ RUxUUyAoc2VjdGlvbnMpOyArK2kpCiAgICAgZHVtcF9tbWFwX3Jlc2V0ICgmc2VjdGlvbnNbaV0p OwogCisgIExpc3BfT2JqZWN0IGhhc2hlcyA9IHplcm9fdmVjdG9yOworICBpZiAoaGVhZGVyLT5o YXNoX2xpc3QpCisgICAgeworICAgICAgc3RydWN0IExpc3BfVmVjdG9yICpoYXNoX3RhYmxlcyA9 CisJKChzdHJ1Y3QgTGlzcF9WZWN0b3IgKikoZHVtcF9iYXNlICsgaGVhZGVyLT5oYXNoX2xpc3Qp KTsKKyAgICAgIFhTRVRWRUNUT1IgKGhhc2hlcywgaGFzaF90YWJsZXMpOworICAgIH0KKworICBw ZHVtcGVyX2hhc2hlcyA9ICZoYXNoZXM7CiAgIC8qIFJ1biB0aGUgZnVuY3Rpb25zIEVtYWNzIHJl Z2lzdGVyZWQgZm9yIGRvaW5nIHBvc3QtZHVtcC1sb2FkCiAgICAgIGluaXRpYWxpemF0aW9uLiAg Ki8KICAgZm9yIChpbnQgaSA9IDA7IGkgPCBucl9kdW1wX2hvb2tzOyArK2kpCkBAIC01NTAxLDYg KzU0NzUsMTggQEAgREVGVU4gKCJwZHVtcGVyLXN0YXRzIiwgRnBkdW1wZXJfc3RhdHMsIFNwZHVt cGVyX3N0YXRzLCAwLCAwLCAwLAogI2VuZGlmIC8qIEhBVkVfUERVTVBFUiAqLwogCiAMCitzdGF0 aWMgdm9pZCB0aGF3X2hhc2hfdGFibGVzICh2b2lkKQoreworICBMaXNwX09iamVjdCBoYXNoX3Rh YmxlcyA9ICpwZHVtcGVyX2hhc2hlczsKKyAgZm9yIChwdHJkaWZmX3QgaSA9IDA7IGkgPCBBU0la RSAoaGFzaF90YWJsZXMpOyBpKyspCisgICAgaGFzaF90YWJsZV90aGF3IChYSEFTSF9UQUJMRSAo QVJFRiAoaGFzaF90YWJsZXMsIGkpKSk7Cit9CisKK3ZvaWQKK2luaXRfcGR1bXBlcl9vbmNlICh2 b2lkKQoreworICBwZHVtcGVyX2RvX25vd19hbmRfYWZ0ZXJfbG9hZCAodGhhd19oYXNoX3RhYmxl cyk7Cit9CiAKIHZvaWQKIHN5bXNfb2ZfcGR1bXBlciAodm9pZCkKZGlmZiAtLWdpdCBhL3NyYy9w ZHVtcGVyLmggYi9zcmMvcGR1bXBlci5oCmluZGV4IGFiMmY0MjZjMWUuLmNmZWEwNmQzM2QgMTAw NjQ0Ci0tLSBhL3NyYy9wZHVtcGVyLmgKKysrIGIvc3JjL3BkdW1wZXIuaApAQCAtMjQ4LDYgKzI0 OCw3IEBAIHBkdW1wZXJfY2xlYXJfbWFya3MgKHZvaWQpCiAgICBmaWxlIHdhcyBsb2FkZWQuICAq LwogZXh0ZXJuIHZvaWQgcGR1bXBlcl9yZWNvcmRfd2QgKGNvbnN0IGNoYXIgKik7CiAKK3ZvaWQg aW5pdF9wZHVtcGVyX29uY2UgKHZvaWQpOwogdm9pZCBzeW1zX29mX3BkdW1wZXIgKHZvaWQpOwog CiBJTkxJTkVfSEVBREVSX0VORAotLSAKMi4yMC4xCgo= --000000000000cd2240058e039dc6-- From debbugs-submit-bounces@debbugs.gnu.org Fri Jul 19 03:46:56 2019 Received: (at 36597) by debbugs.gnu.org; 19 Jul 2019 07:46:56 +0000 Received: from localhost ([127.0.0.1]:55063 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hoNbT-0001z4-Vf for submit@debbugs.gnu.org; Fri, 19 Jul 2019 03:46:56 -0400 Received: from eggs.gnu.org ([209.51.188.92]:55233) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hoNbS-0001ys-Gb for 36597@debbugs.gnu.org; Fri, 19 Jul 2019 03:46:54 -0400 Received: from fencepost.gnu.org ([2001:470:142:3::e]:41502) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1hoNbN-0004At-AS; Fri, 19 Jul 2019 03:46:49 -0400 Received: from [176.228.60.248] (port=3428 helo=home-c4e4a596f7) by fencepost.gnu.org with esmtpsa (TLS1.2:RSA_AES_256_CBC_SHA1:256) (Exim 4.82) (envelope-from ) id 1hoNbM-0006qb-FU; Fri, 19 Jul 2019 03:46:49 -0400 Date: Fri, 19 Jul 2019 10:46:40 +0300 Message-Id: <83r26mv53z.fsf@gnu.org> From: Eli Zaretskii To: Pip Cet In-reply-to: (message from Pip Cet on Fri, 19 Jul 2019 07:23:50 +0000) Subject: Re: bug#36597: 27.0.50; rehash hash tables eagerly in pdumper References: <6a260307-a463-bd08-8a10-d7664d0606a2@cs.ucla.edu> <74235afc-7043-1da7-7c71-07f0ca23b9fd@cs.ucla.edu> X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.2.x-3.x [generic] X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 36597 Cc: eggert@cs.ucla.edu, 36597@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) > From: Pip Cet > Date: Fri, 19 Jul 2019 07:23:50 +0000 > Cc: 36597@debbugs.gnu.org > > But it should be fixed, anyway. The attached patch has no unexpected > performance benefits, as far as I can tell. Thanks. > +static void thaw_hash_tables (void) > +{ This is not our style of defining a function. The name should begin on a new line. From debbugs-submit-bounces@debbugs.gnu.org Sat Jul 20 08:39:06 2019 Received: (at 36597) by debbugs.gnu.org; 20 Jul 2019 12:39:06 +0000 Received: from localhost ([127.0.0.1]:56913 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hoodl-0001xw-Pl for submit@debbugs.gnu.org; Sat, 20 Jul 2019 08:39:06 -0400 Received: from mail-ot1-f49.google.com ([209.85.210.49]:46161) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hoodi-0001xP-Ol for 36597@debbugs.gnu.org; Sat, 20 Jul 2019 08:39:03 -0400 Received: by mail-ot1-f49.google.com with SMTP id z23so7234242ote.13 for <36597@debbugs.gnu.org>; Sat, 20 Jul 2019 05:39:02 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc; bh=/k7Ou8ti6QzsEz4LB93f3r1v3cSE5v+ZhHMc1i+k7ag=; b=cbtTvJJvU3u3/Lm6ZkHnKMDc09kuWdjj3/W9gH0VlVxYcL6bpKfiQoaImKpkE68rDH ndLQbFKmy+btMbEN0xjSTFLOgfFhjIbQo5G9GVL+s5wnmO6jUuPqLVX3f6569q2H/4r+ uIRs+GTooc7s1naMxEsSu101aQQkkAbS6BIQzDX93eXP1l6B8cXgPeM+8sw19nMmcKjW 7/qRHBc+FytCvuF+EIoyfl3+w7uNiYZaO2H39LO0WIrYCNp50jcOzPsE2ZeoVWRas5Wo a38aA3L9808dXFd/6oCc7oFQe4XtOtXMR0vBPEREZZomx6IeIj1oiZz8LBrt87yFGv7W BemQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=/k7Ou8ti6QzsEz4LB93f3r1v3cSE5v+ZhHMc1i+k7ag=; b=SdDsexEA6xxUAgvNwXAZIWfqSQz+ciauPmhrSEuRYsylUd8hDpUZyWgYVGNqmLksnh 6cXIb+S4MtxvIZnQZuhLFRGTqVGDpIozq0byQKUDh8KaVHJw0+xaOl3d6NLCBBas1m+o Ju/8Ul9OMSPkoMooqI/b064jgr2dPUgR+2KwZHebMWzj/Yn5OAaMmnATM1A1OrWWEyEM Ob95ZzMvYXU3WPgL49UMKBqRwdJ6GBMYQ9Nhmu0BY8EaXkv1elGBpGwYG+5MA/+bvEq3 Jy3Q7AWU++yv1kcTPWAk+vbEyioSQIvMfByoqWNNiRUfsyK8m9sLbwtC2XbenCy96Z+p WTvQ== X-Gm-Message-State: APjAAAUtXnZpcXOYZirYtdcslq0pSBe3NL8kebWUIWS3RWn+ZOcq6UBi yi8sJX9gWVB8J02pFqOleLq2kzx+UGc2A3ezQ9k= X-Google-Smtp-Source: APXvYqy0VcroJVfVn+TOUL4oFsgSWo8nwFM1seTkPAYmDr62jK5CyS6bEPlqQ5haN4+j8vpRaVxcos/B5mr5ubCDREY= X-Received: by 2002:a9d:7352:: with SMTP id l18mr39273363otk.292.1563626337076; Sat, 20 Jul 2019 05:38:57 -0700 (PDT) MIME-Version: 1.0 References: <6a260307-a463-bd08-8a10-d7664d0606a2@cs.ucla.edu> <74235afc-7043-1da7-7c71-07f0ca23b9fd@cs.ucla.edu> <83r26mv53z.fsf@gnu.org> In-Reply-To: <83r26mv53z.fsf@gnu.org> From: Pip Cet Date: Sat, 20 Jul 2019 12:38:20 +0000 Message-ID: Subject: Re: bug#36597: 27.0.50; rehash hash tables eagerly in pdumper To: Eli Zaretskii Content-Type: multipart/mixed; boundary="0000000000006235d9058e1c2058" X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 36597 Cc: eggert@cs.ucla.edu, 36597@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) --0000000000006235d9058e1c2058 Content-Type: text/plain; charset="UTF-8" On Fri, Jul 19, 2019 at 7:46 AM Eli Zaretskii wrote: > > +static void thaw_hash_tables (void) > > +{ > > This is not our style of defining a function. The name should begin > on a new line. Thanks for pointing that out, revised patch attached. I'm currently playing around with redefining hash tables not to have internal freelists. That makes the hash table code a lot simpler overall, but some of that simplicity would be lost trying to support lazy hash table rehashing. --0000000000006235d9058e1c2058 Content-Type: text/x-patch; charset="US-ASCII"; name="0001-Rehash-hash-tables-eagerly-after-loading-a-dump.patch" Content-Disposition: attachment; filename="0001-Rehash-hash-tables-eagerly-after-loading-a-dump.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_jybijs2f0 RnJvbSBkZDc3NDNiNTBjNThhNWM5YmIyNWIzZWQwNTI0NWExOWIwZGQxOWQ3IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBQaXAgQ2V0IDxwaXBjZXRAZ21haWwuY29tPgpEYXRlOiBGcmks IDE5IEp1bCAyMDE5IDA3OjEyOjQyICswMDAwClN1YmplY3Q6IFtQQVRDSF0gUmVoYXNoIGhhc2gg dGFibGVzIGVhZ2VybHkgYWZ0ZXIgbG9hZGluZyBhIGR1bXAuCgoqIHNyYy9saXNwLmggKGhhc2hf cmVoYXNoX25lZWRlZF9wKTogUmVtb3ZlLiAgQWxsIHVzZXMgcmVtb3ZlZC4KKGhhc2hfcmVoYXNo X2lmX25lZWRlZCk6IFJlbW92ZS4gIEFsbCB1c2VzIHJlbW92ZWQuCihzdHJ1Y3QgTGlzcF9IYXNo X1RhYmxlKTogUmVtb3ZlIGNvbW1lbnQgYWJvdXQgcmVoYXNoaW5nIGhhc2ggdGFibGVzLgoqIHNy Yy9wZHVtcGVyLmMgKHRoYXdfaGFzaF90YWJsZXMpOiBOZXcgZnVuY3Rpb24uCihoYXNoX3RhYmxl X3RoYXcpOiBOZXcgZnVuY3Rpb24uCihoYXNoX3RhYmxlX2ZyZWV6ZSk6IE5ldyBmdW5jdGlvbi4K KGR1bXBfaGFzaF90YWJsZSk6IFNpbXBsaWZ5LgooZHVtcF9oYXNoX3RhYmxlX2xpc3QpOiBOZXcg ZnVuY3Rpb24uCihoYXNoX3RhYmxlX2NvbnRlbnRzKTogTmV3IGZ1bmN0aW9uLgooRmR1bXBfZW1h Y3NfcG9ydGFibGUpOiBIYW5kbGUgaGFzaCB0YWJsZXMgYnkgZWFnZXIgcmVoYXNoaW5nLgoocGR1 bXBlcl9sb2FkKTogUmVzdG9yZSBoYXNoIHRhYmxlcy4KKGluaXRfcGR1bXBlcl9vbmNlKTogTmV3 IGZ1bmN0aW9uLgotLS0KIHNyYy9ieXRlY29kZS5jICB8ICAgMSAtCiBzcmMvY29tcG9zaXRlLmMg fCAgIDEgLQogc3JjL2VtYWNzLmMgICAgIHwgICAxICsKIHNyYy9mbnMuYyAgICAgICB8ICA2NSAr KysrKy0tLS0tLS0tLS0tLQogc3JjL2xpc3AuaCAgICAgIHwgIDE5ICstLS0tCiBzcmMvbWluaWJ1 Zi5jICAgfCAgIDMgLQogc3JjL3BkdW1wZXIuYyAgIHwgMTgzICsrKysrKysrKysrKysrKysrKysr KystLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogc3JjL3BkdW1wZXIuaCAgIHwgICAxICsKIDgg ZmlsZXMgY2hhbmdlZCwgMTA0IGluc2VydGlvbnMoKyksIDE3MCBkZWxldGlvbnMoLSkKCmRpZmYg LS1naXQgYS9zcmMvYnl0ZWNvZGUuYyBiL3NyYy9ieXRlY29kZS5jCmluZGV4IDI5ZGZmNDRmMDAu LjljNzI0MjllMGMgMTAwNjQ0Ci0tLSBhL3NyYy9ieXRlY29kZS5jCisrKyBiL3NyYy9ieXRlY29k ZS5jCkBAIC0xNDAyLDcgKzE0MDIsNiBAQCAjZGVmaW5lIERFRklORShuYW1lLCB2YWx1ZSkgTEFC RUwgKG5hbWUpICwKICAgICAgICAgICAgIExpc3BfT2JqZWN0IHYxID0gUE9QOwogICAgICAgICAg ICAgcHRyZGlmZl90IGk7CiAgICAgICAgICAgICBzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICpoID0g WEhBU0hfVEFCTEUgKGptcF90YWJsZSk7Ci0gICAgICAgICAgICBoYXNoX3JlaGFzaF9pZl9uZWVk ZWQgKGgpOwogCiAgICAgICAgICAgICAvKiBoLT5jb3VudCBpcyBhIGZhc3RlciBhcHByb3hpbWF0 aW9uIGZvciBIQVNIX1RBQkxFX1NJWkUgKGgpCiAgICAgICAgICAgICAgICBoZXJlLiAqLwpkaWZm IC0tZ2l0IGEvc3JjL2NvbXBvc2l0ZS5jIGIvc3JjL2NvbXBvc2l0ZS5jCmluZGV4IDE4MzA2MmRl NDYuLjQ5YTI4NWNmZjAgMTAwNjQ0Ci0tLSBhL3NyYy9jb21wb3NpdGUuYworKysgYi9zcmMvY29t cG9zaXRlLmMKQEAgLTY1NCw3ICs2NTQsNiBAQCBnc3RyaW5nX2xvb2t1cF9jYWNoZSAoTGlzcF9P YmplY3QgaGVhZGVyKQogY29tcG9zaXRpb25fZ3N0cmluZ19wdXRfY2FjaGUgKExpc3BfT2JqZWN0 IGdzdHJpbmcsIHB0cmRpZmZfdCBsZW4pCiB7CiAgIHN0cnVjdCBMaXNwX0hhc2hfVGFibGUgKmgg PSBYSEFTSF9UQUJMRSAoZ3N0cmluZ19oYXNoX3RhYmxlKTsKLSAgaGFzaF9yZWhhc2hfaWZfbmVl ZGVkIChoKTsKICAgTGlzcF9PYmplY3QgaGVhZGVyID0gTEdTVFJJTkdfSEVBREVSIChnc3RyaW5n KTsKICAgRU1BQ1NfVUlOVCBoYXNoID0gaC0+dGVzdC5oYXNoZm4gKCZoLT50ZXN0LCBoZWFkZXIp OwogICBpZiAobGVuIDwgMCkKZGlmZiAtLWdpdCBhL3NyYy9lbWFjcy5jIGIvc3JjL2VtYWNzLmMK aW5kZXggYWQ2NjFhMDgxYi4uODU1YjJjNjcxNSAxMDA2NDQKLS0tIGEvc3JjL2VtYWNzLmMKKysr IGIvc3JjL2VtYWNzLmMKQEAgLTE1NjAsNiArMTU2MCw3IEBAIG1haW4gKGludCBhcmdjLCBjaGFy ICoqYXJndikKICAgaWYgKCFpbml0aWFsaXplZCkKICAgICB7CiAgICAgICBpbml0X2FsbG9jX29u Y2UgKCk7CisgICAgICBpbml0X3BkdW1wZXJfb25jZSAoKTsKICAgICAgIGluaXRfb2JhcnJheV9v bmNlICgpOwogICAgICAgaW5pdF9ldmFsX29uY2UgKCk7CiAgICAgICBpbml0X2NoYXJzZXRfb25j ZSAoKTsKZGlmZiAtLWdpdCBhL3NyYy9mbnMuYyBiL3NyYy9mbnMuYwppbmRleCAwNDk3NTg4Njg5 Li42Zjg2ZDdmMzE0IDEwMDY0NAotLS0gYS9zcmMvZm5zLmMKKysrIGIvc3JjL2Zucy5jCkBAIC00 MjMzLDUxICs0MjMzLDI3IEBAIG1heWJlX3Jlc2l6ZV9oYXNoX3RhYmxlIChzdHJ1Y3QgTGlzcF9I YXNoX1RhYmxlICpoKQogCiAvKiBSZWNvbXB1dGUgdGhlIGhhc2hlcyAoYW5kIGhlbmNlIGFsc28g dGhlICJuZXh0IiBwb2ludGVycykuCiAgICBOb3JtYWxseSB0aGVyZSdzIG5ldmVyIGEgbmVlZCB0 byByZWNvbXB1dGUgaGFzaGVzLgotICAgVGhpcyBpcyBkb25lIG9ubHkgb24gZmlyc3QtYWNjZXNz IHRvIGEgaGFzaC10YWJsZSBsb2FkZWQgZnJvbQotICAgdGhlICJwZHVtcCIsIGJlY2F1c2UgdGhl IG9iamVjdCdzIGFkZHJlc3NlcyBtYXkgaGF2ZSBjaGFuZ2VkLCB0aHVzCisgICBUaGlzIGlzIGRv bmUgb25seSBvbiBmaXJzdCBhY2Nlc3MgdG8gYSBoYXNoLXRhYmxlIGxvYWRlZCBmcm9tCisgICB0 aGUgInBkdW1wIiwgYmVjYXVzZSB0aGUgb2JqZWN0cycgYWRkcmVzc2VzIG1heSBoYXZlIGNoYW5n ZWQsIHRodXMKICAgIGFmZmVjdGluZyB0aGVpciBoYXNoLiAgKi8KIHZvaWQKIGhhc2hfdGFibGVf cmVoYXNoIChzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICpoKQogewotICBwdHJkaWZmX3Qgc2l6ZSA9 IEhBU0hfVEFCTEVfU0laRSAoaCk7Ci0KLSAgLyogVGhlc2Ugc3RydWN0dXJlcyBtYXkgaGF2ZSBi ZWVuIHB1cmVjb3BpZWQgYW5kIHNoYXJlZAotICAgICAoYnVnIzM2NDQ3KS4gICovCi0gIGgtPm5l eHQgPSBGY29weV9zZXF1ZW5jZSAoaC0+bmV4dCk7Ci0gIGgtPmluZGV4ID0gRmNvcHlfc2VxdWVu Y2UgKGgtPmluZGV4KTsKLSAgaC0+aGFzaCA9IEZjb3B5X3NlcXVlbmNlIChoLT5oYXNoKTsKLQog ICAvKiBSZWNvbXB1dGUgdGhlIGFjdHVhbCBoYXNoIGNvZGVzIGZvciBlYWNoIGVudHJ5IGluIHRo ZSB0YWJsZS4KICAgICAgT3JkZXIgaXMgc3RpbGwgaW52YWxpZC4gICovCi0gIGZvciAocHRyZGlm Zl90IGkgPSAwOyBpIDwgc2l6ZTsgKytpKQotICAgIGlmICghTklMUCAoSEFTSF9IQVNIIChoLCBp KSkpCi0gICAgICB7Ci0gICAgICAgIExpc3BfT2JqZWN0IGtleSA9IEhBU0hfS0VZIChoLCBpKTsK LSAgICAgICAgRU1BQ1NfVUlOVCBoYXNoX2NvZGUgPSBoLT50ZXN0Lmhhc2hmbiAoJmgtPnRlc3Qs IGtleSk7Ci0gICAgICAgIHNldF9oYXNoX2hhc2hfc2xvdCAoaCwgaSwgbWFrZV9maXhudW0gKGhh c2hfY29kZSkpOwotICAgICAgfQotCi0gIC8qIFJlc2V0IHRoZSBpbmRleCBzbyB0aGF0IGFueSBz bG90IHdlIGRvbid0IGZpbGwgYmVsb3cgaXMgbWFya2VkCi0gICAgIGludmFsaWQuICAqLwotICBG ZmlsbGFycmF5IChoLT5pbmRleCwgbWFrZV9maXhudW0gKC0xKSk7Ci0KLSAgLyogUmVidWlsZCB0 aGUgY29sbGlzaW9uIGNoYWlucy4gICovCi0gIGZvciAocHRyZGlmZl90IGkgPSAwOyBpIDwgc2l6 ZTsgKytpKQotICAgIGlmICghTklMUCAoSEFTSF9IQVNIIChoLCBpKSkpCi0gICAgICB7Ci0gICAg ICAgIEVNQUNTX1VJTlQgaGFzaF9jb2RlID0gWFVGSVhOVU0gKEhBU0hfSEFTSCAoaCwgaSkpOwot ICAgICAgICBwdHJkaWZmX3Qgc3RhcnRfb2ZfYnVja2V0ID0gaGFzaF9jb2RlICUgQVNJWkUgKGgt PmluZGV4KTsKLSAgICAgICAgc2V0X2hhc2hfbmV4dF9zbG90IChoLCBpLCBIQVNIX0lOREVYICho LCBzdGFydF9vZl9idWNrZXQpKTsKLSAgICAgICAgc2V0X2hhc2hfaW5kZXhfc2xvdCAoaCwgc3Rh cnRfb2ZfYnVja2V0LCBpKTsKLSAgICAgICAgZWFzc2VydCAoSEFTSF9ORVhUIChoLCBpKSAhPSBp KTsgLyogU3RvcCBsb29wcy4gICovCi0gICAgICB9CisgIGZvciAocHRyZGlmZl90IGkgPSAwOyBp IDwgaC0+Y291bnQ7ICsraSkKKyAgICB7CisgICAgICBMaXNwX09iamVjdCBrZXkgPSBIQVNIX0tF WSAoaCwgaSk7CisgICAgICBFTUFDU19VSU5UIGhhc2hfY29kZSA9IGgtPnRlc3QuaGFzaGZuICgm aC0+dGVzdCwga2V5KTsKKyAgICAgIHB0cmRpZmZfdCBzdGFydF9vZl9idWNrZXQgPSBoYXNoX2Nv ZGUgJSBBU0laRSAoaC0+aW5kZXgpOworICAgICAgc2V0X2hhc2hfaGFzaF9zbG90IChoLCBpLCBt YWtlX2ZpeG51bSAoaGFzaF9jb2RlKSk7CisgICAgICBzZXRfaGFzaF9uZXh0X3Nsb3QgKGgsIGks IEhBU0hfSU5ERVggKGgsIHN0YXJ0X29mX2J1Y2tldCkpOworICAgICAgc2V0X2hhc2hfaW5kZXhf c2xvdCAoaCwgc3RhcnRfb2ZfYnVja2V0LCBpKTsKKyAgICAgIGVhc3NlcnQgKEhBU0hfTkVYVCAo aCwgaSkgIT0gaSk7IC8qIFN0b3AgbG9vcHMuICAqLworICAgIH0KIAotICAvKiBGaW5hbGx5LCBt YXJrIHRoZSBoYXNoIHRhYmxlIGFzIGhhdmluZyBhIHZhbGlkIGhhc2ggb3JkZXIuCi0gICAgIERv IHRoaXMgbGFzdCBzbyB0aGF0IGlmIHdlJ3JlIGludGVycnVwdGVkLCB3ZSByZXRyeSBvbiBuZXh0 Ci0gICAgIGFjY2Vzcy4gKi8KLSAgZWFzc2VydCAoaC0+Y291bnQgPCAwKTsKLSAgaC0+Y291bnQg PSAtaC0+Y291bnQ7Ci0gIGVhc3NlcnQgKCFoYXNoX3JlaGFzaF9uZWVkZWRfcCAoaCkpOworICBm b3IgKHB0cmRpZmZfdCBpID0gaC0+Y291bnQ7IGkgPCBBU0laRSAoaC0+bmV4dCkgLSAxOyBpKysp CisgICAgc2V0X2hhc2hfbmV4dF9zbG90IChoLCBpLCBpICsgMSk7CiB9CiAKIC8qIExvb2t1cCBL RVkgaW4gaGFzaCB0YWJsZSBILiAgSWYgSEFTSCBpcyBub24tbnVsbCwgcmV0dXJuIGluICpIQVNI CkBAIC00MjkwLDggKzQyNjYsNiBAQCBoYXNoX2xvb2t1cCAoc3RydWN0IExpc3BfSGFzaF9UYWJs ZSAqaCwgTGlzcF9PYmplY3Qga2V5LCBFTUFDU19VSU5UICpoYXNoKQogICBFTUFDU19VSU5UIGhh c2hfY29kZTsKICAgcHRyZGlmZl90IHN0YXJ0X29mX2J1Y2tldCwgaTsKIAotICBoYXNoX3JlaGFz aF9pZl9uZWVkZWQgKGgpOwotCiAgIGhhc2hfY29kZSA9IGgtPnRlc3QuaGFzaGZuICgmaC0+dGVz dCwga2V5KTsKICAgZWFzc2VydCAoKGhhc2hfY29kZSAmIH5JTlRNQVNLKSA9PSAwKTsKICAgaWYg KGhhc2gpCkBAIC00MzIwLDggKzQyOTQsNiBAQCBoYXNoX3B1dCAoc3RydWN0IExpc3BfSGFzaF9U YWJsZSAqaCwgTGlzcF9PYmplY3Qga2V5LCBMaXNwX09iamVjdCB2YWx1ZSwKIHsKICAgcHRyZGlm Zl90IHN0YXJ0X29mX2J1Y2tldCwgaTsKIAotICBoYXNoX3JlaGFzaF9pZl9uZWVkZWQgKGgpOwot CiAgIGVhc3NlcnQgKChoYXNoICYgfklOVE1BU0spID09IDApOwogCiAgIC8qIEluY3JlbWVudCBj b3VudCBhZnRlciByZXNpemluZyBiZWNhdXNlIHJlc2l6aW5nIG1heSBmYWlsLiAgKi8KQEAgLTQz NTUsOCArNDMyNyw2IEBAIGhhc2hfcmVtb3ZlX2Zyb21fdGFibGUgKHN0cnVjdCBMaXNwX0hhc2hf VGFibGUgKmgsIExpc3BfT2JqZWN0IGtleSkKICAgcHRyZGlmZl90IHN0YXJ0X29mX2J1Y2tldCA9 IGhhc2hfY29kZSAlIEFTSVpFIChoLT5pbmRleCk7CiAgIHB0cmRpZmZfdCBwcmV2ID0gLTE7CiAK LSAgaGFzaF9yZWhhc2hfaWZfbmVlZGVkIChoKTsKLQogICBmb3IgKHB0cmRpZmZfdCBpID0gSEFT SF9JTkRFWCAoaCwgc3RhcnRfb2ZfYnVja2V0KTsKICAgICAgICAwIDw9IGk7CiAgICAgICAgaSA9 IEhBU0hfTkVYVCAoaCwgaSkpCkBAIC00NDM0LDkgKzQ0MDQsNyBAQCBzd2VlcF93ZWFrX3RhYmxl IChzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICpoLCBib29sIHJlbW92ZV9lbnRyaWVzX3ApCiAgIGZv ciAocHRyZGlmZl90IGJ1Y2tldCA9IDA7IGJ1Y2tldCA8IG47ICsrYnVja2V0KQogICAgIHsKICAg ICAgIC8qIEZvbGxvdyBjb2xsaXNpb24gY2hhaW4sIHJlbW92aW5nIGVudHJpZXMgdGhhdCBkb24n dCBzdXJ2aXZlCi0gICAgICAgICB0aGlzIGdhcmJhZ2UgY29sbGVjdGlvbi4gIEl0J3Mgb2theSBp ZiBoYXNoX3JlaGFzaF9uZWVkZWRfcAotICAgICAgICAgKGgpIGlzIHRydWUsIHNpbmNlIHdlJ3Jl IG9wZXJhdGluZyBlbnRpcmVseSBvbiB0aGUgY2FjaGVkCi0gICAgICAgICBoYXNoIHZhbHVlcy4g Ki8KKyAgICAgICAgIHRoaXMgZ2FyYmFnZSBjb2xsZWN0aW9uLiAgKi8KICAgICAgIHB0cmRpZmZf dCBwcmV2ID0gLTE7CiAgICAgICBwdHJkaWZmX3QgbmV4dDsKICAgICAgIGZvciAocHRyZGlmZl90 IGkgPSBIQVNIX0lOREVYIChoLCBidWNrZXQpOyAwIDw9IGk7IGkgPSBuZXh0KQpAQCAtNDQ3OCw3 ICs0NDQ2LDcgQEAgc3dlZXBfd2Vha190YWJsZSAoc3RydWN0IExpc3BfSGFzaF9UYWJsZSAqaCwg Ym9vbCByZW1vdmVfZW50cmllc19wKQogICAgICAgICAgICAgICAgICAgc2V0X2hhc2hfaGFzaF9z bG90IChoLCBpLCBRbmlsKTsKIAogICAgICAgICAgICAgICAgICAgZWFzc2VydCAoaC0+Y291bnQg IT0gMCk7Ci0gICAgICAgICAgICAgICAgICBoLT5jb3VudCArPSBoLT5jb3VudCA+IDAgPyAtMSA6 IDE7CisgICAgICAgICAgICAgICAgICBoLT5jb3VudC0tOwogICAgICAgICAgICAgICAgIH0KIAkg ICAgICBlbHNlCiAJCXsKQEAgLTQ4ODEsNyArNDg0OSw2IEBAIERFRlVOICgiaGFzaC10YWJsZS1j b3VudCIsIEZoYXNoX3RhYmxlX2NvdW50LCBTaGFzaF90YWJsZV9jb3VudCwgMSwgMSwgMCwKICAg KExpc3BfT2JqZWN0IHRhYmxlKQogewogICBzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICpoID0gY2hl Y2tfaGFzaF90YWJsZSAodGFibGUpOwotICBoYXNoX3JlaGFzaF9pZl9uZWVkZWQgKGgpOwogICBy ZXR1cm4gbWFrZV9maXhudW0gKGgtPmNvdW50KTsKIH0KIApkaWZmIC0tZ2l0IGEvc3JjL2xpc3Au aCBiL3NyYy9saXNwLmgKaW5kZXggMTMwMTRjODJkYy4uZDBlNWM0M2M0MSAxMDA2NDQKLS0tIGEv c3JjL2xpc3AuaAorKysgYi9zcmMvbGlzcC5oCkBAIC0yMjQ1LDExICsyMjQ1LDcgQEAgI2RlZmlu ZSBERUZTWU0oc3ltLCBuYW1lKSAvKiBlbXB0eSAqLwogCiBzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxl CiB7Ci0gIC8qIENoYW5nZSBwZHVtcGVyLmMgaWYgeW91IGNoYW5nZSB0aGUgZmllbGRzIGhlcmUu Ci0KLSAgICAgSU1QT1JUQU5UISEhISEhIQotCi0gICAgIENhbGwgaGFzaF9yZWhhc2hfaWZfbmVl ZGVkKCkgYmVmb3JlIGFjY2Vzc2luZy4gICovCisgIC8qIENoYW5nZSBwZHVtcGVyLmMgaWYgeW91 IGNoYW5nZSB0aGUgZmllbGRzIGhlcmUuICAqLwogCiAgIC8qIFRoaXMgaXMgZm9yIExpc3A7IHRo ZSBoYXNoIHRhYmxlIGNvZGUgZG9lcyBub3QgcmVmZXIgdG8gaXQuICAqLwogICB1bmlvbiB2ZWN0 b3JsaWtlX2hlYWRlciBoZWFkZXI7CkBAIC0yMzYzLDE5ICsyMzU5LDYgQEAgSEFTSF9UQUJMRV9T SVpFIChjb25zdCBzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICpoKQogCiB2b2lkIGhhc2hfdGFibGVf cmVoYXNoIChzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICpoKTsKIAotSU5MSU5FIGJvb2wKLWhhc2hf cmVoYXNoX25lZWRlZF9wIChjb25zdCBzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICpoKQotewotICBy ZXR1cm4gaC0+Y291bnQgPCAwOwotfQotCi1JTkxJTkUgdm9pZAotaGFzaF9yZWhhc2hfaWZfbmVl ZGVkIChzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICpoKQotewotICBpZiAoaGFzaF9yZWhhc2hfbmVl ZGVkX3AgKGgpKQotICAgIGhhc2hfdGFibGVfcmVoYXNoIChoKTsKLX0KLQogLyogRGVmYXVsdCBz aXplIGZvciBoYXNoIHRhYmxlcyBpZiBub3Qgc3BlY2lmaWVkLiAgKi8KIAogZW51bSBERUZBVUxU X0hBU0hfU0laRSB7IERFRkFVTFRfSEFTSF9TSVpFID0gNjUgfTsKZGlmZiAtLWdpdCBhL3NyYy9t aW5pYnVmLmMgYi9zcmMvbWluaWJ1Zi5jCmluZGV4IGQ5YTZlMTViMDUuLmU5MjNjZTJhNDMgMTAw NjQ0Ci0tLSBhL3NyYy9taW5pYnVmLmMKKysrIGIvc3JjL21pbmlidWYuYwpAQCAtMTIwMyw5ICsx MjAzLDYgQEAgREVGVU4gKCJ0cnktY29tcGxldGlvbiIsIEZ0cnlfY29tcGxldGlvbiwgU3RyeV9j b21wbGV0aW9uLCAyLCAzLCAwLAogICAgICAgYnVja2V0ID0gQVJFRiAoY29sbGVjdGlvbiwgaWR4 KTsKICAgICB9CiAKLSAgaWYgKEhBU0hfVEFCTEVfUCAoY29sbGVjdGlvbikpCi0gICAgaGFzaF9y ZWhhc2hfaWZfbmVlZGVkIChYSEFTSF9UQUJMRSAoY29sbGVjdGlvbikpOwotCiAgIHdoaWxlICgx KQogICAgIHsKICAgICAgIC8qIEdldCB0aGUgbmV4dCBlbGVtZW50IG9mIHRoZSBhbGlzdCwgb2Jh cnJheSwgb3IgaGFzaC10YWJsZS4gICovCmRpZmYgLS1naXQgYS9zcmMvcGR1bXBlci5jIGIvc3Jj L3BkdW1wZXIuYwppbmRleCAwM2MwMGJmMjdiLi42OTdmZjk3NjdhIDEwMDY0NAotLS0gYS9zcmMv cGR1bXBlci5jCisrKyBiL3NyYy9wZHVtcGVyLmMKQEAgLTEwNywxNyArMTA3LDYgQEAgI2RlZmlu ZSBWTV9NU19XSU5ET1dTIDIKIAogI2RlZmluZSBEQU5HRVJPVVMgMAogCi0vKiBQRFVNUEVSX0NI RUNLX1JFSEFTSElORyBiZWluZyB0cnVlIGNhdXNlcyB0aGUgcG9ydGFibGUgZHVtcGVyIHRvCi0g ICBjaGVjaywgZm9yIGVhY2ggaGFzaCB0YWJsZSBpdCBkdW1wcywgdGhhdCB0aGUgaGFzaCB0YWJs ZSBtZWFucyB0aGUKLSAgIHNhbWUgdGhpbmcgYWZ0ZXIgcmVoYXNoaW5nLiAgKi8KLSNpZm5kZWYg UERVTVBFUl9DSEVDS19SRUhBU0hJTkcKLSMgaWYgRU5BQkxFX0NIRUNLSU5HCi0jICBkZWZpbmUg UERVTVBFUl9DSEVDS19SRUhBU0hJTkcgMQotIyBlbHNlCi0jICBkZWZpbmUgUERVTVBFUl9DSEVD S19SRUhBU0hJTkcgMAotIyBlbmRpZgotI2VuZGlmCi0KIC8qIFdlIHJlcXVpcmUgYW4gYXJjaGl0 ZWN0dXJlIGluIHdoaWNoIGFsbCBwb2ludGVycyBhcmUgdGhlIHNhbWUgc2l6ZQogICAgYW5kIGhh dmUgdGhlIHNhbWUgbGF5b3V0LCB3aGVyZSBwb2ludGVycyBhcmUgZWl0aGVyIDMyIG9yIDY0IGJp dHMKICAgIGxvbmcsIGFuZCB3aGVyZSBieXRlcyBoYXZlIGVpZ2h0IGJpdHMgLS0tIHRoYXQgaXMs IGEKQEAgLTM5Myw2ICszODIsOCBAQCBkdW1wX2ZpbmdlcnByaW50IChjaGFyIGNvbnN0ICpsYWJl bCwKICAgICAgVGhlIHN0YXJ0IG9mIHRoZSBjb2xkIHJlZ2lvbiBpcyBhbHdheXMgYWxpZ25lZCBv biBhIHBhZ2UKICAgICAgYm91bmRhcnkuICAqLwogICBkdW1wX29mZiBjb2xkX3N0YXJ0OworCisg IGR1bXBfb2ZmIGhhc2hfbGlzdDsKIH07CiAKIC8qIERvdWJsZS1lbmRlZCBzaW5nbHkgbGlua2Vk IGxpc3QuICAqLwpAQCAtNTUwLDYgKzU0MSw4IEBAIGR1bXBfZmluZ2VycHJpbnQgKGNoYXIgY29u c3QgKmxhYmVsLAogICAgICBoZWFwIG9iamVjdHMuICAqLwogICBMaXNwX09iamVjdCBiaWdudW1f ZGF0YTsKIAorICBMaXNwX09iamVjdCBoYXNoX3RhYmxlczsKKwogICB1bnNpZ25lZCBudW1iZXJf aG90X3JlbG9jYXRpb25zOwogICB1bnNpZ25lZCBudW1iZXJfZGlzY2FyZGFibGVfcmVsb2NhdGlv bnM7CiB9OwpAQCAtMjYyMiw2OCArMjYxNSw1OCBAQCBkdW1wX3ZlY3Rvcmxpa2VfZ2VuZXJpYyAo c3RydWN0IGR1bXBfY29udGV4dCAqY3R4LAogICByZXR1cm4gb2Zmc2V0OwogfQogCi0vKiBEZXRl cm1pbmUgd2hldGhlciB0aGUgaGFzaCB0YWJsZSdzIGhhc2ggb3JkZXIgaXMgc3RhYmxlCi0gICBh Y3Jvc3MgZHVtcCBhbmQgbG9hZC4gIElmIGl0IGlzLCB3ZSBkb24ndCBoYXZlIHRvIHRyaWdnZXIK LSAgIGEgcmVoYXNoIG9uIGFjY2Vzcy4gICovCi1zdGF0aWMgYm9vbAotZHVtcF9oYXNoX3RhYmxl X3N0YWJsZV9wIChjb25zdCBzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICpoYXNoKQorLyogUmV0dXJu IGEgdmVjdG9yIG9mIEtFWSwgVkFMVUUgcGFpcnMgaW4gdGhlIGdpdmVuIGhhc2ggdGFibGUgSC4g IFRoZQorICAgZmlyc3QgSC0+Y291bnQgcGFpcnMgYXJlIHZhbGlkLCB0aGUgcmVzdCBpcyBsZWZ0 IGFzIG5pbC4gICovCitzdGF0aWMgTGlzcF9PYmplY3QKK2hhc2hfdGFibGVfY29udGVudHMgKHN0 cnVjdCBMaXNwX0hhc2hfVGFibGUgKmgpCiB7Ci0gIGJvb2wgaXNfZXFsID0gaGFzaC0+dGVzdC5o YXNoZm4gPT0gaGFzaGZuX2VxbDsKLSAgYm9vbCBpc19lcXVhbCA9IGhhc2gtPnRlc3QuaGFzaGZu ID09IGhhc2hmbl9lcXVhbDsKLSAgcHRyZGlmZl90IHNpemUgPSBIQVNIX1RBQkxFX1NJWkUgKGhh c2gpOwotICBmb3IgKHB0cmRpZmZfdCBpID0gMDsgaSA8IHNpemU7ICsraSkKLSAgICBpZiAoIU5J TFAgKEhBU0hfSEFTSCAoaGFzaCwgaSkpKQorICBMaXNwX09iamVjdCBjb250ZW50cyA9IFFuaWw7 CisgIC8qIE1ha2Ugc3VyZSBrZXlfYW5kX3ZhbHVlIGVuZHMgdXAgaW4gdGhlIHNhbWUgb3JkZXIs IGNoYXJzZXQuYworICAgICByZWxpZXMgb24gaXQgYnkgZXhwZWN0aW5nIGhhc2ggdGFibGUgaW5k aWNlcyB0byBzdGF5IGNvbnN0YW50CisgICAgIGFjcm9zcyB0aGUgZHVtcC4gICovCisgIGZvciAo cHRyZGlmZl90IGkgPSAwOyBpIDwgSEFTSF9UQUJMRV9TSVpFIChoKSAtIGgtPmNvdW50OyBpKysp CisgICAgeworICAgICAgZHVtcF9wdXNoICgmY29udGVudHMsIFFuaWwpOworICAgICAgZHVtcF9w dXNoICgmY29udGVudHMsIFFuaWwpOworICAgIH0KKworICBmb3IgKHB0cmRpZmZfdCBpID0gSEFT SF9UQUJMRV9TSVpFIChoKSAtIDE7IGkgPj0gMDsgLS1pKQorICAgIGlmICghTklMUCAoSEFTSF9I QVNIIChoLCBpKSkpCiAgICAgICB7Ci0gICAgICAgIExpc3BfT2JqZWN0IGtleSA9ICBIQVNIX0tF WSAoaGFzaCwgaSk7Ci0JYm9vbCBrZXlfc3RhYmxlID0gKGR1bXBfYnVpbHRpbl9zeW1ib2xfcCAo a2V5KQotCQkJICAgfHwgRklYTlVNUCAoa2V5KQotCQkJICAgfHwgKGlzX2VxdWFsICYmIFNUUklO R1AgKGtleSkpCi0JCQkgICB8fCAoKGlzX2VxdWFsIHx8IGlzX2VxbCkgJiYgRkxPQVRQIChrZXkp KSk7Ci0gICAgICAgIGlmICgha2V5X3N0YWJsZSkKLSAgICAgICAgICByZXR1cm4gZmFsc2U7CisJ ZHVtcF9wdXNoICgmY29udGVudHMsIEhBU0hfVkFMVUUgKGgsIGkpKTsKKwlkdW1wX3B1c2ggKCZj b250ZW50cywgSEFTSF9LRVkgKGgsIGkpKTsKICAgICAgIH0KIAotICByZXR1cm4gdHJ1ZTsKKyAg cmV0dXJuIENBTExOIChGYXBwbHksIFF2ZWN0b3IsIGNvbnRlbnRzKTsKIH0KIAotLyogUmV0dXJu IGEgbGlzdCBvZiAoS0VZIC4gVkFMVUUpIHBhaXJzIGluIHRoZSBnaXZlbiBoYXNoIHRhYmxlLiAg Ki8KLXN0YXRpYyBMaXNwX09iamVjdAotaGFzaF90YWJsZV9jb250ZW50cyAoTGlzcF9PYmplY3Qg dGFibGUpCitzdGF0aWMgZHVtcF9vZmYKK2R1bXBfaGFzaF90YWJsZV9saXN0IChzdHJ1Y3QgZHVt cF9jb250ZXh0ICpjdHgpCiB7Ci0gIExpc3BfT2JqZWN0IGNvbnRlbnRzID0gUW5pbDsKLSAgc3Ry dWN0IExpc3BfSGFzaF9UYWJsZSAqaCA9IFhIQVNIX1RBQkxFICh0YWJsZSk7Ci0gIGZvciAocHRy ZGlmZl90IGkgPSAwOyBpIDwgSEFTSF9UQUJMRV9TSVpFIChoKTsgKytpKQotICAgIGlmICghTklM UCAoSEFTSF9IQVNIIChoLCBpKSkpCi0gICAgICBkdW1wX3B1c2ggKCZjb250ZW50cywgRmNvbnMg KEhBU0hfS0VZIChoLCBpKSwgSEFTSF9WQUxVRSAoaCwgaSkpKTsKLSAgcmV0dXJuIEZucmV2ZXJz ZSAoY29udGVudHMpOworICBpZiAoQ09OU1AgKGN0eC0+aGFzaF90YWJsZXMpKQorICAgIHJldHVy biBkdW1wX29iamVjdCAoY3R4LCBDQUxMTiAoRmFwcGx5LCBRdmVjdG9yLCBjdHgtPmhhc2hfdGFi bGVzKSk7CisgIGVsc2UKKyAgICByZXR1cm4gMDsKIH0KIAotLyogQ29weSB0aGUgZ2l2ZW4gaGFz aCB0YWJsZSwgcmVoYXNoIGl0LCBhbmQgbWFrZSBzdXJlIHRoYXQgd2UgY2FuCi0gICBsb29rIHVw IGFsbCB0aGUgdmFsdWVzIGluIHRoZSBvcmlnaW5hbC4gICovCiBzdGF0aWMgdm9pZAotY2hlY2tf aGFzaF90YWJsZV9yZWhhc2ggKExpc3BfT2JqZWN0IHRhYmxlX29yaWcpCi17Ci0gIGhhc2hfcmVo YXNoX2lmX25lZWRlZCAoWEhBU0hfVEFCTEUgKHRhYmxlX29yaWcpKTsKLSAgTGlzcF9PYmplY3Qg dGFibGVfcmVoYXNoZWQgPSBGY29weV9oYXNoX3RhYmxlICh0YWJsZV9vcmlnKTsKLSAgZWFzc2Vy dCAoWEhBU0hfVEFCTEUgKHRhYmxlX3JlaGFzaGVkKS0+Y291bnQgPj0gMCk7Ci0gIFhIQVNIX1RB QkxFICh0YWJsZV9yZWhhc2hlZCktPmNvdW50ICo9IC0xOwotICBlYXNzZXJ0IChYSEFTSF9UQUJM RSAodGFibGVfcmVoYXNoZWQpLT5jb3VudCA8PSAwKTsKLSAgaGFzaF9yZWhhc2hfaWZfbmVlZGVk IChYSEFTSF9UQUJMRSAodGFibGVfcmVoYXNoZWQpKTsKLSAgZWFzc2VydCAoWEhBU0hfVEFCTEUg KHRhYmxlX3JlaGFzaGVkKS0+Y291bnQgPj0gMCk7Ci0gIExpc3BfT2JqZWN0IGV4cGVjdGVkX2Nv bnRlbnRzID0gaGFzaF90YWJsZV9jb250ZW50cyAodGFibGVfb3JpZyk7Ci0gIHdoaWxlICghTklM UCAoZXhwZWN0ZWRfY29udGVudHMpKQotICAgIHsKLSAgICAgIExpc3BfT2JqZWN0IGtleV92YWx1 ZV9wYWlyID0gZHVtcF9wb3AgKCZleHBlY3RlZF9jb250ZW50cyk7Ci0gICAgICBMaXNwX09iamVj dCBrZXkgPSBYQ0FSIChrZXlfdmFsdWVfcGFpcik7Ci0gICAgICBMaXNwX09iamVjdCBleHBlY3Rl ZF92YWx1ZSA9IFhDRFIgKGtleV92YWx1ZV9wYWlyKTsKLSAgICAgIExpc3BfT2JqZWN0IGFyYml0 cmFyeSA9IFFkdW1wX2VtYWNzX3BvcnRhYmxlX19zb3J0X3ByZWRpY2F0ZV9jb3BpZWQ7Ci0gICAg ICBMaXNwX09iamVjdCBmb3VuZF92YWx1ZSA9IEZnZXRoYXNoIChrZXksIHRhYmxlX3JlaGFzaGVk LCBhcmJpdHJhcnkpOwotICAgICAgZWFzc2VydCAoRVEgKGV4cGVjdGVkX3ZhbHVlLCBmb3VuZF92 YWx1ZSkpOwotICAgICAgRnJlbWhhc2ggKGtleSwgdGFibGVfcmVoYXNoZWQpOwotICAgIH0KK2hh c2hfdGFibGVfZnJlZXplIChzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICpoKQoreworICBwdHJkaWZm X3QgbmtleXMgPSBYRklYTkFUIChGbGVuZ3RoIChoLT5rZXlfYW5kX3ZhbHVlKSkgLyAyOworICBo LT5rZXlfYW5kX3ZhbHVlID0gaGFzaF90YWJsZV9jb250ZW50cyAoaCk7CisgIGgtPm5leHRfZnJl ZSA9IChua2V5cyA9PSBoLT5jb3VudCA/IC0xIDogaC0+Y291bnQpOworICBoLT5pbmRleCA9IEZs ZW5ndGggKGgtPmluZGV4KTsKKyAgaC0+bmV4dCA9IGgtPmhhc2ggPSBtYWtlX2ZpeG51bSAobmtl eXMpOworfQorCitzdGF0aWMgdm9pZAoraGFzaF90YWJsZV90aGF3IChzdHJ1Y3QgTGlzcF9IYXNo X1RhYmxlICpoKQoreworICBoLT5pbmRleCA9IEZtYWtlX3ZlY3RvciAoaC0+aW5kZXgsIG1ha2Vf Zml4bnVtICgtMSkpOworICBoLT5oYXNoID0gRm1ha2VfdmVjdG9yIChoLT5oYXNoLCBRbmlsKTsK KyAgaC0+bmV4dCA9IEZtYWtlX3ZlY3RvciAoaC0+bmV4dCwgbWFrZV9maXhudW0gKC0xKSk7CiAK LSAgZWFzc2VydCAoRVEgKEZoYXNoX3RhYmxlX2NvdW50ICh0YWJsZV9yZWhhc2hlZCksCi0gICAg ICAgICAgICAgICBtYWtlX2ZpeG51bSAoMCkpKTsKKyAgaGFzaF90YWJsZV9yZWhhc2ggKGgpOwog fQogCiBzdGF0aWMgZHVtcF9vZmYKQEAgLTI2OTUsNDUgKzI2NzgsMTEgQEAgZHVtcF9oYXNoX3Rh YmxlIChzdHJ1Y3QgZHVtcF9jb250ZXh0ICpjdHgsCiAjIGVycm9yICJMaXNwX0hhc2hfVGFibGUg Y2hhbmdlZC4gU2VlIENIRUNLX1NUUlVDVFMgY29tbWVudCBpbiBjb25maWcuaC4iCiAjZW5kaWYK ICAgY29uc3Qgc3RydWN0IExpc3BfSGFzaF9UYWJsZSAqaGFzaF9pbiA9IFhIQVNIX1RBQkxFIChv YmplY3QpOwotICBib29sIGlzX3N0YWJsZSA9IGR1bXBfaGFzaF90YWJsZV9zdGFibGVfcCAoaGFz aF9pbik7Ci0gIC8qIElmIHRoZSBoYXNoIHRhYmxlIGlzIGxpa2VseSB0byBiZSBtb2RpZmllZCBp biBtZW1vcnkgKGVpdGhlcgotICAgICBiZWNhdXNlIHdlIG5lZWQgdG8gcmVoYXNoLCBhbmQgdGh1 cyB0b2dnbGUgaGFzaC0+Y291bnQsIG9yCi0gICAgIGJlY2F1c2Ugd2UgbmVlZCB0byBhc3NlbWJs ZSBhIGxpc3Qgb2Ygd2VhayB0YWJsZXMpIHB1bnQgdGhlIGhhc2gKLSAgICAgdGFibGUgdG8gdGhl IGVuZCBvZiB0aGUgZHVtcCwgd2hlcmUgd2UgY2FuIGx1bXAgYWxsIHN1Y2ggaGFzaAotICAgICB0 YWJsZXMgdG9nZXRoZXIuICAqLwotICBpZiAoIShpc19zdGFibGUgfHwgIU5JTFAgKGhhc2hfaW4t PndlYWspKQotICAgICAgJiYgY3R4LT5mbGFncy5kZWZlcl9oYXNoX3RhYmxlcykKLSAgICB7Ci0g ICAgICBpZiAob2Zmc2V0ICE9IERVTVBfT0JKRUNUX09OX0hBU0hfVEFCTEVfUVVFVUUpCi0gICAg ICAgIHsKLQkgIGVhc3NlcnQgKG9mZnNldCA9PSBEVU1QX09CSkVDVF9PTl9OT1JNQUxfUVVFVUUK LQkJICAgfHwgb2Zmc2V0ID09IERVTVBfT0JKRUNUX05PVF9TRUVOKTsKLSAgICAgICAgICAvKiBX ZSBzdGlsbCB3YW50IHRvIGR1bXAgdGhlIGFjdHVhbCBrZXlzIGFuZCB2YWx1ZXMgbm93LiAgKi8K LSAgICAgICAgICBkdW1wX2VucXVldWVfb2JqZWN0IChjdHgsIGhhc2hfaW4tPmtleV9hbmRfdmFs dWUsIFdFSUdIVF9OT05FKTsKLSAgICAgICAgICAvKiBXZSdsbCBnZXQgdG8gdGhlIHJlc3QgbGF0 ZXIuICAqLwotICAgICAgICAgIG9mZnNldCA9IERVTVBfT0JKRUNUX09OX0hBU0hfVEFCTEVfUVVF VUU7Ci0gICAgICAgICAgZHVtcF9yZW1lbWJlcl9vYmplY3QgKGN0eCwgb2JqZWN0LCBvZmZzZXQp OwotICAgICAgICAgIGR1bXBfcHVzaCAoJmN0eC0+ZGVmZXJyZWRfaGFzaF90YWJsZXMsIG9iamVj dCk7Ci0gICAgICAgIH0KLSAgICAgIHJldHVybiBvZmZzZXQ7Ci0gICAgfQotCi0gIGlmIChQRFVN UEVSX0NIRUNLX1JFSEFTSElORykKLSAgICBjaGVja19oYXNoX3RhYmxlX3JlaGFzaCAobWFrZV9s aXNwX3B0ciAoKHZvaWQgKikgaGFzaF9pbiwgTGlzcF9WZWN0b3JsaWtlKSk7Ci0KICAgc3RydWN0 IExpc3BfSGFzaF9UYWJsZSBoYXNoX211bmdlZCA9ICpoYXNoX2luOwogICBzdHJ1Y3QgTGlzcF9I YXNoX1RhYmxlICpoYXNoID0gJmhhc2hfbXVuZ2VkOwogCi0gIC8qIFJlbWVtYmVyIHRvIHJlaGFz aCB0aGlzIGhhc2ggdGFibGUgb24gZmlyc3QgYWNjZXNzLiAgQWZ0ZXIgYQotICAgICBkdW1wIHJl bG9hZCwgdGhlIGhhc2ggdGFibGUgdmFsdWVzIHdpbGwgaGF2ZSBjaGFuZ2VkLCBzbyB3ZSdsbAot ICAgICBuZWVkIHRvIHJlYnVpbGQgdGhlIGluZGV4LgotCi0gICAgIFRPRE86IGZvciBFUSBhbmQg RVFMIGhhc2ggdGFibGVzLCBpdCBzaG91bGQgYmUgcG9zc2libGUgdG8gcmVoYXNoCi0gICAgIGhl cmUgdXNpbmcgdGhlIHByZWZlcnJlZCBsb2FkIGFkZHJlc3Mgb2YgdGhlIGR1bXAsIGVsaW1pbmF0 aW5nCi0gICAgIHRoZSBuZWVkIHRvIHJlaGFzaC1vbi1hY2Nlc3MgaWYgd2UgY2FuIGxvYWQgdGhl IGR1bXAgd2hlcmUgd2UKLSAgICAgd2FudC4gICovCi0gIGlmIChoYXNoLT5jb3VudCA+IDAgJiYg IWlzX3N0YWJsZSkKLSAgICBoYXNoLT5jb3VudCA9IC1oYXNoLT5jb3VudDsKKyAgaGFzaF90YWJs ZV9mcmVlemUgKGhhc2gpOworICBkdW1wX3B1c2ggKCZjdHgtPmhhc2hfdGFibGVzLCBvYmplY3Qp OwogCiAgIFNUQVJUX0RVTVBfUFZFQyAoY3R4LCAmaGFzaC0+aGVhZGVyLCBzdHJ1Y3QgTGlzcF9I YXNoX1RhYmxlLCBvdXQpOwogICBkdW1wX3BzZXVkb3ZlY3Rvcl9saXNwX2ZpZWxkcyAoY3R4LCAm b3V0LT5oZWFkZXIsICZoYXNoLT5oZWFkZXIpOwpAQCAtNDE0MCw2ICs0MDg5LDE5IEBAIERFRlVO ICgiZHVtcC1lbWFjcy1wb3J0YWJsZSIsCiAJIHx8ICFOSUxQIChjdHgtPmRlZmVycmVkX2hhc2hf dGFibGVzKQogCSB8fCAhTklMUCAoY3R4LT5kZWZlcnJlZF9zeW1ib2xzKSk7CiAKKyAgY3R4LT5o ZWFkZXIuaGFzaF9saXN0ID0gY3R4LT5vZmZzZXQ7CisgIGR1bXBfaGFzaF90YWJsZV9saXN0IChj dHgpOworCisgIGRvCisgICAgeworICAgICAgZHVtcF9kcmFpbl9kZWZlcnJlZF9oYXNoX3RhYmxl cyAoY3R4KTsKKyAgICAgIGR1bXBfZHJhaW5fZGVmZXJyZWRfc3ltYm9scyAoY3R4KTsKKyAgICAg IGR1bXBfZHJhaW5fbm9ybWFsX3F1ZXVlIChjdHgpOworICAgIH0KKyAgd2hpbGUgKCFkdW1wX3F1 ZXVlX2VtcHR5X3AgKCZjdHgtPmR1bXBfcXVldWUpCisJIHx8ICFOSUxQIChjdHgtPmRlZmVycmVk X2hhc2hfdGFibGVzKQorCSB8fCAhTklMUCAoY3R4LT5kZWZlcnJlZF9zeW1ib2xzKSk7CisKICAg ZHVtcF9zb3J0X2NvcGllZF9vYmplY3RzIChjdHgpOwogCiAgIC8qIFdoaWxlIHdlIGNvcHkgYnVp bHQtaW4gc3ltYm9scyBpbnRvIHRoZSBFbWFjcyBpbWFnZSwgdGhlc2UKQEAgLTUyOTAsNiArNTI1 Miw5IEBAIGR1bXBfZG9fYWxsX2VtYWNzX3JlbG9jYXRpb25zIChjb25zdCBzdHJ1Y3QgZHVtcF9o ZWFkZXIgKmNvbnN0IGhlYWRlciwKICAgIE5VTUJFUl9EVU1QX1NFQ1RJT05TLAogICB9OwogCisv KiBQb2ludGVyIHRvIGEgc3RhY2sgdmFyaWFibGUgdG8gYXZvaWQgaGF2aW5nIHRvIHN0YXRpY3By byBpdC4gICovCitzdGF0aWMgTGlzcF9PYmplY3QgKnBkdW1wZXJfaGFzaGVzID0gJnplcm9fdmVj dG9yOworCiAvKiBMb2FkIGEgZHVtcCBmcm9tIERVTVBfRklMRU5BTUUuICBSZXR1cm4gYW4gZXJy b3IgY29kZS4KIAogICAgTi5CLiBXZSBydW4gdmVyeSBlYXJseSBpbiBpbml0aWFsaXphdGlvbiwg c28gd2UgY2FuJ3QgdXNlIGxpc3AsCkBAIC01NDMxLDYgKzUzOTYsMTUgQEAgcGR1bXBlcl9sb2Fk IChjb25zdCBjaGFyICpkdW1wX2ZpbGVuYW1lKQogICBmb3IgKGludCBpID0gMDsgaSA8IEFSUkFZ RUxUUyAoc2VjdGlvbnMpOyArK2kpCiAgICAgZHVtcF9tbWFwX3Jlc2V0ICgmc2VjdGlvbnNbaV0p OwogCisgIExpc3BfT2JqZWN0IGhhc2hlcyA9IHplcm9fdmVjdG9yOworICBpZiAoaGVhZGVyLT5o YXNoX2xpc3QpCisgICAgeworICAgICAgc3RydWN0IExpc3BfVmVjdG9yICpoYXNoX3RhYmxlcyA9 CisJKChzdHJ1Y3QgTGlzcF9WZWN0b3IgKikoZHVtcF9iYXNlICsgaGVhZGVyLT5oYXNoX2xpc3Qp KTsKKyAgICAgIFhTRVRWRUNUT1IgKGhhc2hlcywgaGFzaF90YWJsZXMpOworICAgIH0KKworICBw ZHVtcGVyX2hhc2hlcyA9ICZoYXNoZXM7CiAgIC8qIFJ1biB0aGUgZnVuY3Rpb25zIEVtYWNzIHJl Z2lzdGVyZWQgZm9yIGRvaW5nIHBvc3QtZHVtcC1sb2FkCiAgICAgIGluaXRpYWxpemF0aW9uLiAg Ki8KICAgZm9yIChpbnQgaSA9IDA7IGkgPCBucl9kdW1wX2hvb2tzOyArK2kpCkBAIC01NTAxLDYg KzU0NzUsMTkgQEAgREVGVU4gKCJwZHVtcGVyLXN0YXRzIiwgRnBkdW1wZXJfc3RhdHMsIFNwZHVt cGVyX3N0YXRzLCAwLCAwLCAwLAogI2VuZGlmIC8qIEhBVkVfUERVTVBFUiAqLwogCiAMCitzdGF0 aWMgdm9pZAordGhhd19oYXNoX3RhYmxlcyAodm9pZCkKK3sKKyAgTGlzcF9PYmplY3QgaGFzaF90 YWJsZXMgPSAqcGR1bXBlcl9oYXNoZXM7CisgIGZvciAocHRyZGlmZl90IGkgPSAwOyBpIDwgQVNJ WkUgKGhhc2hfdGFibGVzKTsgaSsrKQorICAgIGhhc2hfdGFibGVfdGhhdyAoWEhBU0hfVEFCTEUg KEFSRUYgKGhhc2hfdGFibGVzLCBpKSkpOworfQorCit2b2lkCitpbml0X3BkdW1wZXJfb25jZSAo dm9pZCkKK3sKKyAgcGR1bXBlcl9kb19ub3dfYW5kX2FmdGVyX2xvYWQgKHRoYXdfaGFzaF90YWJs ZXMpOworfQogCiB2b2lkCiBzeW1zX29mX3BkdW1wZXIgKHZvaWQpCmRpZmYgLS1naXQgYS9zcmMv cGR1bXBlci5oIGIvc3JjL3BkdW1wZXIuaAppbmRleCBhYjJmNDI2YzFlLi5jZmVhMDZkMzNkIDEw MDY0NAotLS0gYS9zcmMvcGR1bXBlci5oCisrKyBiL3NyYy9wZHVtcGVyLmgKQEAgLTI0OCw2ICsy NDgsNyBAQCBwZHVtcGVyX2NsZWFyX21hcmtzICh2b2lkKQogICAgZmlsZSB3YXMgbG9hZGVkLiAg Ki8KIGV4dGVybiB2b2lkIHBkdW1wZXJfcmVjb3JkX3dkIChjb25zdCBjaGFyICopOwogCit2b2lk IGluaXRfcGR1bXBlcl9vbmNlICh2b2lkKTsKIHZvaWQgc3ltc19vZl9wZHVtcGVyICh2b2lkKTsK IAogSU5MSU5FX0hFQURFUl9FTkQKLS0gCjIuMjIuMAoK --0000000000006235d9058e1c2058-- From debbugs-submit-bounces@debbugs.gnu.org Sat Jul 20 23:18:24 2019 Received: (at 36597) by debbugs.gnu.org; 21 Jul 2019 03:18:24 +0000 Received: from localhost ([127.0.0.1]:58057 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hp2Me-0007fg-6c for submit@debbugs.gnu.org; Sat, 20 Jul 2019 23:18:22 -0400 Received: from zimbra.cs.ucla.edu ([131.179.128.68]:52890) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hp2Ma-0007fR-6h for 36597@debbugs.gnu.org; Sat, 20 Jul 2019 23:18:18 -0400 Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id 849321626D6; Sat, 20 Jul 2019 20:18:10 -0700 (PDT) Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10032) with ESMTP id Verq1Fh8zyVM; Sat, 20 Jul 2019 20:18:06 -0700 (PDT) Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id 61D731626E0; Sat, 20 Jul 2019 20:18:06 -0700 (PDT) X-Virus-Scanned: amavisd-new at zimbra.cs.ucla.edu Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10026) with ESMTP id LVpECFrgnCfr; Sat, 20 Jul 2019 20:18:06 -0700 (PDT) Received: from [192.168.1.9] (cpe-23-242-74-103.socal.res.rr.com [23.242.74.103]) by zimbra.cs.ucla.edu (Postfix) with ESMTPSA id F0D561626D6; Sat, 20 Jul 2019 20:18:05 -0700 (PDT) Subject: Re: bug#36597: 27.0.50; rehash hash tables eagerly in pdumper To: Pip Cet , Eli Zaretskii References: <6a260307-a463-bd08-8a10-d7664d0606a2@cs.ucla.edu> <74235afc-7043-1da7-7c71-07f0ca23b9fd@cs.ucla.edu> <83r26mv53z.fsf@gnu.org> From: Paul Eggert Organization: UCLA Computer Science Department Message-ID: Date: Sat, 20 Jul 2019 20:18:04 -0700 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Thunderbird/60.8.0 MIME-Version: 1.0 In-Reply-To: Content-Type: multipart/mixed; boundary="------------65B410FA542064ACF23C5ADB" Content-Language: en-US X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 36597 Cc: 36597@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) This is a multi-part message in MIME format. --------------65B410FA542064ACF23C5ADB Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 7bit Pip Cet wrote: > I'm currently playing around with redefining hash tables not to have > internal freelists. That makes the hash table code a lot simpler > overall, but some of that simplicity would be lost trying to support > lazy hash table rehashing. While looking into this I discovered unlikely bugs in Emacs's hash table code and GC that can make Emacs dump core, along with some other unlikely hash-table bugs that can cause Emacs to report memory exhaustion when there should be plenty of memory. I installed the attached patches to fix these problems and to refactor to make this code easier to understand (at least for me :-). These patches will probably affect performance analysis. --------------65B410FA542064ACF23C5ADB Content-Type: text/x-patch; name="0001-Fix-hash-table-overallocation-etc.patch" Content-Disposition: attachment; filename="0001-Fix-hash-table-overallocation-etc.patch" Content-Transfer-Encoding: quoted-printable >From b0908a0fe6dc4f878b05a8b26ed3ff0c702e26c7 Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Sat, 20 Jul 2019 19:40:02 -0700 Subject: [PATCH 1/6] Fix hash table overallocation etc. MIME-Version: 1.0 Content-Type: text/plain; charset=3DUTF-8 Content-Transfer-Encoding: 8bit * src/fns.c (set_hash_key_and_value, set_hash_next) (set_hash_hash, set_hash_index): Remove. All uses removed. (maybe_resize_hash_table): Don=E2=80=99t update h->next until it=E2=80=99= s known that all the allocations succeeded, to avoid trashing the hash table if memory is exhausted. Don=E2=80=99t overallocate the other vectors. Don=E2=80=99t output growth message if the hash table didn=E2=80=99t actually grow due to allocation failure. Assume C99 decls after statements. --- src/fns.c | 87 +++++++++++++++++++------------------------------------ 1 file changed, 29 insertions(+), 58 deletions(-) diff --git a/src/fns.c b/src/fns.c index 0497588689..4c99d974bd 100644 --- a/src/fns.c +++ b/src/fns.c @@ -3803,37 +3803,17 @@ CHECK_HASH_TABLE (Lisp_Object x) CHECK_TYPE (HASH_TABLE_P (x), Qhash_table_p, x); } =20 -static void -set_hash_key_and_value (struct Lisp_Hash_Table *h, Lisp_Object key_and_v= alue) -{ - h->key_and_value =3D key_and_value; -} -static void -set_hash_next (struct Lisp_Hash_Table *h, Lisp_Object next) -{ - h->next =3D next; -} static void set_hash_next_slot (struct Lisp_Hash_Table *h, ptrdiff_t idx, ptrdiff_t = val) { gc_aset (h->next, idx, make_fixnum (val)); } static void -set_hash_hash (struct Lisp_Hash_Table *h, Lisp_Object hash) -{ - h->hash =3D hash; -} -static void set_hash_hash_slot (struct Lisp_Hash_Table *h, ptrdiff_t idx, Lisp_Objec= t val) { gc_aset (h->hash, idx, val); } static void -set_hash_index (struct Lisp_Hash_Table *h, Lisp_Object index) -{ - h->index =3D index; -} -static void set_hash_index_slot (struct Lisp_Hash_Table *h, ptrdiff_t idx, ptrdiff_t= val) { gc_aset (h->index, idx, make_fixnum (val)); @@ -4159,10 +4139,8 @@ maybe_resize_hash_table (struct Lisp_Hash_Table *h= ) if (h->next_free < 0) { ptrdiff_t old_size =3D HASH_TABLE_SIZE (h); - EMACS_INT new_size, index_size, nsize; - ptrdiff_t i; + EMACS_INT new_size; double rehash_size =3D h->rehash_size; - double index_float; =20 if (rehash_size < 0) new_size =3D old_size - rehash_size; @@ -4177,50 +4155,38 @@ maybe_resize_hash_table (struct Lisp_Hash_Table *= h) if (new_size <=3D old_size) new_size =3D old_size + 1; double threshold =3D h->rehash_threshold; - index_float =3D new_size / threshold; - index_size =3D (index_float < INDEX_SIZE_BOUND + 1 - ? next_almost_prime (index_float) - : INDEX_SIZE_BOUND + 1); - nsize =3D max (index_size, 2 * new_size); - if (INDEX_SIZE_BOUND < nsize) + double index_float =3D new_size / threshold; + EMACS_INT index_size =3D (index_float < INDEX_SIZE_BOUND + 1 + ? next_almost_prime (index_float) + : INDEX_SIZE_BOUND + 1); + if (INDEX_SIZE_BOUND < max (index_size, 2 * new_size)) error ("Hash table too large to resize"); =20 -#ifdef ENABLE_CHECKING - if (HASH_TABLE_P (Vpurify_flag) - && XHASH_TABLE (Vpurify_flag) =3D=3D h) - message ("Growing hash table to: %"pI"d", new_size); -#endif - - set_hash_key_and_value (h, larger_vector (h->key_and_value, - 2 * (new_size - old_size), -1)); - set_hash_hash (h, larger_vector (h->hash, new_size - old_size, -1)= ); - set_hash_index (h, make_vector (index_size, make_fixnum (-1))); - set_hash_next (h, larger_vecalloc (h->next, new_size - old_size, -= 1)); + /* Allocate all the new vectors before updating *H, to + avoid problems if memory is exhausted. larger_vecalloc + finishes computing the size of the replacement vectors. */ + Lisp_Object next =3D larger_vecalloc (h->next, new_size - old_size= , -1); + ptrdiff_t next_size =3D ASIZE (next); + Lisp_Object key_and_value + =3D larger_vector (h->key_and_value, 2 * (next_size - old_size), + 2 * next_size); + Lisp_Object hash =3D larger_vector (h->hash, next_size - old_size, + next_size); + h->index =3D make_vector (index_size, make_fixnum (-1)); + h->key_and_value =3D key_and_value; + h->hash =3D hash; + h->next =3D next; =20 /* Update the free list. Do it so that new entries are added at the end of the free list. This makes some operations like maphash faster. */ - for (i =3D old_size; i < new_size - 1; ++i) + for (ptrdiff_t i =3D old_size; i < next_size - 1; i++) set_hash_next_slot (h, i, i + 1); - set_hash_next_slot (h, i, -1); - - if (h->next_free < 0) - h->next_free =3D old_size; - else - { - ptrdiff_t last =3D h->next_free; - while (true) - { - ptrdiff_t next =3D HASH_NEXT (h, last); - if (next < 0) - break; - last =3D next; - } - set_hash_next_slot (h, last, old_size); - } + set_hash_next_slot (h, next_size - 1, -1); + h->next_free =3D old_size; =20 /* Rehash. */ - for (i =3D 0; i < old_size; ++i) + for (ptrdiff_t i =3D 0; i < old_size; i++) if (!NILP (HASH_HASH (h, i))) { EMACS_UINT hash_code =3D XUFIXNUM (HASH_HASH (h, i)); @@ -4228,6 +4194,11 @@ maybe_resize_hash_table (struct Lisp_Hash_Table *h= ) set_hash_next_slot (h, i, HASH_INDEX (h, start_of_bucket)); set_hash_index_slot (h, start_of_bucket, i); } + +#ifdef ENABLE_CHECKING + if (HASH_TABLE_P (Vpurify_flag) && XHASH_TABLE (Vpurify_flag) =3D=3D= h) + message ("Growing hash table to: %"pD"d", new_size); +#endif } } =20 --=20 2.17.1 --------------65B410FA542064ACF23C5ADB Content-Type: text/x-patch; name="0002-Rename-pure-to-purecopy.patch" Content-Disposition: attachment; filename="0002-Rename-pure-to-purecopy.patch" Content-Transfer-Encoding: quoted-printable >From df5024dbaef5e1f7e39a2a8268523f9fc1af3118 Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Sat, 20 Jul 2019 19:40:03 -0700 Subject: [PATCH 2/6] =3D?UTF-8?q?Rename=3D20=3DE2=3D80=3D98pure=3DE2=3D80= =3D99=3D20to=3D20?=3D =3D?UTF-8?q?=3DE2=3D80=3D98purecopy=3DE2=3D80=3D99?=3D MIME-Version: 1.0 Content-Type: text/plain; charset=3DUTF-8 Content-Transfer-Encoding: 8bit * src/lisp.h (struct Lisp_Hash_Table): Rename =E2=80=98pure=E2=80=99 memb= er to =E2=80=98purecopy=E2=80=99, as the old name was quite confusing (it did n= ot mean the hash table was pure). All uses changed. --- src/alloc.c | 6 +++--- src/fns.c | 10 +++++----- src/lisp.h | 2 +- src/pdumper.c | 2 +- src/print.c | 4 ++-- 5 files changed, 12 insertions(+), 12 deletions(-) diff --git a/src/alloc.c b/src/alloc.c index 7a0611dd3e..8649d4e0f4 100644 --- a/src/alloc.c +++ b/src/alloc.c @@ -5329,7 +5329,7 @@ make_pure_vector (ptrdiff_t len) purecopy_hash_table (struct Lisp_Hash_Table *table) { eassert (NILP (table->weak)); - eassert (table->pure); + eassert (table->purecopy); =20 struct Lisp_Hash_Table *pure =3D pure_alloc (sizeof *pure, Lisp_Vector= like); struct hash_table_test pure_test =3D table->test; @@ -5346,7 +5346,7 @@ purecopy_hash_table (struct Lisp_Hash_Table *table) pure->index =3D purecopy (table->index); pure->count =3D table->count; pure->next_free =3D table->next_free; - pure->pure =3D table->pure; + pure->purecopy =3D table->purecopy; pure->rehash_threshold =3D table->rehash_threshold; pure->rehash_size =3D table->rehash_size; pure->key_and_value =3D purecopy (table->key_and_value); @@ -5410,7 +5410,7 @@ purecopy (Lisp_Object obj) /* Do not purify hash tables which haven't been defined with :purecopy as non-nil or are weak - they aren't guaranteed to not change. */ - if (!NILP (table->weak) || !table->pure) + if (!NILP (table->weak) || !table->purecopy) { /* Instead, add the hash table to the list of pinned objects, so that it will be marked during GC. */ diff --git a/src/fns.c b/src/fns.c index 4c99d974bd..d4f6842f27 100644 --- a/src/fns.c +++ b/src/fns.c @@ -4055,7 +4055,7 @@ #define INDEX_SIZE_BOUND \ Lisp_Object make_hash_table (struct hash_table_test test, EMACS_INT size, float rehash_size, float rehash_threshold, - Lisp_Object weak, bool pure) + Lisp_Object weak, bool purecopy) { struct Lisp_Hash_Table *h; Lisp_Object table; @@ -4094,7 +4094,7 @@ make_hash_table (struct hash_table_test test, EMACS= _INT size, h->next =3D make_vector (size, make_fixnum (-1)); h->index =3D make_vector (index_size, make_fixnum (-1)); h->next_weak =3D NULL; - h->pure =3D pure; + h->purecopy =3D purecopy; =20 /* Set up the free list. */ for (i =3D 0; i < size - 1; ++i) @@ -4748,7 +4748,7 @@ DEFUN ("make-hash-table", Fmake_hash_table, Smake_h= ash_table, 0, MANY, 0, (ptrdiff_t nargs, Lisp_Object *args) { Lisp_Object test, weak; - bool pure; + bool purecopy; struct hash_table_test testdesc; ptrdiff_t i; USE_SAFE_ALLOCA; @@ -4784,7 +4784,7 @@ DEFUN ("make-hash-table", Fmake_hash_table, Smake_h= ash_table, 0, MANY, 0, =20 /* See if there's a `:purecopy PURECOPY' argument. */ i =3D get_key_arg (QCpurecopy, nargs, args, used); - pure =3D i && !NILP (args[i]); + purecopy =3D i && !NILP (args[i]); /* See if there's a `:size SIZE' argument. */ i =3D get_key_arg (QCsize, nargs, args, used); Lisp_Object size_arg =3D i ? args[i] : Qnil; @@ -4835,7 +4835,7 @@ DEFUN ("make-hash-table", Fmake_hash_table, Smake_h= ash_table, 0, MANY, 0, =20 SAFE_FREE (); return make_hash_table (testdesc, size, rehash_size, rehash_threshold,= weak, - pure); + purecopy); } =20 =20 diff --git a/src/lisp.h b/src/lisp.h index 13014c82dc..8f60963eb7 100644 --- a/src/lisp.h +++ b/src/lisp.h @@ -2287,7 +2287,7 @@ #define DEFSYM(sym, name) /* empty */ =20 /* True if the table can be purecopied. The table cannot be changed afterwards. */ - bool pure; + bool purecopy; =20 /* Resize hash table when number of entries / table size is >=3D this ratio. */ diff --git a/src/pdumper.c b/src/pdumper.c index 03c00bf27b..206a196890 100644 --- a/src/pdumper.c +++ b/src/pdumper.c @@ -2741,7 +2741,7 @@ dump_hash_table (struct dump_context *ctx, them as close to the hash table as possible. */ DUMP_FIELD_COPY (out, hash, count); DUMP_FIELD_COPY (out, hash, next_free); - DUMP_FIELD_COPY (out, hash, pure); + DUMP_FIELD_COPY (out, hash, purecopy); DUMP_FIELD_COPY (out, hash, rehash_threshold); DUMP_FIELD_COPY (out, hash, rehash_size); dump_field_lv (ctx, out, hash, &hash->key_and_value, WEIGHT_STRONG); diff --git a/src/print.c b/src/print.c index 6623244c59..cb34090514 100644 --- a/src/print.c +++ b/src/print.c @@ -1575,10 +1575,10 @@ print_vectorlike (Lisp_Object obj, Lisp_Object pr= intcharfun, bool escapeflag, print_object (Fhash_table_rehash_threshold (obj), printcharfun, escapeflag); =20 - if (h->pure) + if (h->purecopy) { print_c_string (" purecopy ", printcharfun); - print_object (h->pure ? Qt : Qnil, printcharfun, escapeflag); + print_object (h->purecopy ? Qt : Qnil, printcharfun, escapeflag); } =20 print_c_string (" data ", printcharfun); --=20 2.17.1 --------------65B410FA542064ACF23C5ADB Content-Type: text/x-patch; name="0003-Simplify-maybe_gc-implementation.patch" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename="0003-Simplify-maybe_gc-implementation.patch" >From 26de2d42d0460c5b193456950a568cb04a29dc00 Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Sat, 20 Jul 2019 19:40:03 -0700 Subject: [PATCH 3/6] Simplify maybe_gc implementation * src/alloc.c (consing_until_gc): New variable, replacing the combination of consing_since_gc and gc_relative_threshold. All uses changed. (byte_ct): Move decl here from lisp.h. (memory_full_cons_threshold): New an enum constant. (free_cons): Check for integer overflow in statistics calculation. * src/lisp.h (object_ct): Move decl here from alloc.c. (OBJECT_CT_MAX): New macro. (maybe_gc): Simplify accordingly. --- src/alloc.c | 68 ++++++++++++++++++++++++++--------------------------- src/lisp.h | 12 ++++------ 2 files changed, 38 insertions(+), 42 deletions(-) diff --git a/src/alloc.c b/src/alloc.c index 8649d4e0f4..9d18fd918b 100644 --- a/src/alloc.c +++ b/src/alloc.c @@ -222,13 +222,9 @@ #define GC_DEFAULT_THRESHOLD (100000 * word_size) /* Global variables. */ struct emacs_globals globals; -/* Number of bytes of consing done since the last gc. */ +/* maybe_gc collects garbage if this goes negative. */ -byte_ct consing_since_gc; - -/* Similar minimum, computed from Vgc_cons_percentage. */ - -byte_ct gc_relative_threshold; +object_ct consing_until_gc; #ifdef HAVE_PDUMPER /* Number of finalizers run: used to loop over GC until we stop @@ -240,10 +236,9 @@ #define GC_DEFAULT_THRESHOLD (100000 * word_size) bool gc_in_progress; -/* Type of object counts reported by GC. Unlike byte_ct, this can be - signed, e.g., it is less than 2**31 on a typical 32-bit machine. */ +/* System byte counts reported by GC. */ -typedef intptr_t object_ct; +typedef uintptr_t byte_ct; /* Number of live and free conses etc. */ @@ -1373,7 +1368,7 @@ make_interval (void) MALLOC_UNBLOCK_INPUT; - consing_since_gc += sizeof (struct interval); + consing_until_gc -= sizeof (struct interval); intervals_consed++; gcstat.total_free_intervals--; RESET_INTERVAL (val); @@ -1745,7 +1740,7 @@ allocate_string (void) gcstat.total_free_strings--; gcstat.total_strings++; ++strings_consed; - consing_since_gc += sizeof *s; + consing_until_gc -= sizeof *s; #ifdef GC_CHECK_STRING_BYTES if (!noninteractive) @@ -1865,7 +1860,7 @@ allocate_string_data (struct Lisp_String *s, old_data->string = NULL; } - consing_since_gc += needed; + consing_until_gc -= needed; } @@ -2471,7 +2466,7 @@ make_float (double float_value) XFLOAT_INIT (val, float_value); eassert (!XFLOAT_MARKED_P (XFLOAT (val))); - consing_since_gc += sizeof (struct Lisp_Float); + consing_until_gc -= sizeof (struct Lisp_Float); floats_consed++; gcstat.total_free_floats--; return val; @@ -2521,7 +2516,7 @@ #define XUNMARK_CONS(fptr) \ /* Minimum number of bytes of consing since GC before next GC, when memory is full. */ -byte_ct const memory_full_cons_threshold = sizeof (struct cons_block); +enum { memory_full_cons_threshold = sizeof (struct cons_block) }; /* Current cons_block. */ @@ -2543,7 +2538,8 @@ free_cons (struct Lisp_Cons *ptr) ptr->u.s.u.chain = cons_free_list; ptr->u.s.car = dead_object (); cons_free_list = ptr; - consing_since_gc -= sizeof *ptr; + if (INT_ADD_WRAPV (consing_until_gc, sizeof *ptr, &consing_until_gc)) + consing_until_gc = OBJECT_CT_MAX; gcstat.total_free_conses++; } @@ -2594,7 +2590,7 @@ DEFUN ("cons", Fcons, Scons, 2, 2, 0, XSETCAR (val, car); XSETCDR (val, cdr); eassert (!XCONS_MARKED_P (XCONS (val))); - consing_since_gc += sizeof (struct Lisp_Cons); + consing_until_gc -= sizeof (struct Lisp_Cons); gcstat.total_free_conses--; cons_cells_consed++; return val; @@ -3176,7 +3172,7 @@ allocate_vectorlike (ptrdiff_t len) if (find_suspicious_object_in_range (p, (char *) p + nbytes)) emacs_abort (); - consing_since_gc += nbytes; + consing_until_gc -= nbytes; vector_cells_consed += len; MALLOC_UNBLOCK_INPUT; @@ -3462,7 +3458,7 @@ DEFUN ("make-symbol", Fmake_symbol, Smake_symbol, 1, 1, 0, MALLOC_UNBLOCK_INPUT; init_symbol (val, name); - consing_since_gc += sizeof (struct Lisp_Symbol); + consing_until_gc -= sizeof (struct Lisp_Symbol); symbols_consed++; gcstat.total_free_symbols--; return val; @@ -3862,6 +3858,7 @@ memory_full (size_t nbytes) if (! enough_free_memory) { Vmemory_full = Qt; + consing_until_gc = memory_full_cons_threshold; /* The first time we get here, free the spare memory. */ for (int i = 0; i < ARRAYELTS (spare_memory); i++) @@ -5802,7 +5799,7 @@ garbage_collect_1 (struct gcstat *gcst) /* In case user calls debug_print during GC, don't let that cause a recursive GC. */ - consing_since_gc = 0; + consing_until_gc = OBJECT_CT_MAX; /* Save what's currently displayed in the echo area. Don't do that if we are GC'ing because we've run out of memory, since @@ -5913,23 +5910,26 @@ garbage_collect_1 (struct gcstat *gcst) unblock_input (); - consing_since_gc = 0; - if (gc_cons_threshold < GC_DEFAULT_THRESHOLD / 10) - gc_cons_threshold = GC_DEFAULT_THRESHOLD / 10; - - gc_relative_threshold = 0; - if (FLOATP (Vgc_cons_percentage)) - { /* Set gc_cons_combined_threshold. */ - double tot = total_bytes_of_live_objects (); - - tot *= XFLOAT_DATA (Vgc_cons_percentage); - if (0 < tot) + if (!NILP (Vmemory_full)) + consing_until_gc = memory_full_cons_threshold; + else + { + intptr_t threshold = min (max (GC_DEFAULT_THRESHOLD, + gc_cons_threshold >> 3), + OBJECT_CT_MAX); + if (FLOATP (Vgc_cons_percentage)) { - if (tot < UINTPTR_MAX) - gc_relative_threshold = tot; - else - gc_relative_threshold = UINTPTR_MAX; + double tot = (XFLOAT_DATA (Vgc_cons_percentage) + * total_bytes_of_live_objects ()); + if (threshold < tot) + { + if (tot < OBJECT_CT_MAX) + threshold = tot; + else + threshold = OBJECT_CT_MAX; + } } + consing_until_gc = threshold; } if (garbage_collection_messages && NILP (Vmemory_full)) diff --git a/src/lisp.h b/src/lisp.h index 8f60963eb7..50a61cadd7 100644 --- a/src/lisp.h +++ b/src/lisp.h @@ -3763,10 +3763,9 @@ #define CONS_TO_INTEGER(cons, type, var) \ extern void garbage_collect (void); extern const char *pending_malloc_warning; extern Lisp_Object zero_vector; -typedef uintptr_t byte_ct; /* System byte counts reported by GC. */ -extern byte_ct consing_since_gc; -extern byte_ct gc_relative_threshold; -extern byte_ct const memory_full_cons_threshold; +typedef intptr_t object_ct; /* Signed type of object counts reported by GC. */ +#define OBJECT_CT_MAX INTPTR_MAX +extern object_ct consing_until_gc; #ifdef HAVE_PDUMPER extern int number_finalizers_run; #endif @@ -4993,10 +4992,7 @@ #define FOR_EACH_ALIST_VALUE(head_var, list_var, value_var) \ INLINE void maybe_gc (void) { - if ((consing_since_gc > gc_cons_threshold - && consing_since_gc > gc_relative_threshold) - || (!NILP (Vmemory_full) - && consing_since_gc > memory_full_cons_threshold)) + if (consing_until_gc < 0) garbage_collect (); } -- 2.17.1 --------------65B410FA542064ACF23C5ADB Content-Type: text/x-patch; name="0004-Inhibit-GC-after-inhibit_garbage_collection.patch" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename="0004-Inhibit-GC-after-inhibit_garbage_collection.patch" >From 5018b663c6c0d31f27fb44630a69d9e0bd73273d Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Sat, 20 Jul 2019 19:40:03 -0700 Subject: [PATCH 4/6] Inhibit GC after inhibit_garbage_collection Without this patch, there are unlikely ways that garbage collection could occur (sometimes causing undefined behavior) even when inhibit_garbage_collection is in effect. * src/alloc.c (garbage_collection_inhibited): New var. (pure_alloc): Increment it if pure space is exhausted, so that garbage_collect_1 no longer needs to inspect pure_bytes_used_before_overflow. (allow_garbage_collection): New function. (inhibit_garbage_collection): Increment the new variable rather than specbinding a user variable. (garbage_collect_1): Do not garbage collect if the new variable is set, rather than if pure_bytes_used_before_overflow is set. --- src/alloc.c | 21 +++++++++++++++++---- 1 file changed, 17 insertions(+), 4 deletions(-) diff --git a/src/alloc.c b/src/alloc.c index 9d18fd918b..09b3a4ea7e 100644 --- a/src/alloc.c +++ b/src/alloc.c @@ -292,6 +292,10 @@ #define PUREBEG (char *) pure static ptrdiff_t pure_bytes_used_non_lisp; +/* If positive, garbage collection is inhibited. Otherwise, zero. */ + +static intptr_t garbage_collection_inhibited; + /* If nonzero, this is a warning delivered by malloc and not yet displayed. */ @@ -5120,6 +5124,10 @@ pure_alloc (size_t size, int type) pure_bytes_used_before_overflow += pure_bytes_used - size; pure_bytes_used = 0; pure_bytes_used_lisp = pure_bytes_used_non_lisp = 0; + + /* Can't GC if pure storage overflowed because we can't determine + if something is a pure object or not. */ + garbage_collection_inhibited++; goto again; } @@ -5486,12 +5494,19 @@ staticpro (Lisp_Object const *varaddress) /* Temporarily prevent garbage collection. */ +static void +allow_garbage_collection (void) +{ + garbage_collection_inhibited--; +} + ptrdiff_t inhibit_garbage_collection (void) { ptrdiff_t count = SPECPDL_INDEX (); - specbind (Qgc_cons_threshold, make_fixnum (MOST_POSITIVE_FIXNUM)); + record_unwind_protect_void (allow_garbage_collection); + garbage_collection_inhibited++; return count; } @@ -5779,9 +5794,7 @@ garbage_collect_1 (struct gcstat *gcst) eassert (weak_hash_tables == NULL); - /* Can't GC if pure storage overflowed because we can't determine - if something is a pure object or not. */ - if (pure_bytes_used_before_overflow) + if (garbage_collection_inhibited) return false; /* Record this function, so it appears on the profiler's backtraces. */ -- 2.17.1 --------------65B410FA542064ACF23C5ADB Content-Type: text/x-patch; name="0005-Simplify-hashfn-cmpfn-calling-convention.patch" Content-Disposition: attachment; filename="0005-Simplify-hashfn-cmpfn-calling-convention.patch" Content-Transfer-Encoding: quoted-printable >From b6f194a0fb6dbd1b19aa01f95a955f5b8b23b40e Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Sat, 20 Jul 2019 19:40:03 -0700 Subject: [PATCH 5/6] Simplify hashfn/cmpfn calling convention MIME-Version: 1.0 Content-Type: text/plain; charset=3DUTF-8 Content-Transfer-Encoding: 8bit * src/fns.c (cmpfn_eql, cmpfn_equal, cmpfn_user_defined) (hashfn_eq, hashfn_equal, hashfn_eql, hashfn_user_defined): * src/profiler.c (cmpfn_profiler, hashfn_profiler): Use new calling convention where the return value is a fixnum instead of EMACS_UINT. While we=E2=80=99re at it, put the hash table at the end, since that=E2=80=99s a bit simpler and generates better code (at least on the x86-64). All callers changed. * src/fns.c (hash_lookup): Store fixnum rather than EMACS_UINT. All callers changed. (hash_put): Take a fixnum rather than an EMACS_UINT. All callers changed. Remove unnecessary eassert (XUFIXNUM does it). * src/lisp.h (struct hash_table_test): Adjust signatures of cmpfn and hashfn. --- src/bytecode.c | 8 ++-- src/category.c | 9 ++-- src/charset.c | 2 +- src/composite.c | 5 +-- src/emacs-module.c | 3 +- src/fns.c | 103 ++++++++++++++++++++------------------------- src/image.c | 3 +- src/json.c | 3 +- src/lisp.h | 12 +++--- src/lread.c | 3 +- src/macfont.m | 3 +- src/profiler.c | 34 +++++++-------- 12 files changed, 82 insertions(+), 106 deletions(-) diff --git a/src/bytecode.c b/src/bytecode.c index 29dff44f00..e82de026a8 100644 --- a/src/bytecode.c +++ b/src/bytecode.c @@ -1409,16 +1409,16 @@ #define DEFINE(name, value) LABEL (name) , if (h->count <=3D 5) { /* Do a linear search if there are not many cases FIXME: 5 is arbitrarily chosen. */ - Lisp_Object hash_code =3D h->test.cmpfn - ? make_fixnum (h->test.hashfn (&h->test, v1)) : Qnil; + Lisp_Object hash_code + =3D h->test.cmpfn ? h->test.hashfn (v1, &h->test) : Qnil; =20 for (i =3D h->count; 0 <=3D --i; ) if (EQ (v1, HASH_KEY (h, i)) || (h->test.cmpfn && EQ (hash_code, HASH_HASH (h, i)) - && h->test.cmpfn (&h->test, v1, HASH_KEY (h, i= )))) + && !NILP (h->test.cmpfn (v1, HASH_KEY (h, i), + &h->test)))) break; - } else i =3D hash_lookup (h, v1, NULL); diff --git a/src/category.c b/src/category.c index 132fae9d40..9e460cfc64 100644 --- a/src/category.c +++ b/src/category.c @@ -48,18 +48,15 @@ bset_category_table (struct buffer *b, Lisp_Object va= l) static Lisp_Object hash_get_category_set (Lisp_Object table, Lisp_Object category_set) { - struct Lisp_Hash_Table *h; - ptrdiff_t i; - EMACS_UINT hash; - if (NILP (XCHAR_TABLE (table)->extras[1])) set_char_table_extras (table, 1, make_hash_table (hashtest_equal, DEFAULT_HASH_SIZE, DEFAULT_REHASH_SIZE, DEFAULT_REHASH_THRESHOLD, Qnil, false)); - h =3D XHASH_TABLE (XCHAR_TABLE (table)->extras[1]); - i =3D hash_lookup (h, category_set, &hash); + struct Lisp_Hash_Table *h =3D XHASH_TABLE (XCHAR_TABLE (table)->extras= [1]); + Lisp_Object hash; + ptrdiff_t i =3D hash_lookup (h, category_set, &hash); if (i >=3D 0) return HASH_KEY (h, i); hash_put (h, category_set, Qnil, hash); diff --git a/src/charset.c b/src/charset.c index 85535e8bff..8c54381dc4 100644 --- a/src/charset.c +++ b/src/charset.c @@ -842,7 +842,7 @@ DEFUN ("define-charset-internal", Fdefine_charset_int= ernal, /* Charset attr vector. */ Lisp_Object attrs; Lisp_Object val; - EMACS_UINT hash_code; + Lisp_Object hash_code; struct Lisp_Hash_Table *hash_table =3D XHASH_TABLE (Vcharset_hash_tabl= e); int i, j; struct charset charset; diff --git a/src/composite.c b/src/composite.c index 183062de46..c36663f8e9 100644 --- a/src/composite.c +++ b/src/composite.c @@ -164,11 +164,10 @@ #define MAX_AUTO_COMPOSITION_LOOKBACK 3 get_composition_id (ptrdiff_t charpos, ptrdiff_t bytepos, ptrdiff_t ncha= rs, Lisp_Object prop, Lisp_Object string) { - Lisp_Object id, length, components, key, *key_contents; + Lisp_Object id, length, components, key, *key_contents, hash_code; ptrdiff_t glyph_len; struct Lisp_Hash_Table *hash_table =3D XHASH_TABLE (composition_hash_t= able); ptrdiff_t hash_index; - EMACS_UINT hash_code; enum composition_method method; struct composition *cmp; ptrdiff_t i; @@ -656,7 +655,7 @@ composition_gstring_put_cache (Lisp_Object gstring, p= trdiff_t len) struct Lisp_Hash_Table *h =3D XHASH_TABLE (gstring_hash_table); hash_rehash_if_needed (h); Lisp_Object header =3D LGSTRING_HEADER (gstring); - EMACS_UINT hash =3D h->test.hashfn (&h->test, header); + Lisp_Object hash =3D h->test.hashfn (header, &h->test); if (len < 0) { ptrdiff_t glyph_len =3D LGSTRING_GLYPH_LEN (gstring); diff --git a/src/emacs-module.c b/src/emacs-module.c index 8c09ea6bb6..4b991a1c74 100644 --- a/src/emacs-module.c +++ b/src/emacs-module.c @@ -362,8 +362,7 @@ module_make_global_ref (emacs_env *env, emacs_value r= ef) { MODULE_FUNCTION_BEGIN (NULL); struct Lisp_Hash_Table *h =3D XHASH_TABLE (Vmodule_refs_hash); - Lisp_Object new_obj =3D value_to_lisp (ref); - EMACS_UINT hashcode; + Lisp_Object new_obj =3D value_to_lisp (ref), hashcode; ptrdiff_t i =3D hash_lookup (h, new_obj, &hashcode); =20 if (i >=3D 0) diff --git a/src/fns.c b/src/fns.c index d4f6842f27..d9503c491e 100644 --- a/src/fns.c +++ b/src/fns.c @@ -2373,7 +2373,7 @@ internal_equal (Lisp_Object o1, Lisp_Object o2, enu= m equal_kind equal_kind, case Lisp_Cons: case Lisp_Vectorlike: { struct Lisp_Hash_Table *h =3D XHASH_TABLE (ht); - EMACS_UINT hash; + Lisp_Object hash; ptrdiff_t i =3D hash_lookup (h, o1, &hash); if (i >=3D 0) { /* `o1' was seen already. */ @@ -3934,74 +3934,67 @@ HASH_INDEX (struct Lisp_Hash_Table *h, ptrdiff_t = idx) /* Ignore HT and compare KEY1 and KEY2 using 'eql'. Value is true if KEY1 and KEY2 are the same. */ =20 -static bool -cmpfn_eql (struct hash_table_test *ht, - Lisp_Object key1, - Lisp_Object key2) +static Lisp_Object +cmpfn_eql (Lisp_Object key1, Lisp_Object key2, struct hash_table_test *h= t) { - return !NILP (Feql (key1, key2)); + return Feql (key1, key2); } =20 /* Ignore HT and compare KEY1 and KEY2 using 'equal'. Value is true if KEY1 and KEY2 are the same. */ =20 -static bool -cmpfn_equal (struct hash_table_test *ht, - Lisp_Object key1, - Lisp_Object key2) +static Lisp_Object +cmpfn_equal (Lisp_Object key1, Lisp_Object key2, struct hash_table_test = *ht) { - return !NILP (Fequal (key1, key2)); + return Fequal (key1, key2); } =20 =20 /* Given HT, compare KEY1 and KEY2 using HT->user_cmp_function. Value is true if KEY1 and KEY2 are the same. */ =20 -static bool -cmpfn_user_defined (struct hash_table_test *ht, - Lisp_Object key1, - Lisp_Object key2) +static Lisp_Object +cmpfn_user_defined (Lisp_Object key1, Lisp_Object key2, + struct hash_table_test *ht) { - return !NILP (call2 (ht->user_cmp_function, key1, key2)); + return call2 (ht->user_cmp_function, key1, key2); } =20 -/* Ignore HT and return a hash code for KEY which uses 'eq' to compare k= eys. - The hash code is at most INTMASK. */ +/* Ignore HT and return a hash code for KEY which uses 'eq' to compare + keys. */ =20 -static EMACS_UINT -hashfn_eq (struct hash_table_test *ht, Lisp_Object key) +static Lisp_Object +hashfn_eq (Lisp_Object key, struct hash_table_test *ht) { - return XHASH (key) ^ XTYPE (key); + return make_fixnum (XHASH (key) ^ XTYPE (key)); } =20 /* Ignore HT and return a hash code for KEY which uses 'equal' to compar= e keys. The hash code is at most INTMASK. */ =20 -EMACS_UINT -hashfn_equal (struct hash_table_test *ht, Lisp_Object key) +Lisp_Object +hashfn_equal (Lisp_Object key, struct hash_table_test *ht) { - return sxhash (key, 0); + return make_fixnum (sxhash (key, 0)); } =20 /* Ignore HT and return a hash code for KEY which uses 'eql' to compare = keys. The hash code is at most INTMASK. */ =20 -EMACS_UINT -hashfn_eql (struct hash_table_test *ht, Lisp_Object key) +Lisp_Object +hashfn_eql (Lisp_Object key, struct hash_table_test *ht) { - return ((FLOATP (key) || BIGNUMP (key)) - ? hashfn_equal (ht, key) - : hashfn_eq (ht, key)); + return (FLOATP (key) || BIGNUMP (key) ? hashfn_equal : hashfn_eq) (key= , ht); } =20 /* Given HT, return a hash code for KEY which uses a user-defined - function to compare keys. The hash code is at most INTMASK. */ + function to compare keys. */ =20 -static EMACS_UINT -hashfn_user_defined (struct hash_table_test *ht, Lisp_Object key) +static Lisp_Object +hashfn_user_defined (Lisp_Object key, struct hash_table_test *ht) { Lisp_Object hash =3D call1 (ht->user_hash_function, key); - return hashfn_eq (ht, hash); + return hashfn_eq (hash, ht); } =20 struct hash_table_test const @@ -4224,8 +4217,8 @@ hash_table_rehash (struct Lisp_Hash_Table *h) if (!NILP (HASH_HASH (h, i))) { Lisp_Object key =3D HASH_KEY (h, i); - EMACS_UINT hash_code =3D h->test.hashfn (&h->test, key); - set_hash_hash_slot (h, i, make_fixnum (hash_code)); + Lisp_Object hash_code =3D h->test.hashfn (key, &h->test); + set_hash_hash_slot (h, i, hash_code); } =20 /* Reset the index so that any slot we don't fill below is marked @@ -4256,25 +4249,23 @@ hash_table_rehash (struct Lisp_Hash_Table *h) matching KEY, or -1 if not found. */ =20 ptrdiff_t -hash_lookup (struct Lisp_Hash_Table *h, Lisp_Object key, EMACS_UINT *has= h) +hash_lookup (struct Lisp_Hash_Table *h, Lisp_Object key, Lisp_Object *ha= sh) { - EMACS_UINT hash_code; ptrdiff_t start_of_bucket, i; =20 hash_rehash_if_needed (h); =20 - hash_code =3D h->test.hashfn (&h->test, key); - eassert ((hash_code & ~INTMASK) =3D=3D 0); + Lisp_Object hash_code =3D h->test.hashfn (key, &h->test); if (hash) *hash =3D hash_code; =20 - start_of_bucket =3D hash_code % ASIZE (h->index); + start_of_bucket =3D XUFIXNUM (hash_code) % ASIZE (h->index); =20 for (i =3D HASH_INDEX (h, start_of_bucket); 0 <=3D i; i =3D HASH_NEXT = (h, i)) if (EQ (key, HASH_KEY (h, i)) || (h->test.cmpfn - && hash_code =3D=3D XUFIXNUM (HASH_HASH (h, i)) - && h->test.cmpfn (&h->test, key, HASH_KEY (h, i)))) + && EQ (hash_code, HASH_HASH (h, i)) + && !NILP (h->test.cmpfn (key, HASH_KEY (h, i), &h->test)))) break; =20 return i; @@ -4287,14 +4278,12 @@ hash_lookup (struct Lisp_Hash_Table *h, Lisp_Obje= ct key, EMACS_UINT *hash) =20 ptrdiff_t hash_put (struct Lisp_Hash_Table *h, Lisp_Object key, Lisp_Object value, - EMACS_UINT hash) + Lisp_Object hash) { ptrdiff_t start_of_bucket, i; =20 hash_rehash_if_needed (h); =20 - eassert ((hash & ~INTMASK) =3D=3D 0); - /* Increment count after resizing because resizing may fail. */ maybe_resize_hash_table (h); h->count++; @@ -4306,10 +4295,10 @@ hash_put (struct Lisp_Hash_Table *h, Lisp_Object = key, Lisp_Object value, set_hash_value_slot (h, i, value); =20 /* Remember its hash code. */ - set_hash_hash_slot (h, i, make_fixnum (hash)); + set_hash_hash_slot (h, i, hash); =20 /* Add new entry to its collision chain. */ - start_of_bucket =3D hash % ASIZE (h->index); + start_of_bucket =3D XUFIXNUM (hash) % ASIZE (h->index); set_hash_next_slot (h, i, HASH_INDEX (h, start_of_bucket)); set_hash_index_slot (h, start_of_bucket, i); return i; @@ -4321,9 +4310,8 @@ hash_put (struct Lisp_Hash_Table *h, Lisp_Object ke= y, Lisp_Object value, void hash_remove_from_table (struct Lisp_Hash_Table *h, Lisp_Object key) { - EMACS_UINT hash_code =3D h->test.hashfn (&h->test, key); - eassert ((hash_code & ~INTMASK) =3D=3D 0); - ptrdiff_t start_of_bucket =3D hash_code % ASIZE (h->index); + Lisp_Object hash_code =3D h->test.hashfn (key, &h->test); + ptrdiff_t start_of_bucket =3D XUFIXNUM (hash_code) % ASIZE (h->index); ptrdiff_t prev =3D -1; =20 hash_rehash_if_needed (h); @@ -4334,8 +4322,8 @@ hash_remove_from_table (struct Lisp_Hash_Table *h, = Lisp_Object key) { if (EQ (key, HASH_KEY (h, i)) || (h->test.cmpfn - && hash_code =3D=3D XUFIXNUM (HASH_HASH (h, i)) - && h->test.cmpfn (&h->test, key, HASH_KEY (h, i)))) + && EQ (hash_code, HASH_HASH (h, i)) + && !NILP (h->test.cmpfn (key, HASH_KEY (h, i), &h->test)))) { /* Take entry out of collision chain. */ if (prev < 0) @@ -4685,7 +4673,7 @@ If (eq A B), then (=3D (sxhash-eq A) (sxhash-eq B))= . Hash codes are not guaranteed to be preserved across Emacs sessions. */= ) (Lisp_Object obj) { - return make_fixnum (hashfn_eq (NULL, obj)); + return hashfn_eq (obj, NULL); } =20 DEFUN ("sxhash-eql", Fsxhash_eql, Ssxhash_eql, 1, 1, 0, @@ -4695,7 +4683,7 @@ If (eql A B), then (=3D (sxhash-eql A) (sxhash-eql = B)). Hash codes are not guaranteed to be preserved across Emacs sessions. */= ) (Lisp_Object obj) { - return make_fixnum (hashfn_eql (NULL, obj)); + return hashfn_eql (obj, NULL); } =20 DEFUN ("sxhash-equal", Fsxhash_equal, Ssxhash_equal, 1, 1, 0, @@ -4705,7 +4693,7 @@ If (equal A B), then (=3D (sxhash-equal A) (sxhash-= equal B)). Hash codes are not guaranteed to be preserved across Emacs sessions. */= ) (Lisp_Object obj) { - return make_fixnum (hashfn_equal (NULL, obj)); + return hashfn_equal (obj, NULL); } =20 DEFUN ("make-hash-table", Fmake_hash_table, Smake_hash_table, 0, MANY, 0= , @@ -4951,9 +4939,8 @@ DEFUN ("puthash", Fputhash, Sputhash, 3, 3, 0, struct Lisp_Hash_Table *h =3D check_hash_table (table); CHECK_IMPURE (table, h); =20 - ptrdiff_t i; - EMACS_UINT hash; - i =3D hash_lookup (h, key, &hash); + Lisp_Object hash; + ptrdiff_t i =3D hash_lookup (h, key, &hash); if (i >=3D 0) set_hash_value_slot (h, i, value); else diff --git a/src/image.c b/src/image.c index b081d4b912..355c849491 100644 --- a/src/image.c +++ b/src/image.c @@ -4606,8 +4606,7 @@ xpm_put_color_table_h (Lisp_Object color_table, Lisp_Object color) { struct Lisp_Hash_Table *table =3D XHASH_TABLE (color_table); - EMACS_UINT hash_code; - Lisp_Object chars =3D make_unibyte_string (chars_start, chars_len); + Lisp_Object chars =3D make_unibyte_string (chars_start, chars_len), ha= sh_code; =20 hash_lookup (table, chars, &hash_code); hash_put (table, chars, color, hash_code); diff --git a/src/json.c b/src/json.c index 21c4b946b4..d05f2c54e2 100644 --- a/src/json.c +++ b/src/json.c @@ -867,8 +867,7 @@ json_to_lisp (json_t *json, struct json_configuration= *conf) json_t *value; json_object_foreach (json, key_str, value) { - Lisp_Object key =3D build_string_from_utf8 (key_str); - EMACS_UINT hash; + Lisp_Object key =3D build_string_from_utf8 (key_str), hash; ptrdiff_t i =3D hash_lookup (h, key, &hash); /* Keys in JSON objects are unique, so the key can't be present yet. */ diff --git a/src/lisp.h b/src/lisp.h index 50a61cadd7..e5edb8fd12 100644 --- a/src/lisp.h +++ b/src/lisp.h @@ -2237,10 +2237,10 @@ #define DEFSYM(sym, name) /* empty */ Lisp_Object user_cmp_function; =20 /* C function to compare two keys. */ - bool (*cmpfn) (struct hash_table_test *t, Lisp_Object, Lisp_Object); + Lisp_Object (*cmpfn) (Lisp_Object, Lisp_Object, struct hash_table_test= *t); =20 /* C function to compute hash code. */ - EMACS_UINT (*hashfn) (struct hash_table_test *t, Lisp_Object); + Lisp_Object (*hashfn) (Lisp_Object, struct hash_table_test *t); }; =20 struct Lisp_Hash_Table @@ -3591,13 +3591,13 @@ #define CONS_TO_INTEGER(cons, type, var) \ extern char *extract_data_from_object (Lisp_Object, ptrdiff_t *, ptrdiff= _t *); EMACS_UINT hash_string (char const *, ptrdiff_t); EMACS_UINT sxhash (Lisp_Object, int); -EMACS_UINT hashfn_eql (struct hash_table_test *ht, Lisp_Object key); -EMACS_UINT hashfn_equal (struct hash_table_test *ht, Lisp_Object key); +Lisp_Object hashfn_eql (Lisp_Object, struct hash_table_test *); +Lisp_Object hashfn_equal (Lisp_Object, struct hash_table_test *); Lisp_Object make_hash_table (struct hash_table_test, EMACS_INT, float, f= loat, Lisp_Object, bool); -ptrdiff_t hash_lookup (struct Lisp_Hash_Table *, Lisp_Object, EMACS_UINT= *); +ptrdiff_t hash_lookup (struct Lisp_Hash_Table *, Lisp_Object, Lisp_Objec= t *); ptrdiff_t hash_put (struct Lisp_Hash_Table *, Lisp_Object, Lisp_Object, - EMACS_UINT); + Lisp_Object); void hash_remove_from_table (struct Lisp_Hash_Table *, Lisp_Object); extern struct hash_table_test const hashtest_eq, hashtest_eql, hashtest_= equal; extern void validate_subarray (Lisp_Object, Lisp_Object, Lisp_Object, diff --git a/src/lread.c b/src/lread.c index 3152fcf867..eecb5e141d 100644 --- a/src/lread.c +++ b/src/lread.c @@ -3161,8 +3161,7 @@ read1 (Lisp_Object readcharfun, int *pch, bool firs= t_in_list) Lisp_Object placeholder =3D Fcons (Qnil, Qnil); struct Lisp_Hash_Table *h =3D XHASH_TABLE (read_objects_map); - EMACS_UINT hash; - Lisp_Object number =3D make_fixnum (n); + Lisp_Object number =3D make_fixnum (n), hash; =20 ptrdiff_t i =3D hash_lookup (h, number, &hash); if (i >=3D 0) diff --git a/src/macfont.m b/src/macfont.m index 301951f34a..7170e80140 100644 --- a/src/macfont.m +++ b/src/macfont.m @@ -986,8 +986,7 @@ static void mac_font_get_glyphs_for_variants (CFDataR= ef, UTF32Char, { struct Lisp_Hash_Table *h; ptrdiff_t i; - EMACS_UINT hash; - Lisp_Object value; + Lisp_Object hash, value; =20 if (!HASH_TABLE_P (macfont_family_cache)) macfont_family_cache =3D CALLN (Fmake_hash_table, QCtest, Qeq); diff --git a/src/profiler.c b/src/profiler.c index 87be30acc3..e9b6a37d06 100644 --- a/src/profiler.c +++ b/src/profiler.c @@ -36,11 +36,9 @@ saturated_add (EMACS_INT a, EMACS_INT b) =20 typedef struct Lisp_Hash_Table log_t; =20 -static bool cmpfn_profiler ( - struct hash_table_test *, Lisp_Object, Lisp_Object); - -static EMACS_UINT hashfn_profiler ( - struct hash_table_test *, Lisp_Object); +static Lisp_Object cmpfn_profiler (Lisp_Object, Lisp_Object, + struct hash_table_test *); +static Lisp_Object hashfn_profiler (Lisp_Object, struct hash_table_test = *); =20 static const struct hash_table_test hashtest_profiler =3D { @@ -165,7 +163,7 @@ record_backtrace (log_t *log, EMACS_INT count) careful to avoid memory allocation since we're in a signal handler, and we optimize the code to try and avoid computing the hash+lookup twice. See fns.c:Fputhash for reference. */ - EMACS_UINT hash; + Lisp_Object hash; ptrdiff_t j =3D hash_lookup (log, backtrace, &hash); if (j >=3D 0) { @@ -529,30 +527,30 @@ DEFUN ("function-equal", Ffunction_equal, Sfunction= _equal, 2, 2, 0, return res ? Qt : Qnil; } =20 -static bool -cmpfn_profiler (struct hash_table_test *t, - Lisp_Object bt1, Lisp_Object bt2) +static Lisp_Object +cmpfn_profiler (Lisp_Object bt1, Lisp_Object bt2, struct hash_table_test= *t) { if (VECTORP (bt1) && VECTORP (bt2)) { ptrdiff_t l =3D ASIZE (bt1); if (l !=3D ASIZE (bt2)) - return false; + return Qnil; for (ptrdiff_t i =3D 0; i < l; i++) if (NILP (Ffunction_equal (AREF (bt1, i), AREF (bt2, i)))) - return false; - return true; + return Qnil; + return Qt; } else - return EQ (bt1, bt2); + return EQ (bt1, bt2) ? Qt : Qnil; } =20 -static EMACS_UINT -hashfn_profiler (struct hash_table_test *ht, Lisp_Object bt) +static Lisp_Object +hashfn_profiler (Lisp_Object bt, struct hash_table_test *ht) { + EMACS_UINT hash; if (VECTORP (bt)) { - EMACS_UINT hash =3D 0; + hash =3D 0; ptrdiff_t l =3D ASIZE (bt); for (ptrdiff_t i =3D 0; i < l; i++) { @@ -563,10 +561,10 @@ hashfn_profiler (struct hash_table_test *ht, Lisp_O= bject bt) ? XHASH (XCDR (XCDR (f))) : XHASH (f)); hash =3D sxhash_combine (hash, hash1); } - return SXHASH_REDUCE (hash); } else - return XHASH (bt); + hash =3D XHASH (bt); + return make_fixnum (SXHASH_REDUCE (hash)); } =20 static void syms_of_profiler_for_pdumper (void); --=20 2.17.1 --------------65B410FA542064ACF23C5ADB Content-Type: text/x-patch; name="0006-Fix-crash-if-user-test-munges-hash-table.patch" Content-Disposition: attachment; filename="0006-Fix-crash-if-user-test-munges-hash-table.patch" Content-Transfer-Encoding: quoted-printable >From 515afc9c15870cd7bd6b96e2d8b89938116923ac Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Sat, 20 Jul 2019 19:40:03 -0700 Subject: [PATCH 6/6] Fix crash if user test munges hash table MIME-Version: 1.0 Content-Type: text/plain; charset=3DUTF-8 Content-Transfer-Encoding: 8bit * src/fns.c (restore_mutability) (hash_table_user_defined_call): New functions. (cmpfn_user_defined, hashfn_user_defined): Use them. (make_hash_table, copy_hash_table): Mark new hash table as mutable. (check_mutable_hash_table): New function. (Fclrhash, Fputhash, Fremhash): Use it instead of CHECK_IMPURE. * src/lisp.h (struct hash_table_test): User-defined functions now take pointers to struct Lisp_Hash_Table, not to struct hash_table_test. All uses changed. (struct Lisp_Hash_Table): New member =E2=80=98mutable=E2=80=99. * src/pdumper.c (dump_hash_table): Copy it. * test/src/fns-tests.el (test-hash-function-that-mutates-hash-table): New test, which tests for the bug. --- src/alloc.c | 1 + src/bytecode.c | 5 ++- src/composite.c | 2 +- src/fns.c | 74 ++++++++++++++++++++++++++++++++----------- src/lisp.h | 15 ++++++--- src/pdumper.c | 1 + src/profiler.c | 8 ++--- test/src/fns-tests.el | 12 +++++++ 8 files changed, 87 insertions(+), 31 deletions(-) diff --git a/src/alloc.c b/src/alloc.c index 09b3a4ea7e..1718ce0faf 100644 --- a/src/alloc.c +++ b/src/alloc.c @@ -5352,6 +5352,7 @@ purecopy_hash_table (struct Lisp_Hash_Table *table) pure->count =3D table->count; pure->next_free =3D table->next_free; pure->purecopy =3D table->purecopy; + eassert (!pure->mutable); pure->rehash_threshold =3D table->rehash_threshold; pure->rehash_size =3D table->rehash_size; pure->key_and_value =3D purecopy (table->key_and_value); diff --git a/src/bytecode.c b/src/bytecode.c index e82de026a8..d668a9a6a1 100644 --- a/src/bytecode.c +++ b/src/bytecode.c @@ -1410,14 +1410,13 @@ #define DEFINE(name, value) LABEL (name) , { /* Do a linear search if there are not many cases FIXME: 5 is arbitrarily chosen. */ Lisp_Object hash_code - =3D h->test.cmpfn ? h->test.hashfn (v1, &h->test) : Qnil; + =3D h->test.cmpfn ? h->test.hashfn (v1, h) : Qnil; =20 for (i =3D h->count; 0 <=3D --i; ) if (EQ (v1, HASH_KEY (h, i)) || (h->test.cmpfn && EQ (hash_code, HASH_HASH (h, i)) - && !NILP (h->test.cmpfn (v1, HASH_KEY (h, i), - &h->test)))) + && !NILP (h->test.cmpfn (v1, HASH_KEY (h, i), h)))) break; } else diff --git a/src/composite.c b/src/composite.c index c36663f8e9..a6606d5fc4 100644 --- a/src/composite.c +++ b/src/composite.c @@ -655,7 +655,7 @@ composition_gstring_put_cache (Lisp_Object gstring, p= trdiff_t len) struct Lisp_Hash_Table *h =3D XHASH_TABLE (gstring_hash_table); hash_rehash_if_needed (h); Lisp_Object header =3D LGSTRING_HEADER (gstring); - Lisp_Object hash =3D h->test.hashfn (header, &h->test); + Lisp_Object hash =3D h->test.hashfn (header, h); if (len < 0) { ptrdiff_t glyph_len =3D LGSTRING_GLYPH_LEN (gstring); diff --git a/src/fns.c b/src/fns.c index d9503c491e..5f1ed07a12 100644 --- a/src/fns.c +++ b/src/fns.c @@ -3931,11 +3931,37 @@ HASH_INDEX (struct Lisp_Hash_Table *h, ptrdiff_t = idx) return XFIXNUM (AREF (h->index, idx)); } =20 +/* Restore a hash table's mutability after the critical section exits. = */ + +static void +restore_mutability (void *ptr) +{ + struct Lisp_Hash_Table *h =3D ptr; + h->mutable =3D true; +} + +/* Return the result of calling a user-defined hash or comparison + function ARGS[0] with arguments ARGS[1] through ARGS[NARGS - 1]. + Signal an error if the function attempts to modify H, which + otherwise might lead to undefined behavior. */ + +static Lisp_Object +hash_table_user_defined_call (ptrdiff_t nargs, Lisp_Object *args, + struct Lisp_Hash_Table *h) +{ + if (!h->mutable) + return Ffuncall (nargs, args); + ptrdiff_t count =3D inhibit_garbage_collection (); + record_unwind_protect_ptr (restore_mutability, h); + h->mutable =3D false; + return unbind_to (count, Ffuncall (nargs, args)); +} + /* Ignore HT and compare KEY1 and KEY2 using 'eql'. Value is true if KEY1 and KEY2 are the same. */ =20 static Lisp_Object -cmpfn_eql (Lisp_Object key1, Lisp_Object key2, struct hash_table_test *h= t) +cmpfn_eql (Lisp_Object key1, Lisp_Object key2, struct Lisp_Hash_Table *h= ) { return Feql (key1, key2); } @@ -3944,7 +3970,7 @@ cmpfn_eql (Lisp_Object key1, Lisp_Object key2, stru= ct hash_table_test *ht) Value is true if KEY1 and KEY2 are the same. */ =20 static Lisp_Object -cmpfn_equal (Lisp_Object key1, Lisp_Object key2, struct hash_table_test = *ht) +cmpfn_equal (Lisp_Object key1, Lisp_Object key2, struct Lisp_Hash_Table = *h) { return Fequal (key1, key2); } @@ -3955,16 +3981,17 @@ cmpfn_equal (Lisp_Object key1, Lisp_Object key2, = struct hash_table_test *ht) =20 static Lisp_Object cmpfn_user_defined (Lisp_Object key1, Lisp_Object key2, - struct hash_table_test *ht) + struct Lisp_Hash_Table *h) { - return call2 (ht->user_cmp_function, key1, key2); + Lisp_Object args[] =3D { h->test.user_cmp_function, key1, key2 }; + return hash_table_user_defined_call (ARRAYELTS (args), args, h); } =20 /* Ignore HT and return a hash code for KEY which uses 'eq' to compare keys. */ =20 static Lisp_Object -hashfn_eq (Lisp_Object key, struct hash_table_test *ht) +hashfn_eq (Lisp_Object key, struct Lisp_Hash_Table *h) { return make_fixnum (XHASH (key) ^ XTYPE (key)); } @@ -3973,7 +4000,7 @@ hashfn_eq (Lisp_Object key, struct hash_table_test = *ht) The hash code is at most INTMASK. */ =20 Lisp_Object -hashfn_equal (Lisp_Object key, struct hash_table_test *ht) +hashfn_equal (Lisp_Object key, struct Lisp_Hash_Table *h) { return make_fixnum (sxhash (key, 0)); } @@ -3982,19 +4009,19 @@ hashfn_equal (Lisp_Object key, struct hash_table_= test *ht) The hash code is at most INTMASK. */ =20 Lisp_Object -hashfn_eql (Lisp_Object key, struct hash_table_test *ht) +hashfn_eql (Lisp_Object key, struct Lisp_Hash_Table *h) { - return (FLOATP (key) || BIGNUMP (key) ? hashfn_equal : hashfn_eq) (key= , ht); + return (FLOATP (key) || BIGNUMP (key) ? hashfn_equal : hashfn_eq) (key= , h); } =20 /* Given HT, return a hash code for KEY which uses a user-defined function to compare keys. */ =20 static Lisp_Object -hashfn_user_defined (Lisp_Object key, struct hash_table_test *ht) +hashfn_user_defined (Lisp_Object key, struct Lisp_Hash_Table *h) { - Lisp_Object hash =3D call1 (ht->user_hash_function, key); - return hashfn_eq (hash, ht); + Lisp_Object args[] =3D { h->test.user_hash_function, key }; + return hash_table_user_defined_call (ARRAYELTS (args), args, h); } =20 struct hash_table_test const @@ -4088,6 +4115,7 @@ make_hash_table (struct hash_table_test test, EMACS= _INT size, h->index =3D make_vector (index_size, make_fixnum (-1)); h->next_weak =3D NULL; h->purecopy =3D purecopy; + h->mutable =3D true; =20 /* Set up the free list. */ for (i =3D 0; i < size - 1; ++i) @@ -4113,6 +4141,7 @@ copy_hash_table (struct Lisp_Hash_Table *h1) =20 h2 =3D allocate_hash_table (); *h2 =3D *h1; + h2->mutable =3D true; h2->key_and_value =3D Fcopy_sequence (h1->key_and_value); h2->hash =3D Fcopy_sequence (h1->hash); h2->next =3D Fcopy_sequence (h1->next); @@ -4217,7 +4246,7 @@ hash_table_rehash (struct Lisp_Hash_Table *h) if (!NILP (HASH_HASH (h, i))) { Lisp_Object key =3D HASH_KEY (h, i); - Lisp_Object hash_code =3D h->test.hashfn (key, &h->test); + Lisp_Object hash_code =3D h->test.hashfn (key, h); set_hash_hash_slot (h, i, hash_code); } =20 @@ -4255,7 +4284,7 @@ hash_lookup (struct Lisp_Hash_Table *h, Lisp_Object= key, Lisp_Object *hash) =20 hash_rehash_if_needed (h); =20 - Lisp_Object hash_code =3D h->test.hashfn (key, &h->test); + Lisp_Object hash_code =3D h->test.hashfn (key, h); if (hash) *hash =3D hash_code; =20 @@ -4265,12 +4294,19 @@ hash_lookup (struct Lisp_Hash_Table *h, Lisp_Obje= ct key, Lisp_Object *hash) if (EQ (key, HASH_KEY (h, i)) || (h->test.cmpfn && EQ (hash_code, HASH_HASH (h, i)) - && !NILP (h->test.cmpfn (key, HASH_KEY (h, i), &h->test)))) + && !NILP (h->test.cmpfn (key, HASH_KEY (h, i), h)))) break; =20 return i; } =20 +static void +check_mutable_hash_table (Lisp_Object obj, struct Lisp_Hash_Table *h) +{ + if (!h->mutable) + signal_error ("hash table test modifies table", obj); + eassert (!PURE_P (h)); +} =20 /* Put an entry into hash table H that associates KEY with VALUE. HASH is a previously computed hash code of KEY. @@ -4310,7 +4346,7 @@ hash_put (struct Lisp_Hash_Table *h, Lisp_Object ke= y, Lisp_Object value, void hash_remove_from_table (struct Lisp_Hash_Table *h, Lisp_Object key) { - Lisp_Object hash_code =3D h->test.hashfn (key, &h->test); + Lisp_Object hash_code =3D h->test.hashfn (key, h); ptrdiff_t start_of_bucket =3D XUFIXNUM (hash_code) % ASIZE (h->index); ptrdiff_t prev =3D -1; =20 @@ -4323,7 +4359,7 @@ hash_remove_from_table (struct Lisp_Hash_Table *h, = Lisp_Object key) if (EQ (key, HASH_KEY (h, i)) || (h->test.cmpfn && EQ (hash_code, HASH_HASH (h, i)) - && !NILP (h->test.cmpfn (key, HASH_KEY (h, i), &h->test)))) + && !NILP (h->test.cmpfn (key, HASH_KEY (h, i), h)))) { /* Take entry out of collision chain. */ if (prev < 0) @@ -4912,7 +4948,7 @@ DEFUN ("clrhash", Fclrhash, Sclrhash, 1, 1, 0, (Lisp_Object table) { struct Lisp_Hash_Table *h =3D check_hash_table (table); - CHECK_IMPURE (table, h); + check_mutable_hash_table (table, h); hash_clear (h); /* Be compatible with XEmacs. */ return table; @@ -4937,7 +4973,7 @@ DEFUN ("puthash", Fputhash, Sputhash, 3, 3, 0, (Lisp_Object key, Lisp_Object value, Lisp_Object table) { struct Lisp_Hash_Table *h =3D check_hash_table (table); - CHECK_IMPURE (table, h); + check_mutable_hash_table (table, h); =20 Lisp_Object hash; ptrdiff_t i =3D hash_lookup (h, key, &hash); @@ -4955,7 +4991,7 @@ DEFUN ("remhash", Fremhash, Sremhash, 2, 2, 0, (Lisp_Object key, Lisp_Object table) { struct Lisp_Hash_Table *h =3D check_hash_table (table); - CHECK_IMPURE (table, h); + check_mutable_hash_table (table, h); hash_remove_from_table (h, key); return Qnil; } diff --git a/src/lisp.h b/src/lisp.h index e5edb8fd12..6d101fed90 100644 --- a/src/lisp.h +++ b/src/lisp.h @@ -2225,6 +2225,8 @@ #define DEFSYM(sym, name) /* empty */ =20 /* The structure of a Lisp hash table. */ =20 +struct Lisp_Hash_Table; + struct hash_table_test { /* Name of the function used to compare keys. */ @@ -2237,10 +2239,10 @@ #define DEFSYM(sym, name) /* empty */ Lisp_Object user_cmp_function; =20 /* C function to compare two keys. */ - Lisp_Object (*cmpfn) (Lisp_Object, Lisp_Object, struct hash_table_test= *t); + Lisp_Object (*cmpfn) (Lisp_Object, Lisp_Object, struct Lisp_Hash_Table= *); =20 /* C function to compute hash code. */ - Lisp_Object (*hashfn) (Lisp_Object, struct hash_table_test *t); + Lisp_Object (*hashfn) (Lisp_Object, struct Lisp_Hash_Table *); }; =20 struct Lisp_Hash_Table @@ -2289,6 +2291,11 @@ #define DEFSYM(sym, name) /* empty */ changed afterwards. */ bool purecopy; =20 + /* True if the table is mutable. Ordinarily tables are mutable, but + pure tables are not, and while a table is being mutated it is + immutable for recursive attempts to mutate it. */ + bool mutable; + /* Resize hash table when number of entries / table size is >=3D this ratio. */ float rehash_threshold; @@ -3591,8 +3598,8 @@ #define CONS_TO_INTEGER(cons, type, var) \ extern char *extract_data_from_object (Lisp_Object, ptrdiff_t *, ptrdiff= _t *); EMACS_UINT hash_string (char const *, ptrdiff_t); EMACS_UINT sxhash (Lisp_Object, int); -Lisp_Object hashfn_eql (Lisp_Object, struct hash_table_test *); -Lisp_Object hashfn_equal (Lisp_Object, struct hash_table_test *); +Lisp_Object hashfn_eql (Lisp_Object, struct Lisp_Hash_Table *); +Lisp_Object hashfn_equal (Lisp_Object, struct Lisp_Hash_Table *); Lisp_Object make_hash_table (struct hash_table_test, EMACS_INT, float, f= loat, Lisp_Object, bool); ptrdiff_t hash_lookup (struct Lisp_Hash_Table *, Lisp_Object, Lisp_Objec= t *); diff --git a/src/pdumper.c b/src/pdumper.c index 206a196890..2abac80a37 100644 --- a/src/pdumper.c +++ b/src/pdumper.c @@ -2742,6 +2742,7 @@ dump_hash_table (struct dump_context *ctx, DUMP_FIELD_COPY (out, hash, count); DUMP_FIELD_COPY (out, hash, next_free); DUMP_FIELD_COPY (out, hash, purecopy); + DUMP_FIELD_COPY (out, hash, mutable); DUMP_FIELD_COPY (out, hash, rehash_threshold); DUMP_FIELD_COPY (out, hash, rehash_size); dump_field_lv (ctx, out, hash, &hash->key_and_value, WEIGHT_STRONG); diff --git a/src/profiler.c b/src/profiler.c index e9b6a37d06..ed0e9ddd88 100644 --- a/src/profiler.c +++ b/src/profiler.c @@ -37,8 +37,8 @@ saturated_add (EMACS_INT a, EMACS_INT b) typedef struct Lisp_Hash_Table log_t; =20 static Lisp_Object cmpfn_profiler (Lisp_Object, Lisp_Object, - struct hash_table_test *); -static Lisp_Object hashfn_profiler (Lisp_Object, struct hash_table_test = *); + struct Lisp_Hash_Table *); +static Lisp_Object hashfn_profiler (Lisp_Object, struct Lisp_Hash_Table = *); =20 static const struct hash_table_test hashtest_profiler =3D { @@ -528,7 +528,7 @@ DEFUN ("function-equal", Ffunction_equal, Sfunction_e= qual, 2, 2, 0, } =20 static Lisp_Object -cmpfn_profiler (Lisp_Object bt1, Lisp_Object bt2, struct hash_table_test= *t) +cmpfn_profiler (Lisp_Object bt1, Lisp_Object bt2, struct Lisp_Hash_Table= *h) { if (VECTORP (bt1) && VECTORP (bt2)) { @@ -545,7 +545,7 @@ cmpfn_profiler (Lisp_Object bt1, Lisp_Object bt2, str= uct hash_table_test *t) } =20 static Lisp_Object -hashfn_profiler (Lisp_Object bt, struct hash_table_test *ht) +hashfn_profiler (Lisp_Object bt, struct Lisp_Hash_Table *h) { EMACS_UINT hash; if (VECTORP (bt)) diff --git a/test/src/fns-tests.el b/test/src/fns-tests.el index 9d4ae4fdf3..7d56da77cf 100644 --- a/test/src/fns-tests.el +++ b/test/src/fns-tests.el @@ -846,4 +846,16 @@ test-proper-list-p (should (not (proper-list-p (make-bool-vector 0 nil)))) (should (not (proper-list-p (make-symbol "a"))))) =20 +(ert-deftest test-hash-function-that-mutates-hash-table () + (define-hash-table-test 'badeq 'eq 'bad-hash) + (let ((h (make-hash-table :test 'badeq :size 1 :rehash-size 1))) + (defun bad-hash (k) + (if (eq k 100) + (clrhash h)) + (sxhash-eq k)) + (should-error + (dotimes (k 200) + (puthash k k h))) + (should (=3D 100 (hash-table-count h))))) + (provide 'fns-tests) --=20 2.17.1 --------------65B410FA542064ACF23C5ADB-- From debbugs-submit-bounces@debbugs.gnu.org Sun Jul 21 01:35:33 2019 Received: (at 36597) by debbugs.gnu.org; 21 Jul 2019 05:35:33 +0000 Received: from localhost ([127.0.0.1]:58069 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hp4VR-0002fX-4Q for submit@debbugs.gnu.org; Sun, 21 Jul 2019 01:35:33 -0400 Received: from mail-ot1-f45.google.com ([209.85.210.45]:39186) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hp4VP-0002fL-VG for 36597@debbugs.gnu.org; Sun, 21 Jul 2019 01:35:32 -0400 Received: by mail-ot1-f45.google.com with SMTP id r21so30865508otq.6 for <36597@debbugs.gnu.org>; Sat, 20 Jul 2019 22:35:31 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc; bh=rOMNVpzrxMfkbHfE1JGzBumrgE2BxDKkeeKuu4myLbA=; b=EG68A2v1wwQ1mMTHwWdbfGbwQQtHp6cqkpBLQTbEkSZi9LYh/jv/tLT5KqBB2ieHcR TULhMRFU2SKUnQFioLG2ifJIWucHf7otAeeUHhGiRC/aNIO5LjsKC4E69q37Akgf4Z33 lfj0eZjxkGtA82/sx8tz+EeJbno/G6srWmysV0F0nmJnakAbneoNG3WgG0nn4If7kqRU KBnolNgPyV0rNYUXc86Hmazqwtu5Asp5vlzvwvaf+V6BbiXt6LmvUhQ08yWZ1wWAG4ZU /DSAEY0RoR2LWRgW+ZGKzvrrvnAFb6amysEhbH3eqcTm4IrKubZ7je2AmZf9q5tvN8XC Ll6w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=rOMNVpzrxMfkbHfE1JGzBumrgE2BxDKkeeKuu4myLbA=; b=euyvf78FDDBfs9wfoRMsYzgqs/xNPHBV29fls3mmJPEAuOCXxFwhtdVVQHniyWwJnp luVyLFolPwUR3WZJ34AOxvMDdh/RJvNbVU7rlvx1ubEYHCogxdT6dqdOfx0X0DcUIUmE aSB758k4fLgHLtNi57AR058xxUJyhKKtJsQskk+3uHXwvz+73RrnzvqLWMRRpnk57CsE cVlxt7neJtNc6Ce6j1ctYPNpSoedeNS4w2KKknf73v7lqY3U+MCTZ2L6XjORt65pHdVb w7ikfvVFhoDD5xiIltnUK+JIuIf2HCsv/cYO6TUkznUTlvIAT59LB4EjjeEQ8sgfdBj8 J6hg== X-Gm-Message-State: APjAAAVkab+VxQ9ASfOw2rIWaVJBstq0Emr86jxFWaFKZhipLZIXyyJm UHJjiS9Ve+DIkR93uiZzap5QO0HcA7FtuTZoz9M= X-Google-Smtp-Source: APXvYqzhzNrWdQS8CRpgpfg6eKSXhDMebwPfm7/GOhLL26F5lvfmIbn6EWN2HcD103kV0GO9jUO6+qA/acFSWTolC48= X-Received: by 2002:a9d:664c:: with SMTP id q12mr39455625otm.175.1563687326360; Sat, 20 Jul 2019 22:35:26 -0700 (PDT) MIME-Version: 1.0 References: <6a260307-a463-bd08-8a10-d7664d0606a2@cs.ucla.edu> <74235afc-7043-1da7-7c71-07f0ca23b9fd@cs.ucla.edu> <83r26mv53z.fsf@gnu.org> In-Reply-To: From: Pip Cet Date: Sun, 21 Jul 2019 05:34:50 +0000 Message-ID: Subject: Re: bug#36597: 27.0.50; rehash hash tables eagerly in pdumper To: Paul Eggert Content-Type: text/plain; charset="UTF-8" X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 36597 Cc: Eli Zaretskii , 36597@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) On Sun, Jul 21, 2019 at 3:18 AM Paul Eggert wrote: > Pip Cet wrote: > > I'm currently playing around with redefining hash tables not to have > > internal freelists. That makes the hash table code a lot simpler > > overall, but some of that simplicity would be lost trying to support > > lazy hash table rehashing. > > While looking into this I discovered unlikely bugs in Emacs's hash table code > and GC that can make Emacs dump core, along with some other unlikely hash-table > bugs that can cause Emacs to report memory exhaustion when there should be > plenty of memory. I installed the attached patches to fix these problems and to > refactor to make this code easier to understand (at least for me :-). These > patches will probably affect performance analysis. Well, at least they'll require rebasing, particularly of the no-internal-freelists patch :-) While your changes are extensive, I don't see anything in there that would drastically affect performance or memory footprint. Maybe I'm missing something, though. From debbugs-submit-bounces@debbugs.gnu.org Sun Jul 21 02:32:13 2019 Received: (at 36597) by debbugs.gnu.org; 21 Jul 2019 06:32:13 +0000 Received: from localhost ([127.0.0.1]:58088 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hp5OG-0004GI-Pz for submit@debbugs.gnu.org; Sun, 21 Jul 2019 02:32:13 -0400 Received: from zimbra.cs.ucla.edu ([131.179.128.68]:37178) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hp5OE-0004G4-1q for 36597@debbugs.gnu.org; Sun, 21 Jul 2019 02:32:12 -0400 Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id 639581626E0; Sat, 20 Jul 2019 23:32:04 -0700 (PDT) Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10032) with ESMTP id U1_B8jNdZoz9; Sat, 20 Jul 2019 23:32:03 -0700 (PDT) Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id A8E661626ED; Sat, 20 Jul 2019 23:32:03 -0700 (PDT) X-Virus-Scanned: amavisd-new at zimbra.cs.ucla.edu Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10026) with ESMTP id vKBckyYwpY6P; Sat, 20 Jul 2019 23:32:03 -0700 (PDT) Received: from [192.168.1.9] (cpe-23-242-74-103.socal.res.rr.com [23.242.74.103]) by zimbra.cs.ucla.edu (Postfix) with ESMTPSA id 818201626E0; Sat, 20 Jul 2019 23:32:03 -0700 (PDT) Subject: Re: bug#36597: 27.0.50; rehash hash tables eagerly in pdumper To: Pip Cet References: <6a260307-a463-bd08-8a10-d7664d0606a2@cs.ucla.edu> <74235afc-7043-1da7-7c71-07f0ca23b9fd@cs.ucla.edu> <83r26mv53z.fsf@gnu.org> From: Paul Eggert Organization: UCLA Computer Science Department Message-ID: <0a45d364-73ee-4ef3-62de-4d8d42578036@cs.ucla.edu> Date: Sat, 20 Jul 2019 23:32:03 -0700 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Thunderbird/60.8.0 MIME-Version: 1.0 In-Reply-To: Content-Type: text/plain; charset=utf-8; format=flowed Content-Language: en-US Content-Transfer-Encoding: 7bit X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 36597 Cc: Eli Zaretskii , 36597@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) Pip Cet wrote: > I don't see anything in there that > would drastically affect performance or memory footprint. The drastic change to the memory footprint occurs because the old code incorrectly computed the length of the hash table's vectors, and over-allocated them in some cases. The over-allocation factor could get worse with each hash table resize, following a Fibonacci-like sequence. I think this was a bug I introduced in 2011-07-21T17:41:20!eggert@cs.ucla.edu. From debbugs-submit-bounces@debbugs.gnu.org Sun Jul 21 02:33:12 2019 Received: (at 36597) by debbugs.gnu.org; 21 Jul 2019 06:33:12 +0000 Received: from localhost ([127.0.0.1]:58092 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hp5PD-0004Hm-66 for submit@debbugs.gnu.org; Sun, 21 Jul 2019 02:33:12 -0400 Received: from mail-ot1-f48.google.com ([209.85.210.48]:35688) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hp5PA-0004HZ-VH for 36597@debbugs.gnu.org; Sun, 21 Jul 2019 02:33:09 -0400 Received: by mail-ot1-f48.google.com with SMTP id j19so36985399otq.2 for <36597@debbugs.gnu.org>; Sat, 20 Jul 2019 23:33:08 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc; bh=oLmAW+F4Ct0XdydGzKUsdIya7+wacYrxRt8CuAfUEYI=; b=SoctpprUQw4Nagh2fZ6fzHsZ+zQmB8smRFR9mr0wGs23q0ERmlw2Lukh7X4Cqj1OYO etwLZRnIfiudUjVNzaz26ecqKJ3h7qUp8du0V4Et15pmjTV1RJKJ2NpdH7y8ZpMXtAGq RuTH4MuWm3lGm58gHO/XxgPkamkTcZ1YYenMYHmkJnHZPSe7jUpHFzIB111xAN5Cpq/I uheUGy0asezxlGascFf2OfhH8mHRAiZHawptCwzeAJ4APihPmF6wMNczcSpavlaO5B3n QhMyMe7xPJRFzNyYgoEynD3eR7t4bvg5dwisFzVkkvj7+e7CAjFop2QwCz9GW9PP3WdO 1bPQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=oLmAW+F4Ct0XdydGzKUsdIya7+wacYrxRt8CuAfUEYI=; b=kn09xoAZIB29bB3q+Ck9wM9XdrMX+h7tOPz5gnAvKWq/M08JCQgLI/YswlXdlBQPct Qno+uHE8CpxKgAKNmZD68Frgvmc9Fy+PVDv/Ml3s7zhpwnfaO0D9FLIhvqbOwxbl4DxU onsC3tSx7nycQ9UK8Y53est8ONR0QVdGwLxowABD6Z+7w3gUn+3KpWn1gPF5uKdub6jS Xj8P2irn/pE8uNOx5lo6q4/2xP0QA2A2sXsgO+txyyWaYA1CXP2tJILLagzI12gJQqjB xPBKTkfo7I5gtrKesg/VQfNDvn3ynPmGn+FR+q9fZcOHIjvOm7mrd6a85MCTkZhXd5/o Edjg== X-Gm-Message-State: APjAAAXwDz6LRRRV0ZrYjbyYRDYXEP53Sk4Qk6Xg/+s3dVV5QSIgnYrv KvfZDFVhj3abTDPG/ayMth7QVJhZolZTSTP6Ly5Zxg== X-Google-Smtp-Source: APXvYqxd2ODSuAq8DDBGuyRq7CFQGtubAE3wTFDM8+7FPlTK04C/xXIjSqno9cLH0v1PG+Z4vreKb5CYebEGRERRdMM= X-Received: by 2002:a9d:664c:: with SMTP id q12mr39602149otm.175.1563690783243; Sat, 20 Jul 2019 23:33:03 -0700 (PDT) MIME-Version: 1.0 References: <6a260307-a463-bd08-8a10-d7664d0606a2@cs.ucla.edu> <74235afc-7043-1da7-7c71-07f0ca23b9fd@cs.ucla.edu> <83r26mv53z.fsf@gnu.org> In-Reply-To: From: Pip Cet Date: Sun, 21 Jul 2019 06:32:26 +0000 Message-ID: Subject: Re: bug#36597: 27.0.50; rehash hash tables eagerly in pdumper To: Paul Eggert Content-Type: multipart/mixed; boundary="000000000000acad5b058e2b21f8" X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 36597 Cc: Eli Zaretskii , 36597@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) --000000000000acad5b058e2b21f8 Content-Type: text/plain; charset="UTF-8" On Sun, Jul 21, 2019 at 5:34 AM Pip Cet wrote: > On Sun, Jul 21, 2019 at 3:18 AM Paul Eggert wrote: > > Pip Cet wrote: > > > I'm currently playing around with redefining hash tables not to have > > > internal freelists. That makes the hash table code a lot simpler > > > overall, but some of that simplicity would be lost trying to support > > > lazy hash table rehashing. > > > > While looking into this I discovered unlikely bugs in Emacs's hash table code > > and GC that can make Emacs dump core, along with some other unlikely hash-table > > bugs that can cause Emacs to report memory exhaustion when there should be > > plenty of memory. I installed the attached patches to fix these problems and to > > refactor to make this code easier to understand (at least for me :-). These > > patches will probably affect performance analysis. > > Well, at least they'll require rebasing, particularly of the > no-internal-freelists patch :-) Rebased patches attached. The performance measurements don't seem to change significantly. > While your changes are extensive, I don't see anything in there that > would drastically affect performance or memory footprint. Maybe I'm > missing something, though. --000000000000acad5b058e2b21f8 Content-Type: text/x-patch; charset="US-ASCII"; name="0001-Rehash-hash-tables-eagerly-after-loading-a-dump.patch" Content-Disposition: attachment; filename="0001-Rehash-hash-tables-eagerly-after-loading-a-dump.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_jycl1g8s0 RnJvbSBiODM5ZDA5OTNmNGRmNjY2YmE3ODBmYjMzOGQyYWMxODAwNTk5MTE0IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBQaXAgQ2V0IDxwaXBjZXRAZ21haWwuY29tPgpEYXRlOiBTdW4s IDIxIEp1bCAyMDE5IDA2OjA1OjU0ICswMDAwClN1YmplY3Q6IFtQQVRDSF0gUmVoYXNoIGhhc2gg dGFibGVzIGVhZ2VybHkgYWZ0ZXIgbG9hZGluZyBhIGR1bXAKCiogc3JjL2xpc3AuaCAoaGFzaF9y ZWhhc2hfbmVlZGVkX3ApOiBSZW1vdmUuICBBbGwgdXNlcyByZW1vdmVkLgooaGFzaF9yZWhhc2hf aWZfbmVlZGVkKTogUmVtb3ZlLiAgQWxsIHVzZXMgcmVtb3ZlZC4KKHN0cnVjdCBMaXNwX0hhc2hf VGFibGUpOiBSZW1vdmUgY29tbWVudCBhYm91dCByZWhhc2hpbmcgaGFzaCB0YWJsZXMuCiogc3Jj L3BkdW1wZXIuYyAodGhhd19oYXNoX3RhYmxlcyk6IE5ldyBmdW5jdGlvbi4KKGhhc2hfdGFibGVf dGhhdyk6IE5ldyBmdW5jdGlvbi4KKGhhc2hfdGFibGVfZnJlZXplKTogTmV3IGZ1bmN0aW9uLgoo ZHVtcF9oYXNoX3RhYmxlKTogU2ltcGxpZnkuCihkdW1wX2hhc2hfdGFibGVfbGlzdCk6IE5ldyBm dW5jdGlvbi4KKGhhc2hfdGFibGVfY29udGVudHMpOiBOZXcgZnVuY3Rpb24uCihGZHVtcF9lbWFj c19wb3J0YWJsZSk6IEhhbmRsZSBoYXNoIHRhYmxlcyBieSBlYWdlciByZWhhc2hpbmcuCihwZHVt cGVyX2xvYWQpOiBSZXN0b3JlIGhhc2ggdGFibGVzLgooaW5pdF9wZHVtcGVyX29uY2UpOiBOZXcg ZnVuY3Rpb24uCi0tLQogc3JjL2J5dGVjb2RlLmMgIHwgICAxIC0KIHNyYy9jb21wb3NpdGUuYyB8 ICAgMSAtCiBzcmMvZW1hY3MuYyAgICAgfCAgIDEgKwogc3JjL2Zucy5jICAgICAgIHwgIDY1ICsr KysrLS0tLS0tLS0tLS0tCiBzcmMvbGlzcC5oICAgICAgfCAgMTkgKy0tLS0KIHNyYy9taW5pYnVm LmMgICB8ICAgMyAtCiBzcmMvcGR1bXBlci5jICAgfCAxODMgKysrKysrKysrKysrKysrKysrKysr Ky0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiBzcmMvcGR1bXBlci5oICAgfCAgIDEgKwogOCBm aWxlcyBjaGFuZ2VkLCAxMDQgaW5zZXJ0aW9ucygrKSwgMTcwIGRlbGV0aW9ucygtKQoKZGlmZiAt LWdpdCBhL3NyYy9ieXRlY29kZS5jIGIvc3JjL2J5dGVjb2RlLmMKaW5kZXggZDY2OGE5YTZhMS4u NDg1YTQ0OGIwNiAxMDA2NDQKLS0tIGEvc3JjL2J5dGVjb2RlLmMKKysrIGIvc3JjL2J5dGVjb2Rl LmMKQEAgLTE0MDIsNyArMTQwMiw2IEBAICNkZWZpbmUgREVGSU5FKG5hbWUsIHZhbHVlKSBMQUJF TCAobmFtZSkgLAogICAgICAgICAgICAgTGlzcF9PYmplY3QgdjEgPSBQT1A7CiAgICAgICAgICAg ICBwdHJkaWZmX3QgaTsKICAgICAgICAgICAgIHN0cnVjdCBMaXNwX0hhc2hfVGFibGUgKmggPSBY SEFTSF9UQUJMRSAoam1wX3RhYmxlKTsKLSAgICAgICAgICAgIGhhc2hfcmVoYXNoX2lmX25lZWRl ZCAoaCk7CiAKICAgICAgICAgICAgIC8qIGgtPmNvdW50IGlzIGEgZmFzdGVyIGFwcHJveGltYXRp b24gZm9yIEhBU0hfVEFCTEVfU0laRSAoaCkKICAgICAgICAgICAgICAgIGhlcmUuICovCmRpZmYg LS1naXQgYS9zcmMvY29tcG9zaXRlLmMgYi9zcmMvY29tcG9zaXRlLmMKaW5kZXggYTY2MDZkNWZj NC4uNWI1OTgxOGQwOSAxMDA2NDQKLS0tIGEvc3JjL2NvbXBvc2l0ZS5jCisrKyBiL3NyYy9jb21w b3NpdGUuYwpAQCAtNjUzLDcgKzY1Myw2IEBAIGdzdHJpbmdfbG9va3VwX2NhY2hlIChMaXNwX09i amVjdCBoZWFkZXIpCiBjb21wb3NpdGlvbl9nc3RyaW5nX3B1dF9jYWNoZSAoTGlzcF9PYmplY3Qg Z3N0cmluZywgcHRyZGlmZl90IGxlbikKIHsKICAgc3RydWN0IExpc3BfSGFzaF9UYWJsZSAqaCA9 IFhIQVNIX1RBQkxFIChnc3RyaW5nX2hhc2hfdGFibGUpOwotICBoYXNoX3JlaGFzaF9pZl9uZWVk ZWQgKGgpOwogICBMaXNwX09iamVjdCBoZWFkZXIgPSBMR1NUUklOR19IRUFERVIgKGdzdHJpbmcp OwogICBMaXNwX09iamVjdCBoYXNoID0gaC0+dGVzdC5oYXNoZm4gKGhlYWRlciwgaCk7CiAgIGlm IChsZW4gPCAwKQpkaWZmIC0tZ2l0IGEvc3JjL2VtYWNzLmMgYi9zcmMvZW1hY3MuYwppbmRleCBh ZDY2MWEwODFiLi44NTViMmM2NzE1IDEwMDY0NAotLS0gYS9zcmMvZW1hY3MuYworKysgYi9zcmMv ZW1hY3MuYwpAQCAtMTU2MCw2ICsxNTYwLDcgQEAgbWFpbiAoaW50IGFyZ2MsIGNoYXIgKiphcmd2 KQogICBpZiAoIWluaXRpYWxpemVkKQogICAgIHsKICAgICAgIGluaXRfYWxsb2Nfb25jZSAoKTsK KyAgICAgIGluaXRfcGR1bXBlcl9vbmNlICgpOwogICAgICAgaW5pdF9vYmFycmF5X29uY2UgKCk7 CiAgICAgICBpbml0X2V2YWxfb25jZSAoKTsKICAgICAgIGluaXRfY2hhcnNldF9vbmNlICgpOwpk aWZmIC0tZ2l0IGEvc3JjL2Zucy5jIGIvc3JjL2Zucy5jCmluZGV4IGQ3ZTEyMzEyMmQuLjA2YzAw NmQ3NDcgMTAwNjQ0Ci0tLSBhL3NyYy9mbnMuYworKysgYi9zcmMvZm5zLmMKQEAgLTQyMjMsNTEg KzQyMjMsMjcgQEAgbWF5YmVfcmVzaXplX2hhc2hfdGFibGUgKHN0cnVjdCBMaXNwX0hhc2hfVGFi bGUgKmgpCiAKIC8qIFJlY29tcHV0ZSB0aGUgaGFzaGVzIChhbmQgaGVuY2UgYWxzbyB0aGUgIm5l eHQiIHBvaW50ZXJzKS4KICAgIE5vcm1hbGx5IHRoZXJlJ3MgbmV2ZXIgYSBuZWVkIHRvIHJlY29t cHV0ZSBoYXNoZXMuCi0gICBUaGlzIGlzIGRvbmUgb25seSBvbiBmaXJzdC1hY2Nlc3MgdG8gYSBo YXNoLXRhYmxlIGxvYWRlZCBmcm9tCi0gICB0aGUgInBkdW1wIiwgYmVjYXVzZSB0aGUgb2JqZWN0 J3MgYWRkcmVzc2VzIG1heSBoYXZlIGNoYW5nZWQsIHRodXMKKyAgIFRoaXMgaXMgZG9uZSBvbmx5 IG9uIGZpcnN0IGFjY2VzcyB0byBhIGhhc2gtdGFibGUgbG9hZGVkIGZyb20KKyAgIHRoZSAicGR1 bXAiLCBiZWNhdXNlIHRoZSBvYmplY3RzJyBhZGRyZXNzZXMgbWF5IGhhdmUgY2hhbmdlZCwgdGh1 cwogICAgYWZmZWN0aW5nIHRoZWlyIGhhc2guICAqLwogdm9pZAogaGFzaF90YWJsZV9yZWhhc2gg KHN0cnVjdCBMaXNwX0hhc2hfVGFibGUgKmgpCiB7Ci0gIHB0cmRpZmZfdCBzaXplID0gSEFTSF9U QUJMRV9TSVpFIChoKTsKLQotICAvKiBUaGVzZSBzdHJ1Y3R1cmVzIG1heSBoYXZlIGJlZW4gcHVy ZWNvcGllZCBhbmQgc2hhcmVkCi0gICAgIChidWcjMzY0NDcpLiAgKi8KLSAgaC0+bmV4dCA9IEZj b3B5X3NlcXVlbmNlIChoLT5uZXh0KTsKLSAgaC0+aW5kZXggPSBGY29weV9zZXF1ZW5jZSAoaC0+ aW5kZXgpOwotICBoLT5oYXNoID0gRmNvcHlfc2VxdWVuY2UgKGgtPmhhc2gpOwotCiAgIC8qIFJl Y29tcHV0ZSB0aGUgYWN0dWFsIGhhc2ggY29kZXMgZm9yIGVhY2ggZW50cnkgaW4gdGhlIHRhYmxl LgogICAgICBPcmRlciBpcyBzdGlsbCBpbnZhbGlkLiAgKi8KLSAgZm9yIChwdHJkaWZmX3QgaSA9 IDA7IGkgPCBzaXplOyArK2kpCi0gICAgaWYgKCFOSUxQIChIQVNIX0hBU0ggKGgsIGkpKSkKLSAg ICAgIHsKLSAgICAgICAgTGlzcF9PYmplY3Qga2V5ID0gSEFTSF9LRVkgKGgsIGkpOwotCUxpc3Bf T2JqZWN0IGhhc2hfY29kZSA9IGgtPnRlc3QuaGFzaGZuIChrZXksIGgpOwotCXNldF9oYXNoX2hh c2hfc2xvdCAoaCwgaSwgaGFzaF9jb2RlKTsKLSAgICAgIH0KLQotICAvKiBSZXNldCB0aGUgaW5k ZXggc28gdGhhdCBhbnkgc2xvdCB3ZSBkb24ndCBmaWxsIGJlbG93IGlzIG1hcmtlZAotICAgICBp bnZhbGlkLiAgKi8KLSAgRmZpbGxhcnJheSAoaC0+aW5kZXgsIG1ha2VfZml4bnVtICgtMSkpOwot Ci0gIC8qIFJlYnVpbGQgdGhlIGNvbGxpc2lvbiBjaGFpbnMuICAqLwotICBmb3IgKHB0cmRpZmZf dCBpID0gMDsgaSA8IHNpemU7ICsraSkKLSAgICBpZiAoIU5JTFAgKEhBU0hfSEFTSCAoaCwgaSkp KQotICAgICAgewotICAgICAgICBFTUFDU19VSU5UIGhhc2hfY29kZSA9IFhVRklYTlVNIChIQVNI X0hBU0ggKGgsIGkpKTsKLSAgICAgICAgcHRyZGlmZl90IHN0YXJ0X29mX2J1Y2tldCA9IGhhc2hf Y29kZSAlIEFTSVpFIChoLT5pbmRleCk7Ci0gICAgICAgIHNldF9oYXNoX25leHRfc2xvdCAoaCwg aSwgSEFTSF9JTkRFWCAoaCwgc3RhcnRfb2ZfYnVja2V0KSk7Ci0gICAgICAgIHNldF9oYXNoX2lu ZGV4X3Nsb3QgKGgsIHN0YXJ0X29mX2J1Y2tldCwgaSk7Ci0gICAgICAgIGVhc3NlcnQgKEhBU0hf TkVYVCAoaCwgaSkgIT0gaSk7IC8qIFN0b3AgbG9vcHMuICAqLwotICAgICAgfQorICBmb3IgKHB0 cmRpZmZfdCBpID0gMDsgaSA8IGgtPmNvdW50OyArK2kpCisgICAgeworICAgICAgTGlzcF9PYmpl Y3Qga2V5ID0gSEFTSF9LRVkgKGgsIGkpOworICAgICAgTGlzcF9PYmplY3QgaGFzaF9jb2RlID0g aC0+dGVzdC5oYXNoZm4gKGtleSwgaCk7CisgICAgICBwdHJkaWZmX3Qgc3RhcnRfb2ZfYnVja2V0 ID0gWFVGSVhOVU0gKGhhc2hfY29kZSkgJSBBU0laRSAoaC0+aW5kZXgpOworICAgICAgc2V0X2hh c2hfaGFzaF9zbG90IChoLCBpLCBoYXNoX2NvZGUpOworICAgICAgc2V0X2hhc2hfbmV4dF9zbG90 IChoLCBpLCBIQVNIX0lOREVYIChoLCBzdGFydF9vZl9idWNrZXQpKTsKKyAgICAgIHNldF9oYXNo X2luZGV4X3Nsb3QgKGgsIHN0YXJ0X29mX2J1Y2tldCwgaSk7CisgICAgICBlYXNzZXJ0IChIQVNI X05FWFQgKGgsIGkpICE9IGkpOyAvKiBTdG9wIGxvb3BzLiAgKi8KKyAgICB9CiAKLSAgLyogRmlu YWxseSwgbWFyayB0aGUgaGFzaCB0YWJsZSBhcyBoYXZpbmcgYSB2YWxpZCBoYXNoIG9yZGVyLgot ICAgICBEbyB0aGlzIGxhc3Qgc28gdGhhdCBpZiB3ZSdyZSBpbnRlcnJ1cHRlZCwgd2UgcmV0cnkg b24gbmV4dAotICAgICBhY2Nlc3MuICovCi0gIGVhc3NlcnQgKGgtPmNvdW50IDwgMCk7Ci0gIGgt PmNvdW50ID0gLWgtPmNvdW50OwotICBlYXNzZXJ0ICghaGFzaF9yZWhhc2hfbmVlZGVkX3AgKGgp KTsKKyAgZm9yIChwdHJkaWZmX3QgaSA9IGgtPmNvdW50OyBpIDwgQVNJWkUgKGgtPm5leHQpIC0g MTsgaSsrKQorICAgIHNldF9oYXNoX25leHRfc2xvdCAoaCwgaSwgaSArIDEpOwogfQogCiAvKiBM b29rdXAgS0VZIGluIGhhc2ggdGFibGUgSC4gIElmIEhBU0ggaXMgbm9uLW51bGwsIHJldHVybiBp biAqSEFTSApAQCAtNDI3OSw4ICs0MjU1LDYgQEAgaGFzaF9sb29rdXAgKHN0cnVjdCBMaXNwX0hh c2hfVGFibGUgKmgsIExpc3BfT2JqZWN0IGtleSwgTGlzcF9PYmplY3QgKmhhc2gpCiB7CiAgIHB0 cmRpZmZfdCBzdGFydF9vZl9idWNrZXQsIGk7CiAKLSAgaGFzaF9yZWhhc2hfaWZfbmVlZGVkICho KTsKLQogICBMaXNwX09iamVjdCBoYXNoX2NvZGUgPSBoLT50ZXN0Lmhhc2hmbiAoa2V5LCBoKTsK ICAgaWYgKGhhc2gpCiAgICAgKmhhc2ggPSBoYXNoX2NvZGU7CkBAIC00MzE1LDggKzQyODksNiBA QCBoYXNoX3B1dCAoc3RydWN0IExpc3BfSGFzaF9UYWJsZSAqaCwgTGlzcF9PYmplY3Qga2V5LCBM aXNwX09iamVjdCB2YWx1ZSwKIHsKICAgcHRyZGlmZl90IHN0YXJ0X29mX2J1Y2tldCwgaTsKIAot ICBoYXNoX3JlaGFzaF9pZl9uZWVkZWQgKGgpOwotCiAgIC8qIEluY3JlbWVudCBjb3VudCBhZnRl ciByZXNpemluZyBiZWNhdXNlIHJlc2l6aW5nIG1heSBmYWlsLiAgKi8KICAgbWF5YmVfcmVzaXpl X2hhc2hfdGFibGUgKGgpOwogICBoLT5jb3VudCsrOwpAQCAtNDM0Nyw4ICs0MzE5LDYgQEAgaGFz aF9yZW1vdmVfZnJvbV90YWJsZSAoc3RydWN0IExpc3BfSGFzaF9UYWJsZSAqaCwgTGlzcF9PYmpl Y3Qga2V5KQogICBwdHJkaWZmX3Qgc3RhcnRfb2ZfYnVja2V0ID0gWFVGSVhOVU0gKGhhc2hfY29k ZSkgJSBBU0laRSAoaC0+aW5kZXgpOwogICBwdHJkaWZmX3QgcHJldiA9IC0xOwogCi0gIGhhc2hf cmVoYXNoX2lmX25lZWRlZCAoaCk7Ci0KICAgZm9yIChwdHJkaWZmX3QgaSA9IEhBU0hfSU5ERVgg KGgsIHN0YXJ0X29mX2J1Y2tldCk7CiAgICAgICAgMCA8PSBpOwogICAgICAgIGkgPSBIQVNIX05F WFQgKGgsIGkpKQpAQCAtNDQyNiw5ICs0Mzk2LDcgQEAgc3dlZXBfd2Vha190YWJsZSAoc3RydWN0 IExpc3BfSGFzaF9UYWJsZSAqaCwgYm9vbCByZW1vdmVfZW50cmllc19wKQogICBmb3IgKHB0cmRp ZmZfdCBidWNrZXQgPSAwOyBidWNrZXQgPCBuOyArK2J1Y2tldCkKICAgICB7CiAgICAgICAvKiBG b2xsb3cgY29sbGlzaW9uIGNoYWluLCByZW1vdmluZyBlbnRyaWVzIHRoYXQgZG9uJ3Qgc3Vydml2 ZQotICAgICAgICAgdGhpcyBnYXJiYWdlIGNvbGxlY3Rpb24uICBJdCdzIG9rYXkgaWYgaGFzaF9y ZWhhc2hfbmVlZGVkX3AKLSAgICAgICAgIChoKSBpcyB0cnVlLCBzaW5jZSB3ZSdyZSBvcGVyYXRp bmcgZW50aXJlbHkgb24gdGhlIGNhY2hlZAotICAgICAgICAgaGFzaCB2YWx1ZXMuICovCisgICAg ICAgICB0aGlzIGdhcmJhZ2UgY29sbGVjdGlvbi4gICovCiAgICAgICBwdHJkaWZmX3QgcHJldiA9 IC0xOwogICAgICAgcHRyZGlmZl90IG5leHQ7CiAgICAgICBmb3IgKHB0cmRpZmZfdCBpID0gSEFT SF9JTkRFWCAoaCwgYnVja2V0KTsgMCA8PSBpOyBpID0gbmV4dCkKQEAgLTQ0NzAsNyArNDQzOCw3 IEBAIHN3ZWVwX3dlYWtfdGFibGUgKHN0cnVjdCBMaXNwX0hhc2hfVGFibGUgKmgsIGJvb2wgcmVt b3ZlX2VudHJpZXNfcCkKICAgICAgICAgICAgICAgICAgIHNldF9oYXNoX2hhc2hfc2xvdCAoaCwg aSwgUW5pbCk7CiAKICAgICAgICAgICAgICAgICAgIGVhc3NlcnQgKGgtPmNvdW50ICE9IDApOwot ICAgICAgICAgICAgICAgICAgaC0+Y291bnQgKz0gaC0+Y291bnQgPiAwID8gLTEgOiAxOworICAg ICAgICAgICAgICAgICAgaC0+Y291bnQtLTsKICAgICAgICAgICAgICAgICB9CiAJICAgICAgZWxz ZQogCQl7CkBAIC00ODczLDcgKzQ4NDEsNiBAQCBERUZVTiAoImhhc2gtdGFibGUtY291bnQiLCBG aGFzaF90YWJsZV9jb3VudCwgU2hhc2hfdGFibGVfY291bnQsIDEsIDEsIDAsCiAgIChMaXNwX09i amVjdCB0YWJsZSkKIHsKICAgc3RydWN0IExpc3BfSGFzaF9UYWJsZSAqaCA9IGNoZWNrX2hhc2hf dGFibGUgKHRhYmxlKTsKLSAgaGFzaF9yZWhhc2hfaWZfbmVlZGVkIChoKTsKICAgcmV0dXJuIG1h a2VfZml4bnVtIChoLT5jb3VudCk7CiB9CiAKZGlmZiAtLWdpdCBhL3NyYy9saXNwLmggYi9zcmMv bGlzcC5oCmluZGV4IDZkMTAxZmVkOTAuLmVlMTFkZjdlMzQgMTAwNjQ0Ci0tLSBhL3NyYy9saXNw LmgKKysrIGIvc3JjL2xpc3AuaApAQCAtMjI0NywxMSArMjI0Nyw3IEBAICNkZWZpbmUgREVGU1lN KHN5bSwgbmFtZSkgLyogZW1wdHkgKi8KIAogc3RydWN0IExpc3BfSGFzaF9UYWJsZQogewotICAv KiBDaGFuZ2UgcGR1bXBlci5jIGlmIHlvdSBjaGFuZ2UgdGhlIGZpZWxkcyBoZXJlLgotCi0gICAg IElNUE9SVEFOVCEhISEhISEKLQotICAgICBDYWxsIGhhc2hfcmVoYXNoX2lmX25lZWRlZCgpIGJl Zm9yZSBhY2Nlc3NpbmcuICAqLworICAvKiBDaGFuZ2UgcGR1bXBlci5jIGlmIHlvdSBjaGFuZ2Ug dGhlIGZpZWxkcyBoZXJlLiAgKi8KIAogICAvKiBUaGlzIGlzIGZvciBMaXNwOyB0aGUgaGFzaCB0 YWJsZSBjb2RlIGRvZXMgbm90IHJlZmVyIHRvIGl0LiAgKi8KICAgdW5pb24gdmVjdG9ybGlrZV9o ZWFkZXIgaGVhZGVyOwpAQCAtMjM3MCwxOSArMjM2Niw2IEBAIEhBU0hfVEFCTEVfU0laRSAoY29u c3Qgc3RydWN0IExpc3BfSGFzaF9UYWJsZSAqaCkKIAogdm9pZCBoYXNoX3RhYmxlX3JlaGFzaCAo c3RydWN0IExpc3BfSGFzaF9UYWJsZSAqaCk7CiAKLUlOTElORSBib29sCi1oYXNoX3JlaGFzaF9u ZWVkZWRfcCAoY29uc3Qgc3RydWN0IExpc3BfSGFzaF9UYWJsZSAqaCkKLXsKLSAgcmV0dXJuIGgt PmNvdW50IDwgMDsKLX0KLQotSU5MSU5FIHZvaWQKLWhhc2hfcmVoYXNoX2lmX25lZWRlZCAoc3Ry dWN0IExpc3BfSGFzaF9UYWJsZSAqaCkKLXsKLSAgaWYgKGhhc2hfcmVoYXNoX25lZWRlZF9wICho KSkKLSAgICBoYXNoX3RhYmxlX3JlaGFzaCAoaCk7Ci19Ci0KIC8qIERlZmF1bHQgc2l6ZSBmb3Ig aGFzaCB0YWJsZXMgaWYgbm90IHNwZWNpZmllZC4gICovCiAKIGVudW0gREVGQVVMVF9IQVNIX1NJ WkUgeyBERUZBVUxUX0hBU0hfU0laRSA9IDY1IH07CmRpZmYgLS1naXQgYS9zcmMvbWluaWJ1Zi5j IGIvc3JjL21pbmlidWYuYwppbmRleCBkOWE2ZTE1YjA1Li5lOTIzY2UyYTQzIDEwMDY0NAotLS0g YS9zcmMvbWluaWJ1Zi5jCisrKyBiL3NyYy9taW5pYnVmLmMKQEAgLTEyMDMsOSArMTIwMyw2IEBA IERFRlVOICgidHJ5LWNvbXBsZXRpb24iLCBGdHJ5X2NvbXBsZXRpb24sIFN0cnlfY29tcGxldGlv biwgMiwgMywgMCwKICAgICAgIGJ1Y2tldCA9IEFSRUYgKGNvbGxlY3Rpb24sIGlkeCk7CiAgICAg fQogCi0gIGlmIChIQVNIX1RBQkxFX1AgKGNvbGxlY3Rpb24pKQotICAgIGhhc2hfcmVoYXNoX2lm X25lZWRlZCAoWEhBU0hfVEFCTEUgKGNvbGxlY3Rpb24pKTsKLQogICB3aGlsZSAoMSkKICAgICB7 CiAgICAgICAvKiBHZXQgdGhlIG5leHQgZWxlbWVudCBvZiB0aGUgYWxpc3QsIG9iYXJyYXksIG9y IGhhc2gtdGFibGUuICAqLwpkaWZmIC0tZ2l0IGEvc3JjL3BkdW1wZXIuYyBiL3NyYy9wZHVtcGVy LmMKaW5kZXggMmFiYWM4MGEzNy4uMjliMWFkY2JhNiAxMDA2NDQKLS0tIGEvc3JjL3BkdW1wZXIu YworKysgYi9zcmMvcGR1bXBlci5jCkBAIC0xMDcsMTcgKzEwNyw2IEBAICNkZWZpbmUgVk1fTVNf V0lORE9XUyAyCiAKICNkZWZpbmUgREFOR0VST1VTIDAKIAotLyogUERVTVBFUl9DSEVDS19SRUhB U0hJTkcgYmVpbmcgdHJ1ZSBjYXVzZXMgdGhlIHBvcnRhYmxlIGR1bXBlciB0bwotICAgY2hlY2ss IGZvciBlYWNoIGhhc2ggdGFibGUgaXQgZHVtcHMsIHRoYXQgdGhlIGhhc2ggdGFibGUgbWVhbnMg dGhlCi0gICBzYW1lIHRoaW5nIGFmdGVyIHJlaGFzaGluZy4gICovCi0jaWZuZGVmIFBEVU1QRVJf Q0hFQ0tfUkVIQVNISU5HCi0jIGlmIEVOQUJMRV9DSEVDS0lORwotIyAgZGVmaW5lIFBEVU1QRVJf Q0hFQ0tfUkVIQVNISU5HIDEKLSMgZWxzZQotIyAgZGVmaW5lIFBEVU1QRVJfQ0hFQ0tfUkVIQVNI SU5HIDAKLSMgZW5kaWYKLSNlbmRpZgotCiAvKiBXZSByZXF1aXJlIGFuIGFyY2hpdGVjdHVyZSBp biB3aGljaCBhbGwgcG9pbnRlcnMgYXJlIHRoZSBzYW1lIHNpemUKICAgIGFuZCBoYXZlIHRoZSBz YW1lIGxheW91dCwgd2hlcmUgcG9pbnRlcnMgYXJlIGVpdGhlciAzMiBvciA2NCBiaXRzCiAgICBs b25nLCBhbmQgd2hlcmUgYnl0ZXMgaGF2ZSBlaWdodCBiaXRzIC0tLSB0aGF0IGlzLCBhCkBAIC0z OTMsNiArMzgyLDggQEAgZHVtcF9maW5nZXJwcmludCAoY2hhciBjb25zdCAqbGFiZWwsCiAgICAg IFRoZSBzdGFydCBvZiB0aGUgY29sZCByZWdpb24gaXMgYWx3YXlzIGFsaWduZWQgb24gYSBwYWdl CiAgICAgIGJvdW5kYXJ5LiAgKi8KICAgZHVtcF9vZmYgY29sZF9zdGFydDsKKworICBkdW1wX29m ZiBoYXNoX2xpc3Q7CiB9OwogCiAvKiBEb3VibGUtZW5kZWQgc2luZ2x5IGxpbmtlZCBsaXN0LiAg Ki8KQEAgLTU1MCw2ICs1NDEsOCBAQCBkdW1wX2ZpbmdlcnByaW50IChjaGFyIGNvbnN0ICpsYWJl bCwKICAgICAgaGVhcCBvYmplY3RzLiAgKi8KICAgTGlzcF9PYmplY3QgYmlnbnVtX2RhdGE7CiAK KyAgTGlzcF9PYmplY3QgaGFzaF90YWJsZXM7CisKICAgdW5zaWduZWQgbnVtYmVyX2hvdF9yZWxv Y2F0aW9uczsKICAgdW5zaWduZWQgbnVtYmVyX2Rpc2NhcmRhYmxlX3JlbG9jYXRpb25zOwogfTsK QEAgLTI2MjIsNjggKzI2MTUsNTggQEAgZHVtcF92ZWN0b3JsaWtlX2dlbmVyaWMgKHN0cnVjdCBk dW1wX2NvbnRleHQgKmN0eCwKICAgcmV0dXJuIG9mZnNldDsKIH0KIAotLyogRGV0ZXJtaW5lIHdo ZXRoZXIgdGhlIGhhc2ggdGFibGUncyBoYXNoIG9yZGVyIGlzIHN0YWJsZQotICAgYWNyb3NzIGR1 bXAgYW5kIGxvYWQuICBJZiBpdCBpcywgd2UgZG9uJ3QgaGF2ZSB0byB0cmlnZ2VyCi0gICBhIHJl aGFzaCBvbiBhY2Nlc3MuICAqLwotc3RhdGljIGJvb2wKLWR1bXBfaGFzaF90YWJsZV9zdGFibGVf cCAoY29uc3Qgc3RydWN0IExpc3BfSGFzaF9UYWJsZSAqaGFzaCkKKy8qIFJldHVybiBhIHZlY3Rv ciBvZiBLRVksIFZBTFVFIHBhaXJzIGluIHRoZSBnaXZlbiBoYXNoIHRhYmxlIEguICBUaGUKKyAg IGZpcnN0IEgtPmNvdW50IHBhaXJzIGFyZSB2YWxpZCwgdGhlIHJlc3QgaXMgbGVmdCBhcyBuaWwu ICAqLworc3RhdGljIExpc3BfT2JqZWN0CitoYXNoX3RhYmxlX2NvbnRlbnRzIChzdHJ1Y3QgTGlz cF9IYXNoX1RhYmxlICpoKQogewotICBib29sIGlzX2VxbCA9IGhhc2gtPnRlc3QuaGFzaGZuID09 IGhhc2hmbl9lcWw7Ci0gIGJvb2wgaXNfZXF1YWwgPSBoYXNoLT50ZXN0Lmhhc2hmbiA9PSBoYXNo Zm5fZXF1YWw7Ci0gIHB0cmRpZmZfdCBzaXplID0gSEFTSF9UQUJMRV9TSVpFIChoYXNoKTsKLSAg Zm9yIChwdHJkaWZmX3QgaSA9IDA7IGkgPCBzaXplOyArK2kpCi0gICAgaWYgKCFOSUxQIChIQVNI X0hBU0ggKGhhc2gsIGkpKSkKKyAgTGlzcF9PYmplY3QgY29udGVudHMgPSBRbmlsOworICAvKiBN YWtlIHN1cmUga2V5X2FuZF92YWx1ZSBlbmRzIHVwIGluIHRoZSBzYW1lIG9yZGVyLCBjaGFyc2V0 LmMKKyAgICAgcmVsaWVzIG9uIGl0IGJ5IGV4cGVjdGluZyBoYXNoIHRhYmxlIGluZGljZXMgdG8g c3RheSBjb25zdGFudAorICAgICBhY3Jvc3MgdGhlIGR1bXAuICAqLworICBmb3IgKHB0cmRpZmZf dCBpID0gMDsgaSA8IEhBU0hfVEFCTEVfU0laRSAoaCkgLSBoLT5jb3VudDsgaSsrKQorICAgIHsK KyAgICAgIGR1bXBfcHVzaCAoJmNvbnRlbnRzLCBRbmlsKTsKKyAgICAgIGR1bXBfcHVzaCAoJmNv bnRlbnRzLCBRbmlsKTsKKyAgICB9CisKKyAgZm9yIChwdHJkaWZmX3QgaSA9IEhBU0hfVEFCTEVf U0laRSAoaCkgLSAxOyBpID49IDA7IC0taSkKKyAgICBpZiAoIU5JTFAgKEhBU0hfSEFTSCAoaCwg aSkpKQogICAgICAgewotICAgICAgICBMaXNwX09iamVjdCBrZXkgPSAgSEFTSF9LRVkgKGhhc2gs IGkpOwotCWJvb2wga2V5X3N0YWJsZSA9IChkdW1wX2J1aWx0aW5fc3ltYm9sX3AgKGtleSkKLQkJ CSAgIHx8IEZJWE5VTVAgKGtleSkKLQkJCSAgIHx8IChpc19lcXVhbCAmJiBTVFJJTkdQIChrZXkp KQotCQkJICAgfHwgKChpc19lcXVhbCB8fCBpc19lcWwpICYmIEZMT0FUUCAoa2V5KSkpOwotICAg ICAgICBpZiAoIWtleV9zdGFibGUpCi0gICAgICAgICAgcmV0dXJuIGZhbHNlOworCWR1bXBfcHVz aCAoJmNvbnRlbnRzLCBIQVNIX1ZBTFVFIChoLCBpKSk7CisJZHVtcF9wdXNoICgmY29udGVudHMs IEhBU0hfS0VZIChoLCBpKSk7CiAgICAgICB9CiAKLSAgcmV0dXJuIHRydWU7CisgIHJldHVybiBD QUxMTiAoRmFwcGx5LCBRdmVjdG9yLCBjb250ZW50cyk7CiB9CiAKLS8qIFJldHVybiBhIGxpc3Qg b2YgKEtFWSAuIFZBTFVFKSBwYWlycyBpbiB0aGUgZ2l2ZW4gaGFzaCB0YWJsZS4gICovCi1zdGF0 aWMgTGlzcF9PYmplY3QKLWhhc2hfdGFibGVfY29udGVudHMgKExpc3BfT2JqZWN0IHRhYmxlKQor c3RhdGljIGR1bXBfb2ZmCitkdW1wX2hhc2hfdGFibGVfbGlzdCAoc3RydWN0IGR1bXBfY29udGV4 dCAqY3R4KQogewotICBMaXNwX09iamVjdCBjb250ZW50cyA9IFFuaWw7Ci0gIHN0cnVjdCBMaXNw X0hhc2hfVGFibGUgKmggPSBYSEFTSF9UQUJMRSAodGFibGUpOwotICBmb3IgKHB0cmRpZmZfdCBp ID0gMDsgaSA8IEhBU0hfVEFCTEVfU0laRSAoaCk7ICsraSkKLSAgICBpZiAoIU5JTFAgKEhBU0hf SEFTSCAoaCwgaSkpKQotICAgICAgZHVtcF9wdXNoICgmY29udGVudHMsIEZjb25zIChIQVNIX0tF WSAoaCwgaSksIEhBU0hfVkFMVUUgKGgsIGkpKSk7Ci0gIHJldHVybiBGbnJldmVyc2UgKGNvbnRl bnRzKTsKKyAgaWYgKENPTlNQIChjdHgtPmhhc2hfdGFibGVzKSkKKyAgICByZXR1cm4gZHVtcF9v YmplY3QgKGN0eCwgQ0FMTE4gKEZhcHBseSwgUXZlY3RvciwgY3R4LT5oYXNoX3RhYmxlcykpOwor ICBlbHNlCisgICAgcmV0dXJuIDA7CiB9CiAKLS8qIENvcHkgdGhlIGdpdmVuIGhhc2ggdGFibGUs IHJlaGFzaCBpdCwgYW5kIG1ha2Ugc3VyZSB0aGF0IHdlIGNhbgotICAgbG9vayB1cCBhbGwgdGhl IHZhbHVlcyBpbiB0aGUgb3JpZ2luYWwuICAqLwogc3RhdGljIHZvaWQKLWNoZWNrX2hhc2hfdGFi bGVfcmVoYXNoIChMaXNwX09iamVjdCB0YWJsZV9vcmlnKQotewotICBoYXNoX3JlaGFzaF9pZl9u ZWVkZWQgKFhIQVNIX1RBQkxFICh0YWJsZV9vcmlnKSk7Ci0gIExpc3BfT2JqZWN0IHRhYmxlX3Jl aGFzaGVkID0gRmNvcHlfaGFzaF90YWJsZSAodGFibGVfb3JpZyk7Ci0gIGVhc3NlcnQgKFhIQVNI X1RBQkxFICh0YWJsZV9yZWhhc2hlZCktPmNvdW50ID49IDApOwotICBYSEFTSF9UQUJMRSAodGFi bGVfcmVoYXNoZWQpLT5jb3VudCAqPSAtMTsKLSAgZWFzc2VydCAoWEhBU0hfVEFCTEUgKHRhYmxl X3JlaGFzaGVkKS0+Y291bnQgPD0gMCk7Ci0gIGhhc2hfcmVoYXNoX2lmX25lZWRlZCAoWEhBU0hf VEFCTEUgKHRhYmxlX3JlaGFzaGVkKSk7Ci0gIGVhc3NlcnQgKFhIQVNIX1RBQkxFICh0YWJsZV9y ZWhhc2hlZCktPmNvdW50ID49IDApOwotICBMaXNwX09iamVjdCBleHBlY3RlZF9jb250ZW50cyA9 IGhhc2hfdGFibGVfY29udGVudHMgKHRhYmxlX29yaWcpOwotICB3aGlsZSAoIU5JTFAgKGV4cGVj dGVkX2NvbnRlbnRzKSkKLSAgICB7Ci0gICAgICBMaXNwX09iamVjdCBrZXlfdmFsdWVfcGFpciA9 IGR1bXBfcG9wICgmZXhwZWN0ZWRfY29udGVudHMpOwotICAgICAgTGlzcF9PYmplY3Qga2V5ID0g WENBUiAoa2V5X3ZhbHVlX3BhaXIpOwotICAgICAgTGlzcF9PYmplY3QgZXhwZWN0ZWRfdmFsdWUg PSBYQ0RSIChrZXlfdmFsdWVfcGFpcik7Ci0gICAgICBMaXNwX09iamVjdCBhcmJpdHJhcnkgPSBR ZHVtcF9lbWFjc19wb3J0YWJsZV9fc29ydF9wcmVkaWNhdGVfY29waWVkOwotICAgICAgTGlzcF9P YmplY3QgZm91bmRfdmFsdWUgPSBGZ2V0aGFzaCAoa2V5LCB0YWJsZV9yZWhhc2hlZCwgYXJiaXRy YXJ5KTsKLSAgICAgIGVhc3NlcnQgKEVRIChleHBlY3RlZF92YWx1ZSwgZm91bmRfdmFsdWUpKTsK LSAgICAgIEZyZW1oYXNoIChrZXksIHRhYmxlX3JlaGFzaGVkKTsKLSAgICB9CitoYXNoX3RhYmxl X2ZyZWV6ZSAoc3RydWN0IExpc3BfSGFzaF9UYWJsZSAqaCkKK3sKKyAgcHRyZGlmZl90IG5rZXlz ID0gWEZJWE5BVCAoRmxlbmd0aCAoaC0+a2V5X2FuZF92YWx1ZSkpIC8gMjsKKyAgaC0+a2V5X2Fu ZF92YWx1ZSA9IGhhc2hfdGFibGVfY29udGVudHMgKGgpOworICBoLT5uZXh0X2ZyZWUgPSAobmtl eXMgPT0gaC0+Y291bnQgPyAtMSA6IGgtPmNvdW50KTsKKyAgaC0+aW5kZXggPSBGbGVuZ3RoICho LT5pbmRleCk7CisgIGgtPm5leHQgPSBoLT5oYXNoID0gbWFrZV9maXhudW0gKG5rZXlzKTsKK30K Kworc3RhdGljIHZvaWQKK2hhc2hfdGFibGVfdGhhdyAoc3RydWN0IExpc3BfSGFzaF9UYWJsZSAq aCkKK3sKKyAgaC0+aW5kZXggPSBGbWFrZV92ZWN0b3IgKGgtPmluZGV4LCBtYWtlX2ZpeG51bSAo LTEpKTsKKyAgaC0+aGFzaCA9IEZtYWtlX3ZlY3RvciAoaC0+aGFzaCwgUW5pbCk7CisgIGgtPm5l eHQgPSBGbWFrZV92ZWN0b3IgKGgtPm5leHQsIG1ha2VfZml4bnVtICgtMSkpOwogCi0gIGVhc3Nl cnQgKEVRIChGaGFzaF90YWJsZV9jb3VudCAodGFibGVfcmVoYXNoZWQpLAotICAgICAgICAgICAg ICAgbWFrZV9maXhudW0gKDApKSk7CisgIGhhc2hfdGFibGVfcmVoYXNoIChoKTsKIH0KIAogc3Rh dGljIGR1bXBfb2ZmCkBAIC0yNjk1LDQ1ICsyNjc4LDExIEBAIGR1bXBfaGFzaF90YWJsZSAoc3Ry dWN0IGR1bXBfY29udGV4dCAqY3R4LAogIyBlcnJvciAiTGlzcF9IYXNoX1RhYmxlIGNoYW5nZWQu IFNlZSBDSEVDS19TVFJVQ1RTIGNvbW1lbnQgaW4gY29uZmlnLmguIgogI2VuZGlmCiAgIGNvbnN0 IHN0cnVjdCBMaXNwX0hhc2hfVGFibGUgKmhhc2hfaW4gPSBYSEFTSF9UQUJMRSAob2JqZWN0KTsK LSAgYm9vbCBpc19zdGFibGUgPSBkdW1wX2hhc2hfdGFibGVfc3RhYmxlX3AgKGhhc2hfaW4pOwot ICAvKiBJZiB0aGUgaGFzaCB0YWJsZSBpcyBsaWtlbHkgdG8gYmUgbW9kaWZpZWQgaW4gbWVtb3J5 IChlaXRoZXIKLSAgICAgYmVjYXVzZSB3ZSBuZWVkIHRvIHJlaGFzaCwgYW5kIHRodXMgdG9nZ2xl IGhhc2gtPmNvdW50LCBvcgotICAgICBiZWNhdXNlIHdlIG5lZWQgdG8gYXNzZW1ibGUgYSBsaXN0 IG9mIHdlYWsgdGFibGVzKSBwdW50IHRoZSBoYXNoCi0gICAgIHRhYmxlIHRvIHRoZSBlbmQgb2Yg dGhlIGR1bXAsIHdoZXJlIHdlIGNhbiBsdW1wIGFsbCBzdWNoIGhhc2gKLSAgICAgdGFibGVzIHRv Z2V0aGVyLiAgKi8KLSAgaWYgKCEoaXNfc3RhYmxlIHx8ICFOSUxQIChoYXNoX2luLT53ZWFrKSkK LSAgICAgICYmIGN0eC0+ZmxhZ3MuZGVmZXJfaGFzaF90YWJsZXMpCi0gICAgewotICAgICAgaWYg KG9mZnNldCAhPSBEVU1QX09CSkVDVF9PTl9IQVNIX1RBQkxFX1FVRVVFKQotICAgICAgICB7Ci0J ICBlYXNzZXJ0IChvZmZzZXQgPT0gRFVNUF9PQkpFQ1RfT05fTk9STUFMX1FVRVVFCi0JCSAgIHx8 IG9mZnNldCA9PSBEVU1QX09CSkVDVF9OT1RfU0VFTik7Ci0gICAgICAgICAgLyogV2Ugc3RpbGwg d2FudCB0byBkdW1wIHRoZSBhY3R1YWwga2V5cyBhbmQgdmFsdWVzIG5vdy4gICovCi0gICAgICAg ICAgZHVtcF9lbnF1ZXVlX29iamVjdCAoY3R4LCBoYXNoX2luLT5rZXlfYW5kX3ZhbHVlLCBXRUlH SFRfTk9ORSk7Ci0gICAgICAgICAgLyogV2UnbGwgZ2V0IHRvIHRoZSByZXN0IGxhdGVyLiAgKi8K LSAgICAgICAgICBvZmZzZXQgPSBEVU1QX09CSkVDVF9PTl9IQVNIX1RBQkxFX1FVRVVFOwotICAg ICAgICAgIGR1bXBfcmVtZW1iZXJfb2JqZWN0IChjdHgsIG9iamVjdCwgb2Zmc2V0KTsKLSAgICAg ICAgICBkdW1wX3B1c2ggKCZjdHgtPmRlZmVycmVkX2hhc2hfdGFibGVzLCBvYmplY3QpOwotICAg ICAgICB9Ci0gICAgICByZXR1cm4gb2Zmc2V0OwotICAgIH0KLQotICBpZiAoUERVTVBFUl9DSEVD S19SRUhBU0hJTkcpCi0gICAgY2hlY2tfaGFzaF90YWJsZV9yZWhhc2ggKG1ha2VfbGlzcF9wdHIg KCh2b2lkICopIGhhc2hfaW4sIExpc3BfVmVjdG9ybGlrZSkpOwotCiAgIHN0cnVjdCBMaXNwX0hh c2hfVGFibGUgaGFzaF9tdW5nZWQgPSAqaGFzaF9pbjsKICAgc3RydWN0IExpc3BfSGFzaF9UYWJs ZSAqaGFzaCA9ICZoYXNoX211bmdlZDsKIAotICAvKiBSZW1lbWJlciB0byByZWhhc2ggdGhpcyBo YXNoIHRhYmxlIG9uIGZpcnN0IGFjY2Vzcy4gIEFmdGVyIGEKLSAgICAgZHVtcCByZWxvYWQsIHRo ZSBoYXNoIHRhYmxlIHZhbHVlcyB3aWxsIGhhdmUgY2hhbmdlZCwgc28gd2UnbGwKLSAgICAgbmVl ZCB0byByZWJ1aWxkIHRoZSBpbmRleC4KLQotICAgICBUT0RPOiBmb3IgRVEgYW5kIEVRTCBoYXNo IHRhYmxlcywgaXQgc2hvdWxkIGJlIHBvc3NpYmxlIHRvIHJlaGFzaAotICAgICBoZXJlIHVzaW5n IHRoZSBwcmVmZXJyZWQgbG9hZCBhZGRyZXNzIG9mIHRoZSBkdW1wLCBlbGltaW5hdGluZwotICAg ICB0aGUgbmVlZCB0byByZWhhc2gtb24tYWNjZXNzIGlmIHdlIGNhbiBsb2FkIHRoZSBkdW1wIHdo ZXJlIHdlCi0gICAgIHdhbnQuICAqLwotICBpZiAoaGFzaC0+Y291bnQgPiAwICYmICFpc19zdGFi bGUpCi0gICAgaGFzaC0+Y291bnQgPSAtaGFzaC0+Y291bnQ7CisgIGhhc2hfdGFibGVfZnJlZXpl IChoYXNoKTsKKyAgZHVtcF9wdXNoICgmY3R4LT5oYXNoX3RhYmxlcywgb2JqZWN0KTsKIAogICBT VEFSVF9EVU1QX1BWRUMgKGN0eCwgJmhhc2gtPmhlYWRlciwgc3RydWN0IExpc3BfSGFzaF9UYWJs ZSwgb3V0KTsKICAgZHVtcF9wc2V1ZG92ZWN0b3JfbGlzcF9maWVsZHMgKGN0eCwgJm91dC0+aGVh ZGVyLCAmaGFzaC0+aGVhZGVyKTsKQEAgLTQxNDEsNiArNDA5MCwxOSBAQCBERUZVTiAoImR1bXAt ZW1hY3MtcG9ydGFibGUiLAogCSB8fCAhTklMUCAoY3R4LT5kZWZlcnJlZF9oYXNoX3RhYmxlcykK IAkgfHwgIU5JTFAgKGN0eC0+ZGVmZXJyZWRfc3ltYm9scykpOwogCisgIGN0eC0+aGVhZGVyLmhh c2hfbGlzdCA9IGN0eC0+b2Zmc2V0OworICBkdW1wX2hhc2hfdGFibGVfbGlzdCAoY3R4KTsKKwor ICBkbworICAgIHsKKyAgICAgIGR1bXBfZHJhaW5fZGVmZXJyZWRfaGFzaF90YWJsZXMgKGN0eCk7 CisgICAgICBkdW1wX2RyYWluX2RlZmVycmVkX3N5bWJvbHMgKGN0eCk7CisgICAgICBkdW1wX2Ry YWluX25vcm1hbF9xdWV1ZSAoY3R4KTsKKyAgICB9CisgIHdoaWxlICghZHVtcF9xdWV1ZV9lbXB0 eV9wICgmY3R4LT5kdW1wX3F1ZXVlKQorCSB8fCAhTklMUCAoY3R4LT5kZWZlcnJlZF9oYXNoX3Rh YmxlcykKKwkgfHwgIU5JTFAgKGN0eC0+ZGVmZXJyZWRfc3ltYm9scykpOworCiAgIGR1bXBfc29y dF9jb3BpZWRfb2JqZWN0cyAoY3R4KTsKIAogICAvKiBXaGlsZSB3ZSBjb3B5IGJ1aWx0LWluIHN5 bWJvbHMgaW50byB0aGUgRW1hY3MgaW1hZ2UsIHRoZXNlCkBAIC01MjkxLDYgKzUyNTMsOSBAQCBk dW1wX2RvX2FsbF9lbWFjc19yZWxvY2F0aW9ucyAoY29uc3Qgc3RydWN0IGR1bXBfaGVhZGVyICpj b25zdCBoZWFkZXIsCiAgICBOVU1CRVJfRFVNUF9TRUNUSU9OUywKICAgfTsKIAorLyogUG9pbnRl ciB0byBhIHN0YWNrIHZhcmlhYmxlIHRvIGF2b2lkIGhhdmluZyB0byBzdGF0aWNwcm8gaXQuICAq Lworc3RhdGljIExpc3BfT2JqZWN0ICpwZHVtcGVyX2hhc2hlcyA9ICZ6ZXJvX3ZlY3RvcjsKKwog LyogTG9hZCBhIGR1bXAgZnJvbSBEVU1QX0ZJTEVOQU1FLiAgUmV0dXJuIGFuIGVycm9yIGNvZGUu CiAKICAgIE4uQi4gV2UgcnVuIHZlcnkgZWFybHkgaW4gaW5pdGlhbGl6YXRpb24sIHNvIHdlIGNh bid0IHVzZSBsaXNwLApAQCAtNTQzMiw2ICs1Mzk3LDE1IEBAIHBkdW1wZXJfbG9hZCAoY29uc3Qg Y2hhciAqZHVtcF9maWxlbmFtZSkKICAgZm9yIChpbnQgaSA9IDA7IGkgPCBBUlJBWUVMVFMgKHNl Y3Rpb25zKTsgKytpKQogICAgIGR1bXBfbW1hcF9yZXNldCAoJnNlY3Rpb25zW2ldKTsKIAorICBM aXNwX09iamVjdCBoYXNoZXMgPSB6ZXJvX3ZlY3RvcjsKKyAgaWYgKGhlYWRlci0+aGFzaF9saXN0 KQorICAgIHsKKyAgICAgIHN0cnVjdCBMaXNwX1ZlY3RvciAqaGFzaF90YWJsZXMgPQorCSgoc3Ry dWN0IExpc3BfVmVjdG9yICopKGR1bXBfYmFzZSArIGhlYWRlci0+aGFzaF9saXN0KSk7CisgICAg ICBYU0VUVkVDVE9SIChoYXNoZXMsIGhhc2hfdGFibGVzKTsKKyAgICB9CisKKyAgcGR1bXBlcl9o YXNoZXMgPSAmaGFzaGVzOwogICAvKiBSdW4gdGhlIGZ1bmN0aW9ucyBFbWFjcyByZWdpc3RlcmVk IGZvciBkb2luZyBwb3N0LWR1bXAtbG9hZAogICAgICBpbml0aWFsaXphdGlvbi4gICovCiAgIGZv ciAoaW50IGkgPSAwOyBpIDwgbnJfZHVtcF9ob29rczsgKytpKQpAQCAtNTUwMiw2ICs1NDc2LDE5 IEBAIERFRlVOICgicGR1bXBlci1zdGF0cyIsIEZwZHVtcGVyX3N0YXRzLCBTcGR1bXBlcl9zdGF0 cywgMCwgMCwgMCwKICNlbmRpZiAvKiBIQVZFX1BEVU1QRVIgKi8KIAogDAorc3RhdGljIHZvaWQK K3RoYXdfaGFzaF90YWJsZXMgKHZvaWQpCit7CisgIExpc3BfT2JqZWN0IGhhc2hfdGFibGVzID0g KnBkdW1wZXJfaGFzaGVzOworICBmb3IgKHB0cmRpZmZfdCBpID0gMDsgaSA8IEFTSVpFIChoYXNo X3RhYmxlcyk7IGkrKykKKyAgICBoYXNoX3RhYmxlX3RoYXcgKFhIQVNIX1RBQkxFIChBUkVGICho YXNoX3RhYmxlcywgaSkpKTsKK30KKwordm9pZAoraW5pdF9wZHVtcGVyX29uY2UgKHZvaWQpCit7 CisgIHBkdW1wZXJfZG9fbm93X2FuZF9hZnRlcl9sb2FkICh0aGF3X2hhc2hfdGFibGVzKTsKK30K IAogdm9pZAogc3ltc19vZl9wZHVtcGVyICh2b2lkKQpkaWZmIC0tZ2l0IGEvc3JjL3BkdW1wZXIu aCBiL3NyYy9wZHVtcGVyLmgKaW5kZXggYWIyZjQyNmMxZS4uY2ZlYTA2ZDMzZCAxMDA2NDQKLS0t IGEvc3JjL3BkdW1wZXIuaAorKysgYi9zcmMvcGR1bXBlci5oCkBAIC0yNDgsNiArMjQ4LDcgQEAg cGR1bXBlcl9jbGVhcl9tYXJrcyAodm9pZCkKICAgIGZpbGUgd2FzIGxvYWRlZC4gICovCiBleHRl cm4gdm9pZCBwZHVtcGVyX3JlY29yZF93ZCAoY29uc3QgY2hhciAqKTsKIAordm9pZCBpbml0X3Bk dW1wZXJfb25jZSAodm9pZCk7CiB2b2lkIHN5bXNfb2ZfcGR1bXBlciAodm9pZCk7CiAKIElOTElO RV9IRUFERVJfRU5ECi0tIAoyLjIyLjAKCg== --000000000000acad5b058e2b21f8 Content-Type: application/gzip; name="0001-snapshot.patch.gz" Content-Disposition: attachment; filename="0001-snapshot.patch.gz" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_jycl1mzx1 H4sICGYGNF0AAzAwMDEtc25hcHNob3QucGF0Y2gA7Dxrd9pIlp/xr6juPScN5hHE26aTboJxwoyN 3YZknU3naIVUGCUgsZJI4kn6v++99VLpgY3Tyc7snGZ6IlyPW7fu+94qcRr4a9I66lJn3pgb81aj 124ZbYMujuyF3Vu0Las9b3eaPWPRNVrk3PfIlG6I0SX1+jH7jzTqdePgFMAck0t3Q4Y0Ij9v3I1N o19v1pa7qtn++unBiRXRYzLdehXSMMjftiuYZxyReue40TtuNki5Dp+D6Xb+jtrRMXlzOZgNX7wl oWdtwqUfHRxUq9UDEgb2Y2u18u2aTdjnCyFGnZRF1/w2orbvUNYLXY0edMl5NkzcBGIqdJKWmmcD cjd+cKu6OnGXvZJrKZBlBXJpBSGN+ABEpYudyb6lnNjWJ/qO690IwF9Io3EEnYlPNfFJzFpKXFoI Utugv974oRux7UN3s0lye5e8t8Mn817HDTf0U0QDD7qRAm1FAbq27FCjNzFImfcs3BV1fbULnaIL L9TJ1ux2yF37y/lwOO9C31OAkIrIbNG3ApwFMbDPALlKARfjAmo52gYarRjG2vXc+XahONhrEA0E H7NxtusNDeQYo9NMr5MzeJmh1iZwvUhDo9vTwMghvk3DUGGjERS6kNyBENFGq5eWmHx8gKVrnYAa yE/IdJ0uHU1CP+kT43mNLkE0QgLi7d1Qp0K6rQ5xvZAGket7YbFcqpAecNuhK8pbqqWDA8ddLEi1 euNGxHqsK/Fc/+vA9Rz6CbTI6Nm0vrAWtVq902i37W7PqYOe1zutFtqBJIwD2HgKzq+/kmq72epU DNgS/9Ig0LjZBmAfNrfm0gqXZmTNV5QUwyjY2hE5A2KYL7B9xtoPWXfpgBzA5nFi9ekS5IgG5Alh XfLvfjzgI7XeQ7dchhR/89xVqX9QVRAAfmKAhATt+jgPdDFvHLbr4zjBcgayDhhZliPnW/s9jcK8 saKrpG3E9rdeFG+U/ZlCz1wElMZDVJMGRa2kRskWNohaIYoNKf7Ah6+3nOQahIByTi0DCl5g5cSQ 0j3ZSaH7D5oZj43aRt7TW9PyHPODtdrSPNokBuiYRTSUHDLxe58LSkCjbeCx5j4Tw07T6FUMsBjw pYVfoHFtBe93iuAr8H9+QA43UVA64OrHRoUVNo/43uqWREtKPvCBgB3x/Ii4wFzb9yLqwRdUkmhp RT+F5CM8BJy19R40F3QQ5bRGyOFj7HAXpDgZn12S4pJLcKmEBCIcTZ85ZNaXpkU5b1BCmOgqpHzt zwKFmOlLITNcZ56QycuzMz4LP8lehrBGsVCNS3fA2GWfo08IuF+TU8lENKlDitevRsPZxVXOfuSG 7p0mdyiR/eMA/8uaOC0YmacahKFzOp2edWR1LKNW6zbrnSY9Omp3s4ZOmxjbOq0R5cxo1euVJjgb 9oXL2X84dOF6lJyMTseTUdGz1rRC+G7J2eDZ6IywthKpHJACEaLw7PVsZA4vTkbmdHA6Io8ekR9e DKYvzNng2dnIBCl5t95wYpekfKoPCxVMa+4jg2Nm8g+T7gsuKR8MYNTlxaViFf+AzCMZTZDm1ORd Rhqt6XWMn45dCjYTEmEF3IXpUeogZ5nZTY58fIjix02gGxKLLKwQvCGxNuCEP7lrC/0aWYDuaYSZ jv9rhNCSoHBdGtAaqlqiAymtFvn5CWlnJn5GPE58WH4FPLQCEEsrsJc4M0KYxIL/o+KvLe+W2FZI w8za+DkdX5+PjiGew60EczcKrMAFE2Iv/ZB63ApUCwWdO4xGKFvYQVCluL2r2evNwiO/qL9xIDQU PxgVsiyRY4L+LkNP/CC1ii4Hxb0JqeO+q1W3T7JEExQa/cZhMzr/ffQaaFYhbil3PH6+fGFUjXHd NRA/INkIX21WLIP/xOsUkACoA8pCaoTIww0JUdqF4Rwi0ff9dN8fyQZmNFNDGOUQ0ZXvv99u2Fq4 uDCaQHClvy55+oTUSwflgzJryzKWrlZ3g5NTEZzcuJyJSl/gSH1Oyw2YFgDMCPJqcPZyJEgCAHeO G47OztRgtQYof6GwwxiBPE9engNKAIUhU8ixO4WCv0HLwAfzsf2sidZSwnmqQZjopt3tNpo9ezGv 1RaOYVht/F/WRGsTYxOtNaKJbnY6FUgQ+QMasNsUIT8pxrbPs4Ib8PY6xQ55EyQQLPxeONxig98p cGJidreia3D+EqJJPZ4vmuEtmK+1JAIpgH/bbsxU56m9pPb7dCtOqZBHsPqWwebdKHEFMdKKogC9 LjBpPHlujk/MwWx2NSXF1Jya6zBByJ8Wy8KO2UnZiEMWMR9nmYPpcDwGaTm/HMxIUV+oJKT2s5Bd sKz/SQnEjdsVD562IdhTjzAIQGWkJlh59DAcDOEE4dYSednr1JGX/PENePkHd3c37gdqbjfHBMNJ YQNercD9JBljAr5OguiTwTlokGR9guT7Qol5kAsswQH+ATKOmTdi2wcPGdD/2boBZoWQ/LEOyK0X 0OF64LJc1oQs4CCrQsoYGpEPKSOaYTZNUtLfRpttpEJVZeM4ODOJothWKU/PVX1nnmoQen5EW526 vbA7rVqt3Wsu2j2n7TTy9FxN1PVcNbLMs1M5grQT/4U/Gd1uIKSUo0zQP1LUJYLFK0kh0QczI1dA 11qBUAS8gwg9946JrocvBlfyDx4cVZ9CdB1Y4RvjLQeWdhM8SYrjsRyPoeMIRiLOYXU3xIRYZEUp V8lkc1/3lL9YeaeTKqfXZZLNF09KMvsTpCxnGU5zsVYMTx/Ux+g/K3CsajiPvwsxWyxaDbuzaLQX tdqcNjtOvdttL3LEjM3RJIz9zeL8xpFRMdoQ57MvXT3OH10Pz09IceHSlWOQp09Jh4tO4Rjmlbhf ROF4PpqZunxQf1NiBqdQoMxvpomPiaO5cD95W/AJAb15c3V19bYUhx/cWeNcEXvkxZP5fL0HNIYi hZ1xSEEEIek4x9+s+rIdvmeDEr5jMYKBJ8XxxBxPZubVYPJc0ATjDVSdwXA2uoLFARR6knJ2QUi8 w0RIkxG0nEkcs+vhyRV6Ky/MH8U5cj0cZEbl4q1CHtzArh2QggjhhsMzmAx0ARcCstOXPZIRGFnw Ora59Vw0z4pqOCQIAhwCSymktOYEKgnQXew2+uhAgi4BM0ZZghBubWb10dgXRHhTYOEwk3xWScEM t9mo7yf5aLVwiycjFkMiJWIhqyhcv5VmuN9BJTSY31ET9hHpnCj9X0qoyzuFuny/UN8rveUHS6/a i8pYEFFEfsfm+D4epp2JyXkZjjqhmif/Fg6pZ7dbzZ7h2BD3GIbTO6Lto04rxyGpeZpTUm1MPQ3U yh6op/gCjSej05cTUvyRa2lVTKhC6EsDz1r9WCGnvMuUDJFdFXS3wxej4d/Ns/F0xhKC8I0cBX+Y m5UbRiJ4GUxHOARD/YriLRtQIXdMxOBEHdOxupAopyc1UlUXc4Bh/exthdUJGGseqXJCHArlLCFs Qmr5XHuwx+plsXpi8WRolFlHFu9UYdajH03GDBfLWybqZ11F+q4jZQ1TK1Q+oLg5fX3+7AJE9CSH PQy1UilRi2WLs/qjGa78KLm5LJVgwyx5UznMVFpn3R5ldhZPY5P+SBeiBUK7Gc9jwfvpztfRmE9S 9M8sozP4oatIJicW0XIiOZNBE6ldbOh4K55+oH3heTDYr5EXbgPKjgrkUDI+CSExjTBB9clP8O9P xArJR0QdnqwV0ziu861epYMqD89vofHys6ZrG09hUCiT8iH/9FcOP+E5JPjwF+RQDU5WnhMTgfpq WJ9RIUshMYYfFWEljBUvk7lQvQ+Pn3MmQ3u5XBIFtDCyIteGLJUUHyWGvnHfpkoajB2iVjtbuiFk 0Nb7EAkBiUYFKY95MR6BJfczh6R5TUNZlNt6AbVgBHRB1iyyc20WzzWxFpxEHdVewoApHvwjcMCx LjtWArNgrfrEx/LzRzcEJrh4wLT1bBgX1JhENJrdNkoEPLs8/w1v16HpLyS/SfGD7zriWDXNmixO /cwwyaLB1dXg9ehsNk2LPk7j+vc1fHsQ28qI3eUJOPfRlXk1Oh+dP4Mv0+HgjAU2Wd3L2Y4ownBb uycsnHOXt1+mPPRSePtuvdWwuobV6tRqtjOn3Xrdmvd2e/tljrdfiuOmLp6pl9nTSITi54Ph1JQu 4gUyWhQqBIQDsMG7En9BUiwsMYTB1iR2Hh9a4tmMI3y4PvyVHB+bVnHGoZczYqOPxXO+4om7pl6I Rzu+KGpxSMfEqJBGhTTB6ASklUDBkXMQEyb/vRbLzhu9ZsVo6XTJOM0iaMbcX5UKvyONAIErXl2w POLesZsUduQjnuMQDouZPdBXvobY9w4EmCMdT05G1xoi5bsGo9fVkSbJSCVRcspBHBIZPlkkNMld 45bQ07nzbaTOtmGrAhFB9TR6WPcdP3s5G02lhiBmwOqinubsgZmazu9icNngZaRiJuRID5bxVBY/ 4LLCq6DPQxOY4YzGEjUrsxjHLLvUyfh8NJmOLyb5c5Wk5kzlByyXg+Eofy4GG2a4sWy6a/LZeDIa XJmXd8znp5jmpsTPQpo9Zj+aTXk3B1mioh8QBHUrQgr6ofgCOStmxvpYEb+5zqcKcoHJ1cT3/kHB hENsdPHsb/wgF2JPN3aFXBrzteSy6M/flTKhbswhwgeIQH7HbBF871ImDqMkNWGIJzCI7/Wd2IJT 93ygQujegD9Gc0GDwA8yGoK5k1i5+KmE0SNXWscnnwvi8zuPhnmiytEDfD+V8CT1jq3DgJ9h32gw dk6/b+ugXcKK4Odj4Hs3ZnS7oaY8+iHF38TeNxU2vC938AcYPRfvzfBquDC9zXaDi1S7nnJJu2lB QJLmNEjZVCDlRRzkZOi8k8zmc67ykLmAfudTXJJcC0ucT33Vx+iZ7xrlEJIGlUv+IoDF6tddTNyb i3rycjdHyYM5qnbh6OWMwdXo9MFGHLYM//4u613KRAAz+FJqq7vWyi90VVKQdgghF8OW0YVUqNwy Wjwjii/hqBpkUVkylsZp4nisO6I1jZY+y+Ikzc9HsxcXJ+b54DKe8gv4o122tqCBxs+jR4RfZNI0 k+MVh5ioljFXEH6KUDsnVsQ8Tv0i2xupJnbkejxzLcW8eOgKv8eFvn3WECOPxekiczGaB68IGHLT +43Nu+6lrnTPE3/KO629I6s1bx45Rq3WajbrVqMx7+WdL8ppWuAtm5iRA7HCOwTsAQ3skJ/KA9Dr 6+vYbSZO8g/FyT1zNOPpRaPeaIDLtdlVJjRomkkTh8rTC7AU49l4cCbO0lnBvCRlo5himmBd+hqA mMtDngpn+p1TM1cBYgiaRnI7yLU8Pug33dBn+Z+L9xa4sRQCgKiXpKtodRrsJEE8dVfBkXg5OzWN jjl9eXV18XwwG0kcVKw+HJ4lyJeaHx86XGlTgWp7USmxJdtemVweAxaOfgWxdsPLw3s0+WZ4c+n8 dngreHl4szr5VKEtymVcVqcng9lgTxnNrMriMHaHpLwD1FduJwbMhYonsVi1wBqOvHoiT5shKyT/ LUCINpeGP3HtZVeN6220DfwBDa63dOduZC5W1g3emYiEtXBYS4XMfX8FQWZQytF+FslMTi+U6qeK 61hDL2WiG+E0eCW+lHcrKEHqvnICmRl7UbSvDHwxgVcMht0Lku5EHCTw4vBdkaTRaB0hJcUTmqRD 4NTfRguzd6+hJZzA6+0qcvGy7oZd02IXX56CXTdVB78qjTkNAp77axY1wex1vBE0SD3z2cW5vNjE S0lsBeqDRvvi9ucT8oPkO7bbvveBBqyqIe47xiwZQfg2e305kiCF+P8GsGT9el9oMbuyQHUNELBF 9QQ3b1qLiII64GsVVUPcosdQFLf/wxNGko8uBELbCEnDs0ejfcSuX4lnLoOMzh4cUlQHY089x7U8 Tnv+PUl+GDKanIwHkyQLcCPhFjKDG9DJzAzlQf5t+WYwxlWSjY08bj6JuRmzsoGn+l0sGLNnhpX8 aifoCt2DnXFSxW67+YsFZs68riz+UptgI1gioCoJoe26/27skYxQ18Xke4B4yIeF7m0IJFxv5Pcn 5JEyUhtq12L61+JRqtp51GrjXTfxZMyLICqSzMNwjEWad7JOnfzkD2InEYBWMeP73rhv46MePWkW zgr8q3aPEsUQYSE/WOIr84/4NinvTt6swHdqXG9L1UnmzhuvEnh8+HffLdf0eokDPS0OPz0bPBfD S+QRSfWYpy8B5PTl5eXF1YxFvHhPWpejnW6wQl5JHpkJF1pS94SxP7QW6sAuVC6UJyStjqjkiS8Z Dd5PCEq6iKYqfkqy7QcJskam4fmlOZ0NZi+nmh2u5ghNHl81Nc5cWbyPw1lt7ScNlWaatPhgE/jO 1oZIDbv7f5m2e0wbOw2SRqnVbBjoUcQzTpIdykp5TGAsjCZWe9ilDLMzt2V1vRHmZm9R+krx0Zfc J9iVXhjpr88F8krtlPdBUqDzzUNfELrb44Tu9vKqEQ9QfGTgJqALGgRC6Hm1TQ8jUpkJuTM1YdqN AsjCuSdkh0z+Qn7beu4nckzuEXLGra+At5+YKwap6pxcSrJFW5qtoIS9c9RgPODPjPEN34Hz/Ctw +pP5yANFjzGmV+fKwZ8Zxszdm/ZfjPknMKZd7zH3IJ6ZmNW273cLB6rsGMfLelyabLlFmG/ZZnjF JzbZcd0qGZd8bwfCz3rue4UqfneKReeBTcpPCP7ogRIsTtFGhxWlxTPjB+6lKCyQVI7A+mhG+BMI 9037/P9ZtmMpqj5lgopRSehvA5uyC8aJft8Lt2vhG1OFJDZXCDe6Ynz5iD+zwi0vYd0b94h5rrfw ETtq43vwX0DQBrPR84ur1+b5YKoOPvtfoRIck7f/J+Ku1I5XbaVx0MuxwlCIkizDCu9f5rxkl8Yp OSz9Ft0dCgg88CBhIcWpqCmLI1U+kb2ZX6rEJxg/QjxV7fXaR9UfK/LOY1FrxHMwo4RVlrpMI798 IfstwmSn1eW/VCG/ZHzWXtIjrMWThGjPtwtSTrfwm3xVUjwfXJuDyeQCErTxxcQ8G02ez16QQ9LI JEu6FiA/65VUmzm3Qhp7vH2Kr//ENDD1UjRI3l/Z4fcIE75C//mLnN12BX9eTH7h15SyL08n35vR uio7alp66qOqT4kxKh9LTGTRPyil61B5+VHcQOF0m76ezkbn4h5KCmKFpCV411TtTscOCAk53t+C f4ec7Gs07zuncrrfXuMbzfJ2764Mj8la7+iInUnLL/hSecLs8pT8PturieJBclAKzk6ZZWFV8uVf Z/eruhk7lhN5P1xSpbTsFKuvF+GUINwnPxnOyjqKHjZzYZAl1UxN5TM/njW67NBKPBl/7//RhrvY xH+ygVnv/SJl9JUR2XpYB6P8aiE5BHdYIYfUczKuUFOSfVTx7qkPqYR4HEBIqae5PdmUUDF8B1sG zXEKxejd6nUqDfzlLfEFGi3n3Tb+GQSF5N3hcAIfScq8zQo5fyDZ/hypWCK3s2z0+JAM2M8f3oqt U0f7MQXxOruGPgeoaA8+GRCYjkYQlJ0qYZYvUKl9xJgLDUSN5q5Wwq6QuvYLW5nNZCBo+psLSAS4 OWUx/Kh3vnZuZ3j1pzdkfKsNGTs2BLHNA/bzJ3fT+Fa7aezYzdqy9d1kZI+pbJsfBotnOn3dI/G4 w8Jh2M+sHCHxAHZ6b32AWFp4at1xZ3zbwofoCzfDf+bqX8Fa5hUJ9OQrVTeoJ6oKMpHYlVvwCZwz jSPOmcbR13ImacUBtpLeycVk1Jcv/izIRwpe+gP/dbNbyGNEwMuuaLOykPSShIscR4W48ncOPf+j eudnt7u+K1RFL64CbX7x615Ae4SeabBCY4W2sBPOivbTd0ma8l3i4RUWZfQCjWBRp9XAm8fi+WAW 4XU5cdaeKd9g8i4qN+ItdODU1F+Lt5HwFPt/2/vS7jaOJMHP1NsfUZZfS4RwNG6SkmUvRVIyuylS Jilb3l4/dAEokGUBKDQOURy19rdvXHlVZeEg2Z6d3uGzBaAqz8jIyMg4uTP0uIsqV5WU3AnVEMax XcIEcW84gSnH1NPB6FLUSynWJZKBR5FvV7GpVkrBLm78yxX+W7IoysqYfEncOFBq1pZt3ixgAzp1 vqra1jJVphHudpajbdeC777T9RXL0m7v0C7jzzssoYw7l2ucSTSL1MXS3I3zrRpKNpjz6q00cSiJ /4Jz+xa7NxUkhK0fTi/Sd+KZvT4Mr50dDq4qX+4AsS1F1FXMCqdDHXPhq0Sao+B8/EhVTAsIbTsQ b8m0jNBjBrKFEcEEhfTBr7HtZXqL3orJWydczJP/LxFhr0GSGvXl3xYRsM/1+rtDX2p+Fs6NF8MO ydWoORX80TBCiSUzESK2U90t1fZgLeTL5msh5yGHT/FS0CeKgHITk2kM59RcbMIK9g5YdqR5KssZ s+6S3mVBdRxQWdyvii0uW3DXLhKOcYcoX1YwL8SvbNjSOtyLLE0O9dlVxMdhapYSoE3ZnEBVcVuC JculWo4o2k9qiunaa8Air60ge+orFPHisRNkhaJ4WCId2RAG4Ky7wO044zAevN8ae+hrXlRf7rbf /o0w0ZyD/42Kd0NF3YtW9mcw1X8uC0ayiYV8Gj1itMrkrrBEtBakr/UTuNRPutEVfvDF/j9D+oZ3 QiP9ICkUec761QoFW/KmDCh2GrsUGVg+03rXlSDDNvdPTs4OOrAoPx+dYxSAzi9n53/tAC7tG6OY LBH5g+wV59NwPBuy5aWK9YIhUbPPlW6uqqPesYQjnE5vk0+RJZHYae6SOF0+Nwaai+ge0YmGkhFb KYHCN2tqPgkZdCSuOyk4uQkZLdp1L8Ure59pYbgg6qv3r19TvDzVTx81xbTNRAe1067T9VM+SUNB YBF9+woxuRPSNr2ypbTZUaaEkodwPJEOmgy8DCijSwg9i71DPJ4XgmfBKPwscUcK2W3/72rrubPT JhmcfKbtrNYiE+8vOJR6h+jF/h+0/4mzUfI/9uHEs9s1E1NGXwIFH83geLxm8fWhpIOE7uyx8bd8 ZkxYrsLJKjQ2ek/FaK0pvLScNs6Pfnp/fH7UOTy6hFUGcqy3o96oDoOm9+ofZvvXj2cUSooO904y mcej+D8I2jax8dvMOCXWNCKU1WkxBvPnw6yORLPLVchtbcgTeMuvvbe3lmxuLVm0+P00Yn2TwiwG 3G6tTmbe8pkBnErAs4bd6n8JLLWZK3NMwXE412chxjjxYd+7s4tLmNn+oYt6u/U2eUfLZ8ZIdU0I Bln2AOZm2ATvflGmVsF3uuQfC0IcjQKhc+rLBYkA1GzV0HRUPu8KIMf+xHLpcIqrGICkrORQbj4R jTIatQQ01d9+qywzR9mgGduEBcchGsm0xEctgvs6LehxQP+VHOoB+KISCLZ/OT49PPvl4vSSrgb6 8cGvb+CNIGirSrRRPq1YmrK8DLvyBGNoOuDswEXoIvOkRv9VCWcdKxJZfLFjMLoQ9bys91dWayxl TPxaKfmNsw+zSmKFcM71B3azdSDpwEN6fLp1bvz1FZqeakrgTliCiqIqqaB2fLuqcnRUfYb+Chdz VcY5lk3OlTSb1oZ1wxlZgvTGv9LJFVbZV20glhCf9pRYJECz2I6lwhNTT1e6ywa1UXx1Pe9Q4Aj1 8IUCKEZ5Lcrn3QB6H3PHwG996fwsKePztY6piscsMZ9DqGxGkN1QoZtxFel0K2m42Cfeq31g6pkM aX8/U6eiPQpgCWQhd2rEJMvnXRaSFEBaHZUjSd9ApbxUs/v/rL52d6fZKmHuXvXlTqAkGpfVszCj 6BPfuT4Y5/u/dC6PPly+IFY3x9zHVdQUuCwTLLTQrMXqoNsKnMM0l6JnGiy6DabTeX3VNkFKGvyN H9Z0qcjMehOA7J/+asEilx0wImNFYpi1WBMyG7XrWCBsCKdroMfRbG4ggA+9AHKvFz5AOUj8QrLG pafr6LgyBdbRHGotoST9U1GXUwBSN36Jvfywer/86XtpFdOfddnQ+DeFK3nIsi62pBpNm6oswRSP HpFp0m6d+Hj+vCNFstZhFM4+GrgrAujAmuH7Tw9+LQGqlLIASXmj+ipxFFPkOwJXN+6z/fGli8r0 lgH3VwfNNW7nITV6YyHaf8/oXy4LV7qzR1Za8nmP5Vnj+DXrmN0N2RXlBd1wzRhirylbzLabuQZF 4Jxz8F4r5vRgZXlQ6QxTC5OdKeAlfZEze1fuWbtVnyXj2guw2q4gpR2Hhl6kKeTGjYwTaiZ7RqWI 9kqCrVW99lHj3BJWalcZmvU2WWCpL38UPGEU3UiB435QhaaG0b8OsiktdO65tEI7LsIsHYbIHWTq gpKhZf5bBSu1mGe+vI7G2pQWriplNstEvBhH6JsSTm+t/JfA8ZLBlfpyp3X3XlVtQ1OUDSGMUffC twQ3dC9nkJqH8ZAgs7XCX2jLpkFWXXy1kSPQlkV81163rRWXTBnjetdEdzjLRM6KI1zTgrAbyQLv tWWB+cudN7amLmohsXPXcUEOqg8XR5d6UUqB37NAt6m511Q1jwDP4mT9hfPFedIlni2607U7vEtn gaEeX0Xxt1dr0n1dPi3R4GJMQlrU5FCunbKKiIVCQuslKXA76mVJy39Y+2PS3YrkwCtm8WcIdqU4 d5G+3E2eEqzliad1iinBo5LRpecPY1hbo8XsxF5jj3Tm8slem5FcjeedaXSFumJHADubh9O5qy6P xv2So8FPCd2fKPWXLckfTJMR/0uSg1IwT/B//kEWrYEt7bdkreNkCt1M+yLs3SDDcOac2TyvsG8x LY8gY6dgjZ324A9uZkRpx3FYYaZkr7lHAUnkM70ms/mU1FnumkwzNgyuXNE9zlctkzRXpf9I+cMR Mmel/0+XZLfK24Q/LRI2j6ajeBwOy46aA+mXetNJL8SXXPH6s1QdXqyXweXR+dvj0304PNUXhgRe jHocMf9T1FGVgV7LN+G3crHCZyHsjsDv8JXTSMZ8ON1WZoUwaRjcRLth7+NNOO0HipTFw3h+W1IL COQO0QyTus2Cv2u51FPtC6oWmm2UUgJ1y2UJFtwd+nOipYoW7jbaeLeVT2uRP0a33QTGl15kddwF /aT33MoG5EpvMRBpPIgBg/HWTSuGb1WjQTxWScILGW2XXknRNuZo+TRe/PXo11dn++eHgiCU3G81 lphVXq4mzO2Gsvut0U1Wz/g/GPR7uyRWkE8L9Jh+L6VBZDHBLe4xyrrjqg7lbcmJfSrLBBt6fBX1 zW09UIGK8M+SP/xeLFKeVSMKMrKI5XIFEpgQm6WjmFJmxPi3LKe1vKVCwQnx+o2jdloueuAEfrkD 8NPPVW1aQVVTTJRu3xc4SbVkmMPXFISH2eOf02y8SpeoxDqSWNKEymUxYa1arXPgVv0tX+UsKFHG y6RH/SyvOaQkdmIEvyVbK+oVAo/Cz0r+69yTl94Nc2VeCs2W2BQ4MizBjw1sCXxyqiDbiooVaiN+ btzhu0Yc3iTWcE6UYcXuipZhQiNwiViukpH/HPnc0ipKZsf419rBDDlF9cWTPNRBQl8KUQcNU4lE f3bfhhLQVMapPjirFqValWhYJT7RxD3N344yOl0bzco2AqC6D6kKdue/PRY2tG/xyk79CObtfMmN VNtheAkXt7KKalkcBt+8GAF22g3O587fqpyzItYHUjLGmB5WutBV+qQMKXFCIbiBwys6uGxxSSEb 7vrSaJV2qA+aCru24vnpPNOd8XZaVd50Z/F/OpsPc0m9QBLgYHC1abIAUhIZuV2t1mjWOWVvo1kT ga1aTXLc/jtGlMMGyzvdeP60UDGQH7s5VJdDf51DKqbdllIkBzp169odFnm5N1vJ4qqVlAJONtil TSti/JWzmE76i9Ekmnb6SWec3HTCcV+Ckw2TsB9sTyOL+eIXqgYWUAyerBomtdujZWu1S3XaKysa sKzsFK2nt33OwKCKToJtVzpC1IrgvzwefxYWVXMAswz+u3UiQcIyWvWKRYpyz7+/ZM5zKxSAc66K zlAaMRUD3iOnEYaPSGCG3UU85EgSKQsRJrTdqBfCXTm4iewWcDERPzF+Dt6iQkzPOOuFw3AawLJy HuTBApArGQRXi/FHyqgNz2DdU+3EYwoxp+NTqL9RNKINgxMkoYHyeCB4W3L/XFrsOUhKBC+77tcV eZHX3GKbYgayZsV7rQbw43dfAqjswH0F15eNGrHuGmWvG66S+cv6BjbmTIa7YkpIXBS7KjfYRcrI ZBmS5B/4GmWKjiKLslPBZRqzgdB6daNhckNmVMkYft1iqE1k2caDSjQsWSsXjHm15eSUNFOLWZnd CgfxdIZ391cLzDgfMIUKjqgfXQi6AWI3T6ZRPzfx3rWbLs+kvG7vVfvNer9RqbR6uzut6qC7281N vHedTbwnCa/buxRMTD6zKeOI5SXXGgmKeyFcb27MSSerRkEnrrUSIhNbCggW5gpEAPDHh+kUtg4h QDoQWDmRCZtSyTQdDjeVUrNgp7f1YY/NXFI6r1zMXS/j81qTDXzTpZsOzlcyFK5MIrp03hRpbMnc uTczO8ltuEY20WrBAwq6n+D0h3E4i2b3hMTJMVy+HhIWteWwkP7uAo2aDxqogCYl6L3AoNSlDwiH +lI46A7vAoh6wUsEcLp2QnTnwLAzvROZ2mtRLAD5zJIpVe/d0YEr5+3kpKPHIRwfLu85C3xteprT yZaTbN5/Bi6pGizPPZ+7hpyfNnA4f6d5lZte7MGWFXGhNF2QktsHI87m7eCwAlvO6rzLmzrjcNa8 11ucmGJJsbi9ykPD24JK0G37Wi1dFPqz3ALTksK8fnRm1nqNfDb4Ixd7l8AnyOTmtmtK8u+cvJWW a5wFW052biWP1lKVXGB+VsmHtwAWChI+7TklQV+ZBd2FoUqd7U1gySn1YO9TSj36/J+ZROjOsDFa LlGDzyUiNTweTzr6FIc+xfB8nI6e9EolZDiRUgBjDzSDpsR0I8PeZ4lGbmRgk0vdphergv5iLYsC 6wU3idP5lphKpJ5rPf/ZyVTuCHOdxO1rsva6uWWCYJPu3WApqlzzEEmNMN8HwHS77h2Ea2C/XzOQ yoKgvLUh/q4z/eJmjaqlzcvO3tiTbHV7kh8jRWDeYo524uIpDTI82tqqfq5VsQHfpVe0ing9OgzG i1E3muah/CVFO4SdNA74agJ3IgZm7oGlasHVFY+XGW2x7q1U81zwoML+nBmocDq8RdnVFfFQdNHG 4cxjlNjiHU9a0W2Xa3gBI658Og1vPeaTsLNh5DE+ods1UABpxBHVMwDgte1tw3E8LY8bnwccgPFH mHxAeKl9dhy6A0PMBVcJqJIgFWq8w9WQ0OKAPN87pWPHFMrdeD7LX9woGEXhGB9CEcrf3GV9ey8Z jbRXPYAwhLkhNlNbTjszHo7nhsuZDiMru7x+IvfcsN2utvutQa9ZqdSqvXavH9Xrfd8919S0r7rm Kd92yVoDP9q4S65I0GjyLcLO33azVMCrtHN+6tGYzWDSXpNxvxQMo/HV/LpE1gvJGDY4VPwY3ZaC Z/AvSofn/IxXRkXmNU1fDW8nwAxSaHAtnKJOEJ06lxQ+4plBFLTatDlGe2oWu5hy06Q3BG3bz9LU HEXz66Qf8Ifrt6kLUYrK1OjjF3Js75VqLTy2d/Hz4aFurJeuEtrKJBGzexC1lpmokiopPtvea7RA T/SSFLSWy6qu/YTzRG0btF7MlavxYa6YKNiuv0gA4VBin6MVHmywqcQQnqFYxZo2bLsDMmwI3p2f vcNTFo3q0LBmVN4Pwm4CTQHA6PcrOVim0WQY9nDvolng2enR6eVFgIJ1rG4elX8+OghYcqWoK448 UOQdRtqDA6EfTwEyw1usPAKSMLgVKjOeaWKIY9NyNSYtGCB5BusbufJkgB2A1kh7bLiaxTFiYeIX 7CtxboVipgOfnMfIQftOscydV6vTtKHsZJpMJP2D/epQv/J5mjCOF/RLwp0PuhJeL3RzoofURtvU FXEG7C1e3xOvkAfefA82DTmRzgWlBU8MgYnHgZ+caRTJbu/JYu7ZfUiZUxsws3XXq0mDFvL40vh/ K2KvLMB/4I1zcUxpoM6PTvYvj38+4tWpkdOOThL+wKuDGbJeBp9HFG5KR5tCWq2dqUeT8vd6CorG l+VFFqRyThTtAlk5vWpYH2Dw2j3M6DVncELdyuexGqMuVgrqwbPAGrIuXzAtDOAMheoouVDZMRp0 ScRg4awFZnBGknjPgEnMlc0DNFZOWTPqY/uRqEvdOCBXbA8rhB5YSrjDuGZ6GGgwmiojvdwTPH1w q4bzD+04c8iUpDMdYa5s2QVus8MeoKJDD1FVbWwdjZkfxqQger6t2syOqKSqsb1eKkGPQWFVE7aU D0JXyqbYyvVl0pHcG2L0exox7g46qLTBCCXXhUyYC54ptHvy5uLynOSfR/uHR+e6bU8VBBGsQ/n7 eTSbk8J8MDYwuzaG0LgFyEaKozrvMo6ieUjL4Oj94BWYgWOiZDX4XjK5JdI7ue3Mon8sIrI+Ebzk AebrTXG3WrYPTgdvTn5996NqP852oQtLQT3wuFDIYHPfJbyl7CJg6xQTFLvDomLCbA+JRYZYIO2x mTVVziH5a/ZcTEPbljiqchYzMFX2v5Nb34Yp+xCAPCDcAwDtHoq5Zc2Utr0zfSAyZJGVNDFxjYWX c0gEBG2YOYTrrA2FMqE+GWXiK+dQpFec3LHWaFL4q1qjsWuST6mCi0kfruqd2A7vZJ2tczpW4LMU 5J+xOe6OmIFoMU9GdCi4PLdhWD37lgzdlqw1D8jYXd+hGQsNVGse1tRpFM9cY+6sYYHNqSiNtZ06 5bCBT3HWOgMWbXoTz1AaBRREG3b3oeVhiFvm9dnpZfns1V+ODi6D0WKGhg9BaAoeH5aC0LU8QzZq O9+rQZuMY2RTFD90BsPwakbe+k+UrEuFf1OSLoqeQV7gPyxxmNBNw3n4hFTYKS8Fc69ApkP5xqzO o5pbY82UqtqZ1cgT5TwqLBOpXGdEIMp0oNnq79QHXdg5lUp/px3uVvvN3aUilWuvSOVaHP/RbKsI H7W2K3g0LO9bmPDr4wNOgwob/oAZfxHIWwq50/k1IyPLkAz37+hGD96+w6vt23ckdiQYTRIyk8Xr 7N+zW105hPjGRqcTbpRSMC4YWbBxxWX/U/vLGiIWlhujsq38Pcp60EiOJJIFJVPeCig6L0mA/pZm tp8F9d8KUjBdTDHrL51p/HJ8+WPn/P0JRkC9JEsN6QVYvu0xxpatA2LDt99IbpGdXurW63L3ovch Z9N7jKeoohFlx5TVlFOUvr6DBdPFkCQWwtJnUIZQAQuV0eN/XQSykIca8CNQHv7gHG30eRDsWYI8 6+JOCnUUvMtB7SExwG2WF/GQvH3yF5CwAmjgEZo/JsEbsiC4GibdcMgLiMEViYekhSEnRzhMTqnc OLrBAhX7HazlIazRnBNHmvbFILtNHkS11m5a9WoWkY6KI17LK2geFhP+VSpMmNNbRnItJU+d9+uI TZU+RXQkGQGHIz9LKxJSd+9VYn04jm+u4941HTw671gvHPYWw3Au4sJpNApjkuyPIlTwzFjeLwdy 2JsvQpboc1SxTzGsSD/CkPSw9MY0o96EE6AeFOtw4663bAinOOnt4dWsIN7v8BXthR5ly5q7CxeS m0qwDy9UvZK5V3taQK7D7ivD0OM76r2cqYuUijuJV1TfhgLFoJbXCGb75kFs718c/6+jnHY4ublR Ad95IPW8RjYYSN0PT1wRBVN2dZHFyAMsjAlL+UCDbVlTg1vVisYEzPClV/BN8Y4N1qVB33yPDzOY WsvDVC5LNx8bQ2v0xDYFcG/D2UWxFyGnkurpsxqanhE+Kvpr6pu6ru0sYboJvXRZSBsrhDR0vLjn 3Iq9QKozkIqeyquA1PD1uBaQvDU3A1JDAyk4Pj05Pj1yyPGzR8FQXcdYlhn2+1P3Rk692Lf6zyk3 3hBOH6mnRkQLbN+u/WUa+moN58DPbF2HMlQ8unAIt8wsGfLdqNVZAp2yTDrhNfhl//Av7y8ut68K ViQWecev3h6dAozgNhL8bwnOAOyd5i4U6fJUIMtAYACrtA2jz+jmlpW/riUVs6CJ17Q128oKWBDA m1T2S1xwCaQVikbinUdeDeZqshVu4j5wujmTtr9qe7UVf8Ll0tUUmJRp3JsFz2AgmTsl3ud5cPpS aT9St8por7nTD8M63CrbUdho93u13V72VulUNddK5zEljq+3kG3jDwsvX+8fHOFl+9Xx5cVWvZoV y5BNA/JXuCxxhmEjll9LbrS5l8odzQFkOt2BVeg5+oKXdQe29VeWD8Q/k4a3jz+fB43acpdcddEP WIv+SHc1QusO6BAFLDH9oO07C7Y5lNLL4Pjt/psjpl4Fy162IdIa/rTg93YfaN6HzvnZL52zn4/O T/bfXXQu3h8cdN5twzPF8uZr+JXXxIC0tOPoCkD0SUxvJD4IcImz3jTuRmxeh014WFqSTWUjRONj D0t7gdoa8ogB/lMufGS0E2GqVeiHHpV5AHoxaDNBgxxSBr/NJatsvV6tob8gfToAOr7sXFzuH/y1 Q2dO61GQZwZlQAOLk+oewaNBc6N56ikn/40Bz+Ed2tRg7p/QaUxn+Q02iqWt1mRcNh2jLBP4eNKm otXQNL66Aj6fjaEUej9S8jczBCgLl+BkgpGVnpYI6nNj5RV65Z7SjDNxXUlpz9wNoyzH0PoLNmy5 nqU95JijzYPklzIN6rfbtbC6W+tWKrutVrfea+/UWlmKo2oZYqOe0E5ptavkOIqfhAh4K2InzXB6 1StJ5K9n8ONTQbscGmfUfjbfcTzvkDZTXH0twwF8pTwU9Uu7HtyC0UrN/zICtsP/RtxtzMsMJAfx MIoTDUr1U7kTDXYb9fbOXqtdqezUG7WoXYu61SwsdTUDTP0IodmstxpId+QTHinLju1aAa07Jujd Of0Eu3aGaZZH4fQjoKdCihnh2nadiy7ms2AYzeDyGc5D0qWL6xLlNH/yMvg/tnXjyf7FZefVydnB XyVaYcpNOjeyTS8daCi3yjrxheRwTccfQfe7qRVxZBTedqPOCPY/Z4f5wLGIKOyc+AxjqqiBVtLh H8dRQV0ZlO68OnoDHBWaUSyvTOvS2iU9iXw+6LrIhKIRzibYfrP/rnN0eshDKwN6QrvzqF8K3ry7 pIcl/Sw9Mydfjg46lS2tnuioAW5ophf/eSvvxh3V4/yemFymEtmdOTYUjr7LnuzvRDXYivV6v1Kp 93Zbe43+YG/XsyfHLnXj33TItemIk+R7B8nkdopJEILtg0JQ29ttleGfHbit7u014Otei77ulOFI 3AteT6MouEgG8xs8tV5jRM9Qgux9G497wwVswe+ASKIkf1a5/t5+/GkYpp5E0+k4wWdF82w278f0 LLBKPh7CCVe5fmw/6gIztRjhQ5pUtUE2M/VqUxHsaHoVddiVaObetACt+yW5Db2f4Yn77vzoUMmQ YWYlwHdgLOCqWWZrzQAt2+AAQDM4eLugSpdv3yELRksIeDFJpuH0luzfgCWDkwyqGwUXKuRD+F4X pkfOPvRaf1Skf6lPGXAnHlNXnnG7Kv6SDubvJOeIen9DH1Jg3+fBzyf7naOTo7cXZHBQ+M1fZT6a 5FUJvv8+qKE4ng03MQRqEy03d5TXlQpG0on+gdJBNwFLzTWfSeCCT1JRKtv5GCPzpr+WnCCea6uk r+c6WGaaF1Jx35cbyeAonyj7AR1ANFYmnd6W/VadbltF3ZbPklP0Hl8QD/+e1J4GNyHyPQBxseUU XNnaciE4S1swojyQAkjnlMtVt29tWWN7DdT6H8E2rhDULah8E1Pj9EU1TDJwPM+oOdJDdGbDhI0l Ym3Vp9uS8NaO/CczIl81BSQV99qKfBy4JhoId6s+B7ZRphkk1NitNkgoDV+abOrNzjU2KtkQ5FyU XIZjbZqSnXfohAHdGA0NOmZ8VpIWZ4OXNaTGcJ0VQOVid0oKZP9ECdOjMgmFrnqdkBz0r8vfY6si oXJsXD5JUL+vecOhfzYdTioNkG9A2K4lMls2BDrWHh4k1OwKmDyS+9HZq7/whQQ7tlQuOqSgrQ0M 0DGCB/pIkwUzWNiy2gQCYyZcoU0D3I/grEumyheMnXNqgI1NxMa9XcbGIdwm4Aog7q/bKYruwGDc m3ZG8dix8IzRqwKjWBRY5HaS3MDx9SkaYnRcyqE0gxE/e5g/cmlzlbPMoMhNGFESCP0cHWLGwY9w UMLd54ZcUeAthlEI0YHuQ4nYMpgueuTQVVVpujTC6Ck+KtP+Oz36cLk+rijkSNtCswzS3jwaLZbN KxpG5JQV27o5mB/dpWO+RZMRKc9LiQWGwMHgJZoc37EktYnzN3PXjvHQDLAT89tVgDg+PTz68ICQ MHvG2SHnHI0CdoGZ8dMZsDbwjUJvBhSPh2eKYYV6gPIzztoVRJ9hv2gPYJsE0A2kShZaxWa1KjcQ NpfEEK7Tjk4dZ+8EsrnOnTKgPmfRnUeW7tyNDiTz56Swl0DJL47eH54phbe/6RLp3rcEQu+gsHVq 8Om2tdVd9D5G6LqTfa+l7/vjYDGBi37QpXD4ibi9izDeBjHjCIqN5sxGDtAPYixw43zQzWpTnJaI xtkzlnlYxxOaowb4Tyk4ert/cAH4c0k9l5Ya1WYMXKk1emqaESoOjaWNOF+wN+pCz6gzGCbh3Ajx 3mEs4HGfr5RGWNmsVfcoClSzioxm7UEmCUguZr/za+B2r5MhXhfTj164RWlxdCmeIxfowRrOyTCW rIpThhloOo8DBkZE03RlvV5QNcRaOFPQKUTEVArZBVJHW7lW0FWUfb5Tx6ySt2aRagoW+wZl6hcU CIihuYnCj9rgnp9PFrisE3SdUV/VKyIc5JcmPKUYQVzA0Q08NO6HAd4zkRZqEXE6HB4tCmWdKRZj CYbl47KYHY1JK2+Ds0Nd8NIplxWHEVQeQTxTuLvhrT3NAUoub7fIh0wzBZTJKza0iYHt67R59/ZK 7Rrbp05ufYid3Y01CQ94XQ9e+kkdj+YZFYDyvKx1e11fO0jxWq6429c1Xahg7Pi5cnrNyvw4je8Z i/Ja2lhJVxXE99UwhtxYUJDfVxBfmYIK5X0llU/XspUWTWrK8J0hwogn37/jW9Wr9wd/PbrEaKOA WvJORw8bpDk4+8ooJ66Bd0mqQzuZiyLdIu3altiJOCH7TikCKwy99RouRuyukeu7VuJb2dJALcrC u6jvYdYZqo4CevqoSMwCylAW80i7/0VwIUNB4TWtRjicsZXTY1y8x4qxnomaikUhRYugM9ldk8sZ K/x9VPyS1ozk4b/rlpbZAHfDiCxCfPHp+gS3nRiN62DO+ojjurHRhtGh2aT3fHx6gXYYWz7RB8ra sz4uyxGNQ8wqsYi1aNFNR8P0w3vFlhqfuuBPemG5ritGwG+OFMHx48sUT01SpV7RADXDUdHn2ODD U8D16MAgcjokpjjwjjXWvcygiCDGKBr14Jw0JpdmdQvGqLIU6PeelyJo0r1pFznHnoCxmSQo1LNz 2BsA0/AV54/HrHPRodD6TzE+QkIhCFmv+SN69qIWs4smhFirT7dj48ILVZSHMlaluy4qA6fJTeZ+ 7NwTRCvCra53SOps2wN9w+PzXkWklhfMv33vWRmhoqIyMLgK3KHiBy1OgA2Rro0zgGE9EVmYZSyu asumHqp0tqGSw2tzKcVfuwyry8FqCwKevV1U+6A1azvtUq3eAt4EQ/81G8x03wH8JrUn7QIZe/Dd Sz1rLKSfm8fIqIk7UcD3g31hcjiWBIkWbgIl1+9GA7yakk8PChee/ViiUCNbQYjIE0ymCYxpNMNh wEaT+BzR52vAyjl5khuhC3FTWBVunTGdW3yUKaGFuqSxmSzJ50kUIGPJdfIRMpvqyJI9aDCUNRjk vgm7mi75hGGdV2fvTw+DP5PJVwYzmedlYIplnGGP9LniisFVb8xSmxY4myMeXeUtLVQTOUnajY44 a9NLqrjTpvfS4WKwfS3zXNZ0N9kLpZxu3Nmfg2wV32UVPYvsNr7LghumJ3b3+PcDdxIOR8lsjnGU MZS61ULBKvvc25gViQB2RqbEd9bosDGii8H24x8NDdbkk8PKYsnHptWUrMSw3tDYy7SIMX1lZffq bXvV9H5llKQC+r2/W2Hts32xWNjXusJ3T8t3vMya2ulLivPbLqg8d1ltpB/L/sWP9GN1i9QbyaFc 54S9Dl3I96q19iJvPEszQ8eDsDnsKktaqi+iq2LMfo+obXNnhpXK1M9qxUhm2UkGhhMzTf1JEZRr c5Hi+vk3bltAeV1KN1/ItmDrAbIVWMNV3pKgzktIwI2HAmhDmw33vbgmrd70UjB3x5Mye9CPBsHR KXEMpFSilDuGFriihZ8ni2k8uCVfxgKGGXTDPjpvSboA0Blh5kqgC9uP30xZ2H5tk43nwZ8eTw4f 9x+bI8cN47xkBCpHzMpRFNcaxXF6FMG30RhQkeHxFYXPSr9w1/skNXWKeT2HQ4owM0Wp9Thi47qx Dsut2ue2uZoyQqN4z8kY6idjjt5cDnuYH5RiW1GVMs8Lg9BjzqZpMqIWaEhk1PXYBIgm1QfRSOSG +31AUIx+CxyW+OJwxiFkixccsiwcDFCQzhxIPA0sgsJ6tE1uykoBYO36ZaysiOUuASqRiIcXU3u4 XVRVi3QPnehwVThCj6A1XFWuvm20m82dggnIki/RcQQ6S+Q5FhWy6bannJIkyVRcZBJnJqqNdG5G 1JmimWnFFZZj9yuZ0tkU40GQVWuMpsSpCPf59J1puxFWriDvvCmt0P6pc92NeaTI47oXdVKisLGD TxfMJNy+RsswvlqgJANNrR6jXRiiMe5tQI3cRLh7nqLaAuCkI6iTDZnCjzT0XmNZDshn6aN8h7se hR1UXynZYBvF49kfsCZ3OnhV5XucvaqJex2/mUbWOoFVLVcgLjIV8kv75iWWZPPsZAKEEU3BbB7I INFr9KQfUmSO6cdUvDBMegBUBklfGBCa8MsEN6DajYcJmxNjEkiNgrCKN9HTacR2SdPFhAwNb/DS hrsarakBXNICk/OKDE/PSgsH8G6s6IxS95TV9xdOnW8IinJl4Zgy6NFxbeVK8FDra/tCr0p+NQrD E7Yswn2e0jmL5AWxi8KjjcvjBcqzRDYLpZ/hS7ZPU7AlpIJLLLQH9X9W8TCzem6tuqf6o3Deu8a1 gHolW10/53TzOsqt0VEXneA/jpXUElluRtXruFERPRfhTu7+KaHSsbwizk/ZF7ZnJbkMTNA/kRE9 sy4NKlojh1NJ7+kcyWZ2exftua2qnpUcBY66bAUheBFUUSgTvwh0YWsvW2QR02gRGFKnTkELyB9E ZL2ZoiM7MG8OkUfBFgb1VqvaG00GY7l+AEeLDWiQSjM2yTYl1XDtdvxQQWyxjozuNAo/KmvAnC59 ouxCwdRZ1blX7C7DEOojhEG/F1xR9ML2I5T8X1+9RhuN6l6pUUd7/toemjChApPiNIuW0JESOiaJ 3d+X224EgaZnIZq7foqTxWx4K4K4qJ+lYVRnHTLmkLD1yBVZFt6VVrE8hZAnvTMK+UqVhyFua8cg 9YUe1c5c496UBZx87rGRD8mbEIrqTqMf4LVgEMZD7aeUKzi+LjgGFMWiZQNAlkYwqD9LqGZmwV0R DkuANE8RM8XW8hifmj9N2aiM5nyweZt7gt+pElkLV63O1qwoB0wg+0CNpnqQy9lsq539fp8k3Iy5 Ym+Y4m1NqytOGf8BU74357gpz+iQmPscbqmwnG/3/3pkh1njEpuoB9OlXQqqUCFTLGu6rPAhUzRH 3+g5ELk2axuzr1PKRi85/6pjvzcbzWapgeZT9WYbrZ7Ftu5BiJqiPeSpRD7Pq1RCmXaVMd7mN9bl N6e1uSynHTxqAs6QuZpx9F8pVzFa+uokDJf+7We8itbFYts7qSfB/4GLJ4UxQ9Fb9f6cY+rYeCZQ sWIK+Li4lQwgteO3Twisa9EaTJ97/17Jlm7GInLmFx+TuAmbeEdGsbi8o6XM4b3Zw2CLNQko7As/ KqYpWcw54Jrv6NliyBKGkPp4Q2l+BuFZuC++JUtkG9ijv7qawgGGhiQZFDmBu6wDiigBlVmfS0VY W6zuyGnDw60lXIIYCDllsnyCr1SGB/AVypzMNksjhVNcTsz+MoqxKpcFqhmpxvdCL+Cl2uXLrICw UbnDoGZf67ikamyMG/iBrsuTENphN2gJOfi02m2TM0SzvlPjXCUPcsQ4diQ8AMKOtU1HlIVINZ2k 1SL+pdVidPzzWbAq4aNswGUGrMbkNfiB7VmD53BgpbHmj0DSr/mTypyzaoKaq1FOBvly3SDwWunq F67VtT/N691s9PJZL2MM6A7A5riadbbJr+9VjS/DOgiHwUUAV2+iaEKm1GugOoWQkd2B5DqOZp1J 9vJIIdbRIgNRJ1fGlCmlLMxoo1JXLLaHcpRi6IWVonwFzMeIAcIqKDDtUVaiJmYfYLv+B5m6/iOJ 8FU47aISEo8vdkUhT4qnsyD5CBdV2N4+aa3VCuAHSRSmC/LjQo0SS5WTiYrTAb3H04iVg6SBwBBE fasNugbSbtMSZpd22Hxn+p1jb7Ca4fQK9NjeUwvtmcoQAJFOfBwnN+POPOnMFtNPMYAT8wLI91kH MGJip1G1z2lqgsnI2o3YzqqG97sjw6lh8gdLHcVydnMQLklufBdg+q211VFt7RCOzrNlGGEACW40 IGl4RKo92dwttaqwJxu1nVKj+WB7cstx2KUIK52wi7712yypTlkhuxIaPW5/y8ZR3ClFb+lAtVja 5cysh5tdys6qU0Gpq7cM67qad1WV9ABR4jNPsqznZsyglxs0nTBXTPcBsfQiG4pQmxNsrcVFrMdG BJm/1VyFr1aWcf3mpdLHpf90keLLwGbcgFsq15xoXebvKxvurMMCF7dSjDU8+KrRT5BcYZ3FF1s/ V3PFpsmv6b3jovo3KVynbvCMVvHE0+1yvFrcCUBNSJ5K68+XIiEwIrhVu+EbP30rqPARXxS2p3r2 nBjZ1VK1iKdgl6Jifmu5xHPL25IMkFgzPZs8ArvefFKH18PMyEe/V8/JRhIi3rs7HF1phyK7wCOV PwEbZvOkMqEtJk6wNND0rBRcZB/V6L8quUw6Jyw7A62RhoX1QbbQf+30KyLWdG4HauMVXlh3xr1a jefdlqhSnnmTcaw7bbYYvcg8+RdP2jctz4XREe1mC9tOCu7tY6+1i6ERm7u1KsdGVNCQrD0IBfkK s9ff6iUMXeqZdUb2K25y9qP+YDi/N2CWR2ahYajcRUaRsCxxEY5qcx2Y9GGAn2ETVXf+vas7dhYF tibK4HfrLZZqqEUR3zxcFPkKi6K/NaxFydes2h6qPlH6utDVgW/cqDeuS22+AuxOysbCshSHxN+v q28J7EwsRsOhehNmR/rkZWlVq3VellbTXZZROFHLIl9hWfS3Ov2Hy3IPjA9y9AciQPHJkDa1UEMH k3qwPZCoHx6hc86F7EGEKP9ZxiB58/ZLvlfcoqyDSJtCZGK0/T5LxjpIG/9QUdqqrUG912pG9Uol rIe9bi9sRZ64t1LJhGmTBxQgpl0t1eBORp8kJsEoaMi7YCH4nFBwl04tFUYavutwv1gSYEcVOA/C Nn1XvIjlgKOEWpge/d3hiZIsmAJo5jvtdxbjG5hjZzJN5tBEB7BF2pxGGOEskrZL1OlS76P1MH5t rBcezubHsjazNFJOQuHjVIvewW6+D7Ye2ok38DVgiGFDlEHayXj9+efw1g5fy1lmeyGa83LOFE7Z qlIZiwm+BPqVmHeZkNNwwpYlfdJcJXF1CjDR1KGt59dwa++gUUUfhXPjxZDzhBYknBecrcDwYDy6 3bvtDoNc1qboXKH3Gj6gEwSHQzatxB+k5+RP106t8YE5KVGXaYBiHFnUTSxmak2kczxv0frDHUAp 78KR92fDwnOD2bg996+XjAfWbrnHoHKCDihv8S27N6ctXDQFQJSfZlbmSwb9SNRCFkp4A8ZExF38 WMzg7hHF6B+CWYAoYT2bG+OOSaacz6q9gzS4uItJGsmWQrCsg5MS/JkHz3jVhDFgqgujj68W01DC ZeNk0kNTtcUhzfdW0AOdXdE/IYUewgxlpyx32iwdILN5tdVIvbaYD3ZpexHGl1wvOPtvA47SgyCb D0XuxFnudkXrazOi2WYQVf4a3ZL++C8XZ6fitDOjWN2LcfwP0gkkyjSNKWNOiH1AMgqjCzv+Npo7 hvD2nxZ1xWJy7pmdLpNhmb2TyDLDLtIKa0woaTjk9N/X9CNRBGe4IY7RKnwM/xBuqN2vVWuDqL9X rVTa9fpg0G7V+56Y3FLJcEPygKh9A6PWNhpuWHZ2wDg5vnjX+dGJGJsbhDZCh7VUzFkVmVal7pDk MBhL+fhU7gx1zGiEJAC+pILnw+Xh4te327PbUSkYh6OogOhDAdx0NAPfRUGUdSib5XzsEgIcOEqg brfJQtzB2C4hjob9WYBObBUtKz1+++7s/HL/9PIb/tMvDtBV3itl2S4ol3l2fNBx8Yt3GYkK1yB+ Yuwzh6wPTvVF2qGDmI5+EnEqd0roxfaNmhWArQVEks07hzHG+uL0u/yhYvQDP9xo4EK0diRT7por QX+o0RijB59YCFvJtVIE5IYNHmSRJG1KMrAcxtgDA3//7fg3csKIhxLgfhSF45lE2L+O1IKV59q3 bAazxbNHUwTP9d3tmk4qDFKMqotAlCE8BG7zmMA/jSJWMsiYTPdcys1YQNoXUhhg+MhMa+hVQi1K E267y0I+elyyVCN2xMMp2W3PFsrpzgsOUYUKOF4xC66tgPfHymJpQO1iAgjgMHHwNCnsQEiwGgGZ AeHkVFoCsyqZaZHbpzQ0VvU9miTCfx7U0xkbawiTwY7wiAxjazWsnUGFyRkV45WbtmdeaPgzvun4 LWo/no3Z7VXt2LCLkdjxBJtPwx6g0lj5xna53JsDzvWG0TlnbO4te+YpdfmUKhP/TzFN+/RbWKf4 CprjRIrcFq6ydARgCwRsqvYNuvhFFSA+yo48GeitWdDm+TSRU42wxi5csN910ZQ1EASPZxpnryi9 XWxtePL/nUnAlBQR3KC/dEIO8Qpz0/pBQ4xDtM30BtH6vpI3/GkmtoeYtitqO11E7owE2Yw/rqym fsvheVRmD3Y15mW+Caf9mZ4OKXNN0D6O+l1Vp9+uKBk2obl4oyEcl/2F8T0Y5+MRAPX8iC4DdPsv BjU9EPbNT8WwSVPjj8inaV2WpCtk3n3Au5bJIoXbVJFXBTMwlsVxiYb0SbmQuAW5CI1K6qhj7qrX ERWN4PTw1l0PKIMI7d3C6RAU+giNJAR9jHckpaENlETLrNGSwJdKyllvNKul5h5Gaq81S226Izve +/aAQiuXXSpA3vbP++el4N3lOeXyor9tLOKGTVWFssFPC+LJ7zjp4PpMMHlPoo+bww8eB0fclJJP zXLVcWUvGPN7vsytqPjFEusbCzVj5UQhrzx52yTOLmc+Xd5LJtZuMW24672bpFK8acmQJyoLtmrr JzJCoKrSCGWgzci9Jrzz4SAX9XtAgiD5AICQsBpLgFHLBYZm34xXGfn93xUqvLr3AIqAdSOwsEJi JUrUc6GgglllZ1rO7LdyRkS7est5wFVMi/BzZuxu16yoU4Woky44YqTP58fbvsehJQ1kTSHEVMc4 5VibzdJAEYAp3JhFj1dH43ixdAr5W8U7AwZaZpg1S09Hw5QeyeS07DOB3GBxfcNehsyrQW+73fvh Xk/BPbDH4kzIsixYNhefs9a9wd5wwF70bYfgmYQ5TVsELaUDyvvcG2aAORQPDl47VMI2r3T3FUG0 uDEmeyOwvpAYkofRIFwMJdQMElpDcWYqhIDOw64lCpQiBljL/fcnsjy0Kb94nr0M2q3gq+gEGo29 Uh2VZo1GnfnUTxSF2k2mYA84GQxmaMtnF+AdgMndZqQsyITo/GQF34SzSLVBFUSTpkNwUjM2HdbZ GPDKN0r6qE2xgKKj/juY7THNe9CMHf5z1k7fkTcg2zLgDxgSJ362hsVZnEg4Bf8ObOBiS45bNwsf VDIPdgCCJbKHfXE76ibKiVkpYilZfKO1W3PTjh6cnV50Ls8wqODRm6Nzopwlyo6OI5wWUIUBPHN6 Rw/GnkxJ+Y7xiDt2E2tGwbcC4Jf4KqU+ciTV6s8ZFB4UCOlU1vlVkTxKbisO3fM0t9QpNb+tkuO1 /yAjyzZ457GJyZ71DFfSUNcNnJtK6VYkL3DONZDpFz7Fn4BsJfvH0PkFeCi0s12rk4y9tVdDw4PN 8dyTJHm26Ipmp5usm6lYFH++t9bUnR2Bud5Sjef9KJhszrQUd8u6RgpKl4gtz7mWrbBGxjU6Qz3z 7Sed22jWgRGPk+VJowX4Kv9jbzTJB1MOcGGxe+G8vrQeJzSqtwh/9qpKSZpJIOFGnitYVjZQQvEf vqtD2tGf87k4N4VMZ019s3d3CzUsAqRnOoXCZBYt+okJLorBC9Q/jJNk5Y98yQRKkdKfLIWyijCM cq3tguSXqMKiqNdtRbVmrV+p7DZ7O81qv9/qelRhUsvShckTTs/ebrBtkHyBh/g6ZeyAjzD1JZyJ NI/g2aSnnDVIIgkIj7rAOSeMSiXVw9qid8asUhNlSJ6iaUrc+tK1Vh1rFXJg7KqXq465ITsRn2Xx bnLxeYawTNWbbrVot/pN4EvLt7WFUmBMZE0ScjTPQXEgHgTA2w37KGaF58DMjrT+BiotsZUksoKx SCPRZ2+tMm90a2jAK0eDLUe5q+ZoVUqZPDZqxLsU5fNB8OULpxnLvynWpUAQLEMtlMIMI07lysGT s8gBt755NHJQY8unM9/yWQrkYYbTYtFt0adh5/QFBu5qUD+R1k+Be4vs8wXoe3toZyqfDwJ0Er9S t85i50I0MLgTsJC5UqmgYPnb8bfBDYZmVIFJoQlxQ6MopphyPEiMi5R3Xbyb1l0ZcTXn50u2CMxp 4xX07G2786xpsSqyavfxYFKwUzlPopHX3IL/2CejUa+RhbF8PsTKY+NfzIByN92apHxNmpyh6coU 30ebcY0FSBmTsxebU+68vl0K7jEfTw1jSfZTXrGMSw2GrEXXEvlEb0jkY+P5Yq7sW4F77y2mM8Oz U4ngGX2U0jzwHL30BGm6t7D3XpaCm+u4d23bCdywDm+AKXGRmZhx4EuKgiV1D87evjs5ujw61Iog 5dZJ/aJQQrY+kCXj+fvPf7rAdZAjXRMALSMWiKuTV7flnJp3a1MFc5GClPT2pUrfqotabwtGsX0u kA97aJBMsZET1TwmJgHGrJLlykbxOO4uBpov07+VyfZe2I5qrW61VakM2ntRN+zVqjtZzszUM7yZ eYbYU6txWnX5tNwL5tPbssAEuHH0MoAnHfOkFFykH9j+OY4IBc2RS0HSldgTVQ5OOZ5znDs7RIET FAgmq8OYsktk1oigFPxHNE0wT3O/xOTOa2uQLiYyz0DlMwpM9tyLy/Pj0ze0V2C9CjqQJq4VGnAq qU1HfK0IjPUqbUL63HtAMOokVtmQ5yZagCNNzUqUHWy3a71IZXuah/EwcDI8Seew/fHGryxXv8ic geDUGjjpZrtUezjkMflYKA897CIb/EZ+UGAXUA4UIENEZPOY6eeCgA6HJ0+CjMF+Xg1JOaqCCMEP DAmoYgxh9997gqvk9s+m8NnBa4XxipqcPi1zxOBK8unihPPUS8yaqry2LWN/mp827P9Kn9iP1Q2C z573OkPnA0zGlgqmFA1xw8O/YqJvBw9fuip6oDktGFUVjZvLKjKQOX2tMgK0tOZFShC+KoxFQ5oZ W9Wp7LuYkHk2i9mqUOH7Dzp3aK1RJb+7GkYqfcBNJAueJqI2IxEgJcT0Etm9xTzwD8pNCeVKZKhW QrBKApTA4Zxyl0ZnB5L9gmGBhPPJ7UAr3LDQcypUSxcquF7oDl4CS1xAYdA8HqPNCsG52SQXXPhM nXTQuAXnGQIaHllwhX1wkXkCoG4aKv1cKIg1cQrRhtLI1GMMgAYdH1wen52+SxPktU7OjY9IOvDw AMw9HXWJexyMkpir1mxhnl8AdLvmevc+BKADA4x9pd/XANR3He0FxYTOFFF2CHK0Ft0ZNIRzdA7C JSdgc6/NJ2CrWk+dgPed6/JDsPHfZ99/n33/Bmdfq03aylprp/6wNHmT409vKiUpWHrsUbNrHXzu YbesYeu448PEf+Btdt61W20iw+12+mYXwUU1xVigfs3lLNJPcoMvMKKljRIMwU3rp2hCvpC60+gq +jxBZV0Ys1zLvozkSWKESKeFQ9XlRxdBaKfWKmECydpOnb48KIyIbK+4tclZIvtnmY9+HpJprzef QEytjAlJodAmduUkyyRbqUasULUecVag/hznZl7JlAez4zVmlfD5+DoyzKsEA1Ch5XNHhclHQxOr jHN0wqZNB35cw4s7455tNlvWq9vaeU6dnHnnun0DqNnNcPvi17evztTOBrLxekaWHh00WpeHz0Xw mxnlN4zs7wjbKW5a3viUPO4123FH4tg4U/tEqQvo33XdcLnTO1U1W6nDLhqdXgib6IfgpzlMl4Jv 5bT109z1rce/XDyxyn1V7u/3cqAXJ3x7F/2rQvrhoA3Xs3LbqIL3xjKHz1qGYHbB9XGLfah9qMNv 1sIMLWsnbIBfuRigODrBAjd4Bv5lKz0P9KWBz442BVCt7exUH/p0tWirOS/Th4WtNPAdLkD2fNwG 3fPW5F4IiMsbyQlKAiyKj4cRTZWGPZHnjPDbOHR23d8i/K6H3bC3Ww0bO5VKq1mtVnu9WjvKCr9N PSP8Ns9oEdFRCBexuuP6Cf38tvP2ovPL8enh2S8XQZ28dZUL0f7pm6Pzs/cXQVVMJN8dvn/77uic 02R22D8ImY1uROJ+9H0irzG2ZZ8kU7af4pFQSO9AwkmUTFI/y9QdAINlkS8SD037rdLJsKfeDHfu nDLHqBQoWFY7jZW/jQdjTO2ZM2gogOiXSfz5bRDI/PNmW8NCfN6uLlylwpxDU+XSfCSRO6bRPxYx +vyi8S9sP4zcsqAEaaKFQn9hlTmTXQTRRQAnjnIBQi92RvpkvRqGt8lijoos9OJ0qotTYKOO5pbt JlwZ5jNqZZggmcK2uFb3Fh01qd0ovrqeU8kAEY5TucEKhWJdxA7gu3WWf+DydQAgV9F0MkW1xzaq UpXl7jDsRkMl3bik0CTi/CJuqX3kjNF7EzMNDW9C9CEbAhmM+hjMF65Y4ZXylOsi3QqVZyo8oK6T AUUTxcAF0DIaahWtN8zwxeSM9fWFZHI7pIS1ZVgbdBqDoQ9vg2E8RheyoQ77SfGpWlWca6tZ23iu 11E4UdEKvE7NXZjkYtTph/MQx+W7BLAZMtmeoUv2jMHCuvbOdYKqT7KZwvvhC1+ZfjzrhdO+GI/b ZcVMu96u19EjrVhvw3Whtqcnabl+X0XjaBr3tH6V3pPN9WeYdG/+uWRZj7EBtmVjfRhxpJkI8Yxw 0d3jTyVHT2LSebKIFjG9N4ULNnVImIqpXdkxOmaM1KkteT8kQJDiK1gcri30gfBIkgsSmZBY9Ox5 QbOxzDa5+zW8L9DQQWylyVAgnqFFp9wx3JwpInwma+PhC7cGWh+vqkOWoeW10sWGKoDcvXNtsl/T uilQ7YuA1ET5jw7PzGBFvowAjqFGgKfqCE824XBCSgTxz38GnCjlXeb5tgbakyeBZtU4gLJVyhSD X7wyJM56fXK2f6kq2PcLHWd1JopPi48W1JaA62XFXJctdxkODcrG+aQYZ/8OIidI7LYRMpWAmIkC 0LR4qj2Yr+JPke3n5iKp4+Vmoan2efAFyCxKZUUFHxXTWE7jyt3QysclZXzKHSqhRHmDO70VZPJf G3CPpjJZoJPMEzXikrJmWCP4nhPb8vV4ijmq0bREtWWiJSrdx/wz+wAKsVYx8KQJXgGJ8YakMjjY PzkBTvp1OJlgvtWfmNCWgmxD1BUxHXaLVYu2HqBDjQ+HSor0xXM+40c64LBl4EJAQ2FIsJgQ46E9 VDVyJkBPMTWsnGB2Fo9yOrKidk/KYGQHm1HEch09vlWrkNH72J1RXF5ON237YVj13cywnl5UQ4VU Shaotk7pZ1o3tVEn3+lO1oeHbuRek7JBGX2ewEfU71i720tk0gAVvYbsx0wzakPqIyPtci8x2YAO Qo+8aRM4BJ5kW3qR0wSSmIP9c45OZZrzl9fNKqXAh4PDNauGU2CEp8B1IuGjkXLwfHXV6XTIb0Ff BDsc8sHbFl+81RhUEGBJDuUuXMl0bMalVxxlD+6cSnbj1sn2ehqNcjtRxeQsc5rPxKfOoFZWWuXY CVaJmhZtj5jr8Ga5C+gXnVYw5TZZygiptNtp+qxjtnavVWrtIFvb2CvVDO/ucdbysbNwf5tO4aB6 nB6lBOuoBBdRZKTv7w9gTL1kRFohoJwcaq5yXXkMTfENMAiC1fxkJx6nT85EOXZYTKPmpfJ5V2mN 66HqapC+WmOubuDuh5TZEs3o0f0xphgx6GWZTDEsDF0eZZlVeJgbDtnCUXKY18MTZn69QE+/q6th JNyshDBPljSACDfC0RhOCSN1iP8lMEqId2rg0gwPf55IVtm+uksiMNQVWAw4h3RxgIONohql26Dh 0pXEJDBFHmPbgBhNLC2BZjzmlB2G3wCWkg7uwTC8mlX6GEnLWpBZmgxi+3xDwkCWKD/onL36y9HB Zefs1IrU0fnp/RHwiel0MXp/ShMvM02cnp2/3T/h6qLvgyn4i5+eXXYujo5OXSk7iylmc7RHvwkR +gnfvxDEYW+OLHUq0Avap2ei6TGlHP9jES0ilwHSkEx5lf5ydPzmRxzW6ZFnSE9hPBgPVNYd3bWC IZDbaaZnNdtV4H2RGe5UEse641VRdLndQraaYjcRDwgD4CiwkUA1YVf9qr6mrs02OUZkyZExCWrk cmBEiIdIYigqMDlpBc8KCvYl2/MKqQBn/ApyOXqqN1pQnKKXmla9WBp7O6Rs7E+sqiZokE7Rq4kI a9Yt+pSMJVaTvrrvk8wvFMgRUqJMI+yX0rRN8JKcKkgyIGSbQkXeIC7pgFSKkFHsSxNyzIT2uzw7 PHtOtxY4FRHpj346sZ3ESyiLmF0rbyRtEaBnpoKMIV1azEhqek2RKBlTSKiBmRCnVig8pmXRMKYQ vVBH0a3rNPEtJ+MyQwjxRdE9bFK1o0mitIG72iF4FrWmNC1owqVJoGV8a9Ktla2fL7S4zd4HfvQn nfXF5f75ZYc2JwYokl32hJvk+IJ5HtglzB7EQnbu0fIUZHSXCGvSJpQ2TTo96IORl1dTOFrYrh3W bhbMbse962ky5gToBEwA/8comphVGaGTQG+YzPTJZKEjvFJooSWBNP/Xx0cnh52Ds3dwJSUBLh+n KsFGeXkxO+vQihZVDLHVJSW9weqCcmOZXwPeou/T2jXI35QmJ9JUWLHO8JOitqa8LJj/mACu6wzo oMGFle2QcA2Vf/dtA3gYOeR1fHuPF1K6D3ZDI31asVHdaVkCZZQhU6iFXI6U3Ang0hEXLJKrqsEw zRRU9GqSspttUFIxMHBBCjlrxQV7ZByWg36miJwBOonhqqIm0bAP1Kbwk95MyAc7gHnWaklX/Rh4 8Jm2llThQuB9BQNNdWaTsBdJJ/YDBR33ecGYgbovOqNw9lEyttWaNdQRNKsYltbxjsCJlum2WFa3 xcdovWWxlblMQ2FZOZaazjg/AkCUSS4RtopWeGDuC3yuWAsF+YwUEAV+Sm2SpJwmqEZ/Gsbjjm+U unJ+aRlrfkl27e0Qp+iUIgNWJWigCsxNUkhDvOQIy6XfkAnBWrBdUs6CbVHvKrri88Veee+poSpf qF9ooHgAo1CO5NtluEqp6cMG5nPhCPEhiEfhVVTiSCmsaarvERq16rVqyahh+kkH7QBZ5GBpcFLa CV5YDtH7TGJO8LFHlOn0/dtXwETSvrk4ItvsC3pDGrEiqnklEAveyfBG3fuI4SRiddUKJVbGJ+Xj RXfuydTEDC5m5dXBM1FIE+wjlC09QSNs0S2psEQnxP/wEUzurrK9T45O998eQetKmD6WSzluw4oY Zp5WXlVIr7rAwAVwZ43C6ZCCesbjeB6Hw/g/QrZBIM5PMifgLRTZhRKDvkkRioqtRqspYYzVwImR ElCTpu+ZEK9hRBE2KTamRCmwRdn75+f7vx6doKRixiYHMyXLNug/GoV45yDK/0QV+1v8WyFHHUgQ dAEoDBwttVBNdlN1d7Ev3IK9i1/Chtje9pUqiLoG7VGKQbYjs6MxEKUKysSjLdlKTGtTU8rbDGbw txfKs3DB8mcTRIj3DeqKZ4CoEiqwnyBCAnM1Jz1eGddLzmJ3/U0kU89qjacd3kBJ8nEmyyTaX0aM ZqMhQiSdNYrHT1oast9VE6IHmEHK/V2V/5Q8COf44/7PRx254Emwrf+h9xFtOBSYueTWjraRoy7G C5oLXl9GIU+maHuxglhnEcoI8Bz5lBUVUN+HWPBHK82B6XAtOmpMCSbwdSai3gCxGyc3xOyRfYds vzQUChJBT5KJA4WdYUJ7aUU1nWt5c52yllGx8cNufdCst3u1qFLpDaKw2u43Gv18y5trj+UNR8jH uPSANjo8vZofJaCmWLV6JRHAAzo44JKA09WR1+zIOKoBSfxzk6JJTDCoZB6kVbgjP7BeZCPuH50e ekCINg/GdIl/Cfh63Uazuldt1ZqVSrXf3Rl0q9GOz3BJalnAkyfssQu0GHNS8xcmxmxpYaM7nMFp 02soo134SVAazXrhJELBHPJSX0TsgJG3F+NxhDdmFOrLaa6cwMPJBLOzJmPKJd0jw5yzV395oczS tS3MzTXe9STxSTwLflKx85eF4UgLd3+mYXfEWEMrSbccc2/OHZtN8L5EXcoOLEv0pSgbhGs+yvmz KWnE3lTMDY0CIaM+9Q+/mAobwSHjtR3pPW1R75zVjAwoV1incpJuZeRJyVztnMj5CWmVPeiyVDra cDMDU39etHzo8jmqnahUkJNavcXe7vWWIjzUwmQaAadGIqL0JmKnjL/j7eepls/Hc4nJLoqBTGzt cYD2qVQ1J8i2cuJYeyfgWF5onMuOOy0HsCDhLWxiX9pZfMUtScCF+arQhaSxoy5uaIvFUeCQ7yDR KVHN7WfyuyAEs0C6J6XaeVTUbAGOpVzG60JZawSJPaBBplSFyCZ4n2vnAZ3nUD3oJ73nSMkuMHM3 WTUgtswk2H88ZWhEaFQniRYM+0PnuRtr3CWiXXUgs7QZLRyC7ZA5N/tR136knE9YGRsW8t91C+qa qewrJCYanOmYBUe1UArs8hQ2zLbYkgU3Bmr3ORrEmYrP0e5iIE6erVaddlKr7eykh+sTVXJoHy1+ ZBgWhqXei/kEZRmYkOE54ey3MxbQWvkp6hRdPmD7JsTZYPtjLfhUCz7Wg0/1gnhPYpIttqfkA1TF mlZxhPDZkIJ9zKgAkDAAQCl47OnxT48nh4/7gMipiMy0De/UkE+diybymB6eq2N0P/7HhqYEA7I9 dCzRXkGt326zVG+ie1i1WmpV/xUryO31xPIf9j6vxGPvcPGGrReBypEYmQLLTNjklNbEHI4YA6qT a+VHcPcXNnL5YCtjL6gL6mEdkvkkY8gIsxGJc+NMJ0kxMYHhKPgcjxYjReNxEdBOjyzq5LjiRIRk a/eB32VefadCDiKrxOPKKcoh6zQ8g+2n208z8C2nfVwypo50l1GOvPkmZMUtx96N6Kp20Xs4R5o7 sS5C/mnwd3KuUbnry5YHS1wIbNgGPtjaZ6xSi2YYQXezWIx3qoU7deTypku6ynEH8voJu/ybAYl2 GhJfSmLYdCP8toNyKcvbMtd7KNsAiy4X4xit7YV0mAYUyom5oorBJB5FNm9IJW3mBuk5JmLE7fSd 2ebYu24VmQy4OOJPYEa9nAcf0Kt2XHHLREZDD+Mpu0aJqFYZRtIQdTLUdABeB3HZGotPfamnoKJG z0XUvIvmhkOjSDHtK5DN8NByo5CJiIEvP/Rgop9PdzBSBb7L4uVaY8rr1HObWLNbhBEwpIQXEraT J0/uY/1kLBMWuRzzmOPoOZ7rCqG+oYqIa9lDr1Kp+I+8TNFCIVuQs+O0aiVKjrPXkPTKWkrBN38t KulHg9miCxB8cnEzjdHWDloS/Z15hcg8RSVYP+ourq6Qw2S2KlMyfXUQ/VS6QHaTkPCZ8y0F27KV GPid0WI4p+0NDBBfB/hFWb94LFosb/VxMg5nvThO11bPH4u2za2cuVjk3ETU0NXEF+NIaR87E1Ea aUdBI+TffpJboeDJPynQtARF8ltL2pDbjXZ2okql1turV7v9RrvtExWperawSD1D3GlXa21k1OVT ojvSNbEPtCbBJNiIRlRHsMC1QHwnl8Znk5LcAmh6JYZTPyKdH/yDWGSQmR+Ugm3tcCOSOFbKloIx uVPRnZ9gOWcxAtcrf9+fqV1OatafhyF5TFIvs9vZPBp1KMfgy+Dg7BDOk87xoZw6qgWS2hXXqWpx BU4L9hEYSE5eTA/G7wNuKxixL1jE5qVOsMNvUOIxQdWZDSSuV8odWMEJMtOuc4Q++cS9H3FO86y8 Ah+WAlvwSfeEVDxwapwVRduPz3jFScLah500jSeSrOxPJLUjiw28jlwc7l/u02z4GiH7RGDxkvqW bN3unP4GVQCvBv3f/h9ZSbU625oTEfMb4zDTefv+5PL41a+Xxr5UBzdA55lX71+/Pjo3Nb07HGE6 tbe4PFDhtfvVaK/f7+/uViqtbnWv2+vXI5803VR0Nrl6SGYTHAKU4vEhhoRzzOIc9TF1SrCtcyug OMP86BbE2e8kuVIOeI/KGA0FPURzBFPD5KqDwkq32FJ9SyZ8B1rkiMdh6o0YKgFFIj4m894KgI+C DzUaY+Ps3E9Gk8G4oyC1JOS+DuO/JKsFabuqpTqAudUuNfY2A7PokT2jfFRmS8TkSmt82EYcYMTG B6mMjfZ2httmh1TRcJBP5tc+tdeUrmCZePPKgGplYJVijmaMGijX8BL5PV8my+W0UjUV+eVTnCy0 +wR2ojWjdrfp6PlGf+rJOWVZwWSmmAZOXkOpm2BJD9VU4JxJUwyUFmeMdTRnKDK7KZmS0DNZbsJS WVdaaIMc6ANL9xAbYzLLym7/bHiM8mcyQEBH335whFr6wBIiKWNcjAN/w8XRFdSb1rRiUkSe/TUg /Rp6jkviS164mFMgR5+RV1CqY2CMqWOARyWqBIAK8ZA9TgUKnF31WVntvjLMuyQ+6aRHUjrouRgc dCPOGRyOb0nKou0vPbBio0LAwWE8wRTh5PUMR2EV1477QzgLXN+eXVx23p1dHF8e/3zUYa/JQspZ NAXxdTpIVaGEkofHr1933u5/KLzI+BHhur/MpsPB7xQMQrVbslBChVlkVphSSVnpR5e8vvzx/Oji x7OTQ7sMR9WgG1xhM99EGHvBpDT+hRV8JrluFyWSyWJqYeGMU/dJuAK2hp+SSW8ZZjkEPBJL23h+ zT51YklKpsfBhHIYkNWoJ8NsbGL/ZZQelI3E9r+K0WBXTHQ9ealg3crleG3qQTsZ/1W/KtZibry8 RbU23tXNe2stri7irq0MLXWYqvGZk8UiPunp6kasE9d3jpg2KM0lJ4PRlfVBr4V3nnFxMtCi5SFP 8NVKO2B72zUM0tEotRo6U4t1YCIAhvF8PiRdNLfB9ug60/csRFWCpDtHp4iZemZM4KkdOtZevqxx 2Ad6FaGSu4tEF654IzKQ6sd9aIOjdXyKyfwmeF7eZuP94CKBcQBzimb3N6j8+xgFZ9unBcogjKRT Wa1HLE+GVlC/A4MYDsS8ndpReZy32VgaXurtMkxuOHfSAh0AK9QndIXuHxg3A5qdw5LwLusl7DZ0 tg3rQ9PigmZIOI+QbjacWBSGeDVNbiQXODWiRd0JBSgYRqHuHmAzwGlwC1NKSYyZWwUwOlv1JnCx QOGAgdq5EygcMFAzdwBFCgzUzMagCLTnusUwToBAfI5H6B05ivox9LLNtOYZHpwWFbcUFmjAXArS aYosTascvV5lq5xiPn1r3iulag3WUZOyR5f2xyIK8b1ysLUEsXWhzbL1P/D57Aq2iXeg6RYy9RtS X7Lg4JKzCxaDkfmgbjRHxgMXF88pdCyP2UyUVlQ7HfWuk4T8TyQmjGDg/CaRcCEzy5dKRry9vXLM SnZfXDU9oqG6/J8pJW5ZhbFj1lqGaudbvxEVEX38OWi8yBai1utYRrqRWrqoQcW4BsVy8LGkkE6q F3z16yvr15c30FjdgJmBDi9Nsy9T5sVM42qpYG7fwQC1LuUHeFTHRw34Ct+eqyL0uwG/45pl6OO+ rtHvulu8bmJmfLXuBO662wLrsIDqvvz33ULBDnOWcukl2wsiLx2kg2jOCLTRIh1qI2b0nMJAQZEM CwV498LlvGUFlixLlR0EFJu4nr5R9u0Rjp8uGWRUJq5ps1E4xGs77l/gaxL1nHX6Yioum1xv4FlC t5fEiuYAJJ4ABO9GEYfGGuP7OV9Fwrm1pZGu5G/RGJfqpfRpx3xxtKLseG8UgFIVFXhkYQfNvz16 zmbw6BFHIyW+hJXLg0HciyPtgJYyFZuPJqwKTCW+h9MR/eGIU7d6wVyjjqejaTXt9j7iTDtf4X9N tQk7tBMVusfGWZmBZg6ptE+Ck4d8XFZ02LpTNpFWEWg82uvfGZt+N4a5WBIeKCU2X9dpWr9zHEEe tTd94k/5B57m0gW7TEpdHrjJq+stRfCw+rTK83g8GyyfEDD/rGKh4ND+zMQGgee52TDelQKCjQnJ U9zs3mf7KRZ8VtKba/l503hERGIGmX3xDCUySH2sZNBeIwCuei8bgjXtH1lfu5bp40PROFFL3p3E qfjl+ThmmUPYlC4ddnSF/IzQRl/9LG2y+yIlCZQyaq0FGbwmCxaJXW6vkEtTVIFNKAvscD9hscLD cywiUVTTPPSw7LTp7li/6lw7X0Ugf05W7Bz/bzGdogVcF+7m82nI9tYnZ28qmGDrPbJLLK274ZCE xLHGM5WeoFRDE68Wffpuzna0okBs501P9hXEIlYsO7aSvKeOie+0wMUcRNDgeDaQ0HaErHQlo0sT e1SJNImvXdPQCqsht8/+NJlMxDl8FCTi/TJMEjvAgZcXSkv7WP8iB5Yet3YWYgqQwuI04crryPjl pVP7pRs0jnFv8K4aPL5Jph9xfhxb5LEcrHpyzgVLr1GW1TAOp0trmJ2T2a8wKrgV24igv6pRfxFp dDecxT2yee7jKv5dAvYUJwv6fEpWfKUg+tyLJnMdWUvFIuxGEqq+WaqjiGenKWHYN0VF+QM06ZOQ Te72yQQu9chycCTNvgRAvKX37LGHQXgXc0ErqyGYgwRBn9/EPRRHYzybwXhW6T1/LbMj8kFRClBG pDW/WZWKnL8uoWEXMQm0TvPS07VSVCq29Hc7Yvv9TvD1sxp6BlRUA8qP/o4csVkijDv6iSI45nPW vzNNXl0p57BCMy9TGa5/UjmloJNWrfAB/jy4PKZ0UkdulUe6KidnXs1AsWFMQ/S9XjbUq6NfgD/5 xsrcCsSegovCdDBshcoALTSiwlfTV5jsl88JdD4QHqOfRCKDh+VKkWg4NMo1dRfQhKqKh75bkoDk wVuyEkkjrTNrhrHONVtGU9qTaP505jAuT4EQYFt/1808DaZ0knFMjnjOUwwppfQtOYGxdy0MGGWA mUkIcX8Z/G44wi8py1VzKPO9JsWZ4ApneJVchkfBqegYHGu++MN7hcEEieBPWe44g1AmvqjpQUMy XdjlfqSsTbBXoatU8ayep7Jv8qV8rppaYLYp+7YUZIAoNtfCNVgxucrahyYcjlCUO1jgRgMiL5Fl YCezsScywcHVMOnCnkFDP+SYaRvQC9aX0lmAGyoZDMiFEmM+k6ldncJP1BtNZSy16UGkr5O9yaIz XYzHZMDKfN2PZiLIhQGzdvDuva6RG9Y0wKZY6WRrlM1jbv0imoRI7XgwIu8k+SVKtoHBGiutWvDm wA1XaU0E2rzqdcRAnkDSohw99XabA3LwIas1Wh007wJQk8swf2dLSA6FU3wZJJ+iKQBiJumCVMDv FIueimTPU7PC9GVXwg1dLxUMcS+u04Glv7MMBLJ9PZHypnlFyHUC7WaN09y3WsJtZwTx0EaZKJcj gseWRax64XmorJV8eFVwbblsZOKdwkRTSrNtY9lmcjWYXd7XB5xU/gEbT+jWpNZJ6iplId02DGR9 2vzi1j1V+dJ2vjp/VQ/Ldfmqfd/MlqpQFYqobLfiC/sSadViQguJWxOWjnSRaNVGMSaQWXghoVPa aPBbbKJpVzsXqWAoGZQiZL3IPHoUvGIdFUumyUaT1VU4H0IaZjE4fMBgQcH3WVc6Eyc5mI66QGaC IE+j2YJSkBmatbyAhWTKyvJHjsb1dErCSxUPDMf3Kdahw8T+ZIYBNp6yjcosHGDegFvBUZKnKp0P mc2g+clNOIXln8Wo1dXhLqYReTPjMaBuotIImiwYkEhcv1uxUGFVo7rNaOaM4ZmMjRGLQR3fNg5+ sPeKlvQXc7YLDuv+O2bJblndweoNY2bspVzOlJdsIiWpeS4HbwEYZSs9DP0bfOW9pq9lHNxPmSjU oNT+Yp6M8KTrvDkolMQpxGV4LHqmSzCuqr3IRpaY3XLnYXYiBlfD9CBAeCWeqE29BVJyUJM/iYE/ FbfZCx/bIKU8nIP9BshTZir83nNYScXMeeU819doHdOD4NfcRT6iuVPLOx/v36tzULpASp2Vb7MA X31cGrCp+KbmiefA81V0z1RXpvRf+XDMAcQqEyN9PuasmnaeYiarubtL52GrtpN3HgoS0Ub8ww47 Z6etLHOvIy/4r3LmORiRt7z/hiefM+88arTB+belz778o0+bHiOuWbZzrWoDaW6rseNmYs7ZLawH GNGi4gWvG7GdjTYuSln1uFcqmzpKkoilVzarPEwcbqbbS1aOYbuy5+x9znOXM8XX6pdJlAKdirdV JiUdHlPqCadTgfMp/UDHqKAl2W1iLI1iu7aL3gSOL5/yVNB2jZYTm6CRnodq3KylfiVDU7J6y1vP HZnHmc+vCs941OVpzPONzngw38YDyj52fobR6847cGPtXLx/9+7s/DJPdgKbCONwn78/PT0+ffPC 5aatPCvGE09datN8aC4DqfYSGwlkW6qkJei+Mo7C018kZRuRX9A2Gsh6ZKZFBKuKJJPlJQTQnRXF GKRWtP78I9vkAXKIoXe1LCrgIZ+br5mfFiwrtmTlrFIrF88qu9b62czrGqWWraK7ALSQ5DpYqyGX VGy3GsItpUlNB1iFdFg4YaPpYb+DMnYdLm0Ch7QRBC3bzBlhkD7Y3cfrLHBKYuhBKR8PulbLwoCK KmaDiemDKCVHy4od8yVqmZml6rjnqb/d3JPPyJ6+Zp0TMd+cdkzkH+KU2K22dvu73X7Yr1T2Br16 vR5Ww17WKVEqGYdEecBBIcnjmD/ggTiFcpK7EFO2901ukavh7eQ6eAZNcAhn+NJhL1W0r+GUiy+D 7gImkGkIynKAB7IHnvbK3y8qvdGkEqrbfjaox5UONIGK32QW02koTzmwFUazshpj59P1qxt9qt2K 44AqjUmmS3RfpZKzISqasTQw1uX0Mwr8WgxqbrwuwltOSNvY5YS0DR2QKekvelFHjTTqMKwV5AEb nsVKeZ7ZBJ7cPGvCLp6Xv4cBd+J5RTnu3qElC4xWgxk/XvzD95P4czQEYtWfX+e0yu+2r1SwEKtV 7FCcQMmKz3o1T3Tm88wu+owO9HobyS/ZR63qADZMY9DuVipht9Fv1Xvt/m52H6laZiOpJ7ioO83a Hi4qfRIDj3YZpJzFUsPwtiPBiPyrKkFsYDpoBYZK0ePLzsHZW2Zyz07R4dmabO9ajAyCrS+EXejx rvaSDVT2viB0KjM84dbnM1e9K8rkNaNCntwLa7Z4hQfIRMd9YlfgG56EgwQhSS9Lwckb8QV/fQa3 UIU4hRIVL7Ayi/VjNQyPVwuK+G1XAnSIy/+IA6JHJjfoDSBIchM8uynpUL0cu57pH0d9J2RlGvhF 9js5OOjUFrjmuBBHZydkYlMuk6JPKCMU+wTNUoxCTW4oT01CNXrJGLP2aZcUpo4TAEV62OJtjzFr bN98ZXS//focfqEK+tXZ/jkGmz+kcHaDAnntK6PFdVp2Xfcl7/fSDqxYL7J5g4nl4HjPOV0enb89 Pt0/+ZfNydvB8jkFW0z3l/b96mcKDYhK9gEmW0JGzw2aUCipzLbtOjGI+E2xiOifqTcVbXEd08M+ stXDZzPBW95NJIWdwf5BVhlwbBhO8PxWX9m2jI6hl1hsmtyUv6ffs7/Bz3Aahb/BISd5iqEsRnxY WhQYKL5SyG7H/cyESZ/fzKnze9vaySlmmaIGujSdubqgexbb5WBneUrBUz6vGSJse/d6/+Co8/r8 7C2gHUCUKI3AjoUmw3VZFDVhcbfckDVJgaOgh5mQPvcDEj1JDRVsp0ih6kv4TJp4sUjfxeuWl/g7 Wj7EWjhnHGhrDg23afolruFLs6C43yQSr3/FSpnFLUif1vLkrKIclPY6bst8Ct61lJ3TatfITgS+ SJLvq0XcwdOZdwciPGZUmqUZXfrQ2XsGU0xO/mzAe+jZMBrM5evURK9VjNnWl7uerynwPtAJ618N IVNqgoBOcD2FBnqzQD7VIbwOl+ZdNEW+9moNtkzZq0mymG8l8fyr98cnhx2FtW9Ofn33o4Ra3abk SqXg6PSwFGAk71JwuX98At/h/w9w6u9fXHY+FIL/nbXklEG9UHyiFNlSf/qJ4Sy2gWoVNNkimvU3 GsBvFSn0QiqW3evF9pL1VH2pO02wvaQbveYF1VNx3Z70kqoOi+t3aBtnbm0JXPAkYIUBi1yTARwf hTQ8L/ZfH8F5eXJydrDP2ePrcJjVLIaM1/Pk6NRwZdiKbuH4FNhce9GhO45dhS0h45XcYPbQKCwF gg4/nqgWCLX2art0m4Ive1W+TuH+VlcqnneW57ZvJGMp9JLJRnmj+2fOHeph7k3eWxPsyLvdm1K3 JR1LJwieyH733p0cEcRnRwbR22uH4U4z3AkrlUa11hoMmr3duufulBFCfLakELWdWo0vxPQJjz53 2Ng7ctiaPFJtGJzCQ5Ji59jevIkVR/jadNVicErm9CvZa6buN7W9BgdN508CZH8a3qQFCwqeqHC9 Yt/3JQBlRlagaSQ0DwDRh4ZptkmcjXqBh/Utc6i3mAPGfq7EEWgcVw4e1Sv1eqX66NH/BXraNd7a 7wEA --000000000000acad5b058e2b21f8-- From debbugs-submit-bounces@debbugs.gnu.org Sun Aug 09 15:28:13 2020 Received: (at 36597) by debbugs.gnu.org; 9 Aug 2020 19:28:14 +0000 Received: from localhost ([127.0.0.1]:33484 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k4qzN-0003d2-OY for submit@debbugs.gnu.org; Sun, 09 Aug 2020 15:28:13 -0400 Received: from quimby.gnus.org ([95.216.78.240]:39168) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k4qzM-0003cm-2c for 36597@debbugs.gnu.org; Sun, 09 Aug 2020 15:28:12 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=gnus.org; s=20200322; h=Content-Type:MIME-Version:Message-ID:In-Reply-To:Date: References:Subject:Cc:To:From:Sender:Reply-To:Content-Transfer-Encoding: Content-ID:Content-Description:Resent-Date:Resent-From:Resent-Sender: Resent-To:Resent-Cc:Resent-Message-ID:List-Id:List-Help:List-Unsubscribe: List-Subscribe:List-Post:List-Owner:List-Archive; bh=teHsuM7W+5WIw1c7mFBnNYRAYhiRz9MqcPyjDZEZH+s=; b=DCTPkAk9mlIoX4ijHyPs6eMOS+ XXjbzwDn4Un07NOUcDGEswTBYheMDxu95R9FG4/ce+/JBPfGx//Wn5WYZfUmTa+PDtQkdfOiUtRJ1 QB7UMS8vFjkII4MzVNf0B/V4cxwLF7zNURXNzfqFySn3hfTecmh7fsPiZB6b4drtdFdk=; Received: from cm-84.212.202.86.getinternet.no ([84.212.202.86] helo=xo) by quimby with esmtpsa (TLS1.3:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.92) (envelope-from ) id 1k4qzA-0002lF-EC; Sun, 09 Aug 2020 21:28:04 +0200 From: Lars Ingebrigtsen To: Pip Cet Subject: Re: bug#36597: 27.0.50; rehash hash tables eagerly in pdumper References: <6a260307-a463-bd08-8a10-d7664d0606a2@cs.ucla.edu> <74235afc-7043-1da7-7c71-07f0ca23b9fd@cs.ucla.edu> <83r26mv53z.fsf@gnu.org> Date: Sun, 09 Aug 2020 21:27:58 +0200 In-Reply-To: (Pip Cet's message of "Sun, 21 Jul 2019 06:32:26 +0000") Message-ID: <87ft8vbow1.fsf@gnus.org> User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/28.0.50 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain X-Spam-Report: Spam detection software, running on the system "quimby.gnus.org", has NOT identified this incoming email as spam. The original message has been attached to this so you can view it or label similar future email. If you have any questions, see @@CONTACT_ADDRESS@@ for details. Content preview: Pip Cet writes: >> Well, at least they'll require rebasing, particularly of the >> no-internal-freelists patch :-) > > Rebased patches attached. The performance measurements don't seem to > change significantly. Content analysis details: (-2.9 points, 5.0 required) pts rule name description ---- ---------------------- -------------------------------------------------- -1.0 ALL_TRUSTED Passed through trusted hosts only via SMTP -1.9 BAYES_00 BODY: Bayes spam probability is 0 to 1% [score: 0.0000] X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 36597 Cc: Eli Zaretskii , Paul Eggert , 36597@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) Pip Cet writes: >> Well, at least they'll require rebasing, particularly of the >> no-internal-freelists patch :-) > > Rebased patches attached. The performance measurements don't seem to > change significantly. And this was the final message in this thread. I think the general consensus was that Pip's patches were a good idea... unless they had any negative performance impact? So I tried applying the patch now to Emacs 28 to do some benchmarking, but it didn't apply cleanly, so I gave up. Is this still something worth pursuing? -- (domestic pets only, the antidote for overdose, milk.) bloggy blog: http://lars.ingebrigtsen.no From debbugs-submit-bounces@debbugs.gnu.org Mon Aug 10 07:52:27 2020 Received: (at 36597) by debbugs.gnu.org; 10 Aug 2020 11:52:27 +0000 Received: from localhost ([127.0.0.1]:34724 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k56Lq-0000ub-IH for submit@debbugs.gnu.org; Mon, 10 Aug 2020 07:52:27 -0400 Received: from mail-oi1-f174.google.com ([209.85.167.174]:45586) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k56Lo-0000uJ-9s for 36597@debbugs.gnu.org; Mon, 10 Aug 2020 07:52:25 -0400 Received: by mail-oi1-f174.google.com with SMTP id o21so8567387oie.12 for <36597@debbugs.gnu.org>; Mon, 10 Aug 2020 04:52:24 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc; bh=5MwkV0JDgj6ZAutFMIY+M2sMjqj3yVW/cQJZOphxa9E=; b=sQjKdq7U3qVJKZ4jzXa0trT9CPVmnBhURCZh9MU1Rke1dFsXhS7uwh0oQAzjTSHmdg pwVH2kN+JPZp1vODVFhJlW+Y3mdQJo4fepNFnLPcjayEdd5crjGafdBGKLhOA1HcjVIN Hovq7D7Zp/dQmybu/sxT2gLieeT/K7ppvIaKU/I8JyISTs7wrI6tp4vxEZ///ZhxN3m5 StmCwJ9rAQMh4ezugOJ+0xya5UWmzzf1LZgJL+WKYacBFISpSJ6LcY8jo7Tvh7YUZWWH m4dzG23X1HcFG5PktgWMEgAE5hyKRrGmOj65GV3n5MaysbD2BPMs/wGef04BGKE2nVxv dUJg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=5MwkV0JDgj6ZAutFMIY+M2sMjqj3yVW/cQJZOphxa9E=; b=gM94aw3hr9p7tkz3S7BBFm3O5+k+rR/YptxSy30FKfb5J/1Tm4WfjL/lHp2ClsrevY kMVlq5WdXQ/7dQ7xVuiJ0ZAznejqgIr6kW/b100vOxVUpZkq2d4REFeJng/ccKfy4zOG Ittmh7Tr5TN2/Eyaeb5/uNJXGFBdizU0PhkvSdxeeDFgUX0+ugqGo0+7U1vP0YcecEju GOWTjSrB4IpSdBKp2KIAMiH46F5O8NuXaYtF+QzwY0rLxkY+iO1npOmuDB2yDbMSdMXT PqWNdHVjMObdXYHnVHgWNOj4Co3v+A9fpFtnefY3/ufKs8uNpgo280N6mdFq1VzuTk1I O6gQ== X-Gm-Message-State: AOAM533T20eVEr1B/ezPCGLU8qvx8FurS8ba9b9ufeI4wBWR9enumkEB nIlgJYmuG/O7Z+Nvm8rCDQiToXXVsBupyEwASHw= X-Google-Smtp-Source: ABdhPJwd+bf2NYRewSGbUms0qOLe4U1/Mk/nCTwK9U7RWe5sr2AlYwVONHmCkl7w4p3vnHUay+l+aoJyjlXqfLVb5to= X-Received: by 2002:aca:ed4e:: with SMTP id l75mr366293oih.44.1597060338457; Mon, 10 Aug 2020 04:52:18 -0700 (PDT) MIME-Version: 1.0 References: <6a260307-a463-bd08-8a10-d7664d0606a2@cs.ucla.edu> <74235afc-7043-1da7-7c71-07f0ca23b9fd@cs.ucla.edu> <83r26mv53z.fsf@gnu.org> <87ft8vbow1.fsf@gnus.org> In-Reply-To: <87ft8vbow1.fsf@gnus.org> From: Pip Cet Date: Mon, 10 Aug 2020 11:51:42 +0000 Message-ID: Subject: Re: bug#36597: 27.0.50; rehash hash tables eagerly in pdumper To: Lars Ingebrigtsen Content-Type: multipart/mixed; boundary="00000000000028c00105ac849638" X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 36597 Cc: Eli Zaretskii , Paul Eggert , 36597@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) --00000000000028c00105ac849638 Content-Type: text/plain; charset="UTF-8" On Sun, Aug 9, 2020 at 7:28 PM Lars Ingebrigtsen wrote: > >> Well, at least they'll require rebasing, particularly of the > >> no-internal-freelists patch :-) > > > > Rebased patches attached. The performance measurements don't seem to > > change significantly. > > And this was the final message in this thread. I think the general > consensus was that Pip's patches were a good idea... unless they had > any negative performance impact? I'm not aware of any remaining negative performance impact, but I do seem to recall Daniel was somewhat opposed to the patch. > So I tried applying the patch now to Emacs 28 to do some benchmarking, > but it didn't apply cleanly, so I gave up. I'll try to rebase them again. Does the attached work for you? > Is this still something worth pursuing? I think it is, at least in the case of the "rehash eagerly" patch. As for the more general rewrite of hash tables, it might be a good idea to summarize and discuss this idea some more. Here are some initial notes, but I'll make a proper proposal once things are ready: - there's a new lisp.h type for hash cells, which is four words long and holds a hash, key, value, and a next link (either another hash cell, or the hash table this cell belongs to, or nil if it no longer belongs to any hash table) - hash tables are essentially vectors of such hash cells - hash cells are invisible to Lisp code, but C code can hold on to hash cell Lisp Objects, guaranteeing they won't be collected (they can still be removed from the hash table) - in my current implementation, hash cells aren't pseudovectors, they're cons-like objects with four cells rather than two. The implications are: - more work for the garbage collector - a somewhat ambitious rewrite of the profiler to keep hash cells pre-allocated - shrinkable hash tables - genuinely unordered hash tables, since there's no more HASH_INDEX - rehash thresholds would be interpreted differently There's also a slight reduction in memory usage for hash tables. --00000000000028c00105ac849638 Content-Type: text/x-patch; charset="US-ASCII"; name="0001-Rehash-hash-tables-eagerly-after-loading-a-dump.patch" Content-Disposition: attachment; filename="0001-Rehash-hash-tables-eagerly-after-loading-a-dump.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_kdoge3ao0 RnJvbSAzYWUxN2RiN2QyMTIzYjVhMGI3ZDI1ZTU5MGY5ZTI5ZDdmZjUzN2ZjIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBQaXAgQ2V0IDxwaXBjZXRAZ21haWwuY29tPgpEYXRlOiBGcmks IDE5IEp1bCAyMDE5IDA3OjEyOjQyICswMDAwClN1YmplY3Q6IFtQQVRDSF0gUmVoYXNoIGhhc2gg dGFibGVzIGVhZ2VybHkgYWZ0ZXIgbG9hZGluZyBhIGR1bXAuCgoqIHNyYy9saXNwLmggKGhhc2hf cmVoYXNoX25lZWRlZF9wKTogUmVtb3ZlLiAgQWxsIHVzZXMgcmVtb3ZlZC4KKGhhc2hfcmVoYXNo X2lmX25lZWRlZCk6IFJlbW92ZS4gIEFsbCB1c2VzIHJlbW92ZWQuCihzdHJ1Y3QgTGlzcF9IYXNo X1RhYmxlKTogUmVtb3ZlIGNvbW1lbnQgYWJvdXQgcmVoYXNoaW5nIGhhc2ggdGFibGVzLgoqIHNy Yy9wZHVtcGVyLmMgKHRoYXdfaGFzaF90YWJsZXMpOiBOZXcgZnVuY3Rpb24uCihoYXNoX3RhYmxl X3RoYXcpOiBOZXcgZnVuY3Rpb24uCihoYXNoX3RhYmxlX2ZyZWV6ZSk6IE5ldyBmdW5jdGlvbi4K KGR1bXBfaGFzaF90YWJsZSk6IFNpbXBsaWZ5LgooZHVtcF9oYXNoX3RhYmxlX2xpc3QpOiBOZXcg ZnVuY3Rpb24uCihoYXNoX3RhYmxlX2NvbnRlbnRzKTogTmV3IGZ1bmN0aW9uLgooRmR1bXBfZW1h Y3NfcG9ydGFibGUpOiBIYW5kbGUgaGFzaCB0YWJsZXMgYnkgZWFnZXIgcmVoYXNoaW5nLgoocGR1 bXBlcl9sb2FkKTogUmVzdG9yZSBoYXNoIHRhYmxlcy4KKGluaXRfcGR1bXBlcl9vbmNlKTogTmV3 IGZ1bmN0aW9uLgotLS0KIHNyYy9ieXRlY29kZS5jICB8ICAgMSAtCiBzcmMvY29tcG9zaXRlLmMg fCAgIDEgLQogc3JjL2VtYWNzLmMgICAgIHwgICAxICsKIHNyYy9mbnMuYyAgICAgICB8ICA2NSAr KysrLS0tLS0tLS0tLS0KIHNyYy9saXNwLmggICAgICB8ICAyMSArLS0tLQogc3JjL21pbmlidWYu YyAgIHwgICAzIC0KIHNyYy9wZHVtcGVyLmMgICB8IDIwOCArKysrKysrKysrKysrKysrKysrKyst LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIHNyYy9wZHVtcGVyLmggICB8ICAgMSArCiA4IGZp bGVzIGNoYW5nZWQsIDExMiBpbnNlcnRpb25zKCspLCAxODkgZGVsZXRpb25zKC0pCgpkaWZmIC0t Z2l0IGEvc3JjL2J5dGVjb2RlLmMgYi9zcmMvYnl0ZWNvZGUuYwppbmRleCAxOTEzYTQ4MTJhLi4x YzNiNmVhYzBkIDEwMDY0NAotLS0gYS9zcmMvYnl0ZWNvZGUuYworKysgYi9zcmMvYnl0ZWNvZGUu YwpAQCAtMTQwMSw3ICsxNDAxLDYgQEAgI2RlZmluZSBERUZJTkUobmFtZSwgdmFsdWUpIExBQkVM IChuYW1lKSAsCiAgICAgICAgICAgICBMaXNwX09iamVjdCB2MSA9IFBPUDsKICAgICAgICAgICAg IHB0cmRpZmZfdCBpOwogICAgICAgICAgICAgc3RydWN0IExpc3BfSGFzaF9UYWJsZSAqaCA9IFhI QVNIX1RBQkxFIChqbXBfdGFibGUpOwotICAgICAgICAgICAgaGFzaF9yZWhhc2hfaWZfbmVlZGVk IChoKTsKIAogICAgICAgICAgICAgLyogaC0+Y291bnQgaXMgYSBmYXN0ZXIgYXBwcm94aW1hdGlv biBmb3IgSEFTSF9UQUJMRV9TSVpFIChoKQogICAgICAgICAgICAgICAgaGVyZS4gKi8KZGlmZiAt LWdpdCBhL3NyYy9jb21wb3NpdGUuYyBiL3NyYy9jb21wb3NpdGUuYwppbmRleCBmOTZmMGI3Nzcy Li5lYzJiODMyOGY3IDEwMDY0NAotLS0gYS9zcmMvY29tcG9zaXRlLmMKKysrIGIvc3JjL2NvbXBv c2l0ZS5jCkBAIC02NTIsNyArNjUyLDYgQEAgZ3N0cmluZ19sb29rdXBfY2FjaGUgKExpc3BfT2Jq ZWN0IGhlYWRlcikKIGNvbXBvc2l0aW9uX2dzdHJpbmdfcHV0X2NhY2hlIChMaXNwX09iamVjdCBn c3RyaW5nLCBwdHJkaWZmX3QgbGVuKQogewogICBzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICpoID0g WEhBU0hfVEFCTEUgKGdzdHJpbmdfaGFzaF90YWJsZSk7Ci0gIGhhc2hfcmVoYXNoX2lmX25lZWRl ZCAoaCk7CiAgIExpc3BfT2JqZWN0IGhlYWRlciA9IExHU1RSSU5HX0hFQURFUiAoZ3N0cmluZyk7 CiAgIExpc3BfT2JqZWN0IGhhc2ggPSBoLT50ZXN0Lmhhc2hmbiAoaGVhZGVyLCBoKTsKICAgaWYg KGxlbiA8IDApCmRpZmYgLS1naXQgYS9zcmMvZW1hY3MuYyBiL3NyYy9lbWFjcy5jCmluZGV4IDhl NWVhZjVlNDMuLmQzMWZhMmNiMjggMTAwNjQ0Ci0tLSBhL3NyYy9lbWFjcy5jCisrKyBiL3NyYy9l bWFjcy5jCkBAIC0xNTM2LDYgKzE1MzYsNyBAQCBtYWluIChpbnQgYXJnYywgY2hhciAqKmFyZ3Yp CiAgIGlmICghaW5pdGlhbGl6ZWQpCiAgICAgewogICAgICAgaW5pdF9hbGxvY19vbmNlICgpOwor ICAgICAgaW5pdF9wZHVtcGVyX29uY2UgKCk7CiAgICAgICBpbml0X29iYXJyYXlfb25jZSAoKTsK ICAgICAgIGluaXRfZXZhbF9vbmNlICgpOwogICAgICAgaW5pdF9jaGFyc2V0X29uY2UgKCk7CmRp ZmYgLS1naXQgYS9zcmMvZm5zLmMgYi9zcmMvZm5zLmMKaW5kZXggODExZDZlODIwMC4uNDFlMjYx MDRmMyAxMDA2NDQKLS0tIGEvc3JjL2Zucy5jCisrKyBiL3NyYy9mbnMuYwpAQCAtNDI0OCw1MCAr NDI0OCwyOCBAQCBtYXliZV9yZXNpemVfaGFzaF90YWJsZSAoc3RydWN0IExpc3BfSGFzaF9UYWJs ZSAqaCkKIAogLyogUmVjb21wdXRlIHRoZSBoYXNoZXMgKGFuZCBoZW5jZSBhbHNvIHRoZSAibmV4 dCIgcG9pbnRlcnMpLgogICAgTm9ybWFsbHkgdGhlcmUncyBuZXZlciBhIG5lZWQgdG8gcmVjb21w dXRlIGhhc2hlcy4KLSAgIFRoaXMgaXMgZG9uZSBvbmx5IG9uIGZpcnN0LWFjY2VzcyB0byBhIGhh c2gtdGFibGUgbG9hZGVkIGZyb20KLSAgIHRoZSAicGR1bXAiLCBiZWNhdXNlIHRoZSBvYmplY3Qn cyBhZGRyZXNzZXMgbWF5IGhhdmUgY2hhbmdlZCwgdGh1cworICAgVGhpcyBpcyBkb25lIG9ubHkg b24gZmlyc3QgYWNjZXNzIHRvIGEgaGFzaC10YWJsZSBsb2FkZWQgZnJvbQorICAgdGhlICJwZHVt cCIsIGJlY2F1c2UgdGhlIG9iamVjdHMnIGFkZHJlc3NlcyBtYXkgaGF2ZSBjaGFuZ2VkLCB0aHVz CiAgICBhZmZlY3RpbmcgdGhlaXIgaGFzaC4gICovCiB2b2lkCi1oYXNoX3RhYmxlX3JlaGFzaCAo c3RydWN0IExpc3BfSGFzaF9UYWJsZSAqaCkKK2hhc2hfdGFibGVfcmVoYXNoIChMaXNwX09iamVj dCBoYXNoKQogewotICBwdHJkaWZmX3Qgc2l6ZSA9IEhBU0hfVEFCTEVfU0laRSAoaCk7Ci0KLSAg LyogVGhlc2Ugc3RydWN0dXJlcyBtYXkgaGF2ZSBiZWVuIHB1cmVjb3BpZWQgYW5kIHNoYXJlZAot ICAgICAoYnVnIzM2NDQ3KS4gICovCi0gIExpc3BfT2JqZWN0IGhhc2ggPSBtYWtlX25pbF92ZWN0 b3IgKHNpemUpOwotICBoLT5uZXh0ID0gRmNvcHlfc2VxdWVuY2UgKGgtPm5leHQpOwotICBoLT5p bmRleCA9IEZjb3B5X3NlcXVlbmNlIChoLT5pbmRleCk7Ci0KKyAgc3RydWN0IExpc3BfSGFzaF9U YWJsZSAqaCA9IFhIQVNIX1RBQkxFIChoYXNoKTsKICAgLyogUmVjb21wdXRlIHRoZSBhY3R1YWwg aGFzaCBjb2RlcyBmb3IgZWFjaCBlbnRyeSBpbiB0aGUgdGFibGUuCiAgICAgIE9yZGVyIGlzIHN0 aWxsIGludmFsaWQuICAqLwotICBmb3IgKHB0cmRpZmZfdCBpID0gMDsgaSA8IHNpemU7ICsraSkK KyAgZm9yIChwdHJkaWZmX3QgaSA9IDA7IGkgPCBoLT5jb3VudDsgKytpKQogICAgIHsKICAgICAg IExpc3BfT2JqZWN0IGtleSA9IEhBU0hfS0VZIChoLCBpKTsKLSAgICAgIGlmICghRVEgKGtleSwg UXVuYm91bmQpKQotICAgICAgICBBU0VUIChoYXNoLCBpLCBoLT50ZXN0Lmhhc2hmbiAoa2V5LCBo KSk7CisgICAgICBMaXNwX09iamVjdCBoYXNoX2NvZGUgPSBoLT50ZXN0Lmhhc2hmbiAoa2V5LCBo KTsKKyAgICAgIHB0cmRpZmZfdCBzdGFydF9vZl9idWNrZXQgPSBYVUZJWE5VTSAoaGFzaF9jb2Rl KSAlIEFTSVpFIChoLT5pbmRleCk7CisgICAgICBzZXRfaGFzaF9oYXNoX3Nsb3QgKGgsIGksIGhh c2hfY29kZSk7CisgICAgICBzZXRfaGFzaF9uZXh0X3Nsb3QgKGgsIGksIEhBU0hfSU5ERVggKGgs IHN0YXJ0X29mX2J1Y2tldCkpOworICAgICAgc2V0X2hhc2hfaW5kZXhfc2xvdCAoaCwgc3RhcnRf b2ZfYnVja2V0LCBpKTsKKyAgICAgIGVhc3NlcnQgKEhBU0hfTkVYVCAoaCwgaSkgIT0gaSk7IC8q IFN0b3AgbG9vcHMuICAqLwogICAgIH0KIAotICAvKiBSZXNldCB0aGUgaW5kZXggc28gdGhhdCBh bnkgc2xvdCB3ZSBkb24ndCBmaWxsIGJlbG93IGlzIG1hcmtlZAotICAgICBpbnZhbGlkLiAgKi8K LSAgRmZpbGxhcnJheSAoaC0+aW5kZXgsIG1ha2VfZml4bnVtICgtMSkpOwotCi0gIC8qIFJlYnVp bGQgdGhlIGNvbGxpc2lvbiBjaGFpbnMuICAqLwotICBmb3IgKHB0cmRpZmZfdCBpID0gMDsgaSA8 IHNpemU7ICsraSkKLSAgICBpZiAoIU5JTFAgKEFSRUYgKGhhc2gsIGkpKSkKLSAgICAgIHsKLSAg ICAgICAgRU1BQ1NfVUlOVCBoYXNoX2NvZGUgPSBYVUZJWE5VTSAoQVJFRiAoaGFzaCwgaSkpOwot ICAgICAgICBwdHJkaWZmX3Qgc3RhcnRfb2ZfYnVja2V0ID0gaGFzaF9jb2RlICUgQVNJWkUgKGgt PmluZGV4KTsKLSAgICAgICAgc2V0X2hhc2hfbmV4dF9zbG90IChoLCBpLCBIQVNIX0lOREVYICho LCBzdGFydF9vZl9idWNrZXQpKTsKLSAgICAgICAgc2V0X2hhc2hfaW5kZXhfc2xvdCAoaCwgc3Rh cnRfb2ZfYnVja2V0LCBpKTsKLSAgICAgICAgZWFzc2VydCAoSEFTSF9ORVhUIChoLCBpKSAhPSBp KTsgLyogU3RvcCBsb29wcy4gICovCi0gICAgICB9Ci0KLSAgLyogRmluYWxseSwgbWFyayB0aGUg aGFzaCB0YWJsZSBhcyBoYXZpbmcgYSB2YWxpZCBoYXNoIG9yZGVyLgotICAgICBEbyB0aGlzIGxh c3Qgc28gdGhhdCBpZiB3ZSdyZSBpbnRlcnJ1cHRlZCwgd2UgcmV0cnkgb24gbmV4dAotICAgICBh Y2Nlc3MuICovCi0gIGVhc3NlcnQgKGhhc2hfcmVoYXNoX25lZWRlZF9wIChoKSk7Ci0gIGgtPmhh c2ggPSBoYXNoOwotICBlYXNzZXJ0ICghaGFzaF9yZWhhc2hfbmVlZGVkX3AgKGgpKTsKKyAgZm9y IChwdHJkaWZmX3QgaSA9IGgtPmNvdW50OyBpIDwgQVNJWkUgKGgtPm5leHQpIC0gMTsgaSsrKQor ICAgIHNldF9oYXNoX25leHRfc2xvdCAoaCwgaSwgaSArIDEpOwogfQogCiAvKiBMb29rdXAgS0VZ IGluIGhhc2ggdGFibGUgSC4gIElmIEhBU0ggaXMgbm9uLW51bGwsIHJldHVybiBpbiAqSEFTSApA QCAtNDMwMyw4ICs0MjgxLDYgQEAgaGFzaF9sb29rdXAgKHN0cnVjdCBMaXNwX0hhc2hfVGFibGUg KmgsIExpc3BfT2JqZWN0IGtleSwgTGlzcF9PYmplY3QgKmhhc2gpCiB7CiAgIHB0cmRpZmZfdCBz dGFydF9vZl9idWNrZXQsIGk7CiAKLSAgaGFzaF9yZWhhc2hfaWZfbmVlZGVkIChoKTsKLQogICBM aXNwX09iamVjdCBoYXNoX2NvZGUgPSBoLT50ZXN0Lmhhc2hmbiAoa2V5LCBoKTsKICAgaWYgKGhh c2gpCiAgICAgKmhhc2ggPSBoYXNoX2NvZGU7CkBAIC00MzM5LDggKzQzMTUsNiBAQCBoYXNoX3B1 dCAoc3RydWN0IExpc3BfSGFzaF9UYWJsZSAqaCwgTGlzcF9PYmplY3Qga2V5LCBMaXNwX09iamVj dCB2YWx1ZSwKIHsKICAgcHRyZGlmZl90IHN0YXJ0X29mX2J1Y2tldCwgaTsKIAotICBoYXNoX3Jl aGFzaF9pZl9uZWVkZWQgKGgpOwotCiAgIC8qIEluY3JlbWVudCBjb3VudCBhZnRlciByZXNpemlu ZyBiZWNhdXNlIHJlc2l6aW5nIG1heSBmYWlsLiAgKi8KICAgbWF5YmVfcmVzaXplX2hhc2hfdGFi bGUgKGgpOwogICBoLT5jb3VudCsrOwpAQCAtNDM3Myw4ICs0MzQ3LDYgQEAgaGFzaF9yZW1vdmVf ZnJvbV90YWJsZSAoc3RydWN0IExpc3BfSGFzaF9UYWJsZSAqaCwgTGlzcF9PYmplY3Qga2V5KQog ICBwdHJkaWZmX3Qgc3RhcnRfb2ZfYnVja2V0ID0gWFVGSVhOVU0gKGhhc2hfY29kZSkgJSBBU0la RSAoaC0+aW5kZXgpOwogICBwdHJkaWZmX3QgcHJldiA9IC0xOwogCi0gIGhhc2hfcmVoYXNoX2lm X25lZWRlZCAoaCk7Ci0KICAgZm9yIChwdHJkaWZmX3QgaSA9IEhBU0hfSU5ERVggKGgsIHN0YXJ0 X29mX2J1Y2tldCk7CiAgICAgICAgMCA8PSBpOwogICAgICAgIGkgPSBIQVNIX05FWFQgKGgsIGkp KQpAQCAtNDQxNSw4ICs0Mzg3LDcgQEAgaGFzaF9jbGVhciAoc3RydWN0IExpc3BfSGFzaF9UYWJs ZSAqaCkKICAgaWYgKGgtPmNvdW50ID4gMCkKICAgICB7CiAgICAgICBwdHJkaWZmX3Qgc2l6ZSA9 IEhBU0hfVEFCTEVfU0laRSAoaCk7Ci0gICAgICBpZiAoIWhhc2hfcmVoYXNoX25lZWRlZF9wICho KSkKLQltZW1jbGVhciAoeHZlY3Rvcl9jb250ZW50cyAoaC0+aGFzaCksIHNpemUgKiB3b3JkX3Np emUpOworICAgICAgbWVtY2xlYXIgKHh2ZWN0b3JfY29udGVudHMgKGgtPmhhc2gpLCBzaXplICog d29yZF9zaXplKTsKICAgICAgIGZvciAocHRyZGlmZl90IGkgPSAwOyBpIDwgc2l6ZTsgaSsrKQog CXsKIAkgIHNldF9oYXNoX25leHRfc2xvdCAoaCwgaSwgaSA8IHNpemUgLSAxID8gaSArIDEgOiAt MSk7CkBAIC00NDUyLDkgKzQ0MjMsNyBAQCBzd2VlcF93ZWFrX3RhYmxlIChzdHJ1Y3QgTGlzcF9I YXNoX1RhYmxlICpoLCBib29sIHJlbW92ZV9lbnRyaWVzX3ApCiAgIGZvciAocHRyZGlmZl90IGJ1 Y2tldCA9IDA7IGJ1Y2tldCA8IG47ICsrYnVja2V0KQogICAgIHsKICAgICAgIC8qIEZvbGxvdyBj b2xsaXNpb24gY2hhaW4sIHJlbW92aW5nIGVudHJpZXMgdGhhdCBkb24ndCBzdXJ2aXZlCi0gICAg ICAgICB0aGlzIGdhcmJhZ2UgY29sbGVjdGlvbi4gIEl0J3Mgb2theSBpZiBoYXNoX3JlaGFzaF9u ZWVkZWRfcAotICAgICAgICAgKGgpIGlzIHRydWUsIHNpbmNlIHdlJ3JlIG9wZXJhdGluZyBlbnRp cmVseSBvbiB0aGUgY2FjaGVkCi0gICAgICAgICBoYXNoIHZhbHVlcy4gKi8KKyAgICAgICAgIHRo aXMgZ2FyYmFnZSBjb2xsZWN0aW9uLiAgKi8KICAgICAgIHB0cmRpZmZfdCBwcmV2ID0gLTE7CiAg ICAgICBwdHJkaWZmX3QgbmV4dDsKICAgICAgIGZvciAocHRyZGlmZl90IGkgPSBIQVNIX0lOREVY IChoLCBidWNrZXQpOyAwIDw9IGk7IGkgPSBuZXh0KQpAQCAtNDQ5OSw3ICs0NDY4LDcgQEAgc3dl ZXBfd2Vha190YWJsZSAoc3RydWN0IExpc3BfSGFzaF9UYWJsZSAqaCwgYm9vbCByZW1vdmVfZW50 cmllc19wKQogICAgICAgICAgICAgICAgICAgICBzZXRfaGFzaF9oYXNoX3Nsb3QgKGgsIGksIFFu aWwpOwogCiAgICAgICAgICAgICAgICAgICBlYXNzZXJ0IChoLT5jb3VudCAhPSAwKTsKLSAgICAg ICAgICAgICAgICAgIGgtPmNvdW50ICs9IGgtPmNvdW50ID4gMCA/IC0xIDogMTsKKyAgICAgICAg ICAgICAgICAgIGgtPmNvdW50LS07CiAgICAgICAgICAgICAgICAgfQogCSAgICAgIGVsc2UKIAkJ ewpAQCAtNDkyMyw3ICs0ODkyLDcgQEAgREVGVU4gKCJoYXNoLXRhYmxlLWNvdW50IiwgRmhhc2hf dGFibGVfY291bnQsIFNoYXNoX3RhYmxlX2NvdW50LCAxLCAxLCAwLAogICAoTGlzcF9PYmplY3Qg dGFibGUpCiB7CiAgIHN0cnVjdCBMaXNwX0hhc2hfVGFibGUgKmggPSBjaGVja19oYXNoX3RhYmxl ICh0YWJsZSk7Ci0gIGVhc3NlcnQgKGgtPmNvdW50ID49IDApOworCiAgIHJldHVybiBtYWtlX2Zp eG51bSAoaC0+Y291bnQpOwogfQogCmRpZmYgLS1naXQgYS9zcmMvbGlzcC5oIGIvc3JjL2xpc3Au aAppbmRleCAxN2I5MmEwNDE0Li4wMGQyMzczOTRjIDEwMDY0NAotLS0gYS9zcmMvbGlzcC5oCisr KyBiL3NyYy9saXNwLmgKQEAgLTIyNzUsMTEgKzIyNzUsNyBAQCAjZGVmaW5lIERFRlNZTShzeW0s IG5hbWUpIC8qIGVtcHR5ICovCiAKIHN0cnVjdCBMaXNwX0hhc2hfVGFibGUKIHsKLSAgLyogQ2hh bmdlIHBkdW1wZXIuYyBpZiB5b3UgY2hhbmdlIHRoZSBmaWVsZHMgaGVyZS4KLQotICAgICBJTVBP UlRBTlQhISEhISEhCi0KLSAgICAgQ2FsbCBoYXNoX3JlaGFzaF9pZl9uZWVkZWQoKSBiZWZvcmUg YWNjZXNzaW5nLiAgKi8KKyAgLyogQ2hhbmdlIHBkdW1wZXIuYyBpZiB5b3UgY2hhbmdlIHRoZSBm aWVsZHMgaGVyZS4gICovCiAKICAgLyogVGhpcyBpcyBmb3IgTGlzcDsgdGhlIGhhc2ggdGFibGUg Y29kZSBkb2VzIG5vdCByZWZlciB0byBpdC4gICovCiAgIHVuaW9uIHZlY3Rvcmxpa2VfaGVhZGVy IGhlYWRlcjsKQEAgLTIzOTgsMjAgKzIzOTQsNyBAQCBIQVNIX1RBQkxFX1NJWkUgKGNvbnN0IHN0 cnVjdCBMaXNwX0hhc2hfVGFibGUgKmgpCiAgIHJldHVybiBzaXplOwogfQogCi12b2lkIGhhc2hf dGFibGVfcmVoYXNoIChzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICpoKTsKLQotSU5MSU5FIGJvb2wK LWhhc2hfcmVoYXNoX25lZWRlZF9wIChjb25zdCBzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICpoKQot ewotICByZXR1cm4gTklMUCAoaC0+aGFzaCk7Ci19Ci0KLUlOTElORSB2b2lkCi1oYXNoX3JlaGFz aF9pZl9uZWVkZWQgKHN0cnVjdCBMaXNwX0hhc2hfVGFibGUgKmgpCi17Ci0gIGlmIChoYXNoX3Jl aGFzaF9uZWVkZWRfcCAoaCkpCi0gICAgaGFzaF90YWJsZV9yZWhhc2ggKGgpOwotfQordm9pZCBo YXNoX3RhYmxlX3JlaGFzaCAoTGlzcF9PYmplY3QgaCk7CiAKIC8qIERlZmF1bHQgc2l6ZSBmb3Ig aGFzaCB0YWJsZXMgaWYgbm90IHNwZWNpZmllZC4gICovCiAKZGlmZiAtLWdpdCBhL3NyYy9taW5p YnVmLmMgYi9zcmMvbWluaWJ1Zi5jCmluZGV4IDlkODcwY2UzNjQuLmNiMzAyYzVhNjAgMTAwNjQ0 Ci0tLSBhL3NyYy9taW5pYnVmLmMKKysrIGIvc3JjL21pbmlidWYuYwpAQCAtMTIxMiw5ICsxMjEy LDYgQEAgREVGVU4gKCJ0cnktY29tcGxldGlvbiIsIEZ0cnlfY29tcGxldGlvbiwgU3RyeV9jb21w bGV0aW9uLCAyLCAzLCAwLAogICAgICAgYnVja2V0ID0gQVJFRiAoY29sbGVjdGlvbiwgaWR4KTsK ICAgICB9CiAKLSAgaWYgKEhBU0hfVEFCTEVfUCAoY29sbGVjdGlvbikpCi0gICAgaGFzaF9yZWhh c2hfaWZfbmVlZGVkIChYSEFTSF9UQUJMRSAoY29sbGVjdGlvbikpOwotCiAgIHdoaWxlICgxKQog ICAgIHsKICAgICAgIC8qIEdldCB0aGUgbmV4dCBlbGVtZW50IG9mIHRoZSBhbGlzdCwgb2JhcnJh eSwgb3IgaGFzaC10YWJsZS4gICovCmRpZmYgLS1naXQgYS9zcmMvcGR1bXBlci5jIGIvc3JjL3Bk dW1wZXIuYwppbmRleCA2M2VlMGZjYjdmLi5lZmVlMDAxNjUxIDEwMDY0NAotLS0gYS9zcmMvcGR1 bXBlci5jCisrKyBiL3NyYy9wZHVtcGVyLmMKQEAgLTEwNSwyMSArMTA1LDEwIEBAICNkZWZpbmUg Vk1fTVNfV0lORE9XUyAyCiAjIGRlZmluZSBWTV9TVVBQT1JURUQgMAogI2VuZGlmCiAKLS8qIFBE VU1QRVJfQ0hFQ0tfUkVIQVNISU5HIGJlaW5nIHRydWUgY2F1c2VzIHRoZSBwb3J0YWJsZSBkdW1w ZXIgdG8KLSAgIGNoZWNrLCBmb3IgZWFjaCBoYXNoIHRhYmxlIGl0IGR1bXBzLCB0aGF0IHRoZSBo YXNoIHRhYmxlIG1lYW5zIHRoZQotICAgc2FtZSB0aGluZyBhZnRlciByZWhhc2hpbmcuICAqLwot I2lmbmRlZiBQRFVNUEVSX0NIRUNLX1JFSEFTSElORwotIyBpZiBFTkFCTEVfQ0hFQ0tJTkcKLSMg IGRlZmluZSBQRFVNUEVSX0NIRUNLX1JFSEFTSElORyAxCi0jIGVsc2UKLSMgIGRlZmluZSBQRFVN UEVSX0NIRUNLX1JFSEFTSElORyAwCi0jIGVuZGlmCi0jZW5kaWYKLQotLyogUmVxdWlyZSBhbiBh cmNoaXRlY3R1cmUgaW4gd2hpY2ggcG9pbnRlcnMsIHB0cmRpZmZfdCBhbmQgaW50cHRyX3QKLSAg IGFyZSB0aGUgc2FtZSBzaXplIGFuZCBoYXZlIHRoZSBzYW1lIGxheW91dCwgYW5kIHdoZXJlIGJ5 dGVzIGhhdmUKLSAgIGVpZ2h0IGJpdHMgLS0tIHRoYXQgaXMsIGEgZ2VuZXJhbC1wdXJwb3NlIGNv bXB1dGVyIG1hZGUgYWZ0ZXIgMTk5MC4KLSAgIEFsc28gcmVxdWlyZSBMaXNwX09iamVjdCB0byBi ZSBhdCBsZWFzdCBhcyB3aWRlIGFzIHBvaW50ZXJzLiAgKi8KKy8qIFdlIHJlcXVpcmUgYW4gYXJj aGl0ZWN0dXJlIGluIHdoaWNoIGFsbCBwb2ludGVycyBhcmUgdGhlIHNhbWUgc2l6ZQorICAgYW5k IGhhdmUgdGhlIHNhbWUgbGF5b3V0LCB3aGVyZSBwb2ludGVycyBhcmUgZWl0aGVyIDMyIG9yIDY0 IGJpdHMKKyAgIGxvbmcsIGFuZCB3aGVyZSBieXRlcyBoYXZlIGVpZ2h0IGJpdHMgLS0tIHRoYXQg aXMsIGEKKyAgIGdlbmVyYWwtcHVycG9zZSBjb21wdXRlciBtYWRlIGFmdGVyIDE5OTAuICAqLwog dmVyaWZ5IChzaXplb2YgKHB0cmRpZmZfdCkgPT0gc2l6ZW9mICh2b2lkICopKTsKIHZlcmlmeSAo c2l6ZW9mIChpbnRwdHJfdCkgPT0gc2l6ZW9mIChwdHJkaWZmX3QpKTsKIHZlcmlmeSAoc2l6ZW9m ICh2b2lkICgqKSAodm9pZCkpID09IHNpemVvZiAodm9pZCAqKSk7CkBAIC00MDEsNiArMzkwLDgg QEAgZHVtcF9maW5nZXJwcmludCAoY2hhciBjb25zdCAqbGFiZWwsCiAgICAgIFRoZSBzdGFydCBv ZiB0aGUgY29sZCByZWdpb24gaXMgYWx3YXlzIGFsaWduZWQgb24gYSBwYWdlCiAgICAgIGJvdW5k YXJ5LiAgKi8KICAgZHVtcF9vZmYgY29sZF9zdGFydDsKKworICBkdW1wX29mZiBoYXNoX2xpc3Q7 CiB9OwogCiAvKiBEb3VibGUtZW5kZWQgc2luZ2x5IGxpbmtlZCBsaXN0LiAgKi8KQEAgLTU1OCw2 ICs1NDksOCBAQCBkdW1wX2ZpbmdlcnByaW50IChjaGFyIGNvbnN0ICpsYWJlbCwKICAgICAgaGVh cCBvYmplY3RzLiAgKi8KICAgTGlzcF9PYmplY3QgYmlnbnVtX2RhdGE7CiAKKyAgTGlzcF9PYmpl Y3QgaGFzaF90YWJsZXM7CisKICAgdW5zaWduZWQgbnVtYmVyX2hvdF9yZWxvY2F0aW9uczsKICAg dW5zaWduZWQgbnVtYmVyX2Rpc2NhcmRhYmxlX3JlbG9jYXRpb25zOwogfTsKQEAgLTI2MTYsNzgg KzI2MDksNjEgQEAgZHVtcF92ZWN0b3JsaWtlX2dlbmVyaWMgKHN0cnVjdCBkdW1wX2NvbnRleHQg KmN0eCwKICAgcmV0dXJuIG9mZnNldDsKIH0KIAotLyogRGV0ZXJtaW5lIHdoZXRoZXIgdGhlIGhh c2ggdGFibGUncyBoYXNoIG9yZGVyIGlzIHN0YWJsZQotICAgYWNyb3NzIGR1bXAgYW5kIGxvYWQu ICBJZiBpdCBpcywgd2UgZG9uJ3QgaGF2ZSB0byB0cmlnZ2VyCi0gICBhIHJlaGFzaCBvbiBhY2Nl c3MuICAqLwotc3RhdGljIGJvb2wKLWR1bXBfaGFzaF90YWJsZV9zdGFibGVfcCAoY29uc3Qgc3Ry dWN0IExpc3BfSGFzaF9UYWJsZSAqaGFzaCkKKy8qIFJldHVybiBhIHZlY3RvciBvZiBLRVksIFZB TFVFIHBhaXJzIGluIHRoZSBnaXZlbiBoYXNoIHRhYmxlIEguICBUaGUKKyAgIGZpcnN0IEgtPmNv dW50IHBhaXJzIGFyZSB2YWxpZCwgdGhlIHJlc3QgaXMgbGVmdCBhcyBuaWwuICAqLworc3RhdGlj IExpc3BfT2JqZWN0CitoYXNoX3RhYmxlX2NvbnRlbnRzIChzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxl ICpoKQogewotICBpZiAoaGFzaC0+dGVzdC5oYXNoZm4gPT0gaGFzaGZuX3VzZXJfZGVmaW5lZCkK KyAgaWYgKGgtPnRlc3QuaGFzaGZuID09IGhhc2hmbl91c2VyX2RlZmluZWQpCiAgICAgZXJyb3Ig KCJjYW5ub3QgZHVtcCBoYXNoIHRhYmxlcyB3aXRoIHVzZXItZGVmaW5lZCB0ZXN0cyIpOyAgLyog QnVnIzM2NzY5ICovCi0gIGJvb2wgaXNfZXFsID0gaGFzaC0+dGVzdC5oYXNoZm4gPT0gaGFzaGZu X2VxbDsKLSAgYm9vbCBpc19lcXVhbCA9IGhhc2gtPnRlc3QuaGFzaGZuID09IGhhc2hmbl9lcXVh bDsKLSAgcHRyZGlmZl90IHNpemUgPSBIQVNIX1RBQkxFX1NJWkUgKGhhc2gpOwotICBmb3IgKHB0 cmRpZmZfdCBpID0gMDsgaSA8IHNpemU7ICsraSkKKyAgTGlzcF9PYmplY3QgY29udGVudHMgPSBR bmlsOworICAvKiBNYWtlIHN1cmUga2V5X2FuZF92YWx1ZSBlbmRzIHVwIGluIHRoZSBzYW1lIG9y ZGVyLCBjaGFyc2V0LmMKKyAgICAgcmVsaWVzIG9uIGl0IGJ5IGV4cGVjdGluZyBoYXNoIHRhYmxl IGluZGljZXMgdG8gc3RheSBjb25zdGFudAorICAgICBhY3Jvc3MgdGhlIGR1bXAuICAqLworICBm b3IgKHB0cmRpZmZfdCBpID0gMDsgaSA8IEhBU0hfVEFCTEVfU0laRSAoaCkgLSBoLT5jb3VudDsg aSsrKQogICAgIHsKLSAgICAgIExpc3BfT2JqZWN0IGtleSA9ICBIQVNIX0tFWSAoaGFzaCwgaSk7 Ci0gICAgICBpZiAoIUVRIChrZXksIFF1bmJvdW5kKSkKLSAgICAgICAgewotCSAgYm9vbCBrZXlf c3RhYmxlID0gKGR1bXBfYnVpbHRpbl9zeW1ib2xfcCAoa2V5KQotCQkJICAgICB8fCBGSVhOVU1Q IChrZXkpCi0JCQkgICAgIHx8IChpc19lcXVhbAotCQkJICAgICAgICAgJiYgKFNUUklOR1AgKGtl eSkgfHwgQk9PTF9WRUNUT1JfUCAoa2V5KSkpCi0JCQkgICAgIHx8ICgoaXNfZXF1YWwgfHwgaXNf ZXFsKQotCQkJICAgICAgICAgJiYgKEZMT0FUUCAoa2V5KSB8fCBCSUdOVU1QIChrZXkpKSkpOwot ICAgICAgICAgIGlmICgha2V5X3N0YWJsZSkKLSAgICAgICAgICAgIHJldHVybiBmYWxzZTsKLSAg ICAgICAgfQorICAgICAgZHVtcF9wdXNoICgmY29udGVudHMsIFFuaWwpOworICAgICAgZHVtcF9w dXNoICgmY29udGVudHMsIFF1bmJvdW5kKTsKICAgICB9CiAKLSAgcmV0dXJuIHRydWU7CisgIGZv ciAocHRyZGlmZl90IGkgPSBIQVNIX1RBQkxFX1NJWkUgKGgpIC0gMTsgaSA+PSAwOyAtLWkpCisg ICAgaWYgKCFOSUxQIChIQVNIX0hBU0ggKGgsIGkpKSkKKyAgICAgIHsKKwlkdW1wX3B1c2ggKCZj b250ZW50cywgSEFTSF9WQUxVRSAoaCwgaSkpOworCWR1bXBfcHVzaCAoJmNvbnRlbnRzLCBIQVNI X0tFWSAoaCwgaSkpOworICAgICAgfQorCisgIHJldHVybiBDQUxMTiAoRmFwcGx5LCBRdmVjdG9y LCBjb250ZW50cyk7CiB9CiAKLS8qIFJldHVybiBhIGxpc3Qgb2YgKEtFWSAuIFZBTFVFKSBwYWly cyBpbiB0aGUgZ2l2ZW4gaGFzaCB0YWJsZS4gICovCi1zdGF0aWMgTGlzcF9PYmplY3QKLWhhc2hf dGFibGVfY29udGVudHMgKExpc3BfT2JqZWN0IHRhYmxlKQorc3RhdGljIGR1bXBfb2ZmCitkdW1w X2hhc2hfdGFibGVfbGlzdCAoc3RydWN0IGR1bXBfY29udGV4dCAqY3R4KQogewotICBMaXNwX09i amVjdCBjb250ZW50cyA9IFFuaWw7Ci0gIHN0cnVjdCBMaXNwX0hhc2hfVGFibGUgKmggPSBYSEFT SF9UQUJMRSAodGFibGUpOwotICBmb3IgKHB0cmRpZmZfdCBpID0gMDsgaSA8IEhBU0hfVEFCTEVf U0laRSAoaCk7ICsraSkKLSAgICB7Ci0gICAgICBMaXNwX09iamVjdCBrZXkgPSAgSEFTSF9LRVkg KGgsIGkpOwotICAgICAgaWYgKCFFUSAoa2V5LCBRdW5ib3VuZCkpCi0gICAgICAgIGR1bXBfcHVz aCAoJmNvbnRlbnRzLCBGY29ucyAoa2V5LCBIQVNIX1ZBTFVFIChoLCBpKSkpOwotICAgIH0KLSAg cmV0dXJuIEZucmV2ZXJzZSAoY29udGVudHMpOworICBpZiAoQ09OU1AgKGN0eC0+aGFzaF90YWJs ZXMpKQorICAgIHJldHVybiBkdW1wX29iamVjdCAoY3R4LCBDQUxMTiAoRmFwcGx5LCBRdmVjdG9y LCBjdHgtPmhhc2hfdGFibGVzKSk7CisgIGVsc2UKKyAgICByZXR1cm4gMDsKIH0KIAotLyogQ29w eSB0aGUgZ2l2ZW4gaGFzaCB0YWJsZSwgcmVoYXNoIGl0LCBhbmQgbWFrZSBzdXJlIHRoYXQgd2Ug Y2FuCi0gICBsb29rIHVwIGFsbCB0aGUgdmFsdWVzIGluIHRoZSBvcmlnaW5hbC4gICovCiBzdGF0 aWMgdm9pZAotY2hlY2tfaGFzaF90YWJsZV9yZWhhc2ggKExpc3BfT2JqZWN0IHRhYmxlX29yaWcp Ci17Ci0gIHB0cmRpZmZfdCBjb3VudCA9IFhIQVNIX1RBQkxFICh0YWJsZV9vcmlnKS0+Y291bnQ7 Ci0gIGhhc2hfcmVoYXNoX2lmX25lZWRlZCAoWEhBU0hfVEFCTEUgKHRhYmxlX29yaWcpKTsKLSAg TGlzcF9PYmplY3QgdGFibGVfcmVoYXNoZWQgPSBGY29weV9oYXNoX3RhYmxlICh0YWJsZV9vcmln KTsKLSAgZWFzc2VydCAoIWhhc2hfcmVoYXNoX25lZWRlZF9wIChYSEFTSF9UQUJMRSAodGFibGVf cmVoYXNoZWQpKSk7Ci0gIFhIQVNIX1RBQkxFICh0YWJsZV9yZWhhc2hlZCktPmhhc2ggPSBRbmls OwotICBlYXNzZXJ0IChjb3VudCA9PSAwIHx8IGhhc2hfcmVoYXNoX25lZWRlZF9wIChYSEFTSF9U QUJMRSAodGFibGVfcmVoYXNoZWQpKSk7Ci0gIGhhc2hfcmVoYXNoX2lmX25lZWRlZCAoWEhBU0hf VEFCTEUgKHRhYmxlX3JlaGFzaGVkKSk7Ci0gIGVhc3NlcnQgKCFoYXNoX3JlaGFzaF9uZWVkZWRf cCAoWEhBU0hfVEFCTEUgKHRhYmxlX3JlaGFzaGVkKSkpOwotICBMaXNwX09iamVjdCBleHBlY3Rl ZF9jb250ZW50cyA9IGhhc2hfdGFibGVfY29udGVudHMgKHRhYmxlX29yaWcpOwotICB3aGlsZSAo IU5JTFAgKGV4cGVjdGVkX2NvbnRlbnRzKSkKLSAgICB7Ci0gICAgICBMaXNwX09iamVjdCBrZXlf dmFsdWVfcGFpciA9IGR1bXBfcG9wICgmZXhwZWN0ZWRfY29udGVudHMpOwotICAgICAgTGlzcF9P YmplY3Qga2V5ID0gWENBUiAoa2V5X3ZhbHVlX3BhaXIpOwotICAgICAgTGlzcF9PYmplY3QgZXhw ZWN0ZWRfdmFsdWUgPSBYQ0RSIChrZXlfdmFsdWVfcGFpcik7Ci0gICAgICBMaXNwX09iamVjdCBh cmJpdHJhcnkgPSBRZHVtcF9lbWFjc19wb3J0YWJsZV9fc29ydF9wcmVkaWNhdGVfY29waWVkOwot ICAgICAgTGlzcF9PYmplY3QgZm91bmRfdmFsdWUgPSBGZ2V0aGFzaCAoa2V5LCB0YWJsZV9yZWhh c2hlZCwgYXJiaXRyYXJ5KTsKLSAgICAgIGVhc3NlcnQgKEVRIChleHBlY3RlZF92YWx1ZSwgZm91 bmRfdmFsdWUpKTsKLSAgICAgIEZyZW1oYXNoIChrZXksIHRhYmxlX3JlaGFzaGVkKTsKLSAgICB9 CitoYXNoX3RhYmxlX2ZyZWV6ZSAoc3RydWN0IExpc3BfSGFzaF9UYWJsZSAqaCkKK3sKKyAgcHRy ZGlmZl90IG5rZXlzID0gWEZJWE5BVCAoRmxlbmd0aCAoaC0+a2V5X2FuZF92YWx1ZSkpIC8gMjsK KyAgaC0+a2V5X2FuZF92YWx1ZSA9IGhhc2hfdGFibGVfY29udGVudHMgKGgpOworICBoLT5uZXh0 X2ZyZWUgPSAobmtleXMgPT0gaC0+Y291bnQgPyAtMSA6IGgtPmNvdW50KTsKKyAgaC0+aW5kZXgg PSBGbGVuZ3RoIChoLT5pbmRleCk7CisgIGgtPm5leHQgPSBoLT5oYXNoID0gbWFrZV9maXhudW0g KG5rZXlzKTsKK30KIAotICBlYXNzZXJ0IChFUSAoRmhhc2hfdGFibGVfY291bnQgKHRhYmxlX3Jl aGFzaGVkKSwKLSAgICAgICAgICAgICAgIG1ha2VfZml4bnVtICgwKSkpOworc3RhdGljIHZvaWQK K2hhc2hfdGFibGVfdGhhdyAoTGlzcF9PYmplY3QgaGFzaCkKK3sKKyAgc3RydWN0IExpc3BfSGFz aF9UYWJsZSAqaCA9IFhIQVNIX1RBQkxFIChoYXNoKTsKKyAgaC0+aW5kZXggPSBGbWFrZV92ZWN0 b3IgKGgtPmluZGV4LCBtYWtlX2ZpeG51bSAoLTEpKTsKKyAgaC0+aGFzaCA9IEZtYWtlX3ZlY3Rv ciAoaC0+aGFzaCwgUW5pbCk7CisgIGgtPm5leHQgPSBGbWFrZV92ZWN0b3IgKGgtPm5leHQsIG1h a2VfZml4bnVtICgtMSkpOworCisgIGhhc2hfdGFibGVfcmVoYXNoIChoYXNoKTsKIH0KIAogc3Rh dGljIGR1bXBfb2ZmCkBAIC0yNjk5LDUxICsyNjc1LDExIEBAIGR1bXBfaGFzaF90YWJsZSAoc3Ry dWN0IGR1bXBfY29udGV4dCAqY3R4LAogIyBlcnJvciAiTGlzcF9IYXNoX1RhYmxlIGNoYW5nZWQu IFNlZSBDSEVDS19TVFJVQ1RTIGNvbW1lbnQgaW4gY29uZmlnLmguIgogI2VuZGlmCiAgIGNvbnN0 IHN0cnVjdCBMaXNwX0hhc2hfVGFibGUgKmhhc2hfaW4gPSBYSEFTSF9UQUJMRSAob2JqZWN0KTsK LSAgYm9vbCBpc19zdGFibGUgPSBkdW1wX2hhc2hfdGFibGVfc3RhYmxlX3AgKGhhc2hfaW4pOwot ICAvKiBJZiB0aGUgaGFzaCB0YWJsZSBpcyBsaWtlbHkgdG8gYmUgbW9kaWZpZWQgaW4gbWVtb3J5 IChlaXRoZXIKLSAgICAgYmVjYXVzZSB3ZSBuZWVkIHRvIHJlaGFzaCwgYW5kIHRodXMgdG9nZ2xl IGhhc2gtPmNvdW50LCBvcgotICAgICBiZWNhdXNlIHdlIG5lZWQgdG8gYXNzZW1ibGUgYSBsaXN0 IG9mIHdlYWsgdGFibGVzKSBwdW50IHRoZSBoYXNoCi0gICAgIHRhYmxlIHRvIHRoZSBlbmQgb2Yg dGhlIGR1bXAsIHdoZXJlIHdlIGNhbiBsdW1wIGFsbCBzdWNoIGhhc2gKLSAgICAgdGFibGVzIHRv Z2V0aGVyLiAgKi8KLSAgaWYgKCEoaXNfc3RhYmxlIHx8ICFOSUxQIChoYXNoX2luLT53ZWFrKSkK LSAgICAgICYmIGN0eC0+ZmxhZ3MuZGVmZXJfaGFzaF90YWJsZXMpCi0gICAgewotICAgICAgaWYg KG9mZnNldCAhPSBEVU1QX09CSkVDVF9PTl9IQVNIX1RBQkxFX1FVRVVFKQotICAgICAgICB7Ci0J ICBlYXNzZXJ0IChvZmZzZXQgPT0gRFVNUF9PQkpFQ1RfT05fTk9STUFMX1FVRVVFCi0JCSAgIHx8 IG9mZnNldCA9PSBEVU1QX09CSkVDVF9OT1RfU0VFTik7Ci0gICAgICAgICAgLyogV2Ugc3RpbGwg d2FudCB0byBkdW1wIHRoZSBhY3R1YWwga2V5cyBhbmQgdmFsdWVzIG5vdy4gICovCi0gICAgICAg ICAgZHVtcF9lbnF1ZXVlX29iamVjdCAoY3R4LCBoYXNoX2luLT5rZXlfYW5kX3ZhbHVlLCBXRUlH SFRfTk9ORSk7Ci0gICAgICAgICAgLyogV2UnbGwgZ2V0IHRvIHRoZSByZXN0IGxhdGVyLiAgKi8K LSAgICAgICAgICBvZmZzZXQgPSBEVU1QX09CSkVDVF9PTl9IQVNIX1RBQkxFX1FVRVVFOwotICAg ICAgICAgIGR1bXBfcmVtZW1iZXJfb2JqZWN0IChjdHgsIG9iamVjdCwgb2Zmc2V0KTsKLSAgICAg ICAgICBkdW1wX3B1c2ggKCZjdHgtPmRlZmVycmVkX2hhc2hfdGFibGVzLCBvYmplY3QpOwotICAg ICAgICB9Ci0gICAgICByZXR1cm4gb2Zmc2V0OwotICAgIH0KLQotICBpZiAoUERVTVBFUl9DSEVD S19SRUhBU0hJTkcpCi0gICAgY2hlY2tfaGFzaF90YWJsZV9yZWhhc2ggKG1ha2VfbGlzcF9wdHIg KCh2b2lkICopIGhhc2hfaW4sIExpc3BfVmVjdG9ybGlrZSkpOwotCiAgIHN0cnVjdCBMaXNwX0hh c2hfVGFibGUgaGFzaF9tdW5nZWQgPSAqaGFzaF9pbjsKICAgc3RydWN0IExpc3BfSGFzaF9UYWJs ZSAqaGFzaCA9ICZoYXNoX211bmdlZDsKIAotICAvKiBSZW1lbWJlciB0byByZWhhc2ggdGhpcyBo YXNoIHRhYmxlIG9uIGZpcnN0IGFjY2Vzcy4gIEFmdGVyIGEKLSAgICAgZHVtcCByZWxvYWQsIHRo ZSBoYXNoIHRhYmxlIHZhbHVlcyB3aWxsIGhhdmUgY2hhbmdlZCwgc28gd2UnbGwKLSAgICAgbmVl ZCB0byByZWJ1aWxkIHRoZSBpbmRleC4KLQotICAgICBUT0RPOiBmb3IgRVEgYW5kIEVRTCBoYXNo IHRhYmxlcywgaXQgc2hvdWxkIGJlIHBvc3NpYmxlIHRvIHJlaGFzaAotICAgICBoZXJlIHVzaW5n IHRoZSBwcmVmZXJyZWQgbG9hZCBhZGRyZXNzIG9mIHRoZSBkdW1wLCBlbGltaW5hdGluZwotICAg ICB0aGUgbmVlZCB0byByZWhhc2gtb24tYWNjZXNzIGlmIHdlIGNhbiBsb2FkIHRoZSBkdW1wIHdo ZXJlIHdlCi0gICAgIHdhbnQuICAqLwotICBpZiAoaGFzaC0+Y291bnQgPiAwICYmICFpc19zdGFi bGUpCi0gICAgLyogSGFzaCBjb2RlcyB3aWxsIGhhdmUgdG8gYmUgcmVjb21wdXRlZCBhbnl3YXks IHNvIGxldCdzIG5vdCBkdW1wIHRoZW0uCi0gICAgICAgQWxzbyBzZXQgYGhhc2hgIHRvIG5pbCBm b3IgaGFzaF9yZWhhc2hfbmVlZGVkX3AuCi0gICAgICAgV2UgY291bGQgYWxzbyByZWZyYWluIGZy b20gZHVtcGluZyB0aGUgYG5leHQnIGFuZCBgaW5kZXgnIHZlY3RvcnMsCi0gICAgICAgZXhjZXB0 IHRoYXQgYG5leHQnIGlzIGN1cnJlbnRseSB1c2VkIGZvciBIQVNIX1RBQkxFX1NJWkUgYW5kCi0g ICAgICAgd2UnZCBoYXZlIHRvIHJlYnVpbGQgdGhlIG5leHRfZnJlZSBsaXN0IGFzIHdlbGwgYXMg YWRqdXN0Ci0gICAgICAgc3dlZXBfd2Vha19oYXNoX3RhYmxlIGZvciB0aGUgY2FzZSB3aGVyZSB0 aGVyZSdzIG5vIGBpbmRleCcuICAqLwotICAgIGhhc2gtPmhhc2ggPSBRbmlsOworICBoYXNoX3Rh YmxlX2ZyZWV6ZSAoaGFzaCk7CisgIGR1bXBfcHVzaCAoJmN0eC0+aGFzaF90YWJsZXMsIG9iamVj dCk7CiAKICAgU1RBUlRfRFVNUF9QVkVDIChjdHgsICZoYXNoLT5oZWFkZXIsIHN0cnVjdCBMaXNw X0hhc2hfVGFibGUsIG91dCk7CiAgIGR1bXBfcHNldWRvdmVjdG9yX2xpc3BfZmllbGRzIChjdHgs ICZvdXQtPmhlYWRlciwgJmhhc2gtPmhlYWRlcik7CkBAIC00MTUxLDYgKzQwODcsMTkgQEAgREVG VU4gKCJkdW1wLWVtYWNzLXBvcnRhYmxlIiwKIAkgfHwgIU5JTFAgKGN0eC0+ZGVmZXJyZWRfaGFz aF90YWJsZXMpCiAJIHx8ICFOSUxQIChjdHgtPmRlZmVycmVkX3N5bWJvbHMpKTsKIAorICBjdHgt PmhlYWRlci5oYXNoX2xpc3QgPSBjdHgtPm9mZnNldDsKKyAgZHVtcF9oYXNoX3RhYmxlX2xpc3Qg KGN0eCk7CisKKyAgZG8KKyAgICB7CisgICAgICBkdW1wX2RyYWluX2RlZmVycmVkX2hhc2hfdGFi bGVzIChjdHgpOworICAgICAgZHVtcF9kcmFpbl9kZWZlcnJlZF9zeW1ib2xzIChjdHgpOworICAg ICAgZHVtcF9kcmFpbl9ub3JtYWxfcXVldWUgKGN0eCk7CisgICAgfQorICB3aGlsZSAoIWR1bXBf cXVldWVfZW1wdHlfcCAoJmN0eC0+ZHVtcF9xdWV1ZSkKKwkgfHwgIU5JTFAgKGN0eC0+ZGVmZXJy ZWRfaGFzaF90YWJsZXMpCisJIHx8ICFOSUxQIChjdHgtPmRlZmVycmVkX3N5bWJvbHMpKTsKKwog ICBkdW1wX3NvcnRfY29waWVkX29iamVjdHMgKGN0eCk7CiAKICAgLyogV2hpbGUgd2UgY29weSBi dWlsdC1pbiBzeW1ib2xzIGludG8gdGhlIEVtYWNzIGltYWdlLCB0aGVzZQpAQCAtNTMwMiw2ICs1 MjUxLDkgQEAgZHVtcF9kb19hbGxfZW1hY3NfcmVsb2NhdGlvbnMgKGNvbnN0IHN0cnVjdCBkdW1w X2hlYWRlciAqY29uc3QgaGVhZGVyLAogICAgTlVNQkVSX0RVTVBfU0VDVElPTlMsCiAgIH07CiAK Ky8qIFBvaW50ZXIgdG8gYSBzdGFjayB2YXJpYWJsZSB0byBhdm9pZCBoYXZpbmcgdG8gc3RhdGlj cHJvIGl0LiAgKi8KK3N0YXRpYyBMaXNwX09iamVjdCAqcGR1bXBlcl9oYXNoZXMgPSAmemVyb192 ZWN0b3I7CisKIC8qIExvYWQgYSBkdW1wIGZyb20gRFVNUF9GSUxFTkFNRS4gIFJldHVybiBhbiBl cnJvciBjb2RlLgogCiAgICBOLkIuIFdlIHJ1biB2ZXJ5IGVhcmx5IGluIGluaXRpYWxpemF0aW9u LCBzbyB3ZSBjYW4ndCB1c2UgbGlzcCwKQEAgLTU0NDgsNiArNTQwMCwxNSBAQCBwZHVtcGVyX2xv YWQgKGNvbnN0IGNoYXIgKmR1bXBfZmlsZW5hbWUpCiAgIGZvciAoaW50IGkgPSAwOyBpIDwgQVJS QVlFTFRTIChzZWN0aW9ucyk7ICsraSkKICAgICBkdW1wX21tYXBfcmVzZXQgKCZzZWN0aW9uc1tp XSk7CiAKKyAgTGlzcF9PYmplY3QgaGFzaGVzID0gemVyb192ZWN0b3I7CisgIGlmIChoZWFkZXIt Pmhhc2hfbGlzdCkKKyAgICB7CisgICAgICBzdHJ1Y3QgTGlzcF9WZWN0b3IgKmhhc2hfdGFibGVz ID0KKwkoKHN0cnVjdCBMaXNwX1ZlY3RvciAqKShkdW1wX2Jhc2UgKyBoZWFkZXItPmhhc2hfbGlz dCkpOworICAgICAgWFNFVFZFQ1RPUiAoaGFzaGVzLCBoYXNoX3RhYmxlcyk7CisgICAgfQorCisg IHBkdW1wZXJfaGFzaGVzID0gJmhhc2hlczsKICAgLyogUnVuIHRoZSBmdW5jdGlvbnMgRW1hY3Mg cmVnaXN0ZXJlZCBmb3IgZG9pbmcgcG9zdC1kdW1wLWxvYWQKICAgICAgaW5pdGlhbGl6YXRpb24u ICAqLwogICBmb3IgKGludCBpID0gMDsgaSA8IG5yX2R1bXBfaG9va3M7ICsraSkKQEAgLTU1MTgs NiArNTQ3OSwxOSBAQCBERUZVTiAoInBkdW1wZXItc3RhdHMiLCBGcGR1bXBlcl9zdGF0cywgU3Bk dW1wZXJfc3RhdHMsIDAsIDAsIDAsCiAjZW5kaWYgLyogSEFWRV9QRFVNUEVSICovCiAKIAwKK3N0 YXRpYyB2b2lkCit0aGF3X2hhc2hfdGFibGVzICh2b2lkKQoreworICBMaXNwX09iamVjdCBoYXNo X3RhYmxlcyA9ICpwZHVtcGVyX2hhc2hlczsKKyAgZm9yIChwdHJkaWZmX3QgaSA9IDA7IGkgPCBB U0laRSAoaGFzaF90YWJsZXMpOyBpKyspCisgICAgaGFzaF90YWJsZV90aGF3IChBUkVGIChoYXNo X3RhYmxlcywgaSkpOworfQorCit2b2lkCitpbml0X3BkdW1wZXJfb25jZSAodm9pZCkKK3sKKyAg cGR1bXBlcl9kb19ub3dfYW5kX2FmdGVyX2xvYWQgKHRoYXdfaGFzaF90YWJsZXMpOworfQogCiB2 b2lkCiBzeW1zX29mX3BkdW1wZXIgKHZvaWQpCmRpZmYgLS1naXQgYS9zcmMvcGR1bXBlci5oIGIv c3JjL3BkdW1wZXIuaAppbmRleCA2YTk5YjUxMWYyLi5jNzkzZmI0MDU4IDEwMDY0NAotLS0gYS9z cmMvcGR1bXBlci5oCisrKyBiL3NyYy9wZHVtcGVyLmgKQEAgLTI1Niw2ICsyNTYsNyBAQCBwZHVt cGVyX2NsZWFyX21hcmtzICh2b2lkKQogICAgZmlsZSB3YXMgbG9hZGVkLiAgKi8KIGV4dGVybiB2 b2lkIHBkdW1wZXJfcmVjb3JkX3dkIChjb25zdCBjaGFyICopOwogCit2b2lkIGluaXRfcGR1bXBl cl9vbmNlICh2b2lkKTsKIHZvaWQgc3ltc19vZl9wZHVtcGVyICh2b2lkKTsKIAogSU5MSU5FX0hF QURFUl9FTkQKLS0gCjIuMjguMAoK --00000000000028c00105ac849638-- From debbugs-submit-bounces@debbugs.gnu.org Mon Aug 10 09:04:31 2020 Received: (at 36597) by debbugs.gnu.org; 10 Aug 2020 13:04:31 +0000 Received: from localhost ([127.0.0.1]:34894 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k57Tb-0007DK-J7 for submit@debbugs.gnu.org; Mon, 10 Aug 2020 09:04:31 -0400 Received: from quimby.gnus.org ([95.216.78.240]:47454) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k57TZ-0007D7-TZ for 36597@debbugs.gnu.org; Mon, 10 Aug 2020 09:04:30 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=gnus.org; s=20200322; h=Content-Type:MIME-Version:Message-ID:In-Reply-To:Date: References:Subject:Cc:To:From:Sender:Reply-To:Content-Transfer-Encoding: Content-ID:Content-Description:Resent-Date:Resent-From:Resent-Sender: Resent-To:Resent-Cc:Resent-Message-ID:List-Id:List-Help:List-Unsubscribe: List-Subscribe:List-Post:List-Owner:List-Archive; bh=L8GTLXuwGNogLngbwlFAB6hti1drZql3333hYiz2W6Q=; b=eZO94GH5WoPgJeg6c60XaESXlX STF6vmbTEUStRT/Qrmmy23GyGXGFTUx+sbxVGT982WVdmdK82eT7TyNE0ct0cACpZ+uOMazIRNPLl r0iLSsBGRVXWw5gxsINN6XnGdXnWhbCF36D+x1e5H9PKr5q5682s1XgVOoVLvPlhMY3o=; Received: from cm-84.212.202.86.getinternet.no ([84.212.202.86] helo=xo) by quimby with esmtpsa (TLS1.3:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.92) (envelope-from ) id 1k57TQ-000463-Fr; Mon, 10 Aug 2020 15:04:23 +0200 From: Lars Ingebrigtsen To: Pip Cet Subject: Re: bug#36597: 27.0.50; rehash hash tables eagerly in pdumper References: <6a260307-a463-bd08-8a10-d7664d0606a2@cs.ucla.edu> <74235afc-7043-1da7-7c71-07f0ca23b9fd@cs.ucla.edu> <83r26mv53z.fsf@gnu.org> <87ft8vbow1.fsf@gnus.org> Date: Mon, 10 Aug 2020 15:04:18 +0200 In-Reply-To: (Pip Cet's message of "Mon, 10 Aug 2020 11:51:42 +0000") Message-ID: <87v9hq4ppp.fsf@gnus.org> User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/28.0.50 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain X-Spam-Report: Spam detection software, running on the system "quimby.gnus.org", has NOT identified this incoming email as spam. The original message has been attached to this so you can view it or label similar future email. If you have any questions, see @@CONTACT_ADDRESS@@ for details. Content preview: Pip Cet writes: >> So I tried applying the patch now to Emacs 28 to do some benchmarking, >> but it didn't apply cleanly, so I gave up. > > I'll try to rebase them again. Does the attached work for you? Content analysis details: (-2.9 points, 5.0 required) pts rule name description ---- ---------------------- -------------------------------------------------- -1.0 ALL_TRUSTED Passed through trusted hosts only via SMTP -1.9 BAYES_00 BODY: Bayes spam probability is 0 to 1% [score: 0.0000] X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 36597 Cc: Eli Zaretskii , Paul Eggert , 36597@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) Pip Cet writes: >> So I tried applying the patch now to Emacs 28 to do some benchmarking, >> but it didn't apply cleanly, so I gave up. > > I'll try to rebase them again. Does the attached work for you? Yup. I've now done some benchmarking with time make -j32 compile-always Without patch: real 0m38.855s real 0m40.295s real 0m39.299s real 0m39.864s real 0m40.428s real 0m40.012s real 0m38.988s real 0m39.807s real 0m40.455s real 0m37.341s real 0m33.349s real 0m34.379s real 0m34.339s real 0m33.139s real 0m32.902s real 0m33.755s real 0m34.143s real 0m34.598s real 0m34.484s real 0m34.342s With patch: real 0m36.064s real 0m36.617s real 0m34.502s real 0m36.817s real 0m31.782s real 0m32.859s real 0m29.779s real 0m29.703s real 0m30.313s real 0m29.496s real 0m29.585s real 0m29.807s real 0m30.235s real 0m30.142s real 0m29.960s real 0m30.067s real 0m30.114s real 0m29.975s real 0m30.388s real 0m30.112s Er... It's weird that there's so much difference in time between runs -- this is running on a machine that does nothing else and has a load of 0.0 if I'm not compiling Emacs. So I don't know what can be concluded here... if we just take the mean from these numbers, it seems that your patch is making compilation faster. :-) -- (domestic pets only, the antidote for overdose, milk.) bloggy blog: http://lars.ingebrigtsen.no From debbugs-submit-bounces@debbugs.gnu.org Tue Aug 11 05:33:48 2020 Received: (at 36597-done) by debbugs.gnu.org; 11 Aug 2020 09:33:48 +0000 Received: from localhost ([127.0.0.1]:38690 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5QfC-0003Jd-PO for submit@debbugs.gnu.org; Tue, 11 Aug 2020 05:33:48 -0400 Received: from zimbra.cs.ucla.edu ([131.179.128.68]:60004) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5Qf9-0003JP-Gd for 36597-done@debbugs.gnu.org; Tue, 11 Aug 2020 05:33:45 -0400 Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id 07F14160115; Tue, 11 Aug 2020 02:33:38 -0700 (PDT) Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10032) with ESMTP id RROVLh0uQbzZ; Tue, 11 Aug 2020 02:33:35 -0700 (PDT) Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id F0A7C160116; Tue, 11 Aug 2020 02:33:34 -0700 (PDT) X-Virus-Scanned: amavisd-new at zimbra.cs.ucla.edu Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10026) with ESMTP id ikKmPrKncwLk; Tue, 11 Aug 2020 02:33:34 -0700 (PDT) Received: from [192.168.1.9] (cpe-75-82-69-226.socal.res.rr.com [75.82.69.226]) by zimbra.cs.ucla.edu (Postfix) with ESMTPSA id 98C5E160115; Tue, 11 Aug 2020 02:33:34 -0700 (PDT) Subject: Re: bug#36597: 27.0.50; rehash hash tables eagerly in pdumper To: Lars Ingebrigtsen , Pip Cet References: <6a260307-a463-bd08-8a10-d7664d0606a2@cs.ucla.edu> <74235afc-7043-1da7-7c71-07f0ca23b9fd@cs.ucla.edu> <83r26mv53z.fsf@gnu.org> <87ft8vbow1.fsf@gnus.org> <87v9hq4ppp.fsf@gnus.org> From: Paul Eggert Autocrypt: addr=eggert@cs.ucla.edu; prefer-encrypt=mutual; keydata= LS0tLS1CRUdJTiBQR1AgUFVCTElDIEtFWSBCTE9DSy0tLS0tCgptUUlOQkV5QWNtUUJFQURB QXlIMnhvVHU3cHBHNUQzYThGTVpFb243NGRDdmM0K3ExWEEySjJ0QnkycHdhVHFmCmhweHhk R0E5Smo1MFVKM1BENGJTVUVnTjh0TFowc2FuNDdsNVhUQUZMaTI0NTZjaVNsNW04c0thSGxH ZHQ5WG0KQUF0bVhxZVpWSVlYL1VGUzk2ZkR6ZjR4aEVtbS95N0xiWUVQUWRVZHh1NDd4QTVL aFRZcDVibHRGM1dZRHoxWQpnZDdneDA3QXV3cDdpdzdlTnZub0RUQWxLQWw4S1lEWnpiRE5D UUdFYnBZM2VmWkl2UGRlSStGV1FONFcra2doCnkrUDZhdTZQcklJaFlyYWV1YTdYRGRiMkxT MWVuM1NzbUUzUWpxZlJxSS9BMnVlOEpNd3N2WGUvV0szOEV6czYKeDc0aVRhcUkzQUZINmls QWhEcXBNbmQvbXNTRVNORnQ3NkRpTzFaS1FNcjlhbVZQa25qZlBtSklTcWRoZ0IxRApsRWR3 MzRzUk9mNlY4bVp3MHhmcVQ2UEtFNDZMY0ZlZnpzMGtiZzRHT1JmOHZqRzJTZjF0azVlVThN Qml5Ti9iClowM2JLTmpOWU1wT0REUVF3dVA4NGtZTGtYMndCeHhNQWhCeHdiRFZadWR6eERa SjFDMlZYdWpDT0pWeHEya2wKakJNOUVUWXVVR3FkNzVBVzJMWHJMdzYrTXVJc0hGQVlBZ1Jy NytLY3dEZ0JBZndoUEJZWDM0blNTaUhsbUxDKwpLYUhMZUNMRjVaSTJ2S20zSEVlQ1R0bE9n N3haRU9OZ3d6TCtmZEtvK0Q2U29DOFJSeEpLczhhM3NWZkk0dDZDCm5yUXp2SmJCbjZneGRn Q3U1aTI5SjFRQ1lyQ1l2cWwyVXlGUEFLK2RvOTkvMWpPWFQ0bTI4MzZqMXdBUkFRQUIKdENC UVlYVnNJRVZuWjJWeWRDQThaV2RuWlhKMFFHTnpMblZqYkdFdVpXUjFQb2tDUGdRVEFRSUFL QVVDVElCeQpaQUliQXdVSkVzd0RBQVlMQ1FnSEF3SUdGUWdDQ1FvTEJCWUNBd0VDSGdFQ0Y0 QUFDZ2tRN1pmcERtS3FmalJSCkd3LytJajAzZGhZZllsL2dYVlJpdXpWMWdHcmJIayt0bmZy SS9DN2ZBZW9GelE1dFZnVmluU2hhUGtabzBIVFAKZjE4eDZJREVkQWlPOE1xbzF5cDBDdEht ekdNQ0o1MG80R3JnZmpscjZnLyt2dEVPS2JobGVzek4yWHBKdnB3TQoyUWdHdm4vbGFUTFV1 OFBIOWFSV1RzN3FKSlpLS0tBYjRzeFljOTJGZWhQdTZGT0QwZERpeWhsREFxNGxPVjJtCmRC cHpRYmlvam9aelFMTVF3anBnQ1RLMjU3MmVLOUVPRVF5U1VUaFhyU0l6NkFTZW5wNE5ZVEZI czl0dUpRdlgKazlnWkRkUFNsM2JwKzQ3ZEd4bHhFV0xwQklNN3pJT053NGtzNGF6Z1Q4bnZE WnhBNUlaSHR2cUJsSkxCT2JZWQowTGU2MVdwMHkzVGxCRGgycWRLOGVZTDQyNlc0c2NFTVN1 aWc1Z2I4T0F0UWlCVzZrMnNHVXh4ZWl2OG92V3U4CllBWmdLSmZ1b1dJK3VSbk1FZGRydVk4 SnNvTTU0S2FLdlppa2tLczJiZzFuZHRMVnpIcEo2cUZaQzdRVmplSFUKaDYvQm1ndmRqV1Ba WUZUdE4rS0E5Q1dYM0dRS0tnTjN1dTk4OHl6bkQ3TG5COThUNEVVSDFIQS9HbmZCcU1WMQpn cHpUdlBjNHFWUWluQ21Ja0VGcDgzemwrRzVmQ2pKSjNXN2l2ekNuWW80S2hLTHBGVW05N29r VEtSMkxXM3haCnpFVzRjTFNXTzM4N01USzNDekRPeDVxZTZzNGE5MVp1Wk0vai9UUWRUTERh cU5uODNrQTRIcTQ4VUhYWXhjSWgKK05kOGsvM3c2bEZ1b0swd3JPRml5d2pMeCswdXI1am1t YmVjQkdIYzF4ZGhBRkc1QWcwRVRJQnlaQUVRQUthRgo2NzhUOXd5SDR3alRyVjFQejNjREVv U25WLzBaVXJPVDM3cDFkY0d5ai9JWHExeDY3MEhSVmFoQW1rMHNacFljCjI1UEY5RDVHUFlI RldsTmp1UFU5NnJEbmRYQjNoZWRtQlJoTGRDNGJBWGpJNERWK2JtZFZlK3EvSU1ubFpSYVYK bG05RWlNQ1ZBUjZ3MTNzUmV1N3FYa1c5cjNSd1kyQXpYc2twL3RBZTRCUktyMVptYnZpMm5i blE2ZXBFQzQycgpSYngwQjFFaGpiSVFaNUpIR2syNGlQVDdMZEJnbk5tb3M1d1lqendObGtN UUQ1VDBZZHpoazdKK1V4d0E1bTQ2Cm1PaFJEQzJyRlYvQTBnbTVUTHk4RFhqdi9Fc2M0Z1lu WWFpNlNRcW5VRVZoNUx1VjhZQ0pCbmlqcytUaXc3MXgKMWljbW42eEdJNDVFdWdKT2dlYyty THlwWWdwVnA0eDBISTVUODhxQlJZQ2t4SDNLZzhRbytFV05BOUE0TFJROQpEWDhuam9uYTBn ZjBzMDN0b2NLOGtCTjY2VW9xcVB0SEJuYzRlTWdCeW1DZmxLMTJlS2ZkMllZeG55ZzljWmF6 CldBNVZzbHZUeHBtNzZoYmc1b2lBRUgvVmcvOE14SHlBblBoZnJnd3lQcm1KRWNWQmFmZHNw Sm5ZUXhCWU5jbzIKTEZQSWhsT3ZXaDhyNGF0K3MrTTNMYjI2b1VUY3psZ2RXMVNmM1NEQTc3 Qk1SbkYwRlF5RSs3QXpWNzlNQk40eQpraXFhZXpReHRhRjFGeS90dmtoZmZTbzh1K2R3RzBF Z0poK3RlMzhnVGNJU1ZyMEdJUHBsTHo2WWhqcmJIclBSCkYxQ041VXVMOURCR2p4dU4zNVJM TlZFZnRhNlJVRmxSNk5jdFRqdnJBQkVCQUFHSkFpVUVHQUVDQUE4RkFreUEKY21RQ0d3d0ZD UkxNQXdBQUNna1E3WmZwRG1LcWZqU3JIQS8rS3pBS3ZUeFJoQTlNV05MeEl5SjdTNXVKMTZn cwpUM29DalpyQktHRWhLTU9HWDRPMEdBNlZPRXJ5TzdRUkNDWWFoM294U0czOElBbk5laXdK WGdVOUJ6a2s4NVVHCmJQRWQ3SEdGL1ZTZUhDUXdXb3U2anFVRFRTRHZuOVloTlRkRzBLWFBN NzRhQyt4cjJab3cxTzJtaFhpaGdXS0QKMER3KzBMWVBuVU9zUTBLT0Z4SFhYWUhtUnJTMU9a UFU1OUJMdmMrVFJoSWhhZlNIS0x3YlhLKzZja2t4Qng2aAo4ejVjY3BHMFFzNGJGaGRGWW5G ckVpZURMb0dtbkUyWUxoZFY2c3dKOVZOQ1M2cExpRW9oVDNmbTdhWG0xNXRaCk9JeXpNWmhI UlNBUGJsWHhRMFpTV2pxOG9ScmNZTkZ4YzRXMVVScEFrQkNPWUpvWHZRZkQ1TDNscUFsOFRD cUQKVXpZeGhIL3RKaGJEZEhycUhINzY3amFEYVRCMStUYWxwLzJBTUt3Y1hOT2Rpa2xHeGJt SFZHNllHbDZnOExyYgpzdTlOWkVJNHlMbEh6dWlrdGhKV2d6KzN2WmhWR3lObHQrSE5Jb0Y2 Q2pETDJvbXU1Y0VxNFJESE00NFFxUGs2Cmw3TzBwVXZOMW1UNEIrUzFiMDhSS3BxbS9mZjAx NUUzN0hOVi9waUl2Smx4R0FZejhQU2Z1R0NCMXRoTVlxbG0KZ2RoZDkvQmFiR0ZiR0dZSEE2 VTQvVDV6cVUrZjZ4SHkxU3NBUVoxTVNLbEx3ZWtCSVQrNC9jTFJHcUNIam5WMApxNUgvVDZh N3Q1bVBrYnpTck9MU280cHVqK0lUb05qWXlZSURCV3pobEExOWF2T2ErcnZVam1IdEQzc0ZO N2NYCld0a0dvaThidU5jYnk0VT0KPUFMNm8KLS0tLS1FTkQgUEdQIFBVQkxJQyBLRVkgQkxP Q0stLS0tLQo= Organization: UCLA Computer Science Department Message-ID: Date: Tue, 11 Aug 2020 02:33:34 -0700 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.10.0 MIME-Version: 1.0 In-Reply-To: <87v9hq4ppp.fsf@gnus.org> Content-Type: multipart/mixed; boundary="------------299BED56E3B48389E1EA849F" Content-Language: en-US X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 36597-done Cc: Eli Zaretskii , 36597-done@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) This is a multi-part message in MIME format. --------------299BED56E3B48389E1EA849F Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 7bit On 8/10/20 6:04 AM, Lars Ingebrigtsen wrote: > time make -j32 compile-always > ... > Er... It's weird that there's so much difference in time between > runs I think I get less variance if I do a sequential 'make' (i.e., without -j). Of course this takes longer. > if we just take the mean > from these numbers, it seems that your patch is making compilation > faster. :-) It also simplifies the code a bit, so I took the liberty of installing it, after updating its commit message a bit and changing it to keep a comment that was updated recently (I figure this was a merge error). The patch I installed is the first patch attached. While reviewing the patch I noticed some relatively minor things in the neighborhood that could easily be fixed, so I did so by installing some followup patches, also attached (the last patch is the only one that's at all nontrivial). I'll mark the bug as done. Thanks to both of you for following up on this. --------------299BED56E3B48389E1EA849F Content-Type: text/x-patch; charset=UTF-8; name="0001-Rehash-hash-tables-eagerly-after-loading-a-dump.patch" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename*0="0001-Rehash-hash-tables-eagerly-after-loading-a-dump.patch" >From 8a33944ee20f57a8d2efe6fe68aa0f4745aa2d03 Mon Sep 17 00:00:00 2001 From: Pip Cet Date: Tue, 11 Aug 2020 02:16:53 -0700 Subject: [PATCH 1/7] Rehash hash tables eagerly after loading a dump This simplifies code, and helps performance in some cases (Bug#36597). * src/lisp.h (hash_rehash_needed_p): Remove. All uses removed. (hash_rehash_if_needed): Remove. All uses removed. (struct Lisp_Hash_Table): Remove comment about rehashing hash tables. * src/pdumper.c (thaw_hash_tables): New function. (hash_table_thaw): New function. (hash_table_freeze): New function. (dump_hash_table): Simplify. (dump_hash_table_list): New function. (hash_table_contents): New function. (Fdump_emacs_portable): Handle hash tables by eager rehashing. (pdumper_load): Restore hash tables. (init_pdumper_once): New function. --- src/bytecode.c | 1 - src/composite.c | 1 - src/emacs.c | 1 + src/fns.c | 65 ++++------------ src/lisp.h | 21 +---- src/minibuf.c | 3 - src/pdumper.c | 201 +++++++++++++++++++++--------------------------- src/pdumper.h | 1 + 8 files changed, 109 insertions(+), 185 deletions(-) diff --git a/src/bytecode.c b/src/bytecode.c index 1913a4812a..1c3b6eac0d 100644 --- a/src/bytecode.c +++ b/src/bytecode.c @@ -1401,7 +1401,6 @@ #define DEFINE(name, value) LABEL (name) , Lisp_Object v1 = POP; ptrdiff_t i; struct Lisp_Hash_Table *h = XHASH_TABLE (jmp_table); - hash_rehash_if_needed (h); /* h->count is a faster approximation for HASH_TABLE_SIZE (h) here. */ diff --git a/src/composite.c b/src/composite.c index f96f0b7772..ec2b8328f7 100644 --- a/src/composite.c +++ b/src/composite.c @@ -652,7 +652,6 @@ gstring_lookup_cache (Lisp_Object header) composition_gstring_put_cache (Lisp_Object gstring, ptrdiff_t len) { struct Lisp_Hash_Table *h = XHASH_TABLE (gstring_hash_table); - hash_rehash_if_needed (h); Lisp_Object header = LGSTRING_HEADER (gstring); Lisp_Object hash = h->test.hashfn (header, h); if (len < 0) diff --git a/src/emacs.c b/src/emacs.c index 8e5eaf5e43..d31fa2cb28 100644 --- a/src/emacs.c +++ b/src/emacs.c @@ -1536,6 +1536,7 @@ main (int argc, char **argv) if (!initialized) { init_alloc_once (); + init_pdumper_once (); init_obarray_once (); init_eval_once (); init_charset_once (); diff --git a/src/fns.c b/src/fns.c index 811d6e8200..41e26104f3 100644 --- a/src/fns.c +++ b/src/fns.c @@ -4248,50 +4248,28 @@ maybe_resize_hash_table (struct Lisp_Hash_Table *h) /* Recompute the hashes (and hence also the "next" pointers). Normally there's never a need to recompute hashes. - This is done only on first-access to a hash-table loaded from - the "pdump", because the object's addresses may have changed, thus + This is done only on first access to a hash-table loaded from + the "pdump", because the objects' addresses may have changed, thus affecting their hash. */ void -hash_table_rehash (struct Lisp_Hash_Table *h) +hash_table_rehash (Lisp_Object hash) { - ptrdiff_t size = HASH_TABLE_SIZE (h); - - /* These structures may have been purecopied and shared - (bug#36447). */ - Lisp_Object hash = make_nil_vector (size); - h->next = Fcopy_sequence (h->next); - h->index = Fcopy_sequence (h->index); - + struct Lisp_Hash_Table *h = XHASH_TABLE (hash); /* Recompute the actual hash codes for each entry in the table. Order is still invalid. */ - for (ptrdiff_t i = 0; i < size; ++i) + for (ptrdiff_t i = 0; i < h->count; ++i) { Lisp_Object key = HASH_KEY (h, i); - if (!EQ (key, Qunbound)) - ASET (hash, i, h->test.hashfn (key, h)); + Lisp_Object hash_code = h->test.hashfn (key, h); + ptrdiff_t start_of_bucket = XUFIXNUM (hash_code) % ASIZE (h->index); + set_hash_hash_slot (h, i, hash_code); + set_hash_next_slot (h, i, HASH_INDEX (h, start_of_bucket)); + set_hash_index_slot (h, start_of_bucket, i); + eassert (HASH_NEXT (h, i) != i); /* Stop loops. */ } - /* Reset the index so that any slot we don't fill below is marked - invalid. */ - Ffillarray (h->index, make_fixnum (-1)); - - /* Rebuild the collision chains. */ - for (ptrdiff_t i = 0; i < size; ++i) - if (!NILP (AREF (hash, i))) - { - EMACS_UINT hash_code = XUFIXNUM (AREF (hash, i)); - ptrdiff_t start_of_bucket = hash_code % ASIZE (h->index); - set_hash_next_slot (h, i, HASH_INDEX (h, start_of_bucket)); - set_hash_index_slot (h, start_of_bucket, i); - eassert (HASH_NEXT (h, i) != i); /* Stop loops. */ - } - - /* Finally, mark the hash table as having a valid hash order. - Do this last so that if we're interrupted, we retry on next - access. */ - eassert (hash_rehash_needed_p (h)); - h->hash = hash; - eassert (!hash_rehash_needed_p (h)); + for (ptrdiff_t i = h->count; i < ASIZE (h->next) - 1; i++) + set_hash_next_slot (h, i, i + 1); } /* Lookup KEY in hash table H. If HASH is non-null, return in *HASH @@ -4303,8 +4281,6 @@ hash_lookup (struct Lisp_Hash_Table *h, Lisp_Object key, Lisp_Object *hash) { ptrdiff_t start_of_bucket, i; - hash_rehash_if_needed (h); - Lisp_Object hash_code = h->test.hashfn (key, h); if (hash) *hash = hash_code; @@ -4339,8 +4315,6 @@ hash_put (struct Lisp_Hash_Table *h, Lisp_Object key, Lisp_Object value, { ptrdiff_t start_of_bucket, i; - hash_rehash_if_needed (h); - /* Increment count after resizing because resizing may fail. */ maybe_resize_hash_table (h); h->count++; @@ -4373,8 +4347,6 @@ hash_remove_from_table (struct Lisp_Hash_Table *h, Lisp_Object key) ptrdiff_t start_of_bucket = XUFIXNUM (hash_code) % ASIZE (h->index); ptrdiff_t prev = -1; - hash_rehash_if_needed (h); - for (ptrdiff_t i = HASH_INDEX (h, start_of_bucket); 0 <= i; i = HASH_NEXT (h, i)) @@ -4415,8 +4387,7 @@ hash_clear (struct Lisp_Hash_Table *h) if (h->count > 0) { ptrdiff_t size = HASH_TABLE_SIZE (h); - if (!hash_rehash_needed_p (h)) - memclear (xvector_contents (h->hash), size * word_size); + memclear (xvector_contents (h->hash), size * word_size); for (ptrdiff_t i = 0; i < size; i++) { set_hash_next_slot (h, i, i < size - 1 ? i + 1 : -1); @@ -4452,9 +4423,7 @@ sweep_weak_table (struct Lisp_Hash_Table *h, bool remove_entries_p) for (ptrdiff_t bucket = 0; bucket < n; ++bucket) { /* Follow collision chain, removing entries that don't survive - this garbage collection. It's okay if hash_rehash_needed_p - (h) is true, since we're operating entirely on the cached - hash values. */ + this garbage collection. */ ptrdiff_t prev = -1; ptrdiff_t next; for (ptrdiff_t i = HASH_INDEX (h, bucket); 0 <= i; i = next) @@ -4499,7 +4468,7 @@ sweep_weak_table (struct Lisp_Hash_Table *h, bool remove_entries_p) set_hash_hash_slot (h, i, Qnil); eassert (h->count != 0); - h->count += h->count > 0 ? -1 : 1; + h->count--; } else { @@ -4923,7 +4892,7 @@ DEFUN ("hash-table-count", Fhash_table_count, Shash_table_count, 1, 1, 0, (Lisp_Object table) { struct Lisp_Hash_Table *h = check_hash_table (table); - eassert (h->count >= 0); + return make_fixnum (h->count); } diff --git a/src/lisp.h b/src/lisp.h index 17b92a0414..d88038d91b 100644 --- a/src/lisp.h +++ b/src/lisp.h @@ -2275,11 +2275,7 @@ #define DEFSYM(sym, name) /* empty */ struct Lisp_Hash_Table { - /* Change pdumper.c if you change the fields here. - - IMPORTANT!!!!!!! - - Call hash_rehash_if_needed() before accessing. */ + /* Change pdumper.c if you change the fields here. */ /* This is for Lisp; the hash table code does not refer to it. */ union vectorlike_header header; @@ -2398,20 +2394,7 @@ HASH_TABLE_SIZE (const struct Lisp_Hash_Table *h) return size; } -void hash_table_rehash (struct Lisp_Hash_Table *h); - -INLINE bool -hash_rehash_needed_p (const struct Lisp_Hash_Table *h) -{ - return NILP (h->hash); -} - -INLINE void -hash_rehash_if_needed (struct Lisp_Hash_Table *h) -{ - if (hash_rehash_needed_p (h)) - hash_table_rehash (h); -} +void hash_table_rehash (Lisp_Object); /* Default size for hash tables if not specified. */ diff --git a/src/minibuf.c b/src/minibuf.c index 9d870ce364..cb302c5a60 100644 --- a/src/minibuf.c +++ b/src/minibuf.c @@ -1212,9 +1212,6 @@ DEFUN ("try-completion", Ftry_completion, Stry_completion, 2, 3, 0, bucket = AREF (collection, idx); } - if (HASH_TABLE_P (collection)) - hash_rehash_if_needed (XHASH_TABLE (collection)); - while (1) { /* Get the next element of the alist, obarray, or hash-table. */ diff --git a/src/pdumper.c b/src/pdumper.c index 63ee0fcb7f..10dfa8737f 100644 --- a/src/pdumper.c +++ b/src/pdumper.c @@ -105,17 +105,6 @@ #define VM_MS_WINDOWS 2 # define VM_SUPPORTED 0 #endif -/* PDUMPER_CHECK_REHASHING being true causes the portable dumper to - check, for each hash table it dumps, that the hash table means the - same thing after rehashing. */ -#ifndef PDUMPER_CHECK_REHASHING -# if ENABLE_CHECKING -# define PDUMPER_CHECK_REHASHING 1 -# else -# define PDUMPER_CHECK_REHASHING 0 -# endif -#endif - /* Require an architecture in which pointers, ptrdiff_t and intptr_t are the same size and have the same layout, and where bytes have eight bits --- that is, a general-purpose computer made after 1990. @@ -401,6 +390,8 @@ dump_fingerprint (char const *label, The start of the cold region is always aligned on a page boundary. */ dump_off cold_start; + + dump_off hash_list; }; /* Double-ended singly linked list. */ @@ -558,6 +549,8 @@ dump_fingerprint (char const *label, heap objects. */ Lisp_Object bignum_data; + Lisp_Object hash_tables; + unsigned number_hot_relocations; unsigned number_discardable_relocations; }; @@ -2616,78 +2609,62 @@ dump_vectorlike_generic (struct dump_context *ctx, return offset; } -/* Determine whether the hash table's hash order is stable - across dump and load. If it is, we don't have to trigger - a rehash on access. */ -static bool -dump_hash_table_stable_p (const struct Lisp_Hash_Table *hash) +/* Return a vector of KEY, VALUE pairs in the given hash table H. The + first H->count pairs are valid, the rest is left as nil. */ +static Lisp_Object +hash_table_contents (struct Lisp_Hash_Table *h) { - if (hash->test.hashfn == hashfn_user_defined) + if (h->test.hashfn == hashfn_user_defined) error ("cannot dump hash tables with user-defined tests"); /* Bug#36769 */ - bool is_eql = hash->test.hashfn == hashfn_eql; - bool is_equal = hash->test.hashfn == hashfn_equal; - ptrdiff_t size = HASH_TABLE_SIZE (hash); - for (ptrdiff_t i = 0; i < size; ++i) + Lisp_Object contents = Qnil; + + /* Make sure key_and_value ends up in the same order; charset.c + relies on it by expecting hash table indices to stay constant + across the dump. */ + for (ptrdiff_t i = 0; i < HASH_TABLE_SIZE (h) - h->count; i++) { - Lisp_Object key = HASH_KEY (hash, i); - if (!EQ (key, Qunbound)) - { - bool key_stable = (dump_builtin_symbol_p (key) - || FIXNUMP (key) - || (is_equal - && (STRINGP (key) || BOOL_VECTOR_P (key))) - || ((is_equal || is_eql) - && (FLOATP (key) || BIGNUMP (key)))); - if (!key_stable) - return false; - } + dump_push (&contents, Qnil); + dump_push (&contents, Qunbound); } - return true; + for (ptrdiff_t i = HASH_TABLE_SIZE (h) - 1; i >= 0; --i) + if (!NILP (HASH_HASH (h, i))) + { + dump_push (&contents, HASH_VALUE (h, i)); + dump_push (&contents, HASH_KEY (h, i)); + } + + return CALLN (Fapply, Qvector, contents); } -/* Return a list of (KEY . VALUE) pairs in the given hash table. */ -static Lisp_Object -hash_table_contents (Lisp_Object table) +static dump_off +dump_hash_table_list (struct dump_context *ctx) { - Lisp_Object contents = Qnil; - struct Lisp_Hash_Table *h = XHASH_TABLE (table); - for (ptrdiff_t i = 0; i < HASH_TABLE_SIZE (h); ++i) - { - Lisp_Object key = HASH_KEY (h, i); - if (!EQ (key, Qunbound)) - dump_push (&contents, Fcons (key, HASH_VALUE (h, i))); - } - return Fnreverse (contents); + if (CONSP (ctx->hash_tables)) + return dump_object (ctx, CALLN (Fapply, Qvector, ctx->hash_tables)); + else + return 0; } -/* Copy the given hash table, rehash it, and make sure that we can - look up all the values in the original. */ static void -check_hash_table_rehash (Lisp_Object table_orig) -{ - ptrdiff_t count = XHASH_TABLE (table_orig)->count; - hash_rehash_if_needed (XHASH_TABLE (table_orig)); - Lisp_Object table_rehashed = Fcopy_hash_table (table_orig); - eassert (!hash_rehash_needed_p (XHASH_TABLE (table_rehashed))); - XHASH_TABLE (table_rehashed)->hash = Qnil; - eassert (count == 0 || hash_rehash_needed_p (XHASH_TABLE (table_rehashed))); - hash_rehash_if_needed (XHASH_TABLE (table_rehashed)); - eassert (!hash_rehash_needed_p (XHASH_TABLE (table_rehashed))); - Lisp_Object expected_contents = hash_table_contents (table_orig); - while (!NILP (expected_contents)) - { - Lisp_Object key_value_pair = dump_pop (&expected_contents); - Lisp_Object key = XCAR (key_value_pair); - Lisp_Object expected_value = XCDR (key_value_pair); - Lisp_Object arbitrary = Qdump_emacs_portable__sort_predicate_copied; - Lisp_Object found_value = Fgethash (key, table_rehashed, arbitrary); - eassert (EQ (expected_value, found_value)); - Fremhash (key, table_rehashed); - } +hash_table_freeze (struct Lisp_Hash_Table *h) +{ + ptrdiff_t nkeys = XFIXNAT (Flength (h->key_and_value)) / 2; + h->key_and_value = hash_table_contents (h); + h->next_free = (nkeys == h->count ? -1 : h->count); + h->index = Flength (h->index); + h->next = h->hash = make_fixnum (nkeys); +} - eassert (EQ (Fhash_table_count (table_rehashed), - make_fixnum (0))); +static void +hash_table_thaw (Lisp_Object hash) +{ + struct Lisp_Hash_Table *h = XHASH_TABLE (hash); + h->index = Fmake_vector (h->index, make_fixnum (-1)); + h->hash = Fmake_vector (h->hash, Qnil); + h->next = Fmake_vector (h->next, make_fixnum (-1)); + + hash_table_rehash (hash); } static dump_off @@ -2699,51 +2676,11 @@ dump_hash_table (struct dump_context *ctx, # error "Lisp_Hash_Table changed. See CHECK_STRUCTS comment in config.h." #endif const struct Lisp_Hash_Table *hash_in = XHASH_TABLE (object); - bool is_stable = dump_hash_table_stable_p (hash_in); - /* If the hash table is likely to be modified in memory (either - because we need to rehash, and thus toggle hash->count, or - because we need to assemble a list of weak tables) punt the hash - table to the end of the dump, where we can lump all such hash - tables together. */ - if (!(is_stable || !NILP (hash_in->weak)) - && ctx->flags.defer_hash_tables) - { - if (offset != DUMP_OBJECT_ON_HASH_TABLE_QUEUE) - { - eassert (offset == DUMP_OBJECT_ON_NORMAL_QUEUE - || offset == DUMP_OBJECT_NOT_SEEN); - /* We still want to dump the actual keys and values now. */ - dump_enqueue_object (ctx, hash_in->key_and_value, WEIGHT_NONE); - /* We'll get to the rest later. */ - offset = DUMP_OBJECT_ON_HASH_TABLE_QUEUE; - dump_remember_object (ctx, object, offset); - dump_push (&ctx->deferred_hash_tables, object); - } - return offset; - } - - if (PDUMPER_CHECK_REHASHING) - check_hash_table_rehash (make_lisp_ptr ((void *) hash_in, Lisp_Vectorlike)); - struct Lisp_Hash_Table hash_munged = *hash_in; struct Lisp_Hash_Table *hash = &hash_munged; - /* Remember to rehash this hash table on first access. After a - dump reload, the hash table values will have changed, so we'll - need to rebuild the index. - - TODO: for EQ and EQL hash tables, it should be possible to rehash - here using the preferred load address of the dump, eliminating - the need to rehash-on-access if we can load the dump where we - want. */ - if (hash->count > 0 && !is_stable) - /* Hash codes will have to be recomputed anyway, so let's not dump them. - Also set `hash` to nil for hash_rehash_needed_p. - We could also refrain from dumping the `next' and `index' vectors, - except that `next' is currently used for HASH_TABLE_SIZE and - we'd have to rebuild the next_free list as well as adjust - sweep_weak_hash_table for the case where there's no `index'. */ - hash->hash = Qnil; + hash_table_freeze (hash); + dump_push (&ctx->hash_tables, object); START_DUMP_PVEC (ctx, &hash->header, struct Lisp_Hash_Table, out); dump_pseudovector_lisp_fields (ctx, &out->header, &hash->header); @@ -4151,6 +4088,19 @@ DEFUN ("dump-emacs-portable", || !NILP (ctx->deferred_hash_tables) || !NILP (ctx->deferred_symbols)); + ctx->header.hash_list = ctx->offset; + dump_hash_table_list (ctx); + + do + { + dump_drain_deferred_hash_tables (ctx); + dump_drain_deferred_symbols (ctx); + dump_drain_normal_queue (ctx); + } + while (!dump_queue_empty_p (&ctx->dump_queue) + || !NILP (ctx->deferred_hash_tables) + || !NILP (ctx->deferred_symbols)); + dump_sort_copied_objects (ctx); /* While we copy built-in symbols into the Emacs image, these @@ -5302,6 +5252,9 @@ dump_do_all_emacs_relocations (const struct dump_header *const header, NUMBER_DUMP_SECTIONS, }; +/* Pointer to a stack variable to avoid having to staticpro it. */ +static Lisp_Object *pdumper_hashes = &zero_vector; + /* Load a dump from DUMP_FILENAME. Return an error code. N.B. We run very early in initialization, so we can't use lisp, @@ -5448,6 +5401,15 @@ pdumper_load (const char *dump_filename) for (int i = 0; i < ARRAYELTS (sections); ++i) dump_mmap_reset (§ions[i]); + Lisp_Object hashes = zero_vector; + if (header->hash_list) + { + struct Lisp_Vector *hash_tables = + ((struct Lisp_Vector *)(dump_base + header->hash_list)); + XSETVECTOR (hashes, hash_tables); + } + + pdumper_hashes = &hashes; /* Run the functions Emacs registered for doing post-dump-load initialization. */ for (int i = 0; i < nr_dump_hooks; ++i) @@ -5518,6 +5480,19 @@ DEFUN ("pdumper-stats", Fpdumper_stats, Spdumper_stats, 0, 0, 0, #endif /* HAVE_PDUMPER */ +static void +thaw_hash_tables (void) +{ + Lisp_Object hash_tables = *pdumper_hashes; + for (ptrdiff_t i = 0; i < ASIZE (hash_tables); i++) + hash_table_thaw (AREF (hash_tables, i)); +} + +void +init_pdumper_once (void) +{ + pdumper_do_now_and_after_load (thaw_hash_tables); +} void syms_of_pdumper (void) diff --git a/src/pdumper.h b/src/pdumper.h index 6a99b511f2..c793fb4058 100644 --- a/src/pdumper.h +++ b/src/pdumper.h @@ -256,6 +256,7 @@ pdumper_clear_marks (void) file was loaded. */ extern void pdumper_record_wd (const char *); +void init_pdumper_once (void); void syms_of_pdumper (void); INLINE_HEADER_END -- 2.17.1 --------------299BED56E3B48389E1EA849F Content-Type: text/x-patch; charset=UTF-8; name="0002-src-fns.c-hash_table_rehash-Help-the-compiler-a-bit.patch" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename*0="0002-src-fns.c-hash_table_rehash-Help-the-compiler-a-bit.pat"; filename*1="ch" >From 5c9fa99d3f0cbb2a44d3e0507533f4ab5a13f906 Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Tue, 11 Aug 2020 02:16:54 -0700 Subject: [PATCH 2/7] * src/fns.c (hash_table_rehash): Help the compiler a bit. --- src/fns.c | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/src/fns.c b/src/fns.c index 41e26104f3..9199178212 100644 --- a/src/fns.c +++ b/src/fns.c @@ -4250,14 +4250,16 @@ maybe_resize_hash_table (struct Lisp_Hash_Table *h) Normally there's never a need to recompute hashes. This is done only on first access to a hash-table loaded from the "pdump", because the objects' addresses may have changed, thus - affecting their hash. */ + affecting their hashes. */ void hash_table_rehash (Lisp_Object hash) { struct Lisp_Hash_Table *h = XHASH_TABLE (hash); + ptrdiff_t i, count = h->count; + /* Recompute the actual hash codes for each entry in the table. Order is still invalid. */ - for (ptrdiff_t i = 0; i < h->count; ++i) + for (i = 0; i < count; i++) { Lisp_Object key = HASH_KEY (h, i); Lisp_Object hash_code = h->test.hashfn (key, h); @@ -4268,7 +4270,8 @@ hash_table_rehash (Lisp_Object hash) eassert (HASH_NEXT (h, i) != i); /* Stop loops. */ } - for (ptrdiff_t i = h->count; i < ASIZE (h->next) - 1; i++) + ptrdiff_t size = ASIZE (h->next); + for (; i + 1 < size; i++) set_hash_next_slot (h, i, i + 1); } @@ -4892,7 +4895,6 @@ DEFUN ("hash-table-count", Fhash_table_count, Shash_table_count, 1, 1, 0, (Lisp_Object table) { struct Lisp_Hash_Table *h = check_hash_table (table); - return make_fixnum (h->count); } -- 2.17.1 --------------299BED56E3B48389E1EA849F Content-Type: text/x-patch; charset=UTF-8; name="0003-src-pdumper.c-pdumper_load-XSETVECTOR-make_lisp_ptr.patch" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename*0="0003-src-pdumper.c-pdumper_load-XSETVECTOR-make_lisp_ptr.pat"; filename*1="ch" >From 523b92c3e7b61e5e625101c7ec99273689f7a75a Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Tue, 11 Aug 2020 02:16:54 -0700 Subject: [PATCH 3/7] * src/pdumper.c (pdumper_load): XSETVECTOR -> make_lisp_ptr. --- src/pdumper.c | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/pdumper.c b/src/pdumper.c index 10dfa8737f..c38cb2d34f 100644 --- a/src/pdumper.c +++ b/src/pdumper.c @@ -391,6 +391,7 @@ dump_fingerprint (char const *label, boundary. */ dump_off cold_start; + /* Offset of a vector of the dumped hash tables. */ dump_off hash_list; }; @@ -549,6 +550,7 @@ dump_fingerprint (char const *label, heap objects. */ Lisp_Object bignum_data; + /* List of hash tables that have been dumped. */ Lisp_Object hash_tables; unsigned number_hot_relocations; @@ -2610,7 +2612,7 @@ dump_vectorlike_generic (struct dump_context *ctx, } /* Return a vector of KEY, VALUE pairs in the given hash table H. The - first H->count pairs are valid, the rest is left as nil. */ + first H->count pairs are valid, and the rest are unbound. */ static Lisp_Object hash_table_contents (struct Lisp_Hash_Table *h) { @@ -5405,8 +5407,8 @@ pdumper_load (const char *dump_filename) if (header->hash_list) { struct Lisp_Vector *hash_tables = - ((struct Lisp_Vector *)(dump_base + header->hash_list)); - XSETVECTOR (hashes, hash_tables); + (struct Lisp_Vector *) (dump_base + header->hash_list); + hashes = make_lisp_ptr (hash_tables, Lisp_Vectorlike); } pdumper_hashes = &hashes; -- 2.17.1 --------------299BED56E3B48389E1EA849F Content-Type: text/x-patch; charset=UTF-8; name="0004-Don-t-needlessly-convert-to-unsigned-in-pdumper.patch" Content-Disposition: attachment; filename*0="0004-Don-t-needlessly-convert-to-unsigned-in-pdumper.patch" Content-Transfer-Encoding: quoted-printable >From 1d50d5a039ca4d40473c862b021d2ed97279ffe8 Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Tue, 11 Aug 2020 02:16:54 -0700 Subject: [PATCH 4/7] =3D?UTF-8?q?Don=3DE2=3D80=3D99t=3D20needlessly=3D20c= onvert=3D20to?=3D =3D?UTF-8?q?=3D20=3DE2=3D80=3D98unsigned=3DE2=3D80=3D99=3D20in=3D20pdump= er?=3D MIME-Version: 1.0 Content-Type: text/plain; charset=3DUTF-8 Content-Transfer-Encoding: 8bit * src/pdumper.c (PRIdDUMP_OFF): New macro. (EMACS_INT_XDIGITS): New constant. (struct dump_context): Use dump_off for relocation counts. All uses changed. (dump_queue_enqueue, dump_queue_dequeue, Fdump_emacs_portable): Don=E2=80=99t assume counts fit in =E2=80=98unsigned=E2=80=99 or =E2=80=98= unsigned long=E2=80=99. Use EMACS_INT_XDIGITS instead of assuming it=E2=80=99s 16. --- src/pdumper.c | 58 +++++++++++++++++++++++++++------------------------ 1 file changed, 31 insertions(+), 27 deletions(-) diff --git a/src/pdumper.c b/src/pdumper.c index c38cb2d34f..6d303af77d 100644 --- a/src/pdumper.c +++ b/src/pdumper.c @@ -141,6 +141,9 @@ divide_round_up (size_t x, size_t y) typedef int_least32_t dump_off; #define DUMP_OFF_MIN INT_LEAST32_MIN #define DUMP_OFF_MAX INT_LEAST32_MAX +#define PRIdDUMP_OFF PRIdLEAST32 + +enum { EMACS_INT_XDIGITS =3D (EMACS_INT_WIDTH + 3) / 4 }; =20 static void ATTRIBUTE_FORMAT ((printf, 1, 2)) dump_trace (const char *fmt, ...) @@ -553,8 +556,8 @@ dump_fingerprint (char const *label, /* List of hash tables that have been dumped. */ Lisp_Object hash_tables; =20 - unsigned number_hot_relocations; - unsigned number_discardable_relocations; + dump_off number_hot_relocations; + dump_off number_discardable_relocations; }; =20 /* These special values for use as offsets in dump_remember_object and @@ -1007,9 +1010,9 @@ dump_queue_enqueue (struct dump_queue *dump_queue, if (NILP (weights)) { /* Object is new. */ - dump_trace ("new object %016x weight=3D%u\n", - (unsigned) XLI (object), - (unsigned) weight.value); + EMACS_UINT uobj =3D XLI (object); + dump_trace ("new object %0*"pI"x weight=3D%d\n", EMACS_INT_XDIGITS= , uobj, + weight.value); =20 if (weight.value =3D=3D WEIGHT_NONE.value) { @@ -1224,17 +1227,15 @@ dump_queue_dequeue (struct dump_queue *dump_queue= , dump_off basis) + dump_tailq_length (&dump_queue->one_weight_normal_objects) + dump_tailq_length (&dump_queue->one_weight_strong_objects))); =20 - bool dump_object_counts =3D true; - if (dump_object_counts) - dump_trace - ("dump_queue_dequeue basis=3D%d fancy=3D%u zero=3D%u " - "normal=3D%u strong=3D%u hash=3D%u\n", - basis, - (unsigned) dump_tailq_length (&dump_queue->fancy_weight_objects), - (unsigned) dump_tailq_length (&dump_queue->zero_weight_objects), - (unsigned) dump_tailq_length (&dump_queue->one_weight_normal_obje= cts), - (unsigned) dump_tailq_length (&dump_queue->one_weight_strong_obje= cts), - (unsigned) XFIXNUM (Fhash_table_count (dump_queue->link_weights))= ); + dump_trace + (("dump_queue_dequeue basis=3D%"PRIdDUMP_OFF" fancy=3D%"PRIdPTR + " zero=3D%"PRIdPTR" normal=3D%"PRIdPTR" strong=3D%"PRIdPTR" hash=3D= %td\n"), + basis, + dump_tailq_length (&dump_queue->fancy_weight_objects), + dump_tailq_length (&dump_queue->zero_weight_objects), + dump_tailq_length (&dump_queue->one_weight_normal_objects), + dump_tailq_length (&dump_queue->one_weight_strong_objects), + XHASH_TABLE (dump_queue->link_weights)->count); =20 static const int nr_candidates =3D 3; struct candidate @@ -1307,10 +1308,10 @@ dump_queue_dequeue (struct dump_queue *dump_queue= , dump_off basis) else emacs_abort (); =20 - dump_trace (" result score=3D%f src=3D%s object=3D%016x\n", + EMACS_UINT uresult =3D XLI (result); + dump_trace (" result score=3D%f src=3D%s object=3D%0*"pI"x\n", best < 0 ? -1.0 : (double) candidates[best].score, - src, - (unsigned) XLI (result)); + src, EMACS_INT_XDIGITS, uresult); =20 { Lisp_Object weights =3D Fgethash (result, dump_queue->link_weights, = Qnil); @@ -4162,9 +4163,9 @@ DEFUN ("dump-emacs-portable", of the dump. */ drain_reloc_list (ctx, dump_emit_dump_reloc, emacs_reloc_merger, &ctx->dump_relocs, &ctx->header.dump_relocs); - unsigned number_hot_relocations =3D ctx->number_hot_relocations; + dump_off number_hot_relocations =3D ctx->number_hot_relocations; ctx->number_hot_relocations =3D 0; - unsigned number_discardable_relocations =3D ctx->number_discardable_re= locations; + dump_off number_discardable_relocations =3D ctx->number_discardable_re= locations; ctx->number_discardable_relocations =3D 0; drain_reloc_list (ctx, dump_emit_dump_reloc, emacs_reloc_merger, &ctx->object_starts, &ctx->header.object_starts); @@ -4188,14 +4189,17 @@ DEFUN ("dump-emacs-portable", dump_seek (ctx, 0); dump_write (ctx, &ctx->header, sizeof (ctx->header)); =20 + dump_off + header_bytes =3D header_end - header_start, + hot_bytes =3D hot_end - hot_start, + discardable_bytes =3D discardable_end - ctx->header.discardable_star= t, + cold_bytes =3D cold_end - ctx->header.cold_start; fprintf (stderr, ("Dump complete\n" - "Byte counts: header=3D%lu hot=3D%lu discardable=3D%lu cold=3D%lu\n= " - "Reloc counts: hot=3D%u discardable=3D%u\n"), - (unsigned long) (header_end - header_start), - (unsigned long) (hot_end - hot_start), - (unsigned long) (discardable_end - ctx->header.discardable_st= art), - (unsigned long) (cold_end - ctx->header.cold_start), + "Byte counts: header=3D%"PRIdDUMP_OFF" hot=3D%"PRIdDUMP_OFF + " discardable=3D%"PRIdDUMP_OFF" cold=3D%"PRIdDUMP_OFF"\n" + "Reloc counts: hot=3D%"PRIdDUMP_OFF" discardable=3D%"PRIdDUMP_OFF"\= n"), + header_bytes, hot_bytes, discardable_bytes, cold_bytes, number_hot_relocations, number_discardable_relocations); =20 --=20 2.17.1 --------------299BED56E3B48389E1EA849F Content-Type: text/x-patch; charset=UTF-8; name="0005-In-pdumper-simplify-INT_MAX-computation.patch" Content-Disposition: attachment; filename="0005-In-pdumper-simplify-INT_MAX-computation.patch" Content-Transfer-Encoding: quoted-printable >From 597bb393156730e0f68b0b3e80098d977b8dbdb8 Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Tue, 11 Aug 2020 02:16:54 -0700 Subject: [PATCH 5/7] In pdumper, simplify INT_MAX computation MIME-Version: 1.0 Content-Type: text/plain; charset=3DUTF-8 Content-Transfer-Encoding: 8bit * src/pdumper.c (dump_read_all): Avoid unnecessary cast. Also, round down to page size, as sysdep.c does. Also, don=E2=80=99t assume INT_MAX <=3D UINT_MAX (!). --- src/pdumper.c | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/src/pdumper.c b/src/pdumper.c index 6d303af77d..fcad5242df 100644 --- a/src/pdumper.c +++ b/src/pdumper.c @@ -5065,14 +5065,13 @@ dump_read_all (int fd, void *buf, size_t bytes_to= _read) { /* We don't want to use emacs_read, since that relies on the lisp world, and we're not in the lisp world yet. */ - eassert (bytes_to_read <=3D SSIZE_MAX); size_t bytes_read =3D 0; while (bytes_read < bytes_to_read) { - /* Some platforms accept only int-sized values to read. */ - unsigned chunk_to_read =3D INT_MAX; - if (bytes_to_read - bytes_read < chunk_to_read) - chunk_to_read =3D (unsigned) (bytes_to_read - bytes_read); + /* Some platforms accept only int-sized values to read. + Round this down to a page size (see MAX_RW_COUNT in sysdep.c). = */ + int max_rw_count =3D INT_MAX >> 18 << 18; + size_t chunk_to_read =3D min (bytes_to_read - bytes_read, max_rw_c= ount); ssize_t chunk =3D read (fd, (char *) buf + bytes_read, chunk_to_re= ad); if (chunk < 0) return chunk; --=20 2.17.1 --------------299BED56E3B48389E1EA849F Content-Type: text/x-patch; charset=UTF-8; name="0006-pdumper-speed-tweeks-for-hash-tables.patch" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename="0006-pdumper-speed-tweeks-for-hash-tables.patch" >From ba8bff6bfca9daefd3917d706b94fc55b7d93191 Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Tue, 11 Aug 2020 02:16:54 -0700 Subject: [PATCH 6/7] pdumper speed tweeks for hash tables * src/pdumper.c (dump_queue_empty_p): Avoid unnecessary call to Fhash_table_count on a known hash table. (dump_hash_table_list): !NILP, not CONSP. (hash_table_freeze, hash_table_thaw): ASIZE, not Flength, on vectors. Initialize in same order as struct. (hash_table_thaw): make_nil_vector, not Fmake_vector with nil. --- src/pdumper.c | 22 ++++++++++------------ 1 file changed, 10 insertions(+), 12 deletions(-) diff --git a/src/pdumper.c b/src/pdumper.c index fcad5242df..bc9d197ca2 100644 --- a/src/pdumper.c +++ b/src/pdumper.c @@ -964,11 +964,9 @@ dump_queue_init (struct dump_queue *dump_queue) static bool dump_queue_empty_p (struct dump_queue *dump_queue) { - bool is_empty = - EQ (Fhash_table_count (dump_queue->sequence_numbers), - make_fixnum (0)); - eassert (EQ (Fhash_table_count (dump_queue->sequence_numbers), - Fhash_table_count (dump_queue->link_weights))); + ptrdiff_t count = XHASH_TABLE (dump_queue->sequence_numbers)->count; + bool is_empty = count == 0; + eassert (count == XFIXNAT (Fhash_table_count (dump_queue->link_weights))); if (!is_empty) { eassert (!dump_tailq_empty_p (&dump_queue->zero_weight_objects) @@ -2643,7 +2641,7 @@ hash_table_contents (struct Lisp_Hash_Table *h) static dump_off dump_hash_table_list (struct dump_context *ctx) { - if (CONSP (ctx->hash_tables)) + if (!NILP (ctx->hash_tables)) return dump_object (ctx, CALLN (Fapply, Qvector, ctx->hash_tables)); else return 0; @@ -2652,20 +2650,20 @@ dump_hash_table_list (struct dump_context *ctx) static void hash_table_freeze (struct Lisp_Hash_Table *h) { - ptrdiff_t nkeys = XFIXNAT (Flength (h->key_and_value)) / 2; + ptrdiff_t npairs = ASIZE (h->key_and_value) / 2; h->key_and_value = hash_table_contents (h); - h->next_free = (nkeys == h->count ? -1 : h->count); - h->index = Flength (h->index); - h->next = h->hash = make_fixnum (nkeys); + h->next = h->hash = make_fixnum (npairs); + h->index = make_fixnum (ASIZE (h->index)); + h->next_free = (npairs == h->count ? -1 : h->count); } static void hash_table_thaw (Lisp_Object hash) { struct Lisp_Hash_Table *h = XHASH_TABLE (hash); - h->index = Fmake_vector (h->index, make_fixnum (-1)); - h->hash = Fmake_vector (h->hash, Qnil); + h->hash = make_nil_vector (XFIXNUM (h->hash)); h->next = Fmake_vector (h->next, make_fixnum (-1)); + h->index = Fmake_vector (h->index, make_fixnum (-1)); hash_table_rehash (hash); } -- 2.17.1 --------------299BED56E3B48389E1EA849F Content-Type: text/x-patch; charset=UTF-8; name="0007-pdumper-avoid-listing-hash-table-contents.patch" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename="0007-pdumper-avoid-listing-hash-table-contents.patch" >From 88d3e15f47b675d8d3fc922eb5a6ff7df8295b34 Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Tue, 11 Aug 2020 02:16:54 -0700 Subject: [PATCH 7/7] pdumper avoid listing hash table contents * src/pdumper.c (hash_table_contents): Create a vector directly, instead of creating a list and then converting that to a vector. --- src/pdumper.c | 25 ++++++++++++++----------- 1 file changed, 14 insertions(+), 11 deletions(-) diff --git a/src/pdumper.c b/src/pdumper.c index bc9d197ca2..94921dc9ea 100644 --- a/src/pdumper.c +++ b/src/pdumper.c @@ -2617,25 +2617,28 @@ hash_table_contents (struct Lisp_Hash_Table *h) { if (h->test.hashfn == hashfn_user_defined) error ("cannot dump hash tables with user-defined tests"); /* Bug#36769 */ - Lisp_Object contents = Qnil; + + ptrdiff_t size = HASH_TABLE_SIZE (h); + Lisp_Object key_and_value = make_uninit_vector (2 * size); + ptrdiff_t n = 0; /* Make sure key_and_value ends up in the same order; charset.c relies on it by expecting hash table indices to stay constant across the dump. */ - for (ptrdiff_t i = 0; i < HASH_TABLE_SIZE (h) - h->count; i++) - { - dump_push (&contents, Qnil); - dump_push (&contents, Qunbound); - } - - for (ptrdiff_t i = HASH_TABLE_SIZE (h) - 1; i >= 0; --i) + for (ptrdiff_t i = 0; i < size; i++) if (!NILP (HASH_HASH (h, i))) { - dump_push (&contents, HASH_VALUE (h, i)); - dump_push (&contents, HASH_KEY (h, i)); + ASET (key_and_value, n++, HASH_KEY (h, i)); + ASET (key_and_value, n++, HASH_VALUE (h, i)); } - return CALLN (Fapply, Qvector, contents); + while (n < 2 * size) + { + ASET (key_and_value, n++, Qunbound); + ASET (key_and_value, n++, Qnil); + } + + return key_and_value; } static dump_off -- 2.17.1 --------------299BED56E3B48389E1EA849F-- From debbugs-submit-bounces@debbugs.gnu.org Tue Aug 11 05:41:11 2020 Received: (at 36597-done) by debbugs.gnu.org; 11 Aug 2020 09:41:11 +0000 Received: from localhost ([127.0.0.1]:38702 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5QmN-0003W6-2J for submit@debbugs.gnu.org; Tue, 11 Aug 2020 05:41:11 -0400 Received: from mail-oi1-f169.google.com ([209.85.167.169]:34544) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5QmL-0003Vs-TF for 36597-done@debbugs.gnu.org; Tue, 11 Aug 2020 05:41:10 -0400 Received: by mail-oi1-f169.google.com with SMTP id z22so11665395oid.1 for <36597-done@debbugs.gnu.org>; Tue, 11 Aug 2020 02:41:09 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc; bh=fsFcf6yU/cSGFgKMAWm4tSbIxhRy0mnuf6+AjskxTLk=; b=TTrgUTXXUp/O4UCttXAYqsnGuc73SLJ0Mk6Ac+Ulh/7D4N0UGW7Ez6sZn5el8FKs4S yyiPfh/NGQaZlwHmzSvpx1iP/NpEZOYu78SgcVHM2nsKRP/smydjd1wCAktsgDxj0uZk tkOrMAAIHeJ0XDZZLsqhMJphfuFwT7JvN/a6hkl55Aclhqu+FvwiYf2IsSxOuMhS1S27 yZvnJvQ+Rrv7jxfb5tAdogGyoZMk/+nE87CdYTbOMO2EjFc91wDfIeWcWCRcI8gCYfPQ SGmtvq+XCVW136Pt1Q4QaHwC3Ed1mDtEBCYG90t1jZGC88oTLgO9MbAY82bPZjioqqoK LL2A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=fsFcf6yU/cSGFgKMAWm4tSbIxhRy0mnuf6+AjskxTLk=; b=V0hqDRKQWvhNi8F8PsOwwa/8QDiNIKmRZEVcIv2wVOHxy9xoGWC6LrHCcFSxOeIY2E MnPLVnoGe8kFfFydIMlT5I+VQ7867xcMuVYwdISqH/nPcrsZS/HKVfXRcCUkLtB/a2C3 jcPTsC+y7dGmY1Wiys7LYpB0pBThUO9mYKDHRm1gjJoBjRSxD2TsBDR7Gj3Uf9K+XYdE 1EhZVqtmUlOsv6pC5TaIbcymJeKXNB8UN5TDFUA8u7XdFOlUoFypLk4iJqm6SC3D2Nvo eSzf5tuVfKdA0HF2pn2752uV3x9T9WveyBLoKdgxQXgJuy6a5c5IlNmselJzfPQwIiPZ isqw== X-Gm-Message-State: AOAM5318znLlKYoDjvYimKI5AZHUEDOo9RqPW3yrM/2IZaO6vb/JEQS1 myiABNx5agGKqm4Ktr5m4DvFayyB8HuxHkMFm3Y= X-Google-Smtp-Source: ABdhPJwU6IJJ9+9Z0bbuwH8vqTPs8L5qZAN4ScXQ4/TE2hPdGCzduP2MnHdQ4t7wVz5uXaNECqVIi4zLhqsLCzFOQtQ= X-Received: by 2002:aca:dc04:: with SMTP id t4mr2717202oig.30.1597138864116; Tue, 11 Aug 2020 02:41:04 -0700 (PDT) MIME-Version: 1.0 References: <6a260307-a463-bd08-8a10-d7664d0606a2@cs.ucla.edu> <74235afc-7043-1da7-7c71-07f0ca23b9fd@cs.ucla.edu> <83r26mv53z.fsf@gnu.org> <87ft8vbow1.fsf@gnus.org> <87v9hq4ppp.fsf@gnus.org> In-Reply-To: From: Pip Cet Date: Tue, 11 Aug 2020 09:40:27 +0000 Message-ID: Subject: Re: bug#36597: 27.0.50; rehash hash tables eagerly in pdumper To: Paul Eggert Content-Type: text/plain; charset="UTF-8" X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 36597-done Cc: Lars Ingebrigtsen , Eli Zaretskii , 36597-done@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) On Tue, Aug 11, 2020 at 9:33 AM Paul Eggert wrote: > On 8/10/20 6:04 AM, Lars Ingebrigtsen wrote: > > time make -j32 compile-always > > ... > > Er... It's weird that there's so much difference in time between > > runs > > I think I get less variance if I do a sequential 'make' (i.e., without -j). Of > course this takes longer. It's worse than just execution time variance: at least in the past, byte code used to differ between runs if -jN was used. I'm not sure whether that's still true. > It also simplifies the code a bit, so I took the liberty of installing it, after > updating its commit message a bit and changing it to keep a comment that was > updated recently (I figure this was a merge error). It was, thank you! From debbugs-submit-bounces@debbugs.gnu.org Tue Aug 11 07:50:41 2020 Received: (at 36597-done) by debbugs.gnu.org; 11 Aug 2020 11:50:42 +0000 Received: from localhost ([127.0.0.1]:38842 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5Snh-0000bj-NZ for submit@debbugs.gnu.org; Tue, 11 Aug 2020 07:50:41 -0400 Received: from quimby.gnus.org ([95.216.78.240]:59376) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5Snf-0000bX-VL for 36597-done@debbugs.gnu.org; Tue, 11 Aug 2020 07:50:41 -0400 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=gnus.org; s=20200322; h=Content-Type:MIME-Version:Message-ID:In-Reply-To:Date: References:Subject:Cc:To:From:Sender:Reply-To:Content-Transfer-Encoding: Content-ID:Content-Description:Resent-Date:Resent-From:Resent-Sender: Resent-To:Resent-Cc:Resent-Message-ID:List-Id:List-Help:List-Unsubscribe: List-Subscribe:List-Post:List-Owner:List-Archive; bh=55a8JpgKSHcv8DZOAhQIKO8s+E5z7vGCR7GdwsEPED4=; b=h73dvqn2Ka+YoowP4ZlBGpV5o8 I0+3jSfZw1PFvxChnBbUebi6s84xawlvidniR45jtpOt9vYyNj+iWRhjyaPRCvfD6kFfdioQgflqF WjUhF3cIEVqfMH85xdBSP/gnJf2c9FAOBW8zHMiENY8KNVVKK05cE7Y3ATT3zaocyl4o=; Received: from cm-84.212.202.86.getinternet.no ([84.212.202.86] helo=xo) by quimby with esmtpsa (TLS1.3:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.92) (envelope-from ) id 1k5SnW-0002wl-Mc; Tue, 11 Aug 2020 13:50:33 +0200 From: Lars Ingebrigtsen To: Paul Eggert Subject: Re: bug#36597: 27.0.50; rehash hash tables eagerly in pdumper References: <6a260307-a463-bd08-8a10-d7664d0606a2@cs.ucla.edu> <74235afc-7043-1da7-7c71-07f0ca23b9fd@cs.ucla.edu> <83r26mv53z.fsf@gnu.org> <87ft8vbow1.fsf@gnus.org> <87v9hq4ppp.fsf@gnus.org> Date: Tue, 11 Aug 2020 13:50:29 +0200 In-Reply-To: (Paul Eggert's message of "Tue, 11 Aug 2020 02:33:34 -0700") Message-ID: <871rkdxuyi.fsf@gnus.org> User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/28.0.50 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain X-Spam-Report: Spam detection software, running on the system "quimby.gnus.org", has NOT identified this incoming email as spam. The original message has been attached to this so you can view it or label similar future email. If you have any questions, see @@CONTACT_ADDRESS@@ for details. Content preview: Paul Eggert writes: > It also simplifies the code a bit, so I took the liberty of installing > it, after updating its commit message a bit and changing it to keep a > comment that was updated recently (I figure this was [...] Content analysis details: (-2.9 points, 5.0 required) pts rule name description ---- ---------------------- -------------------------------------------------- -1.0 ALL_TRUSTED Passed through trusted hosts only via SMTP -1.9 BAYES_00 BODY: Bayes spam probability is 0 to 1% [score: 0.0000] X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 36597-done Cc: Eli Zaretskii , 36597-done@debbugs.gnu.org, Pip Cet X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) Paul Eggert writes: > It also simplifies the code a bit, so I took the liberty of installing > it, after updating its commit message a bit and changing it to keep a > comment that was updated recently (I figure this was a merge > error). Just for fun, I re-ran the "make compile-always" test 20 times before/after pulling the new version, and the mean compilation speed is slightly smaller after. But as before, the speeds vary ~10% between runs. But at least there's no obvious negative performance impact here. -- (domestic pets only, the antidote for overdose, milk.) bloggy blog: http://lars.ingebrigtsen.no From debbugs-submit-bounces@debbugs.gnu.org Tue Aug 11 10:53:06 2020 Received: (at 36597-done) by debbugs.gnu.org; 11 Aug 2020 14:53:06 +0000 Received: from localhost ([127.0.0.1]:41376 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5VeE-0004Eb-CU for submit@debbugs.gnu.org; Tue, 11 Aug 2020 10:53:06 -0400 Received: from eggs.gnu.org ([209.51.188.92]:35952) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5VeC-0004E3-LF for 36597-done@debbugs.gnu.org; Tue, 11 Aug 2020 10:53:05 -0400 Received: from fencepost.gnu.org ([2001:470:142:3::e]:43562) by eggs.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1k5Ve5-00063T-10; Tue, 11 Aug 2020 10:52:57 -0400 Received: from [176.228.60.248] (port=2048 helo=home-c4e4a596f7) by fencepost.gnu.org with esmtpsa (TLS1.2:RSA_AES_256_CBC_SHA1:256) (Exim 4.82) (envelope-from ) id 1k5Ve4-00059J-CT; Tue, 11 Aug 2020 10:52:56 -0400 Date: Tue, 11 Aug 2020 17:52:44 +0300 Message-Id: <83k0y544lf.fsf@gnu.org> From: Eli Zaretskii To: Paul Eggert In-Reply-To: (message from Paul Eggert on Tue, 11 Aug 2020 02:33:34 -0700) Subject: Re: bug#36597: 27.0.50; rehash hash tables eagerly in pdumper References: <6a260307-a463-bd08-8a10-d7664d0606a2@cs.ucla.edu> <74235afc-7043-1da7-7c71-07f0ca23b9fd@cs.ucla.edu> <83r26mv53z.fsf@gnu.org> <87ft8vbow1.fsf@gnus.org> <87v9hq4ppp.fsf@gnus.org> X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 36597-done Cc: larsi@gnus.org, 36597-done@debbugs.gnu.org, pipcet@gmail.com X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) > Cc: Eli Zaretskii , 36597-done@debbugs.gnu.org > From: Paul Eggert > Date: Tue, 11 Aug 2020 02:33:34 -0700 > > It also simplifies the code a bit, so I took the liberty of installing it It doesn't compile here: pdumper.c: In function 'dump_queue_enqueue': pdumper.c:1012:19: warning: unknown conversion type character 'l' in format [-Wformat=] 1012 | dump_trace ("new object %0*"pI"x weight=%d\n", EMACS_INT_XDIGITS, uobj, | ^~~~~~~~~~~~~~~~ In file included from character.h:27, from buffer.h:27, from pdumper.c:34: lisp.h:108:17: note: format string is defined here 108 | # define pI "ll" | ^ pdumper.c:1012:19: warning: format '%d' expects argument of type 'int', but argument 3 has type 'EMACS_UINT' {aka 'long long unsigned int'} [-Wformat=] 1012 | dump_trace ("new object %0*"pI"x weight=%d\n", EMACS_INT_XDIGITS, uobj, | ^~~~~~~~~~~~~~~~ ~~~~ | | | EMACS_UINT {aka long long unsigned int} pdumper.c:1012:48: note: format string is defined here 1012 | dump_trace ("new object %0*"pI"x weight=%d\n", EMACS_INT_XDIGITS, uobj, | ~^ | | | int | %I64d pdumper.c:1012:19: warning: too many arguments for format [-Wformat-extra-args] 1012 | dump_trace ("new object %0*"pI"x weight=%d\n", EMACS_INT_XDIGITS, uobj, | ^~~~~~~~~~~~~~~~ pdumper.c: In function 'dump_queue_dequeue': pdumper.c:1229:6: warning: format '%d' expects argument of type 'int', but argument 3 has type 'gl_intptr_t' {aka 'long int'} [-Wformat=] 1229 | (("dump_queue_dequeue basis=%"PRIdDUMP_OFF" fancy=%"PRIdPTR | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 1230 | " zero=%"PRIdPTR" normal=%"PRIdPTR" strong=%"PRIdPTR" hash=%td\n"), | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 1231 | basis, 1232 | dump_tailq_length (&dump_queue->fancy_weight_objects), | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | | | gl_intptr_t {aka long int} pdumper.c:1229:6: warning: format '%d' expects argument of type 'int', but argument 4 has type 'gl_intptr_t' {aka 'long int'} [-Wformat=] pdumper.c:1229:6: warning: format '%d' expects argument of type 'int', but argument 5 has type 'gl_intptr_t' {aka 'long int'} [-Wformat=] pdumper.c:1229:6: warning: format '%d' expects argument of type 'int', but argument 6 has type 'gl_intptr_t' {aka 'long int'} [-Wformat=] pdumper.c:1229:6: warning: unknown conversion type character 't' in format [-Wformat=] pdumper.c:1229:6: warning: too many arguments for format [-Wformat-extra-args] pdumper.c:1310:15: warning: unknown conversion type character 'l' in format [-Wformat=] 1310 | dump_trace (" result score=%f src=%s object=%0*"pI"x\n", | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ In file included from character.h:27, from buffer.h:27, from pdumper.c:34: lisp.h:108:17: note: format string is defined here 108 | # define pI "ll" | ^ pdumper.c:1310:15: warning: too many arguments for format [-Wformat-extra-args] 1310 | dump_trace (" result score=%f src=%s object=%0*"pI"x\n", | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ pdumper.c: In function 'hash_table_thaw': pdumper.c:2667:30: error: conversion from 'EMACS_INT' {aka 'long long int'} to 'ptrdiff_t' {aka 'int'} may change value [-Werror=conversion] 2667 | h->hash = make_nil_vector (XFIXNUM (h->hash)); | ^~~~~~~~~~~~~~~~~ cc1.exe: some warnings being treated as errors Makefile:401: recipe for target `pdumper.o' failed make[1]: *** [pdumper.o] Error 1 From debbugs-submit-bounces@debbugs.gnu.org Tue Aug 11 11:30:36 2020 Received: (at 36597) by debbugs.gnu.org; 11 Aug 2020 15:30:36 +0000 Received: from localhost ([127.0.0.1]:41473 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5WEW-0001iu-9t for submit@debbugs.gnu.org; Tue, 11 Aug 2020 11:30:36 -0400 Received: from zimbra.cs.ucla.edu ([131.179.128.68]:36430) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5WET-0001bD-RA for 36597@debbugs.gnu.org; Tue, 11 Aug 2020 11:30:35 -0400 Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id 57EA4160115; Tue, 11 Aug 2020 08:30:28 -0700 (PDT) Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10032) with ESMTP id emEGzCMPUhH5; Tue, 11 Aug 2020 08:30:27 -0700 (PDT) Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id 41CC0160118; Tue, 11 Aug 2020 08:30:27 -0700 (PDT) X-Virus-Scanned: amavisd-new at zimbra.cs.ucla.edu Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10026) with ESMTP id 0pgDvhhtFZwV; Tue, 11 Aug 2020 08:30:27 -0700 (PDT) Received: from [192.168.1.9] (cpe-75-82-69-226.socal.res.rr.com [75.82.69.226]) by zimbra.cs.ucla.edu (Postfix) with ESMTPSA id 1356A160115; Tue, 11 Aug 2020 08:30:27 -0700 (PDT) Subject: Re: bug#36597: 27.0.50; rehash hash tables eagerly in pdumper To: Eli Zaretskii References: <6a260307-a463-bd08-8a10-d7664d0606a2@cs.ucla.edu> <74235afc-7043-1da7-7c71-07f0ca23b9fd@cs.ucla.edu> <83r26mv53z.fsf@gnu.org> <87ft8vbow1.fsf@gnus.org> <87v9hq4ppp.fsf@gnus.org> <83k0y544lf.fsf@gnu.org> From: Paul Eggert Autocrypt: addr=eggert@cs.ucla.edu; prefer-encrypt=mutual; keydata= LS0tLS1CRUdJTiBQR1AgUFVCTElDIEtFWSBCTE9DSy0tLS0tCgptUUlOQkV5QWNtUUJFQURB QXlIMnhvVHU3cHBHNUQzYThGTVpFb243NGRDdmM0K3ExWEEySjJ0QnkycHdhVHFmCmhweHhk R0E5Smo1MFVKM1BENGJTVUVnTjh0TFowc2FuNDdsNVhUQUZMaTI0NTZjaVNsNW04c0thSGxH ZHQ5WG0KQUF0bVhxZVpWSVlYL1VGUzk2ZkR6ZjR4aEVtbS95N0xiWUVQUWRVZHh1NDd4QTVL aFRZcDVibHRGM1dZRHoxWQpnZDdneDA3QXV3cDdpdzdlTnZub0RUQWxLQWw4S1lEWnpiRE5D UUdFYnBZM2VmWkl2UGRlSStGV1FONFcra2doCnkrUDZhdTZQcklJaFlyYWV1YTdYRGRiMkxT MWVuM1NzbUUzUWpxZlJxSS9BMnVlOEpNd3N2WGUvV0szOEV6czYKeDc0aVRhcUkzQUZINmls QWhEcXBNbmQvbXNTRVNORnQ3NkRpTzFaS1FNcjlhbVZQa25qZlBtSklTcWRoZ0IxRApsRWR3 MzRzUk9mNlY4bVp3MHhmcVQ2UEtFNDZMY0ZlZnpzMGtiZzRHT1JmOHZqRzJTZjF0azVlVThN Qml5Ti9iClowM2JLTmpOWU1wT0REUVF3dVA4NGtZTGtYMndCeHhNQWhCeHdiRFZadWR6eERa SjFDMlZYdWpDT0pWeHEya2wKakJNOUVUWXVVR3FkNzVBVzJMWHJMdzYrTXVJc0hGQVlBZ1Jy NytLY3dEZ0JBZndoUEJZWDM0blNTaUhsbUxDKwpLYUhMZUNMRjVaSTJ2S20zSEVlQ1R0bE9n N3haRU9OZ3d6TCtmZEtvK0Q2U29DOFJSeEpLczhhM3NWZkk0dDZDCm5yUXp2SmJCbjZneGRn Q3U1aTI5SjFRQ1lyQ1l2cWwyVXlGUEFLK2RvOTkvMWpPWFQ0bTI4MzZqMXdBUkFRQUIKdENC UVlYVnNJRVZuWjJWeWRDQThaV2RuWlhKMFFHTnpMblZqYkdFdVpXUjFQb2tDUGdRVEFRSUFL QVVDVElCeQpaQUliQXdVSkVzd0RBQVlMQ1FnSEF3SUdGUWdDQ1FvTEJCWUNBd0VDSGdFQ0Y0 QUFDZ2tRN1pmcERtS3FmalJSCkd3LytJajAzZGhZZllsL2dYVlJpdXpWMWdHcmJIayt0bmZy SS9DN2ZBZW9GelE1dFZnVmluU2hhUGtabzBIVFAKZjE4eDZJREVkQWlPOE1xbzF5cDBDdEht ekdNQ0o1MG80R3JnZmpscjZnLyt2dEVPS2JobGVzek4yWHBKdnB3TQoyUWdHdm4vbGFUTFV1 OFBIOWFSV1RzN3FKSlpLS0tBYjRzeFljOTJGZWhQdTZGT0QwZERpeWhsREFxNGxPVjJtCmRC cHpRYmlvam9aelFMTVF3anBnQ1RLMjU3MmVLOUVPRVF5U1VUaFhyU0l6NkFTZW5wNE5ZVEZI czl0dUpRdlgKazlnWkRkUFNsM2JwKzQ3ZEd4bHhFV0xwQklNN3pJT053NGtzNGF6Z1Q4bnZE WnhBNUlaSHR2cUJsSkxCT2JZWQowTGU2MVdwMHkzVGxCRGgycWRLOGVZTDQyNlc0c2NFTVN1 aWc1Z2I4T0F0UWlCVzZrMnNHVXh4ZWl2OG92V3U4CllBWmdLSmZ1b1dJK3VSbk1FZGRydVk4 SnNvTTU0S2FLdlppa2tLczJiZzFuZHRMVnpIcEo2cUZaQzdRVmplSFUKaDYvQm1ndmRqV1Ba WUZUdE4rS0E5Q1dYM0dRS0tnTjN1dTk4OHl6bkQ3TG5COThUNEVVSDFIQS9HbmZCcU1WMQpn cHpUdlBjNHFWUWluQ21Ja0VGcDgzemwrRzVmQ2pKSjNXN2l2ekNuWW80S2hLTHBGVW05N29r VEtSMkxXM3haCnpFVzRjTFNXTzM4N01USzNDekRPeDVxZTZzNGE5MVp1Wk0vai9UUWRUTERh cU5uODNrQTRIcTQ4VUhYWXhjSWgKK05kOGsvM3c2bEZ1b0swd3JPRml5d2pMeCswdXI1am1t YmVjQkdIYzF4ZGhBRkc1QWcwRVRJQnlaQUVRQUthRgo2NzhUOXd5SDR3alRyVjFQejNjREVv U25WLzBaVXJPVDM3cDFkY0d5ai9JWHExeDY3MEhSVmFoQW1rMHNacFljCjI1UEY5RDVHUFlI RldsTmp1UFU5NnJEbmRYQjNoZWRtQlJoTGRDNGJBWGpJNERWK2JtZFZlK3EvSU1ubFpSYVYK bG05RWlNQ1ZBUjZ3MTNzUmV1N3FYa1c5cjNSd1kyQXpYc2twL3RBZTRCUktyMVptYnZpMm5i blE2ZXBFQzQycgpSYngwQjFFaGpiSVFaNUpIR2syNGlQVDdMZEJnbk5tb3M1d1lqendObGtN UUQ1VDBZZHpoazdKK1V4d0E1bTQ2Cm1PaFJEQzJyRlYvQTBnbTVUTHk4RFhqdi9Fc2M0Z1lu WWFpNlNRcW5VRVZoNUx1VjhZQ0pCbmlqcytUaXc3MXgKMWljbW42eEdJNDVFdWdKT2dlYyty THlwWWdwVnA0eDBISTVUODhxQlJZQ2t4SDNLZzhRbytFV05BOUE0TFJROQpEWDhuam9uYTBn ZjBzMDN0b2NLOGtCTjY2VW9xcVB0SEJuYzRlTWdCeW1DZmxLMTJlS2ZkMllZeG55ZzljWmF6 CldBNVZzbHZUeHBtNzZoYmc1b2lBRUgvVmcvOE14SHlBblBoZnJnd3lQcm1KRWNWQmFmZHNw Sm5ZUXhCWU5jbzIKTEZQSWhsT3ZXaDhyNGF0K3MrTTNMYjI2b1VUY3psZ2RXMVNmM1NEQTc3 Qk1SbkYwRlF5RSs3QXpWNzlNQk40eQpraXFhZXpReHRhRjFGeS90dmtoZmZTbzh1K2R3RzBF Z0poK3RlMzhnVGNJU1ZyMEdJUHBsTHo2WWhqcmJIclBSCkYxQ041VXVMOURCR2p4dU4zNVJM TlZFZnRhNlJVRmxSNk5jdFRqdnJBQkVCQUFHSkFpVUVHQUVDQUE4RkFreUEKY21RQ0d3d0ZD UkxNQXdBQUNna1E3WmZwRG1LcWZqU3JIQS8rS3pBS3ZUeFJoQTlNV05MeEl5SjdTNXVKMTZn cwpUM29DalpyQktHRWhLTU9HWDRPMEdBNlZPRXJ5TzdRUkNDWWFoM294U0czOElBbk5laXdK WGdVOUJ6a2s4NVVHCmJQRWQ3SEdGL1ZTZUhDUXdXb3U2anFVRFRTRHZuOVloTlRkRzBLWFBN NzRhQyt4cjJab3cxTzJtaFhpaGdXS0QKMER3KzBMWVBuVU9zUTBLT0Z4SFhYWUhtUnJTMU9a UFU1OUJMdmMrVFJoSWhhZlNIS0x3YlhLKzZja2t4Qng2aAo4ejVjY3BHMFFzNGJGaGRGWW5G ckVpZURMb0dtbkUyWUxoZFY2c3dKOVZOQ1M2cExpRW9oVDNmbTdhWG0xNXRaCk9JeXpNWmhI UlNBUGJsWHhRMFpTV2pxOG9ScmNZTkZ4YzRXMVVScEFrQkNPWUpvWHZRZkQ1TDNscUFsOFRD cUQKVXpZeGhIL3RKaGJEZEhycUhINzY3amFEYVRCMStUYWxwLzJBTUt3Y1hOT2Rpa2xHeGJt SFZHNllHbDZnOExyYgpzdTlOWkVJNHlMbEh6dWlrdGhKV2d6KzN2WmhWR3lObHQrSE5Jb0Y2 Q2pETDJvbXU1Y0VxNFJESE00NFFxUGs2Cmw3TzBwVXZOMW1UNEIrUzFiMDhSS3BxbS9mZjAx NUUzN0hOVi9waUl2Smx4R0FZejhQU2Z1R0NCMXRoTVlxbG0KZ2RoZDkvQmFiR0ZiR0dZSEE2 VTQvVDV6cVUrZjZ4SHkxU3NBUVoxTVNLbEx3ZWtCSVQrNC9jTFJHcUNIam5WMApxNUgvVDZh N3Q1bVBrYnpTck9MU280cHVqK0lUb05qWXlZSURCV3pobEExOWF2T2ErcnZVam1IdEQzc0ZO N2NYCld0a0dvaThidU5jYnk0VT0KPUFMNm8KLS0tLS1FTkQgUEdQIFBVQkxJQyBLRVkgQkxP Q0stLS0tLQo= Organization: UCLA Computer Science Department Message-ID: <8bf60d70-6b0d-0e07-fef9-9baad9d7749c@cs.ucla.edu> Date: Tue, 11 Aug 2020 08:30:23 -0700 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.10.0 MIME-Version: 1.0 In-Reply-To: <83k0y544lf.fsf@gnu.org> Content-Type: text/plain; charset=utf-8; format=flowed Content-Language: en-US Content-Transfer-Encoding: quoted-printable X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 36597 Cc: larsi@gnus.org, 36597@debbugs.gnu.org, pipcet@gmail.com X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) On 8/11/20 7:52 AM, Eli Zaretskii wrote: > It doesn't compile here: >=20 > pdumper.c: In function 'dump_queue_enqueue': > pdumper.c:1012:19: warning: unknown conversion type character 'l' in = format [-Wformat=3D] > 1012 | dump_trace ("new object %0*"pI"x weight=3D%d\n", EMACS_= INT_XDIGITS, uobj, > | ^~~~~~~~~~~~~~~~ > In file included from character.h:27, > from buffer.h:27, > from pdumper.c:34: > lisp.h:108:17: note: format string is defined here > 108 | # define pI "ll" =20 suggests that this is a problem on MinGW, but pI is supposed to be "I64" = on that=20 platform, not "ll". What warnings does your compiler generate for the following? #include int a; long long b; int main (void) { printf ("x=3D%0*llx\n", a, b); printf ("x=3D%0*I64x\n", a, b); return 0; } and what are __MINGW32__, __USE_MINGW_ANSI_STDIO, MINGW_W64,=20 __MINGW32_MAJOR_VERSION, __GNUC__, and __GNUC_MINOR__ on your platform? On my Fedora 31 platform, the above program causes 'gcc -Wall' to say: t.c: In function =E2=80=98main=E2=80=99: t.c:6:17: warning: unknown conversion type character =E2=80=98I=E2=80=99 = in format [-Wformat=3D] 6 | printf ("x=3D%0*I64x\n", a, b); | ^ t.c:6:11: warning: too many arguments for format [-Wformat-extra-args] 6 | printf ("x=3D%0*I64x\n", a, b); | ^~~~~~~~~~~~~ which is what I'd expect on Fedora. From debbugs-submit-bounces@debbugs.gnu.org Tue Aug 11 11:59:56 2020 Received: (at 36597-done) by debbugs.gnu.org; 11 Aug 2020 15:59:56 +0000 Received: from localhost ([127.0.0.1]:41500 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5Wgu-0006JO-0U for submit@debbugs.gnu.org; Tue, 11 Aug 2020 11:59:56 -0400 Received: from mail-ot1-f45.google.com ([209.85.210.45]:33186) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5Wgs-0006JA-Rg for 36597-done@debbugs.gnu.org; Tue, 11 Aug 2020 11:59:55 -0400 Received: by mail-ot1-f45.google.com with SMTP id t7so10491691otp.0 for <36597-done@debbugs.gnu.org>; Tue, 11 Aug 2020 08:59:54 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc; bh=aEv44mgSrUzVuDxc2SulVchwuxNEfROIGyr2QF6SIV4=; b=ofRVWAjS6RIEJNBcw1awld3dXvJnvKWlVgYzzE+f1pnhiQitxRviJ1X/T5kC0JRsaN T9ZsC40R3BI22U9JluGpg0pzU09lQHQZ6NGGGK/GzcwyUlaoaR+u2kvV65iaXdDlM+kX Pqc0NmNIqOqAm4mhKAX8LkuiUXu7NtymGWisIJOn25+OIQ1Skr9ZWkxtJasLS4w7WBmM dZFOWWK53PzdwJyInbuTohNUJiFNvfhQnB5+hUNUCuWqraK7B4ClDMBjAiT+yuiJJTby wSRsWR8CRibEgBGQaE1syWlFzxGBO/uMGt+S7IEpEovKn2FjUdfFwFyHDRA2aAnehocZ SLiw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=aEv44mgSrUzVuDxc2SulVchwuxNEfROIGyr2QF6SIV4=; b=mXAL5ltU94RWmxmM/6hBGQSrgUtgTZ+R5k9DKNSTLQ5/lefHn7gZ4AZ5w9TIo0MgIn yCafQ3aa7BDtYGqVfcpR8EHd5phyd+xCurZrAh1PKrQjRmuXgyhq/hXjG4pqmrbBcVwQ EoKsUV7mesyxj68CUylRDf3boL0icIt4oS2OXzn6LOSfkpvqjHdpr1GfJGLUPAzu2DN7 btpKsSawUbUQ8gz4tSpslXyQS/Pa0vc2bDbLZ0/7hDGxrSEJUvyqQWqz+8FZry85kSeX VEKQT0IZ4m2sBS0wdGzwYC/212dJjyO6uQMmYfNxRwFmfvcOIFGiLgnrMfy9opvco+El B6yw== X-Gm-Message-State: AOAM530B66fCy/u/jqqCbTtQTIuWQs97G6sFRqAvF5N8N6yrqisBQygM 25rRtv8rOuXGFCB3uJUhwOMy1GvLhBTkhCbxWqo= X-Google-Smtp-Source: ABdhPJxmJl8IZ+oHUgyyElqdJMlZM2bW1N2MYR5f5y5UP4cgS/tgDd8HndOTKJ9ju5h8HJukx3dwSQXIoeWW5/ENeOk= X-Received: by 2002:a05:6830:11:: with SMTP id c17mr5613417otp.287.1597161589024; Tue, 11 Aug 2020 08:59:49 -0700 (PDT) MIME-Version: 1.0 References: <6a260307-a463-bd08-8a10-d7664d0606a2@cs.ucla.edu> <74235afc-7043-1da7-7c71-07f0ca23b9fd@cs.ucla.edu> <83r26mv53z.fsf@gnu.org> <87ft8vbow1.fsf@gnus.org> <87v9hq4ppp.fsf@gnus.org> <83k0y544lf.fsf@gnu.org> In-Reply-To: <83k0y544lf.fsf@gnu.org> From: Pip Cet Date: Tue, 11 Aug 2020 15:59:12 +0000 Message-ID: Subject: Re: bug#36597: 27.0.50; rehash hash tables eagerly in pdumper To: Eli Zaretskii Content-Type: multipart/mixed; boundary="00000000000029d1e005ac9c2994" X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 36597-done Cc: larsi@gnus.org, Paul Eggert , 36597-done@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) --00000000000029d1e005ac9c2994 Content-Type: text/plain; charset="UTF-8" On Tue, Aug 11, 2020 at 2:52 PM Eli Zaretskii wrote: > pdumper.c: In function 'hash_table_thaw': > pdumper.c:2667:30: error: conversion from 'EMACS_INT' {aka 'long long int'} to 'ptrdiff_t' {aka 'int'} may change value [-Werror=conversion] > 2667 | h->hash = make_nil_vector (XFIXNUM (h->hash)); > | ^~~~~~~~~~~~~~~~~ > cc1.exe: some warnings being treated as errors I suggest going back to Fmake_vector (h->hash, Qnil), as in the attached patch. It's shorter, and it actually compiles. --00000000000029d1e005ac9c2994 Content-Type: text/x-patch; charset="US-ASCII"; name="0001-Fix-wide-int-compilation-issue-in-pdumper.c.patch" Content-Disposition: attachment; filename="0001-Fix-wide-int-compilation-issue-in-pdumper.c.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_kdq4qkar0 RnJvbSBlYWFlZmNlNTY0YmNlZTFkNzZlMzYxMDVjYWVhOWQ3OTM3NzQzYWQ0IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBQaXAgQ2V0IDxwaXBjZXRAZ21haWwuY29tPgpEYXRlOiBUdWUs IDExIEF1ZyAyMDIwIDE1OjUyOjM2ICswMDAwClN1YmplY3Q6IFtQQVRDSF0gRml4IHdpZGUtaW50 IGNvbXBpbGF0aW9uIGlzc3VlIGluIHBkdW1wZXIuYwoKKiBzcmMvcGR1bXBlci5jIChoYXNoX3Rh YmxlX3RoYXcpOiBBdm9pZCBtYWtlX25pbF92ZWN0b3IsIHdoaWNoCnJlcXVpcmVzIGFkZGl0aW9u YWwgY2FzdGluZy4KLS0tCiBzcmMvcGR1bXBlci5jIHwgMiArLQogMSBmaWxlIGNoYW5nZWQsIDEg aW5zZXJ0aW9uKCspLCAxIGRlbGV0aW9uKC0pCgpkaWZmIC0tZ2l0IGEvc3JjL3BkdW1wZXIuYyBi L3NyYy9wZHVtcGVyLmMKaW5kZXggOTQ5MjFkYzllYS4uZTEzMmRhMTU1MSAxMDA2NDQKLS0tIGEv c3JjL3BkdW1wZXIuYworKysgYi9zcmMvcGR1bXBlci5jCkBAIC0yNjY0LDcgKzI2NjQsNyBAQCBo YXNoX3RhYmxlX2ZyZWV6ZSAoc3RydWN0IExpc3BfSGFzaF9UYWJsZSAqaCkKIGhhc2hfdGFibGVf dGhhdyAoTGlzcF9PYmplY3QgaGFzaCkKIHsKICAgc3RydWN0IExpc3BfSGFzaF9UYWJsZSAqaCA9 IFhIQVNIX1RBQkxFIChoYXNoKTsKLSAgaC0+aGFzaCA9IG1ha2VfbmlsX3ZlY3RvciAoWEZJWE5V TSAoaC0+aGFzaCkpOworICBoLT5oYXNoID0gRm1ha2VfdmVjdG9yIChoLT5oYXNoLCBRbmlsKTsK ICAgaC0+bmV4dCA9IEZtYWtlX3ZlY3RvciAoaC0+bmV4dCwgbWFrZV9maXhudW0gKC0xKSk7CiAg IGgtPmluZGV4ID0gRm1ha2VfdmVjdG9yIChoLT5pbmRleCwgbWFrZV9maXhudW0gKC0xKSk7CiAK LS0gCjIuMjguMAoK --00000000000029d1e005ac9c2994-- From debbugs-submit-bounces@debbugs.gnu.org Tue Aug 11 13:00:34 2020 Received: (at 36597) by debbugs.gnu.org; 11 Aug 2020 17:00:34 +0000 Received: from localhost ([127.0.0.1]:41534 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5Xda-0008NW-86 for submit@debbugs.gnu.org; Tue, 11 Aug 2020 13:00:34 -0400 Received: from eggs.gnu.org ([209.51.188.92]:37740) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5XdX-0008FQ-22 for 36597@debbugs.gnu.org; Tue, 11 Aug 2020 13:00:33 -0400 Received: from fencepost.gnu.org ([2001:470:142:3::e]:45803) by eggs.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1k5XdR-0004Vd-2V; Tue, 11 Aug 2020 13:00:25 -0400 Received: from [176.228.60.248] (port=1948 helo=home-c4e4a596f7) by fencepost.gnu.org with esmtpsa (TLS1.2:RSA_AES_256_CBC_SHA1:256) (Exim 4.82) (envelope-from ) id 1k5XdP-0004Gv-Dl; Tue, 11 Aug 2020 13:00:24 -0400 Date: Tue, 11 Aug 2020 20:00:10 +0300 Message-Id: <837du5p17p.fsf@gnu.org> From: Eli Zaretskii To: Paul Eggert In-Reply-To: <8bf60d70-6b0d-0e07-fef9-9baad9d7749c@cs.ucla.edu> (message from Paul Eggert on Tue, 11 Aug 2020 08:30:23 -0700) Subject: Re: bug#36597: 27.0.50; rehash hash tables eagerly in pdumper References: <6a260307-a463-bd08-8a10-d7664d0606a2@cs.ucla.edu> <74235afc-7043-1da7-7c71-07f0ca23b9fd@cs.ucla.edu> <83r26mv53z.fsf@gnu.org> <87ft8vbow1.fsf@gnus.org> <87v9hq4ppp.fsf@gnus.org> <83k0y544lf.fsf@gnu.org> <8bf60d70-6b0d-0e07-fef9-9baad9d7749c@cs.ucla.edu> X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 36597 Cc: larsi@gnus.org, 36597@debbugs.gnu.org, pipcet@gmail.com X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) > Cc: larsi@gnus.org, pipcet@gmail.com, 36597@debbugs.gnu.org > From: Paul Eggert > Date: Tue, 11 Aug 2020 08:30:23 -0700 > > > lisp.h:108:17: note: format string is defined here > > 108 | # define pI "ll" > > > suggests that this is a problem on MinGW, but pI is supposed to be "I64" on that > platform, not "ll". No, it's supposed to be "ll". The problem is not in lisp.h, it's in pdumper.c: its declaration of attributes of dump_trace was incorrect for MinGW. I fixed that. The warnings about %d vs gl_intptr_t should be fixed in Gnulib, I think: why does it use 'long int' instead of 'int' on 32-bit platforms? Or maybe the format in pdumper.c should use %ld instead, I don't know. From debbugs-submit-bounces@debbugs.gnu.org Tue Aug 11 13:01:03 2020 Received: (at 36597-done) by debbugs.gnu.org; 11 Aug 2020 17:01:03 +0000 Received: from localhost ([127.0.0.1]:41538 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5Xe3-0000Ni-HR for submit@debbugs.gnu.org; Tue, 11 Aug 2020 13:01:03 -0400 Received: from eggs.gnu.org ([209.51.188.92]:37856) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5Xe0-0000GP-Vq for 36597-done@debbugs.gnu.org; Tue, 11 Aug 2020 13:01:02 -0400 Received: from fencepost.gnu.org ([2001:470:142:3::e]:45809) by eggs.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1k5Xdv-0004iv-Lz; Tue, 11 Aug 2020 13:00:55 -0400 Received: from [176.228.60.248] (port=1976 helo=home-c4e4a596f7) by fencepost.gnu.org with esmtpsa (TLS1.2:RSA_AES_256_CBC_SHA1:256) (Exim 4.82) (envelope-from ) id 1k5Xdo-0004Wh-Td; Tue, 11 Aug 2020 13:00:53 -0400 Date: Tue, 11 Aug 2020 20:00:38 +0300 Message-Id: <835z9pp16x.fsf@gnu.org> From: Eli Zaretskii To: Pip Cet In-Reply-To: (message from Pip Cet on Tue, 11 Aug 2020 15:59:12 +0000) Subject: Re: bug#36597: 27.0.50; rehash hash tables eagerly in pdumper References: <6a260307-a463-bd08-8a10-d7664d0606a2@cs.ucla.edu> <74235afc-7043-1da7-7c71-07f0ca23b9fd@cs.ucla.edu> <83r26mv53z.fsf@gnu.org> <87ft8vbow1.fsf@gnus.org> <87v9hq4ppp.fsf@gnus.org> <83k0y544lf.fsf@gnu.org> X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 36597-done Cc: larsi@gnus.org, eggert@cs.ucla.edu, 36597-done@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) > From: Pip Cet > Date: Tue, 11 Aug 2020 15:59:12 +0000 > Cc: Paul Eggert , larsi@gnus.org, 36597-done@debbugs.gnu.org > > I suggest going back to Fmake_vector (h->hash, Qnil), as in the > attached patch. It's shorter, and it actually compiles. Yes, I did that, thanks. From debbugs-submit-bounces@debbugs.gnu.org Tue Aug 11 13:31:36 2020 Received: (at 36597-done) by debbugs.gnu.org; 11 Aug 2020 17:31:36 +0000 Received: from localhost ([127.0.0.1]:41570 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5Y7b-0002MU-Nd for submit@debbugs.gnu.org; Tue, 11 Aug 2020 13:31:35 -0400 Received: from zimbra.cs.ucla.edu ([131.179.128.68]:60346) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5Y7Y-0002ME-Lj for 36597-done@debbugs.gnu.org; Tue, 11 Aug 2020 13:31:34 -0400 Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id 1FC381600D1; Tue, 11 Aug 2020 10:31:27 -0700 (PDT) Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10032) with ESMTP id FJ1kxFIYf5On; Tue, 11 Aug 2020 10:31:25 -0700 (PDT) Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id 37D59160115; Tue, 11 Aug 2020 10:31:25 -0700 (PDT) X-Virus-Scanned: amavisd-new at zimbra.cs.ucla.edu Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10026) with ESMTP id Z7WmX0xznM5d; Tue, 11 Aug 2020 10:31:25 -0700 (PDT) Received: from [192.168.1.9] (cpe-75-82-69-226.socal.res.rr.com [75.82.69.226]) by zimbra.cs.ucla.edu (Postfix) with ESMTPSA id 0473D1600D1; Tue, 11 Aug 2020 10:31:24 -0700 (PDT) Subject: Re: bug#36597: 27.0.50; rehash hash tables eagerly in pdumper To: Eli Zaretskii , Pip Cet References: <74235afc-7043-1da7-7c71-07f0ca23b9fd@cs.ucla.edu> <83r26mv53z.fsf@gnu.org> <87ft8vbow1.fsf@gnus.org> <87v9hq4ppp.fsf@gnus.org> <83k0y544lf.fsf@gnu.org> <835z9pp16x.fsf@gnu.org> From: Paul Eggert Autocrypt: addr=eggert@cs.ucla.edu; prefer-encrypt=mutual; keydata= LS0tLS1CRUdJTiBQR1AgUFVCTElDIEtFWSBCTE9DSy0tLS0tCgptUUlOQkV5QWNtUUJFQURB QXlIMnhvVHU3cHBHNUQzYThGTVpFb243NGRDdmM0K3ExWEEySjJ0QnkycHdhVHFmCmhweHhk R0E5Smo1MFVKM1BENGJTVUVnTjh0TFowc2FuNDdsNVhUQUZMaTI0NTZjaVNsNW04c0thSGxH ZHQ5WG0KQUF0bVhxZVpWSVlYL1VGUzk2ZkR6ZjR4aEVtbS95N0xiWUVQUWRVZHh1NDd4QTVL aFRZcDVibHRGM1dZRHoxWQpnZDdneDA3QXV3cDdpdzdlTnZub0RUQWxLQWw4S1lEWnpiRE5D UUdFYnBZM2VmWkl2UGRlSStGV1FONFcra2doCnkrUDZhdTZQcklJaFlyYWV1YTdYRGRiMkxT MWVuM1NzbUUzUWpxZlJxSS9BMnVlOEpNd3N2WGUvV0szOEV6czYKeDc0aVRhcUkzQUZINmls QWhEcXBNbmQvbXNTRVNORnQ3NkRpTzFaS1FNcjlhbVZQa25qZlBtSklTcWRoZ0IxRApsRWR3 MzRzUk9mNlY4bVp3MHhmcVQ2UEtFNDZMY0ZlZnpzMGtiZzRHT1JmOHZqRzJTZjF0azVlVThN Qml5Ti9iClowM2JLTmpOWU1wT0REUVF3dVA4NGtZTGtYMndCeHhNQWhCeHdiRFZadWR6eERa SjFDMlZYdWpDT0pWeHEya2wKakJNOUVUWXVVR3FkNzVBVzJMWHJMdzYrTXVJc0hGQVlBZ1Jy NytLY3dEZ0JBZndoUEJZWDM0blNTaUhsbUxDKwpLYUhMZUNMRjVaSTJ2S20zSEVlQ1R0bE9n N3haRU9OZ3d6TCtmZEtvK0Q2U29DOFJSeEpLczhhM3NWZkk0dDZDCm5yUXp2SmJCbjZneGRn Q3U1aTI5SjFRQ1lyQ1l2cWwyVXlGUEFLK2RvOTkvMWpPWFQ0bTI4MzZqMXdBUkFRQUIKdENC UVlYVnNJRVZuWjJWeWRDQThaV2RuWlhKMFFHTnpMblZqYkdFdVpXUjFQb2tDUGdRVEFRSUFL QVVDVElCeQpaQUliQXdVSkVzd0RBQVlMQ1FnSEF3SUdGUWdDQ1FvTEJCWUNBd0VDSGdFQ0Y0 QUFDZ2tRN1pmcERtS3FmalJSCkd3LytJajAzZGhZZllsL2dYVlJpdXpWMWdHcmJIayt0bmZy SS9DN2ZBZW9GelE1dFZnVmluU2hhUGtabzBIVFAKZjE4eDZJREVkQWlPOE1xbzF5cDBDdEht ekdNQ0o1MG80R3JnZmpscjZnLyt2dEVPS2JobGVzek4yWHBKdnB3TQoyUWdHdm4vbGFUTFV1 OFBIOWFSV1RzN3FKSlpLS0tBYjRzeFljOTJGZWhQdTZGT0QwZERpeWhsREFxNGxPVjJtCmRC cHpRYmlvam9aelFMTVF3anBnQ1RLMjU3MmVLOUVPRVF5U1VUaFhyU0l6NkFTZW5wNE5ZVEZI czl0dUpRdlgKazlnWkRkUFNsM2JwKzQ3ZEd4bHhFV0xwQklNN3pJT053NGtzNGF6Z1Q4bnZE WnhBNUlaSHR2cUJsSkxCT2JZWQowTGU2MVdwMHkzVGxCRGgycWRLOGVZTDQyNlc0c2NFTVN1 aWc1Z2I4T0F0UWlCVzZrMnNHVXh4ZWl2OG92V3U4CllBWmdLSmZ1b1dJK3VSbk1FZGRydVk4 SnNvTTU0S2FLdlppa2tLczJiZzFuZHRMVnpIcEo2cUZaQzdRVmplSFUKaDYvQm1ndmRqV1Ba WUZUdE4rS0E5Q1dYM0dRS0tnTjN1dTk4OHl6bkQ3TG5COThUNEVVSDFIQS9HbmZCcU1WMQpn cHpUdlBjNHFWUWluQ21Ja0VGcDgzemwrRzVmQ2pKSjNXN2l2ekNuWW80S2hLTHBGVW05N29r VEtSMkxXM3haCnpFVzRjTFNXTzM4N01USzNDekRPeDVxZTZzNGE5MVp1Wk0vai9UUWRUTERh cU5uODNrQTRIcTQ4VUhYWXhjSWgKK05kOGsvM3c2bEZ1b0swd3JPRml5d2pMeCswdXI1am1t YmVjQkdIYzF4ZGhBRkc1QWcwRVRJQnlaQUVRQUthRgo2NzhUOXd5SDR3alRyVjFQejNjREVv U25WLzBaVXJPVDM3cDFkY0d5ai9JWHExeDY3MEhSVmFoQW1rMHNacFljCjI1UEY5RDVHUFlI RldsTmp1UFU5NnJEbmRYQjNoZWRtQlJoTGRDNGJBWGpJNERWK2JtZFZlK3EvSU1ubFpSYVYK bG05RWlNQ1ZBUjZ3MTNzUmV1N3FYa1c5cjNSd1kyQXpYc2twL3RBZTRCUktyMVptYnZpMm5i blE2ZXBFQzQycgpSYngwQjFFaGpiSVFaNUpIR2syNGlQVDdMZEJnbk5tb3M1d1lqendObGtN UUQ1VDBZZHpoazdKK1V4d0E1bTQ2Cm1PaFJEQzJyRlYvQTBnbTVUTHk4RFhqdi9Fc2M0Z1lu WWFpNlNRcW5VRVZoNUx1VjhZQ0pCbmlqcytUaXc3MXgKMWljbW42eEdJNDVFdWdKT2dlYyty THlwWWdwVnA0eDBISTVUODhxQlJZQ2t4SDNLZzhRbytFV05BOUE0TFJROQpEWDhuam9uYTBn ZjBzMDN0b2NLOGtCTjY2VW9xcVB0SEJuYzRlTWdCeW1DZmxLMTJlS2ZkMllZeG55ZzljWmF6 CldBNVZzbHZUeHBtNzZoYmc1b2lBRUgvVmcvOE14SHlBblBoZnJnd3lQcm1KRWNWQmFmZHNw Sm5ZUXhCWU5jbzIKTEZQSWhsT3ZXaDhyNGF0K3MrTTNMYjI2b1VUY3psZ2RXMVNmM1NEQTc3 Qk1SbkYwRlF5RSs3QXpWNzlNQk40eQpraXFhZXpReHRhRjFGeS90dmtoZmZTbzh1K2R3RzBF Z0poK3RlMzhnVGNJU1ZyMEdJUHBsTHo2WWhqcmJIclBSCkYxQ041VXVMOURCR2p4dU4zNVJM TlZFZnRhNlJVRmxSNk5jdFRqdnJBQkVCQUFHSkFpVUVHQUVDQUE4RkFreUEKY21RQ0d3d0ZD UkxNQXdBQUNna1E3WmZwRG1LcWZqU3JIQS8rS3pBS3ZUeFJoQTlNV05MeEl5SjdTNXVKMTZn cwpUM29DalpyQktHRWhLTU9HWDRPMEdBNlZPRXJ5TzdRUkNDWWFoM294U0czOElBbk5laXdK WGdVOUJ6a2s4NVVHCmJQRWQ3SEdGL1ZTZUhDUXdXb3U2anFVRFRTRHZuOVloTlRkRzBLWFBN NzRhQyt4cjJab3cxTzJtaFhpaGdXS0QKMER3KzBMWVBuVU9zUTBLT0Z4SFhYWUhtUnJTMU9a UFU1OUJMdmMrVFJoSWhhZlNIS0x3YlhLKzZja2t4Qng2aAo4ejVjY3BHMFFzNGJGaGRGWW5G ckVpZURMb0dtbkUyWUxoZFY2c3dKOVZOQ1M2cExpRW9oVDNmbTdhWG0xNXRaCk9JeXpNWmhI UlNBUGJsWHhRMFpTV2pxOG9ScmNZTkZ4YzRXMVVScEFrQkNPWUpvWHZRZkQ1TDNscUFsOFRD cUQKVXpZeGhIL3RKaGJEZEhycUhINzY3amFEYVRCMStUYWxwLzJBTUt3Y1hOT2Rpa2xHeGJt SFZHNllHbDZnOExyYgpzdTlOWkVJNHlMbEh6dWlrdGhKV2d6KzN2WmhWR3lObHQrSE5Jb0Y2 Q2pETDJvbXU1Y0VxNFJESE00NFFxUGs2Cmw3TzBwVXZOMW1UNEIrUzFiMDhSS3BxbS9mZjAx NUUzN0hOVi9waUl2Smx4R0FZejhQU2Z1R0NCMXRoTVlxbG0KZ2RoZDkvQmFiR0ZiR0dZSEE2 VTQvVDV6cVUrZjZ4SHkxU3NBUVoxTVNLbEx3ZWtCSVQrNC9jTFJHcUNIam5WMApxNUgvVDZh N3Q1bVBrYnpTck9MU280cHVqK0lUb05qWXlZSURCV3pobEExOWF2T2ErcnZVam1IdEQzc0ZO N2NYCld0a0dvaThidU5jYnk0VT0KPUFMNm8KLS0tLS1FTkQgUEdQIFBVQkxJQyBLRVkgQkxP Q0stLS0tLQo= Organization: UCLA Computer Science Department Message-ID: <8525b631-b24e-ce89-6314-741449ca8403@cs.ucla.edu> Date: Tue, 11 Aug 2020 10:31:24 -0700 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.10.0 MIME-Version: 1.0 In-Reply-To: <835z9pp16x.fsf@gnu.org> Content-Type: multipart/mixed; boundary="------------23C6A6AE843030C10CD992B8" Content-Language: en-US X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 36597-done Cc: larsi@gnus.org, 36597-done@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) This is a multi-part message in MIME format. --------------23C6A6AE843030C10CD992B8 Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 7bit On 8/11/20 10:00 AM, Eli Zaretskii wrote: >> I suggest going back to Fmake_vector (h->hash, Qnil), as in the >> attached patch. It's shorter, and it actually compiles. > Yes, I did that, thanks. The compilation issue was due to pdumper enabling -Wconversion, which causes more trouble than it cures (but that is a different topic). I worked around the glitch by installing the attached further patch, which should also help explain the motivation for make_nil_vector. --------------23C6A6AE843030C10CD992B8 Content-Type: text/x-patch; charset=UTF-8; name="0001-Prefer-make_nil_vector-to-make-vector-with-nil.patch" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename*0="0001-Prefer-make_nil_vector-to-make-vector-with-nil.patch" >From 669aeafbd14b0ebb824bacba0a6b3daad30847a9 Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Tue, 11 Aug 2020 10:29:02 -0700 Subject: [PATCH] Prefer make_nil_vector to make-vector with nil * src/pdumper.c (hash_table_thaw): Pacify -Wconversion so we can use make_nil_vector again. * src/timefns.c (syms_of_timefns): Prefer make_nil_vector to make_vector with Qnil. --- src/lisp.h | 3 ++- src/pdumper.c | 4 +++- src/timefns.c | 2 +- 3 files changed, 6 insertions(+), 3 deletions(-) diff --git a/src/lisp.h b/src/lisp.h index d88038d91b..2962babb4f 100644 --- a/src/lisp.h +++ b/src/lisp.h @@ -3947,7 +3947,8 @@ make_uninit_sub_char_table (int depth, int min_char) return v; } -/* Make a vector of SIZE nils. */ +/* Make a vector of SIZE nils - faster than make_vector (size, Qnil) + if the OS already cleared the new memory. */ INLINE Lisp_Object make_nil_vector (ptrdiff_t size) diff --git a/src/pdumper.c b/src/pdumper.c index 6c581bcd0b..aaa760d70d 100644 --- a/src/pdumper.c +++ b/src/pdumper.c @@ -2664,7 +2664,9 @@ hash_table_freeze (struct Lisp_Hash_Table *h) hash_table_thaw (Lisp_Object hash) { struct Lisp_Hash_Table *h = XHASH_TABLE (hash); - h->hash = Fmake_vector (h->hash, Qnil); + ALLOW_IMPLICIT_CONVERSION; + h->hash = make_nil_vector (XFIXNUM (h->hash)); + DISALLOW_IMPLICIT_CONVERSION; h->next = Fmake_vector (h->next, make_fixnum (-1)); h->index = Fmake_vector (h->index, make_fixnum (-1)); diff --git a/src/timefns.c b/src/timefns.c index 7bcc37d7c1..94cfddf0da 100644 --- a/src/timefns.c +++ b/src/timefns.c @@ -2048,7 +2048,7 @@ syms_of_timefns (void) defsubr (&Scurrent_time_zone); defsubr (&Sset_time_zone_rule); - flt_radix_power = make_vector (flt_radix_power_size, Qnil); + flt_radix_power = make_nil_vector (flt_radix_power_size); staticpro (&flt_radix_power); #ifdef NEED_ZTRILLION_INIT -- 2.17.1 --------------23C6A6AE843030C10CD992B8-- From debbugs-submit-bounces@debbugs.gnu.org Tue Aug 11 14:11:31 2020 Received: (at 36597) by debbugs.gnu.org; 11 Aug 2020 18:11:31 +0000 Received: from localhost ([127.0.0.1]:41637 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5YkE-0003Sb-Nl for submit@debbugs.gnu.org; Tue, 11 Aug 2020 14:11:31 -0400 Received: from zimbra.cs.ucla.edu ([131.179.128.68]:38666) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5YkB-0003SL-6A for 36597@debbugs.gnu.org; Tue, 11 Aug 2020 14:11:29 -0400 Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id 9980A1600D1; Tue, 11 Aug 2020 11:11:21 -0700 (PDT) Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10032) with ESMTP id 96WpHW3p1kK9; Tue, 11 Aug 2020 11:11:20 -0700 (PDT) Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id A8804160115; Tue, 11 Aug 2020 11:11:20 -0700 (PDT) X-Virus-Scanned: amavisd-new at zimbra.cs.ucla.edu Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10026) with ESMTP id 1zd0A6CCZzIh; Tue, 11 Aug 2020 11:11:20 -0700 (PDT) Received: from [192.168.1.9] (cpe-75-82-69-226.socal.res.rr.com [75.82.69.226]) by zimbra.cs.ucla.edu (Postfix) with ESMTPSA id 78ADF1600D1; Tue, 11 Aug 2020 11:11:20 -0700 (PDT) Subject: Re: bug#36597: 27.0.50; rehash hash tables eagerly in pdumper To: Eli Zaretskii References: <74235afc-7043-1da7-7c71-07f0ca23b9fd@cs.ucla.edu> <83r26mv53z.fsf@gnu.org> <87ft8vbow1.fsf@gnus.org> <87v9hq4ppp.fsf@gnus.org> <83k0y544lf.fsf@gnu.org> <8bf60d70-6b0d-0e07-fef9-9baad9d7749c@cs.ucla.edu> <837du5p17p.fsf@gnu.org> From: Paul Eggert Autocrypt: addr=eggert@cs.ucla.edu; prefer-encrypt=mutual; keydata= LS0tLS1CRUdJTiBQR1AgUFVCTElDIEtFWSBCTE9DSy0tLS0tCgptUUlOQkV5QWNtUUJFQURB QXlIMnhvVHU3cHBHNUQzYThGTVpFb243NGRDdmM0K3ExWEEySjJ0QnkycHdhVHFmCmhweHhk R0E5Smo1MFVKM1BENGJTVUVnTjh0TFowc2FuNDdsNVhUQUZMaTI0NTZjaVNsNW04c0thSGxH ZHQ5WG0KQUF0bVhxZVpWSVlYL1VGUzk2ZkR6ZjR4aEVtbS95N0xiWUVQUWRVZHh1NDd4QTVL aFRZcDVibHRGM1dZRHoxWQpnZDdneDA3QXV3cDdpdzdlTnZub0RUQWxLQWw4S1lEWnpiRE5D UUdFYnBZM2VmWkl2UGRlSStGV1FONFcra2doCnkrUDZhdTZQcklJaFlyYWV1YTdYRGRiMkxT MWVuM1NzbUUzUWpxZlJxSS9BMnVlOEpNd3N2WGUvV0szOEV6czYKeDc0aVRhcUkzQUZINmls QWhEcXBNbmQvbXNTRVNORnQ3NkRpTzFaS1FNcjlhbVZQa25qZlBtSklTcWRoZ0IxRApsRWR3 MzRzUk9mNlY4bVp3MHhmcVQ2UEtFNDZMY0ZlZnpzMGtiZzRHT1JmOHZqRzJTZjF0azVlVThN Qml5Ti9iClowM2JLTmpOWU1wT0REUVF3dVA4NGtZTGtYMndCeHhNQWhCeHdiRFZadWR6eERa SjFDMlZYdWpDT0pWeHEya2wKakJNOUVUWXVVR3FkNzVBVzJMWHJMdzYrTXVJc0hGQVlBZ1Jy NytLY3dEZ0JBZndoUEJZWDM0blNTaUhsbUxDKwpLYUhMZUNMRjVaSTJ2S20zSEVlQ1R0bE9n N3haRU9OZ3d6TCtmZEtvK0Q2U29DOFJSeEpLczhhM3NWZkk0dDZDCm5yUXp2SmJCbjZneGRn Q3U1aTI5SjFRQ1lyQ1l2cWwyVXlGUEFLK2RvOTkvMWpPWFQ0bTI4MzZqMXdBUkFRQUIKdENC UVlYVnNJRVZuWjJWeWRDQThaV2RuWlhKMFFHTnpMblZqYkdFdVpXUjFQb2tDUGdRVEFRSUFL QVVDVElCeQpaQUliQXdVSkVzd0RBQVlMQ1FnSEF3SUdGUWdDQ1FvTEJCWUNBd0VDSGdFQ0Y0 QUFDZ2tRN1pmcERtS3FmalJSCkd3LytJajAzZGhZZllsL2dYVlJpdXpWMWdHcmJIayt0bmZy SS9DN2ZBZW9GelE1dFZnVmluU2hhUGtabzBIVFAKZjE4eDZJREVkQWlPOE1xbzF5cDBDdEht ekdNQ0o1MG80R3JnZmpscjZnLyt2dEVPS2JobGVzek4yWHBKdnB3TQoyUWdHdm4vbGFUTFV1 OFBIOWFSV1RzN3FKSlpLS0tBYjRzeFljOTJGZWhQdTZGT0QwZERpeWhsREFxNGxPVjJtCmRC cHpRYmlvam9aelFMTVF3anBnQ1RLMjU3MmVLOUVPRVF5U1VUaFhyU0l6NkFTZW5wNE5ZVEZI czl0dUpRdlgKazlnWkRkUFNsM2JwKzQ3ZEd4bHhFV0xwQklNN3pJT053NGtzNGF6Z1Q4bnZE WnhBNUlaSHR2cUJsSkxCT2JZWQowTGU2MVdwMHkzVGxCRGgycWRLOGVZTDQyNlc0c2NFTVN1 aWc1Z2I4T0F0UWlCVzZrMnNHVXh4ZWl2OG92V3U4CllBWmdLSmZ1b1dJK3VSbk1FZGRydVk4 SnNvTTU0S2FLdlppa2tLczJiZzFuZHRMVnpIcEo2cUZaQzdRVmplSFUKaDYvQm1ndmRqV1Ba WUZUdE4rS0E5Q1dYM0dRS0tnTjN1dTk4OHl6bkQ3TG5COThUNEVVSDFIQS9HbmZCcU1WMQpn cHpUdlBjNHFWUWluQ21Ja0VGcDgzemwrRzVmQ2pKSjNXN2l2ekNuWW80S2hLTHBGVW05N29r VEtSMkxXM3haCnpFVzRjTFNXTzM4N01USzNDekRPeDVxZTZzNGE5MVp1Wk0vai9UUWRUTERh cU5uODNrQTRIcTQ4VUhYWXhjSWgKK05kOGsvM3c2bEZ1b0swd3JPRml5d2pMeCswdXI1am1t YmVjQkdIYzF4ZGhBRkc1QWcwRVRJQnlaQUVRQUthRgo2NzhUOXd5SDR3alRyVjFQejNjREVv U25WLzBaVXJPVDM3cDFkY0d5ai9JWHExeDY3MEhSVmFoQW1rMHNacFljCjI1UEY5RDVHUFlI RldsTmp1UFU5NnJEbmRYQjNoZWRtQlJoTGRDNGJBWGpJNERWK2JtZFZlK3EvSU1ubFpSYVYK bG05RWlNQ1ZBUjZ3MTNzUmV1N3FYa1c5cjNSd1kyQXpYc2twL3RBZTRCUktyMVptYnZpMm5i blE2ZXBFQzQycgpSYngwQjFFaGpiSVFaNUpIR2syNGlQVDdMZEJnbk5tb3M1d1lqendObGtN UUQ1VDBZZHpoazdKK1V4d0E1bTQ2Cm1PaFJEQzJyRlYvQTBnbTVUTHk4RFhqdi9Fc2M0Z1lu WWFpNlNRcW5VRVZoNUx1VjhZQ0pCbmlqcytUaXc3MXgKMWljbW42eEdJNDVFdWdKT2dlYyty THlwWWdwVnA0eDBISTVUODhxQlJZQ2t4SDNLZzhRbytFV05BOUE0TFJROQpEWDhuam9uYTBn ZjBzMDN0b2NLOGtCTjY2VW9xcVB0SEJuYzRlTWdCeW1DZmxLMTJlS2ZkMllZeG55ZzljWmF6 CldBNVZzbHZUeHBtNzZoYmc1b2lBRUgvVmcvOE14SHlBblBoZnJnd3lQcm1KRWNWQmFmZHNw Sm5ZUXhCWU5jbzIKTEZQSWhsT3ZXaDhyNGF0K3MrTTNMYjI2b1VUY3psZ2RXMVNmM1NEQTc3 Qk1SbkYwRlF5RSs3QXpWNzlNQk40eQpraXFhZXpReHRhRjFGeS90dmtoZmZTbzh1K2R3RzBF Z0poK3RlMzhnVGNJU1ZyMEdJUHBsTHo2WWhqcmJIclBSCkYxQ041VXVMOURCR2p4dU4zNVJM TlZFZnRhNlJVRmxSNk5jdFRqdnJBQkVCQUFHSkFpVUVHQUVDQUE4RkFreUEKY21RQ0d3d0ZD UkxNQXdBQUNna1E3WmZwRG1LcWZqU3JIQS8rS3pBS3ZUeFJoQTlNV05MeEl5SjdTNXVKMTZn cwpUM29DalpyQktHRWhLTU9HWDRPMEdBNlZPRXJ5TzdRUkNDWWFoM294U0czOElBbk5laXdK WGdVOUJ6a2s4NVVHCmJQRWQ3SEdGL1ZTZUhDUXdXb3U2anFVRFRTRHZuOVloTlRkRzBLWFBN NzRhQyt4cjJab3cxTzJtaFhpaGdXS0QKMER3KzBMWVBuVU9zUTBLT0Z4SFhYWUhtUnJTMU9a UFU1OUJMdmMrVFJoSWhhZlNIS0x3YlhLKzZja2t4Qng2aAo4ejVjY3BHMFFzNGJGaGRGWW5G ckVpZURMb0dtbkUyWUxoZFY2c3dKOVZOQ1M2cExpRW9oVDNmbTdhWG0xNXRaCk9JeXpNWmhI UlNBUGJsWHhRMFpTV2pxOG9ScmNZTkZ4YzRXMVVScEFrQkNPWUpvWHZRZkQ1TDNscUFsOFRD cUQKVXpZeGhIL3RKaGJEZEhycUhINzY3amFEYVRCMStUYWxwLzJBTUt3Y1hOT2Rpa2xHeGJt SFZHNllHbDZnOExyYgpzdTlOWkVJNHlMbEh6dWlrdGhKV2d6KzN2WmhWR3lObHQrSE5Jb0Y2 Q2pETDJvbXU1Y0VxNFJESE00NFFxUGs2Cmw3TzBwVXZOMW1UNEIrUzFiMDhSS3BxbS9mZjAx NUUzN0hOVi9waUl2Smx4R0FZejhQU2Z1R0NCMXRoTVlxbG0KZ2RoZDkvQmFiR0ZiR0dZSEE2 VTQvVDV6cVUrZjZ4SHkxU3NBUVoxTVNLbEx3ZWtCSVQrNC9jTFJHcUNIam5WMApxNUgvVDZh N3Q1bVBrYnpTck9MU280cHVqK0lUb05qWXlZSURCV3pobEExOWF2T2ErcnZVam1IdEQzc0ZO N2NYCld0a0dvaThidU5jYnk0VT0KPUFMNm8KLS0tLS1FTkQgUEdQIFBVQkxJQyBLRVkgQkxP Q0stLS0tLQo= Organization: UCLA Computer Science Department Message-ID: <63d00359-f7cc-5564-ecf0-d374dea979ff@cs.ucla.edu> Date: Tue, 11 Aug 2020 11:11:20 -0700 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.10.0 MIME-Version: 1.0 In-Reply-To: <837du5p17p.fsf@gnu.org> Content-Type: multipart/mixed; boundary="------------B36ECABD862D25F86D08C581" Content-Language: en-US X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 36597 Cc: larsi@gnus.org, 36597@debbugs.gnu.org, pipcet@gmail.com X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) This is a multi-part message in MIME format. --------------B36ECABD862D25F86D08C581 Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 7bit On 8/11/20 10:00 AM, Eli Zaretskii wrote: > The warnings about %d vs gl_intptr_t should be fixed in Gnulib, I > think: why does it use 'long int' instead of 'int' on 32-bit > platforms? Or maybe the format in pdumper.c should use %ld instead, I > don't know. Ah, it's because Emacs uses C99 inttypes.h macros like PRIdPTR without also using the Gnulib inttypes module which implements these macros on platforms like MinGW where the macros don't work. This problem occurs elsewhere in Emacs in a couple of places, we just never noticed it. I installed the attached patch, which I hope fixes the glitch. --------------B36ECABD862D25F86D08C581 Content-Type: text/x-patch; charset=UTF-8; name="0001-Use-Gnulib-inttypes-module.patch" Content-Disposition: attachment; filename="0001-Use-Gnulib-inttypes-module.patch" Content-Transfer-Encoding: quoted-printable >From 39c16c1170fd8bd7035e6e265048dd371cde4609 Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Tue, 11 Aug 2020 11:06:39 -0700 Subject: [PATCH] Use Gnulib inttypes module MIME-Version: 1.0 Content-Type: text/plain; charset=3DUTF-8 Content-Transfer-Encoding: 8bit Needed for platforms like MinGW that don=E2=80=99t support C99 PRIdPTR. * admin/merge-gnulib (GNULIB_MODULES): Add inttypes. * m4/gnulib-comp.m4: Regenerate. --- admin/merge-gnulib | 2 +- lib/gnulib.mk.in | 1 + m4/gnulib-comp.m4 | 2 ++ 3 files changed, 4 insertions(+), 1 deletion(-) diff --git a/admin/merge-gnulib b/admin/merge-gnulib index 3f32536a62..98f7941bd8 100755 --- a/admin/merge-gnulib +++ b/admin/merge-gnulib @@ -36,7 +36,7 @@ GNULIB_MODULES=3D fchmodat fcntl fcntl-h fdopendir filemode filename filevercmp flexmember fpieee fstatat fsusage fsync f= utimens getloadavg getopt-gnu getrandom gettime gettimeofday gitlog-to-changel= og - ieee754-h ignore-value intprops largefile libgmp lstat + ieee754-h ignore-value intprops inttypes largefile libgmp lstat manywarnings memmem-simple mempcpy memrchr minmax mkostemp mktime nstr= ftime pathmax pipe2 pselect pthread_sigmask qcopy-acl readlink readlinkat regex diff --git a/lib/gnulib.mk.in b/lib/gnulib.mk.in index 92d0621c61..e7e9fbdc31 100644 --- a/lib/gnulib.mk.in +++ b/lib/gnulib.mk.in @@ -116,6 +116,7 @@ # ieee754-h \ # ignore-value \ # intprops \ +# inttypes \ # largefile \ # libgmp \ # lstat \ diff --git a/m4/gnulib-comp.m4 b/m4/gnulib-comp.m4 index 5bfa1473ed..1f8a87218e 100644 --- a/m4/gnulib-comp.m4 +++ b/m4/gnulib-comp.m4 @@ -113,6 +113,7 @@ AC_DEFUN # Code from module ignore-value: # Code from module include_next: # Code from module intprops: + # Code from module inttypes: # Code from module inttypes-incomplete: # Code from module largefile: AC_REQUIRE([AC_SYS_LARGEFILE]) @@ -342,6 +343,7 @@ AC_DEFUN fi gl_SYS_TIME_MODULE_INDICATOR([gettimeofday]) gl_IEEE754_H + gl_INTTYPES_H gl_INTTYPES_INCOMPLETE AC_REQUIRE([gl_LARGEFILE]) gl___INLINE --=20 2.17.1 --------------B36ECABD862D25F86D08C581-- From debbugs-submit-bounces@debbugs.gnu.org Tue Aug 11 14:27:15 2020 Received: (at submit) by debbugs.gnu.org; 11 Aug 2020 18:27:15 +0000 Received: from localhost ([127.0.0.1]:41659 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5YzT-0003qI-Dc for submit@debbugs.gnu.org; Tue, 11 Aug 2020 14:27:15 -0400 Received: from lists.gnu.org ([209.51.188.17]:55844) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5YzR-0003q9-HG for submit@debbugs.gnu.org; Tue, 11 Aug 2020 14:27:13 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:39002) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1k5YzR-0002CT-Aq for bug-gnu-emacs@gnu.org; Tue, 11 Aug 2020 14:27:13 -0400 Received: from static.214.254.202.116.clients.your-server.de ([116.202.254.214]:37966 helo=ciao.gmane.io) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1k5YzP-0006dq-MK for bug-gnu-emacs@gnu.org; Tue, 11 Aug 2020 14:27:12 -0400 Received: from list by ciao.gmane.io with local (Exim 4.92) (envelope-from ) id 1k5YzI-0000yp-N4 for bug-gnu-emacs@gnu.org; Tue, 11 Aug 2020 20:27:04 +0200 X-Injected-Via-Gmane: http://gmane.org/ To: bug-gnu-emacs@gnu.org From: Andy Moreton Subject: Re: bug#36597: 27.0.50; rehash hash tables eagerly in pdumper Date: Tue, 11 Aug 2020 19:27:00 +0100 Message-ID: <86y2mlf37v.fsf@gmail.com> References: <74235afc-7043-1da7-7c71-07f0ca23b9fd@cs.ucla.edu> <83r26mv53z.fsf@gnu.org> <87ft8vbow1.fsf@gnus.org> <87v9hq4ppp.fsf@gnus.org> <83k0y544lf.fsf@gnu.org> <835z9pp16x.fsf@gnu.org> <8525b631-b24e-ce89-6314-741449ca8403@cs.ucla.edu> Mime-Version: 1.0 Content-Type: text/plain User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/27.1 (windows-nt) Cancel-Lock: sha1:hkISmRHXmxSX+lNbyR/POT7Xr6s= Received-SPF: pass client-ip=116.202.254.214; envelope-from=geb-bug-gnu-emacs@m.gmane-mx.org; helo=ciao.gmane.io X-detected-operating-system: by eggs.gnu.org: First seen = 2020/08/11 14:15:57 X-ACL-Warn: Detected OS = Linux 2.2.x-3.x [generic] [fuzzy] X-Spam_score_int: 20 X-Spam_score: 2.0 X-Spam_bar: ++ X-Spam_report: (2.0 / 5.0 requ) BAYES_00=-1.9, DKIM_ADSP_CUSTOM_MED=0.001, FORGED_GMAIL_RCVD=1, FREEMAIL_FORGED_FROMDOMAIN=1, FREEMAIL_FROM=0.001, HEADER_FROM_DIFFERENT_DOMAINS=1, NML_ADSP_CUSTOM_MED=0.9, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=no autolearn_force=no X-Spam_action: no action X-Spam-Score: -0.4 (/) X-Debbugs-Envelope-To: submit X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.4 (-) On Tue 11 Aug 2020, Paul Eggert wrote: > On 8/11/20 10:00 AM, Eli Zaretskii wrote: >>> I suggest going back to Fmake_vector (h->hash, Qnil), as in the >>> attached patch. It's shorter, and it actually compiles. >> Yes, I did that, thanks. > > The compilation issue was due to pdumper enabling -Wconversion, which causes > more trouble than it cures (but that is a different topic). I worked around > the glitch by installing the attached further patch, which should also help > explain the motivation for make_nil_vector. Eli's fixes have addressed issues with the MinGW toolchains, but Mingw64 64bit builds are still broken: C:/emacs/git/emacs/master/src/pdumper.c: In function 'dump_read_all': C:/emacs/git/emacs/master/src/pdumper.c:5078:60: error: conversion from 'size_t' {aka 'long long unsigned int'} to 'unsigned int' may change value [-Werror=conversion] 5078 | ssize_t chunk = read (fd, (char *) buf + bytes_read, chunk_to_read); | ^~~~~~~~~~~~~ From debbugs-submit-bounces@debbugs.gnu.org Tue Aug 11 14:32:35 2020 Received: (at 36597-done) by debbugs.gnu.org; 11 Aug 2020 18:32:35 +0000 Received: from localhost ([127.0.0.1]:41671 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5Z4d-0003zX-HH for submit@debbugs.gnu.org; Tue, 11 Aug 2020 14:32:35 -0400 Received: from eggs.gnu.org ([209.51.188.92]:58054) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5Z4b-0003zJ-67 for 36597-done@debbugs.gnu.org; Tue, 11 Aug 2020 14:32:34 -0400 Received: from fencepost.gnu.org ([2001:470:142:3::e]:47179) by eggs.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1k5Z4V-0007DW-De; Tue, 11 Aug 2020 14:32:27 -0400 Received: from [176.228.60.248] (port=3601 helo=home-c4e4a596f7) by fencepost.gnu.org with esmtpsa (TLS1.2:RSA_AES_256_CBC_SHA1:256) (Exim 4.82) (envelope-from ) id 1k5Z4U-0000DM-Tm; Tue, 11 Aug 2020 14:32:27 -0400 Date: Tue, 11 Aug 2020 21:32:16 +0300 Message-Id: <831rkdowy7.fsf@gnu.org> From: Eli Zaretskii To: Paul Eggert In-Reply-To: <8525b631-b24e-ce89-6314-741449ca8403@cs.ucla.edu> (message from Paul Eggert on Tue, 11 Aug 2020 10:31:24 -0700) Subject: Re: bug#36597: 27.0.50; rehash hash tables eagerly in pdumper References: <74235afc-7043-1da7-7c71-07f0ca23b9fd@cs.ucla.edu> <83r26mv53z.fsf@gnu.org> <87ft8vbow1.fsf@gnus.org> <87v9hq4ppp.fsf@gnus.org> <83k0y544lf.fsf@gnu.org> <835z9pp16x.fsf@gnu.org> <8525b631-b24e-ce89-6314-741449ca8403@cs.ucla.edu> X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 36597-done Cc: larsi@gnus.org, 36597-done@debbugs.gnu.org, pipcet@gmail.com X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) > Cc: larsi@gnus.org, 36597-done@debbugs.gnu.org > From: Paul Eggert > Date: Tue, 11 Aug 2020 10:31:24 -0700 > > The compilation issue was due to pdumper enabling -Wconversion, which causes > more trouble than it cures (but that is a different topic). I worked around the > glitch by installing the attached further patch, which should also help explain > the motivation for make_nil_vector. Is it really worth it? The code is now a kind of puzzle (what doe those ALLOW/DISALLOW_IMPLICIT_CONVERSION macros do?), and Fmake_vector is a very thin wrapper around the C function it calls. So I think this change is for the worse, sorry. From debbugs-submit-bounces@debbugs.gnu.org Tue Aug 11 14:36:11 2020 Received: (at 36597) by debbugs.gnu.org; 11 Aug 2020 18:36:11 +0000 Received: from localhost ([127.0.0.1]:41675 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5Z87-00044r-1J for submit@debbugs.gnu.org; Tue, 11 Aug 2020 14:36:11 -0400 Received: from eggs.gnu.org ([209.51.188.92]:58948) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5Z85-00044g-Hn for 36597@debbugs.gnu.org; Tue, 11 Aug 2020 14:36:10 -0400 Received: from fencepost.gnu.org ([2001:470:142:3::e]:47230) by eggs.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1k5Z80-0007jf-2x; Tue, 11 Aug 2020 14:36:04 -0400 Received: from [176.228.60.248] (port=3825 helo=home-c4e4a596f7) by fencepost.gnu.org with esmtpsa (TLS1.2:RSA_AES_256_CBC_SHA1:256) (Exim 4.82) (envelope-from ) id 1k5Z7z-0007Ob-8g; Tue, 11 Aug 2020 14:36:03 -0400 Date: Tue, 11 Aug 2020 21:35:52 +0300 Message-Id: <83zh71ni7r.fsf@gnu.org> From: Eli Zaretskii To: Paul Eggert In-Reply-To: <63d00359-f7cc-5564-ecf0-d374dea979ff@cs.ucla.edu> (message from Paul Eggert on Tue, 11 Aug 2020 11:11:20 -0700) Subject: Re: bug#36597: 27.0.50; rehash hash tables eagerly in pdumper References: <74235afc-7043-1da7-7c71-07f0ca23b9fd@cs.ucla.edu> <83r26mv53z.fsf@gnu.org> <87ft8vbow1.fsf@gnus.org> <87v9hq4ppp.fsf@gnus.org> <83k0y544lf.fsf@gnu.org> <8bf60d70-6b0d-0e07-fef9-9baad9d7749c@cs.ucla.edu> <837du5p17p.fsf@gnu.org> <63d00359-f7cc-5564-ecf0-d374dea979ff@cs.ucla.edu> X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 36597 Cc: larsi@gnus.org, 36597@debbugs.gnu.org, pipcet@gmail.com X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) > Cc: larsi@gnus.org, pipcet@gmail.com, 36597@debbugs.gnu.org > From: Paul Eggert > Date: Tue, 11 Aug 2020 11:11:20 -0700 > > Ah, it's because Emacs uses C99 inttypes.h macros like PRIdPTR without also > using the Gnulib inttypes module which implements these macros on platforms like > MinGW where the macros don't work. This problem occurs elsewhere in Emacs in a > couple of places, we just never noticed it. I installed the attached patch, > which I hope fixes the glitch. It doesn't, because we avoid the Gnulib inttypes module on MinGW. I don't understand why it's needed; there's nothing wrong with MinGW's inttypes.h header. From debbugs-submit-bounces@debbugs.gnu.org Tue Aug 11 14:55:29 2020 Received: (at 36597) by debbugs.gnu.org; 11 Aug 2020 18:55:29 +0000 Received: from localhost ([127.0.0.1]:41692 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5ZQn-0004Wx-JY for submit@debbugs.gnu.org; Tue, 11 Aug 2020 14:55:29 -0400 Received: from eggs.gnu.org ([209.51.188.92]:34778) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5ZQi-0004Wg-TP for 36597@debbugs.gnu.org; Tue, 11 Aug 2020 14:55:28 -0400 Received: from fencepost.gnu.org ([2001:470:142:3::e]:47489) by eggs.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1k5ZQc-0001Xo-P3; Tue, 11 Aug 2020 14:55:18 -0400 Received: from [176.228.60.248] (port=1213 helo=home-c4e4a596f7) by fencepost.gnu.org with esmtpsa (TLS1.2:RSA_AES_256_CBC_SHA1:256) (Exim 4.82) (envelope-from ) id 1k5ZQa-0000GX-6w; Tue, 11 Aug 2020 14:55:16 -0400 Date: Tue, 11 Aug 2020 21:55:03 +0300 Message-Id: <83y2mlnhbs.fsf@gnu.org> From: Eli Zaretskii To: eggert@cs.ucla.edu In-Reply-To: <83zh71ni7r.fsf@gnu.org> (message from Eli Zaretskii on Tue, 11 Aug 2020 21:35:52 +0300) Subject: Re: bug#36597: 27.0.50; rehash hash tables eagerly in pdumper References: <74235afc-7043-1da7-7c71-07f0ca23b9fd@cs.ucla.edu> <83r26mv53z.fsf@gnu.org> <87ft8vbow1.fsf@gnus.org> <87v9hq4ppp.fsf@gnus.org> <83k0y544lf.fsf@gnu.org> <8bf60d70-6b0d-0e07-fef9-9baad9d7749c@cs.ucla.edu> <837du5p17p.fsf@gnu.org> <63d00359-f7cc-5564-ecf0-d374dea979ff@cs.ucla.edu> <83zh71ni7r.fsf@gnu.org> X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 36597 Cc: larsi@gnus.org, 36597@debbugs.gnu.org, pipcet@gmail.com X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) > Date: Tue, 11 Aug 2020 21:35:52 +0300 > From: Eli Zaretskii > Cc: larsi@gnus.org, 36597@debbugs.gnu.org, pipcet@gmail.com > > I don't understand why it's needed; there's nothing wrong with MinGW's > inttypes.h header. And, btw, Gnulib's inttypes.h does this: #if !defined PRIdPTR # ifdef INTPTR_MAX # define PRIdPTR @PRIPTR_PREFIX@ "d" # endif #endif But since MinGW's inttypes.h does provide PRIdPTR, this will do nothing, so it cannot possibly help here. Am I missing something? From debbugs-submit-bounces@debbugs.gnu.org Tue Aug 11 19:43:27 2020 Received: (at 36597) by debbugs.gnu.org; 11 Aug 2020 23:43:27 +0000 Received: from localhost ([127.0.0.1]:42015 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5dvS-0005Ij-RG for submit@debbugs.gnu.org; Tue, 11 Aug 2020 19:43:27 -0400 Received: from zimbra.cs.ucla.edu ([131.179.128.68]:39760) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5dvQ-0005IU-HO for 36597@debbugs.gnu.org; Tue, 11 Aug 2020 19:43:25 -0400 Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id 00CB11600ED; Tue, 11 Aug 2020 16:43:19 -0700 (PDT) Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10032) with ESMTP id gyiGSdtfP6LZ; Tue, 11 Aug 2020 16:43:18 -0700 (PDT) Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id 2167C1600FC; Tue, 11 Aug 2020 16:43:18 -0700 (PDT) X-Virus-Scanned: amavisd-new at zimbra.cs.ucla.edu Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10026) with ESMTP id VGiQm_ExxJjf; Tue, 11 Aug 2020 16:43:18 -0700 (PDT) Received: from [192.168.1.9] (cpe-75-82-69-226.socal.res.rr.com [75.82.69.226]) by zimbra.cs.ucla.edu (Postfix) with ESMTPSA id E47661600ED; Tue, 11 Aug 2020 16:43:17 -0700 (PDT) Subject: Re: bug#36597: 27.0.50; rehash hash tables eagerly in pdumper To: Eli Zaretskii References: <74235afc-7043-1da7-7c71-07f0ca23b9fd@cs.ucla.edu> <83r26mv53z.fsf@gnu.org> <87ft8vbow1.fsf@gnus.org> <87v9hq4ppp.fsf@gnus.org> <83k0y544lf.fsf@gnu.org> <8bf60d70-6b0d-0e07-fef9-9baad9d7749c@cs.ucla.edu> <837du5p17p.fsf@gnu.org> <63d00359-f7cc-5564-ecf0-d374dea979ff@cs.ucla.edu> <83zh71ni7r.fsf@gnu.org> From: Paul Eggert Autocrypt: addr=eggert@cs.ucla.edu; prefer-encrypt=mutual; keydata= LS0tLS1CRUdJTiBQR1AgUFVCTElDIEtFWSBCTE9DSy0tLS0tCgptUUlOQkV5QWNtUUJFQURB QXlIMnhvVHU3cHBHNUQzYThGTVpFb243NGRDdmM0K3ExWEEySjJ0QnkycHdhVHFmCmhweHhk R0E5Smo1MFVKM1BENGJTVUVnTjh0TFowc2FuNDdsNVhUQUZMaTI0NTZjaVNsNW04c0thSGxH ZHQ5WG0KQUF0bVhxZVpWSVlYL1VGUzk2ZkR6ZjR4aEVtbS95N0xiWUVQUWRVZHh1NDd4QTVL aFRZcDVibHRGM1dZRHoxWQpnZDdneDA3QXV3cDdpdzdlTnZub0RUQWxLQWw4S1lEWnpiRE5D UUdFYnBZM2VmWkl2UGRlSStGV1FONFcra2doCnkrUDZhdTZQcklJaFlyYWV1YTdYRGRiMkxT MWVuM1NzbUUzUWpxZlJxSS9BMnVlOEpNd3N2WGUvV0szOEV6czYKeDc0aVRhcUkzQUZINmls QWhEcXBNbmQvbXNTRVNORnQ3NkRpTzFaS1FNcjlhbVZQa25qZlBtSklTcWRoZ0IxRApsRWR3 MzRzUk9mNlY4bVp3MHhmcVQ2UEtFNDZMY0ZlZnpzMGtiZzRHT1JmOHZqRzJTZjF0azVlVThN Qml5Ti9iClowM2JLTmpOWU1wT0REUVF3dVA4NGtZTGtYMndCeHhNQWhCeHdiRFZadWR6eERa SjFDMlZYdWpDT0pWeHEya2wKakJNOUVUWXVVR3FkNzVBVzJMWHJMdzYrTXVJc0hGQVlBZ1Jy NytLY3dEZ0JBZndoUEJZWDM0blNTaUhsbUxDKwpLYUhMZUNMRjVaSTJ2S20zSEVlQ1R0bE9n N3haRU9OZ3d6TCtmZEtvK0Q2U29DOFJSeEpLczhhM3NWZkk0dDZDCm5yUXp2SmJCbjZneGRn Q3U1aTI5SjFRQ1lyQ1l2cWwyVXlGUEFLK2RvOTkvMWpPWFQ0bTI4MzZqMXdBUkFRQUIKdENC UVlYVnNJRVZuWjJWeWRDQThaV2RuWlhKMFFHTnpMblZqYkdFdVpXUjFQb2tDUGdRVEFRSUFL QVVDVElCeQpaQUliQXdVSkVzd0RBQVlMQ1FnSEF3SUdGUWdDQ1FvTEJCWUNBd0VDSGdFQ0Y0 QUFDZ2tRN1pmcERtS3FmalJSCkd3LytJajAzZGhZZllsL2dYVlJpdXpWMWdHcmJIayt0bmZy SS9DN2ZBZW9GelE1dFZnVmluU2hhUGtabzBIVFAKZjE4eDZJREVkQWlPOE1xbzF5cDBDdEht ekdNQ0o1MG80R3JnZmpscjZnLyt2dEVPS2JobGVzek4yWHBKdnB3TQoyUWdHdm4vbGFUTFV1 OFBIOWFSV1RzN3FKSlpLS0tBYjRzeFljOTJGZWhQdTZGT0QwZERpeWhsREFxNGxPVjJtCmRC cHpRYmlvam9aelFMTVF3anBnQ1RLMjU3MmVLOUVPRVF5U1VUaFhyU0l6NkFTZW5wNE5ZVEZI czl0dUpRdlgKazlnWkRkUFNsM2JwKzQ3ZEd4bHhFV0xwQklNN3pJT053NGtzNGF6Z1Q4bnZE WnhBNUlaSHR2cUJsSkxCT2JZWQowTGU2MVdwMHkzVGxCRGgycWRLOGVZTDQyNlc0c2NFTVN1 aWc1Z2I4T0F0UWlCVzZrMnNHVXh4ZWl2OG92V3U4CllBWmdLSmZ1b1dJK3VSbk1FZGRydVk4 SnNvTTU0S2FLdlppa2tLczJiZzFuZHRMVnpIcEo2cUZaQzdRVmplSFUKaDYvQm1ndmRqV1Ba WUZUdE4rS0E5Q1dYM0dRS0tnTjN1dTk4OHl6bkQ3TG5COThUNEVVSDFIQS9HbmZCcU1WMQpn cHpUdlBjNHFWUWluQ21Ja0VGcDgzemwrRzVmQ2pKSjNXN2l2ekNuWW80S2hLTHBGVW05N29r VEtSMkxXM3haCnpFVzRjTFNXTzM4N01USzNDekRPeDVxZTZzNGE5MVp1Wk0vai9UUWRUTERh cU5uODNrQTRIcTQ4VUhYWXhjSWgKK05kOGsvM3c2bEZ1b0swd3JPRml5d2pMeCswdXI1am1t YmVjQkdIYzF4ZGhBRkc1QWcwRVRJQnlaQUVRQUthRgo2NzhUOXd5SDR3alRyVjFQejNjREVv U25WLzBaVXJPVDM3cDFkY0d5ai9JWHExeDY3MEhSVmFoQW1rMHNacFljCjI1UEY5RDVHUFlI RldsTmp1UFU5NnJEbmRYQjNoZWRtQlJoTGRDNGJBWGpJNERWK2JtZFZlK3EvSU1ubFpSYVYK bG05RWlNQ1ZBUjZ3MTNzUmV1N3FYa1c5cjNSd1kyQXpYc2twL3RBZTRCUktyMVptYnZpMm5i blE2ZXBFQzQycgpSYngwQjFFaGpiSVFaNUpIR2syNGlQVDdMZEJnbk5tb3M1d1lqendObGtN UUQ1VDBZZHpoazdKK1V4d0E1bTQ2Cm1PaFJEQzJyRlYvQTBnbTVUTHk4RFhqdi9Fc2M0Z1lu WWFpNlNRcW5VRVZoNUx1VjhZQ0pCbmlqcytUaXc3MXgKMWljbW42eEdJNDVFdWdKT2dlYyty THlwWWdwVnA0eDBISTVUODhxQlJZQ2t4SDNLZzhRbytFV05BOUE0TFJROQpEWDhuam9uYTBn ZjBzMDN0b2NLOGtCTjY2VW9xcVB0SEJuYzRlTWdCeW1DZmxLMTJlS2ZkMllZeG55ZzljWmF6 CldBNVZzbHZUeHBtNzZoYmc1b2lBRUgvVmcvOE14SHlBblBoZnJnd3lQcm1KRWNWQmFmZHNw Sm5ZUXhCWU5jbzIKTEZQSWhsT3ZXaDhyNGF0K3MrTTNMYjI2b1VUY3psZ2RXMVNmM1NEQTc3 Qk1SbkYwRlF5RSs3QXpWNzlNQk40eQpraXFhZXpReHRhRjFGeS90dmtoZmZTbzh1K2R3RzBF Z0poK3RlMzhnVGNJU1ZyMEdJUHBsTHo2WWhqcmJIclBSCkYxQ041VXVMOURCR2p4dU4zNVJM TlZFZnRhNlJVRmxSNk5jdFRqdnJBQkVCQUFHSkFpVUVHQUVDQUE4RkFreUEKY21RQ0d3d0ZD UkxNQXdBQUNna1E3WmZwRG1LcWZqU3JIQS8rS3pBS3ZUeFJoQTlNV05MeEl5SjdTNXVKMTZn cwpUM29DalpyQktHRWhLTU9HWDRPMEdBNlZPRXJ5TzdRUkNDWWFoM294U0czOElBbk5laXdK WGdVOUJ6a2s4NVVHCmJQRWQ3SEdGL1ZTZUhDUXdXb3U2anFVRFRTRHZuOVloTlRkRzBLWFBN NzRhQyt4cjJab3cxTzJtaFhpaGdXS0QKMER3KzBMWVBuVU9zUTBLT0Z4SFhYWUhtUnJTMU9a UFU1OUJMdmMrVFJoSWhhZlNIS0x3YlhLKzZja2t4Qng2aAo4ejVjY3BHMFFzNGJGaGRGWW5G ckVpZURMb0dtbkUyWUxoZFY2c3dKOVZOQ1M2cExpRW9oVDNmbTdhWG0xNXRaCk9JeXpNWmhI UlNBUGJsWHhRMFpTV2pxOG9ScmNZTkZ4YzRXMVVScEFrQkNPWUpvWHZRZkQ1TDNscUFsOFRD cUQKVXpZeGhIL3RKaGJEZEhycUhINzY3amFEYVRCMStUYWxwLzJBTUt3Y1hOT2Rpa2xHeGJt SFZHNllHbDZnOExyYgpzdTlOWkVJNHlMbEh6dWlrdGhKV2d6KzN2WmhWR3lObHQrSE5Jb0Y2 Q2pETDJvbXU1Y0VxNFJESE00NFFxUGs2Cmw3TzBwVXZOMW1UNEIrUzFiMDhSS3BxbS9mZjAx NUUzN0hOVi9waUl2Smx4R0FZejhQU2Z1R0NCMXRoTVlxbG0KZ2RoZDkvQmFiR0ZiR0dZSEE2 VTQvVDV6cVUrZjZ4SHkxU3NBUVoxTVNLbEx3ZWtCSVQrNC9jTFJHcUNIam5WMApxNUgvVDZh N3Q1bVBrYnpTck9MU280cHVqK0lUb05qWXlZSURCV3pobEExOWF2T2ErcnZVam1IdEQzc0ZO N2NYCld0a0dvaThidU5jYnk0VT0KPUFMNm8KLS0tLS1FTkQgUEdQIFBVQkxJQyBLRVkgQkxP Q0stLS0tLQo= Organization: UCLA Computer Science Department Message-ID: <80399aee-a2ef-5d24-a19e-5ea615190cf9@cs.ucla.edu> Date: Tue, 11 Aug 2020 16:43:16 -0700 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.10.0 MIME-Version: 1.0 In-Reply-To: <83zh71ni7r.fsf@gnu.org> Content-Type: multipart/mixed; boundary="------------E4C7ADFDC9C38D3F93513070" Content-Language: en-US X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 36597 Cc: larsi@gnus.org, 36597@debbugs.gnu.org, pipcet@gmail.com X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) This is a multi-part message in MIME format. --------------E4C7ADFDC9C38D3F93513070 Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 7bit On 8/11/20 11:35 AM, Eli Zaretskii wrote: > It doesn't, because we avoid the Gnulib inttypes module on MinGW. In that case perhaps I should revert the change that added the Gnulib inttypes module, as MS-Windows is the only currently-active platform with PRIdPTR etc. problems that I've heard of. > I don't understand why it's needed; there's nothing wrong with MinGW's > inttypes.h header. I don't know what the problems with MS-Windows are or were. Perhaps they're fixed on all development environments we know about. That would suggest reverting the inttypes change too. Does the attached simplification pacify GCC on MinGW? If so, that could be combined with reverting the inttypes change. Does the following standalone program compile OK with 'gcc -Wall' on MinGW? If so, why does the same thing not work when compiling Emacs? The error message you quoted in Bug#36597#67 suggests that PRIdPTR is "d" whereas intptr_t is 'long' which means the following program should run afoul of MinGW. #include #include char buf[1000]; intptr_t ip; int main (void) { return sprintf (buf, "%"PRIdPTR, ip); } --------------E4C7ADFDC9C38D3F93513070 Content-Type: text/x-patch; charset=UTF-8; name="pdumper.diff" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename="pdumper.diff" diff --git a/src/pdumper.c b/src/pdumper.c index 7708bc892f..0bc48aedbe 100644 --- a/src/pdumper.c +++ b/src/pdumper.c @@ -143,8 +143,6 @@ #define DUMP_OFF_MIN INT_LEAST32_MIN #define DUMP_OFF_MAX INT_LEAST32_MAX #define PRIdDUMP_OFF PRIdLEAST32 -enum { EMACS_INT_XDIGITS = (EMACS_INT_WIDTH + 3) / 4 }; - static void ATTRIBUTE_FORMAT_PRINTF (1, 2) dump_trace (const char *fmt, ...) { @@ -1008,9 +1006,7 @@ dump_queue_enqueue (struct dump_queue *dump_queue, if (NILP (weights)) { /* Object is new. */ - EMACS_UINT uobj = XLI (object); - dump_trace ("new object %0*"pI"x weight=%d\n", EMACS_INT_XDIGITS, uobj, - weight.value); + dump_trace ("new object %p weight=%d\n", XLP (object), weight.value); if (weight.value == WEIGHT_NONE.value) { @@ -1306,10 +1302,9 @@ dump_queue_dequeue (struct dump_queue *dump_queue, dump_off basis) else emacs_abort (); - EMACS_UINT uresult = XLI (result); - dump_trace (" result score=%f src=%s object=%0*"pI"x\n", + dump_trace (" result score=%f src=%s object=%p\n", best < 0 ? -1.0 : (double) candidates[best].score, - src, EMACS_INT_XDIGITS, uresult); + src, XLP (result)); { Lisp_Object weights = Fgethash (result, dump_queue->link_weights, Qnil); --------------E4C7ADFDC9C38D3F93513070-- From debbugs-submit-bounces@debbugs.gnu.org Wed Aug 12 10:10:53 2020 Received: (at 36597) by debbugs.gnu.org; 12 Aug 2020 14:10:53 +0000 Received: from localhost ([127.0.0.1]:45055 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5rSv-00009w-6l for submit@debbugs.gnu.org; Wed, 12 Aug 2020 10:10:53 -0400 Received: from eggs.gnu.org ([209.51.188.92]:50330) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5rSs-00009i-Oc for 36597@debbugs.gnu.org; Wed, 12 Aug 2020 10:10:51 -0400 Received: from fencepost.gnu.org ([2001:470:142:3::e]:34507) by eggs.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1k5rSn-0000u1-Fl; Wed, 12 Aug 2020 10:10:45 -0400 Received: from [176.228.60.248] (port=4034 helo=home-c4e4a596f7) by fencepost.gnu.org with esmtpsa (TLS1.2:RSA_AES_256_CBC_SHA1:256) (Exim 4.82) (envelope-from ) id 1k5rSm-0004RJ-4N; Wed, 12 Aug 2020 10:10:44 -0400 Date: Wed, 12 Aug 2020 17:10:34 +0300 Message-Id: <83pn7wneed.fsf@gnu.org> From: Eli Zaretskii To: Paul Eggert In-Reply-To: <80399aee-a2ef-5d24-a19e-5ea615190cf9@cs.ucla.edu> (message from Paul Eggert on Tue, 11 Aug 2020 16:43:16 -0700) Subject: Re: bug#36597: 27.0.50; rehash hash tables eagerly in pdumper References: <74235afc-7043-1da7-7c71-07f0ca23b9fd@cs.ucla.edu> <83r26mv53z.fsf@gnu.org> <87ft8vbow1.fsf@gnus.org> <87v9hq4ppp.fsf@gnus.org> <83k0y544lf.fsf@gnu.org> <8bf60d70-6b0d-0e07-fef9-9baad9d7749c@cs.ucla.edu> <837du5p17p.fsf@gnu.org> <63d00359-f7cc-5564-ecf0-d374dea979ff@cs.ucla.edu> <83zh71ni7r.fsf@gnu.org> <80399aee-a2ef-5d24-a19e-5ea615190cf9@cs.ucla.edu> X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 36597 Cc: larsi@gnus.org, 36597@debbugs.gnu.org, pipcet@gmail.com X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) > Cc: larsi@gnus.org, pipcet@gmail.com, 36597@debbugs.gnu.org > From: Paul Eggert > Date: Tue, 11 Aug 2020 16:43:16 -0700 > > [1:text/plain Hide] > > On 8/11/20 11:35 AM, Eli Zaretskii wrote: > > It doesn't, because we avoid the Gnulib inttypes module on MinGW. > > In that case perhaps I should revert the change that added the Gnulib inttypes > module, as MS-Windows is the only currently-active platform with PRIdPTR etc. > problems that I've heard of. If that module is in our repository only because of MS-Windows, then it indeed isn't needed. > > I don't understand why it's needed; there's nothing wrong with MinGW's > > inttypes.h header. > > I don't know what the problems with MS-Windows are or were. Perhaps they're > fixed on all development environments we know about. That would suggest > reverting the inttypes change too. I see no problems in MinGW headers with PRIdPTR nor with intptr_t. > Does the attached simplification pacify GCC on MinGW? If so, that could be > combined with reverting the inttypes change. The warnings disappeared because you installed a change that no longer uses the GCC warning options which triggered them. So I'm unsure how you'd like me to test the patch, please elaborate. > Does the following standalone program compile OK with 'gcc -Wall' on MinGW? If > so, why does the same thing not work when compiling Emacs? The error message you > quoted in Bug#36597#67 suggests that PRIdPTR is "d" whereas intptr_t is 'long' > which means the following program should run afoul of MinGW. The problem is not with MinGW's definition of intptr_t: it is typedef'ed as 'int' in 32-bit builds in the MinGW headers. The problem is not with intptr_t, it's with its Gnulib equivalent: pdumper.c:1229:6: warning: format '%d' expects argument of type 'int', but argument 4 has type 'gl_intptr_t' {aka 'long int'} [-Wformat=] It complains about gl_intptr_t, not intptr_t. That's because Gnulib's stdint.h does this: # ifdef _WIN64 typedef long long int gl_intptr_t; typedef unsigned long long int gl_uintptr_t; # else typedef long int gl_intptr_t; typedef unsigned long int gl_uintptr_t; # endif # define intptr_t gl_intptr_t # define uintptr_t gl_uintptr_t I don't understand why it uses 'long int' 32-bit platforms, it looks gratuitous, especially since MinGW itself uses just 'int'. (Another question is why Gnulib thinks it needs to redefine intptr_t, but if the redefinition was correct, this would not be especially important.) From debbugs-submit-bounces@debbugs.gnu.org Wed Aug 12 10:46:36 2020 Received: (at 36597) by debbugs.gnu.org; 12 Aug 2020 14:46:36 +0000 Received: from localhost ([127.0.0.1]:45143 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5s1U-000172-EX for submit@debbugs.gnu.org; Wed, 12 Aug 2020 10:46:36 -0400 Received: from eggs.gnu.org ([209.51.188.92]:33010) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5s1R-00016o-Om for 36597@debbugs.gnu.org; Wed, 12 Aug 2020 10:46:35 -0400 Received: from fencepost.gnu.org ([2001:470:142:3::e]:35227) by eggs.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1k5s1L-0006G5-Kf; Wed, 12 Aug 2020 10:46:27 -0400 Received: from [176.228.60.248] (port=2277 helo=home-c4e4a596f7) by fencepost.gnu.org with esmtpsa (TLS1.2:RSA_AES_256_CBC_SHA1:256) (Exim 4.82) (envelope-from ) id 1k5s1L-0000oY-4N; Wed, 12 Aug 2020 10:46:27 -0400 Date: Wed, 12 Aug 2020 17:46:17 +0300 Message-Id: <83ft8rorba.fsf@gnu.org> From: Eli Zaretskii To: eggert@cs.ucla.edu In-Reply-To: <83pn7wneed.fsf@gnu.org> (message from Eli Zaretskii on Wed, 12 Aug 2020 17:10:34 +0300) Subject: Re: bug#36597: 27.0.50; rehash hash tables eagerly in pdumper References: <74235afc-7043-1da7-7c71-07f0ca23b9fd@cs.ucla.edu> <83r26mv53z.fsf@gnu.org> <87ft8vbow1.fsf@gnus.org> <87v9hq4ppp.fsf@gnus.org> <83k0y544lf.fsf@gnu.org> <8bf60d70-6b0d-0e07-fef9-9baad9d7749c@cs.ucla.edu> <837du5p17p.fsf@gnu.org> <63d00359-f7cc-5564-ecf0-d374dea979ff@cs.ucla.edu> <83zh71ni7r.fsf@gnu.org> <80399aee-a2ef-5d24-a19e-5ea615190cf9@cs.ucla.edu> <83pn7wneed.fsf@gnu.org> X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 36597 Cc: larsi@gnus.org, 36597@debbugs.gnu.org, pipcet@gmail.com X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) > Date: Wed, 12 Aug 2020 17:10:34 +0300 > From: Eli Zaretskii > Cc: larsi@gnus.org, 36597@debbugs.gnu.org, pipcet@gmail.com > > > Does the attached simplification pacify GCC on MinGW? If so, that could be > > combined with reverting the inttypes change. > > The warnings disappeared because you installed a change that no > longer uses the GCC warning options which triggered them. So I'm > unsure how you'd like me to test the patch, please elaborate. Sorry, I wasn't paying attention: the warnings did not disappear. I've now tried the proposed changes, but they don't affect the code which is cited in the warning messages. The offending code is here: dump_trace (("dump_queue_dequeue basis=%"PRIdDUMP_OFF" fancy=%"PRIdPTR " zero=%"PRIdPTR" normal=%"PRIdPTR" strong=%"PRIdPTR" hash=%td\n"), basis, dump_tailq_length (&dump_queue->fancy_weight_objects), dump_tailq_length (&dump_queue->zero_weight_objects), dump_tailq_length (&dump_queue->one_weight_normal_objects), dump_tailq_length (&dump_queue->one_weight_strong_objects), XHASH_TABLE (dump_queue->link_weights)->count); And it triggers warnings because intptr_t is redefined to be 'long int', whereas PRIdPTR is "d". Here are the warnings again: pdumper.c: In function 'dump_queue_dequeue': pdumper.c:1214:6: warning: format '%d' expects argument of type 'int', but argument 3 has type 'gl_intptr_t' {aka 'long int'} [-Wformat=] 1214 | (("dump_queue_dequeue basis=%"PRIdDUMP_OFF" fancy=%"PRIdPTR | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 1215 | " zero=%"PRIdPTR" normal=%"PRIdPTR" strong=%"PRIdPTR" hash=%td\n"), | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 1216 | basis, 1217 | dump_tailq_length (&dump_queue->fancy_weight_objects), | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | | | gl_intptr_t {aka long int} pdumper.c:1214:6: warning: format '%d' expects argument of type 'int', but argument 4 has type 'gl_intptr_t' {aka 'long int'} [-Wformat=] pdumper.c:1214:6: warning: format '%d' expects argument of type 'int', but argument 5 has type 'gl_intptr_t' {aka 'long int'} [-Wformat=] pdumper.c:1214:6: warning: format '%d' expects argument of type 'int', but argument 6 has type 'gl_intptr_t' {aka 'long int'} [-Wformat=] From debbugs-submit-bounces@debbugs.gnu.org Wed Aug 12 15:11:20 2020 Received: (at 36597) by debbugs.gnu.org; 12 Aug 2020 19:11:20 +0000 Received: from localhost ([127.0.0.1]:45614 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5w9g-0008Re-0n for submit@debbugs.gnu.org; Wed, 12 Aug 2020 15:11:20 -0400 Received: from zimbra.cs.ucla.edu ([131.179.128.68]:57060) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5w9c-0008RQ-Dp for 36597@debbugs.gnu.org; Wed, 12 Aug 2020 15:11:18 -0400 Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id 029091600DA; Wed, 12 Aug 2020 12:11:11 -0700 (PDT) Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10032) with ESMTP id lrzeFcjhmJVX; Wed, 12 Aug 2020 12:11:10 -0700 (PDT) Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id 09DB21600F9; Wed, 12 Aug 2020 12:11:10 -0700 (PDT) X-Virus-Scanned: amavisd-new at zimbra.cs.ucla.edu Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10026) with ESMTP id DbBKt0_JucHQ; Wed, 12 Aug 2020 12:11:09 -0700 (PDT) Received: from [192.168.1.9] (cpe-75-82-69-226.socal.res.rr.com [75.82.69.226]) by zimbra.cs.ucla.edu (Postfix) with ESMTPSA id D042A1600DA; Wed, 12 Aug 2020 12:11:09 -0700 (PDT) Subject: Re: bug#36597: 27.0.50; rehash hash tables eagerly in pdumper To: Eli Zaretskii References: <83r26mv53z.fsf@gnu.org> <87ft8vbow1.fsf@gnus.org> <87v9hq4ppp.fsf@gnus.org> <83k0y544lf.fsf@gnu.org> <8bf60d70-6b0d-0e07-fef9-9baad9d7749c@cs.ucla.edu> <837du5p17p.fsf@gnu.org> <63d00359-f7cc-5564-ecf0-d374dea979ff@cs.ucla.edu> <83zh71ni7r.fsf@gnu.org> <80399aee-a2ef-5d24-a19e-5ea615190cf9@cs.ucla.edu> <83pn7wneed.fsf@gnu.org> From: Paul Eggert Autocrypt: addr=eggert@cs.ucla.edu; prefer-encrypt=mutual; keydata= LS0tLS1CRUdJTiBQR1AgUFVCTElDIEtFWSBCTE9DSy0tLS0tCgptUUlOQkV5QWNtUUJFQURB QXlIMnhvVHU3cHBHNUQzYThGTVpFb243NGRDdmM0K3ExWEEySjJ0QnkycHdhVHFmCmhweHhk R0E5Smo1MFVKM1BENGJTVUVnTjh0TFowc2FuNDdsNVhUQUZMaTI0NTZjaVNsNW04c0thSGxH ZHQ5WG0KQUF0bVhxZVpWSVlYL1VGUzk2ZkR6ZjR4aEVtbS95N0xiWUVQUWRVZHh1NDd4QTVL aFRZcDVibHRGM1dZRHoxWQpnZDdneDA3QXV3cDdpdzdlTnZub0RUQWxLQWw4S1lEWnpiRE5D UUdFYnBZM2VmWkl2UGRlSStGV1FONFcra2doCnkrUDZhdTZQcklJaFlyYWV1YTdYRGRiMkxT MWVuM1NzbUUzUWpxZlJxSS9BMnVlOEpNd3N2WGUvV0szOEV6czYKeDc0aVRhcUkzQUZINmls QWhEcXBNbmQvbXNTRVNORnQ3NkRpTzFaS1FNcjlhbVZQa25qZlBtSklTcWRoZ0IxRApsRWR3 MzRzUk9mNlY4bVp3MHhmcVQ2UEtFNDZMY0ZlZnpzMGtiZzRHT1JmOHZqRzJTZjF0azVlVThN Qml5Ti9iClowM2JLTmpOWU1wT0REUVF3dVA4NGtZTGtYMndCeHhNQWhCeHdiRFZadWR6eERa SjFDMlZYdWpDT0pWeHEya2wKakJNOUVUWXVVR3FkNzVBVzJMWHJMdzYrTXVJc0hGQVlBZ1Jy NytLY3dEZ0JBZndoUEJZWDM0blNTaUhsbUxDKwpLYUhMZUNMRjVaSTJ2S20zSEVlQ1R0bE9n N3haRU9OZ3d6TCtmZEtvK0Q2U29DOFJSeEpLczhhM3NWZkk0dDZDCm5yUXp2SmJCbjZneGRn Q3U1aTI5SjFRQ1lyQ1l2cWwyVXlGUEFLK2RvOTkvMWpPWFQ0bTI4MzZqMXdBUkFRQUIKdENC UVlYVnNJRVZuWjJWeWRDQThaV2RuWlhKMFFHTnpMblZqYkdFdVpXUjFQb2tDUGdRVEFRSUFL QVVDVElCeQpaQUliQXdVSkVzd0RBQVlMQ1FnSEF3SUdGUWdDQ1FvTEJCWUNBd0VDSGdFQ0Y0 QUFDZ2tRN1pmcERtS3FmalJSCkd3LytJajAzZGhZZllsL2dYVlJpdXpWMWdHcmJIayt0bmZy SS9DN2ZBZW9GelE1dFZnVmluU2hhUGtabzBIVFAKZjE4eDZJREVkQWlPOE1xbzF5cDBDdEht ekdNQ0o1MG80R3JnZmpscjZnLyt2dEVPS2JobGVzek4yWHBKdnB3TQoyUWdHdm4vbGFUTFV1 OFBIOWFSV1RzN3FKSlpLS0tBYjRzeFljOTJGZWhQdTZGT0QwZERpeWhsREFxNGxPVjJtCmRC cHpRYmlvam9aelFMTVF3anBnQ1RLMjU3MmVLOUVPRVF5U1VUaFhyU0l6NkFTZW5wNE5ZVEZI czl0dUpRdlgKazlnWkRkUFNsM2JwKzQ3ZEd4bHhFV0xwQklNN3pJT053NGtzNGF6Z1Q4bnZE WnhBNUlaSHR2cUJsSkxCT2JZWQowTGU2MVdwMHkzVGxCRGgycWRLOGVZTDQyNlc0c2NFTVN1 aWc1Z2I4T0F0UWlCVzZrMnNHVXh4ZWl2OG92V3U4CllBWmdLSmZ1b1dJK3VSbk1FZGRydVk4 SnNvTTU0S2FLdlppa2tLczJiZzFuZHRMVnpIcEo2cUZaQzdRVmplSFUKaDYvQm1ndmRqV1Ba WUZUdE4rS0E5Q1dYM0dRS0tnTjN1dTk4OHl6bkQ3TG5COThUNEVVSDFIQS9HbmZCcU1WMQpn cHpUdlBjNHFWUWluQ21Ja0VGcDgzemwrRzVmQ2pKSjNXN2l2ekNuWW80S2hLTHBGVW05N29r VEtSMkxXM3haCnpFVzRjTFNXTzM4N01USzNDekRPeDVxZTZzNGE5MVp1Wk0vai9UUWRUTERh cU5uODNrQTRIcTQ4VUhYWXhjSWgKK05kOGsvM3c2bEZ1b0swd3JPRml5d2pMeCswdXI1am1t YmVjQkdIYzF4ZGhBRkc1QWcwRVRJQnlaQUVRQUthRgo2NzhUOXd5SDR3alRyVjFQejNjREVv U25WLzBaVXJPVDM3cDFkY0d5ai9JWHExeDY3MEhSVmFoQW1rMHNacFljCjI1UEY5RDVHUFlI RldsTmp1UFU5NnJEbmRYQjNoZWRtQlJoTGRDNGJBWGpJNERWK2JtZFZlK3EvSU1ubFpSYVYK bG05RWlNQ1ZBUjZ3MTNzUmV1N3FYa1c5cjNSd1kyQXpYc2twL3RBZTRCUktyMVptYnZpMm5i blE2ZXBFQzQycgpSYngwQjFFaGpiSVFaNUpIR2syNGlQVDdMZEJnbk5tb3M1d1lqendObGtN UUQ1VDBZZHpoazdKK1V4d0E1bTQ2Cm1PaFJEQzJyRlYvQTBnbTVUTHk4RFhqdi9Fc2M0Z1lu WWFpNlNRcW5VRVZoNUx1VjhZQ0pCbmlqcytUaXc3MXgKMWljbW42eEdJNDVFdWdKT2dlYyty THlwWWdwVnA0eDBISTVUODhxQlJZQ2t4SDNLZzhRbytFV05BOUE0TFJROQpEWDhuam9uYTBn ZjBzMDN0b2NLOGtCTjY2VW9xcVB0SEJuYzRlTWdCeW1DZmxLMTJlS2ZkMllZeG55ZzljWmF6 CldBNVZzbHZUeHBtNzZoYmc1b2lBRUgvVmcvOE14SHlBblBoZnJnd3lQcm1KRWNWQmFmZHNw Sm5ZUXhCWU5jbzIKTEZQSWhsT3ZXaDhyNGF0K3MrTTNMYjI2b1VUY3psZ2RXMVNmM1NEQTc3 Qk1SbkYwRlF5RSs3QXpWNzlNQk40eQpraXFhZXpReHRhRjFGeS90dmtoZmZTbzh1K2R3RzBF Z0poK3RlMzhnVGNJU1ZyMEdJUHBsTHo2WWhqcmJIclBSCkYxQ041VXVMOURCR2p4dU4zNVJM TlZFZnRhNlJVRmxSNk5jdFRqdnJBQkVCQUFHSkFpVUVHQUVDQUE4RkFreUEKY21RQ0d3d0ZD UkxNQXdBQUNna1E3WmZwRG1LcWZqU3JIQS8rS3pBS3ZUeFJoQTlNV05MeEl5SjdTNXVKMTZn cwpUM29DalpyQktHRWhLTU9HWDRPMEdBNlZPRXJ5TzdRUkNDWWFoM294U0czOElBbk5laXdK WGdVOUJ6a2s4NVVHCmJQRWQ3SEdGL1ZTZUhDUXdXb3U2anFVRFRTRHZuOVloTlRkRzBLWFBN NzRhQyt4cjJab3cxTzJtaFhpaGdXS0QKMER3KzBMWVBuVU9zUTBLT0Z4SFhYWUhtUnJTMU9a UFU1OUJMdmMrVFJoSWhhZlNIS0x3YlhLKzZja2t4Qng2aAo4ejVjY3BHMFFzNGJGaGRGWW5G ckVpZURMb0dtbkUyWUxoZFY2c3dKOVZOQ1M2cExpRW9oVDNmbTdhWG0xNXRaCk9JeXpNWmhI UlNBUGJsWHhRMFpTV2pxOG9ScmNZTkZ4YzRXMVVScEFrQkNPWUpvWHZRZkQ1TDNscUFsOFRD cUQKVXpZeGhIL3RKaGJEZEhycUhINzY3amFEYVRCMStUYWxwLzJBTUt3Y1hOT2Rpa2xHeGJt SFZHNllHbDZnOExyYgpzdTlOWkVJNHlMbEh6dWlrdGhKV2d6KzN2WmhWR3lObHQrSE5Jb0Y2 Q2pETDJvbXU1Y0VxNFJESE00NFFxUGs2Cmw3TzBwVXZOMW1UNEIrUzFiMDhSS3BxbS9mZjAx NUUzN0hOVi9waUl2Smx4R0FZejhQU2Z1R0NCMXRoTVlxbG0KZ2RoZDkvQmFiR0ZiR0dZSEE2 VTQvVDV6cVUrZjZ4SHkxU3NBUVoxTVNLbEx3ZWtCSVQrNC9jTFJHcUNIam5WMApxNUgvVDZh N3Q1bVBrYnpTck9MU280cHVqK0lUb05qWXlZSURCV3pobEExOWF2T2ErcnZVam1IdEQzc0ZO N2NYCld0a0dvaThidU5jYnk0VT0KPUFMNm8KLS0tLS1FTkQgUEdQIFBVQkxJQyBLRVkgQkxP Q0stLS0tLQo= Organization: UCLA Computer Science Department Message-ID: <5d686746-a4aa-5864-d3b8-c58621d24279@cs.ucla.edu> Date: Wed, 12 Aug 2020 12:11:09 -0700 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.10.0 MIME-Version: 1.0 In-Reply-To: <83pn7wneed.fsf@gnu.org> Content-Type: text/plain; charset=utf-8; format=flowed Content-Language: en-US Content-Transfer-Encoding: 7bit X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 36597 Cc: larsi@gnus.org, 36597@debbugs.gnu.org, pipcet@gmail.com X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) On 8/12/20 7:10 AM, Eli Zaretskii wrote: > If that module is in our repository only because of MS-Windows, then > it indeed isn't needed. OK, I removed it. > I don't understand why it uses 'long int' 32-bit platforms, it looks > gratuitous, especially since MinGW itself uses just 'int'. (Another > question is why Gnulib thinks it needs to redefine intptr_t, but if > the redefinition was correct, this would not be especially important.) As I recall the idea was to not worry about the plethora of buggy intptr_t implementations at the time, and just substitute Gnulib's own. Nowadays perhaps that decision should be revisited. I looked into the MinGW situation and the problem seems to be that MinGW defined a macro _INTPTR_T_DEFINED that it no longer defines, and Gnulib was keying off that no-longer-present macro. I installed a patch for that in Gnulib here: https://lists.gnu.org/r/bug-gnulib/2020-08/msg00088.html and migrated the patch into Emacs. Hope it fixes things. As an aside, we're spending too much time on pdumper.c code that has no effect because dump_trace never outputs anything. How about if I remove dump_trace and its callers? Although dump_trace may have been useful when the portable dumper got developed, it's just a developer time sink now. From debbugs-submit-bounces@debbugs.gnu.org Wed Aug 12 15:28:49 2020 Received: (at 36597) by debbugs.gnu.org; 12 Aug 2020 19:28:49 +0000 Received: from localhost ([127.0.0.1]:45627 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5wQb-0000QB-1k for submit@debbugs.gnu.org; Wed, 12 Aug 2020 15:28:49 -0400 Received: from eggs.gnu.org ([209.51.188.92]:50530) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5wQX-0000Pp-JP for 36597@debbugs.gnu.org; Wed, 12 Aug 2020 15:28:47 -0400 Received: from fencepost.gnu.org ([2001:470:142:3::e]:40498) by eggs.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1k5wQS-00018q-6f; Wed, 12 Aug 2020 15:28:40 -0400 Received: from [176.228.60.248] (port=4019 helo=home-c4e4a596f7) by fencepost.gnu.org with esmtpsa (TLS1.2:RSA_AES_256_CBC_SHA1:256) (Exim 4.82) (envelope-from ) id 1k5wQR-0004f6-7q; Wed, 12 Aug 2020 15:28:39 -0400 Date: Wed, 12 Aug 2020 22:28:28 +0300 Message-Id: <83wo23mzoj.fsf@gnu.org> From: Eli Zaretskii To: Paul Eggert , Daniel Colascione In-Reply-To: <5d686746-a4aa-5864-d3b8-c58621d24279@cs.ucla.edu> (message from Paul Eggert on Wed, 12 Aug 2020 12:11:09 -0700) Subject: Re: bug#36597: 27.0.50; rehash hash tables eagerly in pdumper References: <83r26mv53z.fsf@gnu.org> <87ft8vbow1.fsf@gnus.org> <87v9hq4ppp.fsf@gnus.org> <83k0y544lf.fsf@gnu.org> <8bf60d70-6b0d-0e07-fef9-9baad9d7749c@cs.ucla.edu> <837du5p17p.fsf@gnu.org> <63d00359-f7cc-5564-ecf0-d374dea979ff@cs.ucla.edu> <83zh71ni7r.fsf@gnu.org> <80399aee-a2ef-5d24-a19e-5ea615190cf9@cs.ucla.edu> <83pn7wneed.fsf@gnu.org> <5d686746-a4aa-5864-d3b8-c58621d24279@cs.ucla.edu> X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 36597 Cc: larsi@gnus.org, 36597@debbugs.gnu.org, pipcet@gmail.com X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) > Cc: larsi@gnus.org, pipcet@gmail.com, 36597@debbugs.gnu.org > From: Paul Eggert > Date: Wed, 12 Aug 2020 12:11:09 -0700 > > I looked into the MinGW situation and the problem seems to be that MinGW defined > a macro _INTPTR_T_DEFINED that it no longer defines, and Gnulib was keying off > that no-longer-present macro. I think _INTPTR_T_DEFINED is still being used, but only by MinGW64. I use mingw.org's MinGW, where that macro was never used. However, both MinGW flavors typedef intptr_t as 'int', not 'long int', on 32-bit platforms. > I installed a patch for that in Gnulib here: > > https://lists.gnu.org/r/bug-gnulib/2020-08/msg00088.html > > and migrated the patch into Emacs. Hope it fixes things. It does here, thanks. I hope someone will be able to make sure MinGW64 builds are not adversely affected (I don't think they should be). > As an aside, we're spending too much time on pdumper.c code that has no effect > because dump_trace never outputs anything. How about if I remove dump_trace and > its callers? Although dump_trace may have been useful when the portable dumper > got developed, it's just a developer time sink now. I have no opinion on this, but I'd like to hear from Daniel (CC'ed) what he thinks. From debbugs-submit-bounces@debbugs.gnu.org Wed Aug 12 16:41:18 2020 Received: (at submit) by debbugs.gnu.org; 12 Aug 2020 20:41:18 +0000 Received: from localhost ([127.0.0.1]:45655 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5xYj-0002DN-Vr for submit@debbugs.gnu.org; Wed, 12 Aug 2020 16:41:18 -0400 Received: from lists.gnu.org ([209.51.188.17]:58596) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1k5xYh-0002DF-Rt for submit@debbugs.gnu.org; Wed, 12 Aug 2020 16:41:16 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:45606) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1k5xYh-0004ps-Jx for bug-gnu-emacs@gnu.org; Wed, 12 Aug 2020 16:41:15 -0400 Received: from static.214.254.202.116.clients.your-server.de ([116.202.254.214]:49710 helo=ciao.gmane.io) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1k5xYg-0000lk-2U for bug-gnu-emacs@gnu.org; Wed, 12 Aug 2020 16:41:15 -0400 Received: from list by ciao.gmane.io with local (Exim 4.92) (envelope-from ) id 1k5xYc-0007Gh-3t for bug-gnu-emacs@gnu.org; Wed, 12 Aug 2020 22:41:10 +0200 X-Injected-Via-Gmane: http://gmane.org/ To: bug-gnu-emacs@gnu.org From: Andy Moreton Subject: Re: bug#36597: 27.0.50; rehash hash tables eagerly in pdumper Date: Wed, 12 Aug 2020 21:41:02 +0100 Message-ID: <86wo238un5.fsf@gmail.com> References: <83r26mv53z.fsf@gnu.org> <87ft8vbow1.fsf@gnus.org> <87v9hq4ppp.fsf@gnus.org> <83k0y544lf.fsf@gnu.org> <8bf60d70-6b0d-0e07-fef9-9baad9d7749c@cs.ucla.edu> <837du5p17p.fsf@gnu.org> <63d00359-f7cc-5564-ecf0-d374dea979ff@cs.ucla.edu> <83zh71ni7r.fsf@gnu.org> <80399aee-a2ef-5d24-a19e-5ea615190cf9@cs.ucla.edu> <83pn7wneed.fsf@gnu.org> <5d686746-a4aa-5864-d3b8-c58621d24279@cs.ucla.edu> <83wo23mzoj.fsf@gnu.org> Mime-Version: 1.0 Content-Type: text/plain User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/28.0.50 (windows-nt) Cancel-Lock: sha1:M+SrVXjBv7Ei0nNUPUKrid4oSdg= Received-SPF: pass client-ip=116.202.254.214; envelope-from=geb-bug-gnu-emacs@m.gmane-mx.org; helo=ciao.gmane.io X-detected-operating-system: by eggs.gnu.org: First seen = 2020/08/12 16:41:10 X-ACL-Warn: Detected OS = Linux 2.2.x-3.x [generic] [fuzzy] X-Spam_score_int: 30 X-Spam_score: 3.0 X-Spam_bar: +++ X-Spam_report: (3.0 / 5.0 requ) BAYES_00=-1.9, DKIM_ADSP_CUSTOM_MED=0.001, FORGED_GMAIL_RCVD=1, FREEMAIL_FORGED_FROMDOMAIN=1, FREEMAIL_FROM=0.001, FREEMAIL_REPLY=1, HEADER_FROM_DIFFERENT_DOMAINS=1, NML_ADSP_CUSTOM_MED=0.9, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=no autolearn_force=no X-Spam_action: no action X-Spam-Score: 0.6 (/) X-Debbugs-Envelope-To: submit X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.4 (-) On Wed 12 Aug 2020, Eli Zaretskii wrote: >> Cc: larsi@gnus.org, pipcet@gmail.com, 36597@debbugs.gnu.org >> From: Paul Eggert >> Date: Wed, 12 Aug 2020 12:11:09 -0700 >> >> I looked into the MinGW situation and the problem seems to be that MinGW defined >> a macro _INTPTR_T_DEFINED that it no longer defines, and Gnulib was keying off >> that no-longer-present macro. > > I think _INTPTR_T_DEFINED is still being used, but only by MinGW64. I > use mingw.org's MinGW, where that macro was never used. Yes, MinGW64 still defines this in corecrt.h, and in _cygwin.h (which I think is to support cross conpiling to cygwin). > However, both MinGW flavors typedef intptr_t as 'int', not 'long int', > on 32-bit platforms. Agreed. >> I installed a patch for that in Gnulib here: >> >> https://lists.gnu.org/r/bug-gnulib/2020-08/msg00088.html >> >> and migrated the patch into Emacs. Hope it fixes things. > > It does here, thanks. I hope someone will be able to make sure > MinGW64 builds are not adversely affected (I don't think they should > be). On msys2, 32bit mingw64 and 64bit mingw64 builds are both ok (using commit fd6058b8). AndyM From unknown Thu Aug 14 22:18:44 2025 Received: (at fakecontrol) by fakecontrolmessage; To: internal_control@debbugs.gnu.org From: Debbugs Internal Request Subject: Internal Control Message-Id: bug archived. Date: Thu, 10 Sep 2020 11:24:16 +0000 User-Agent: Fakemail v42.6.9 # This is a fake control message. # # The action: # bug archived. thanks # This fakemail brought to you by your local debbugs # administrator