From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from ozlabs.org (ozlabs.org [103.22.144.67]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by lists.ozlabs.org (Postfix) with ESMTPS id 184941A015B for ; Thu, 4 Sep 2014 17:56:30 +1000 (EST) Received: from smtp-outbound-2.vmware.com (smtp-outbound-2.vmware.com [208.91.2.13]) (using TLSv1 with cipher ADH-AES256-SHA (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 761A81401F6 for ; Thu, 4 Sep 2014 17:56:28 +1000 (EST) Message-ID: <54081844.7000604@vmware.com> Date: Thu, 4 Sep 2014 09:44:04 +0200 From: Thomas Hellstrom MIME-Version: 1.0 To: Benjamin Herrenschmidt Subject: Re: TTM placement & caching issue/questions References: <1409789547.30640.136.camel@pasglop> In-Reply-To: <1409789547.30640.136.camel@pasglop> Content-Type: text/plain; charset="ISO-8859-1" Cc: Jerome Glisse , linuxppc-dev@ozlabs.org, Michel Danzer , dri-devel@lists.freedesktop.org List-Id: Linux on PowerPC Developers Mail List List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Hi! Let me try to bring some clarity and suggestions into this. On 09/04/2014 02:12 AM, Benjamin Herrenschmidt wrote: > Hi folks ! > > I've been tracking down some problems with the recent DRI on powerpc and > stumbled upon something that doesn't look right, and not necessarily > only for us. > > Now it's possible that I haven't fully understood the code here and I > also don't know to what extent some of that behaviour is necessary for > some platforms such as Intel GTT bits. > > What I've observed with a simple/dumb (no DMA) driver like AST (but this > probably happens more generally) is that when evicting a BO from VRAM > into System memory, the TTM tries to preserve the existing caching > attributes of the VRAM object. > > >From what I can tell, we end up with going from VRAM to System memory > type, and we eventually call ttm_bo_select_caching() to select the > caching option for the target. > > This will, from what I can tell, try to use the same caching mode as the > original object: > > if ((cur_placement & caching) != 0) > result |= (cur_placement & caching); > > And cur_placement comes from bo->mem.placement which as far as I can > tell is based on the placement array which the drivers set up. This originates from the fact that when evicting GTT memory, on x86 it's unnecessary and undesirable to switch caching mode when going to system. > > Now they tend to uniformly setup the placement for System memory as > TTM_PL_MASK_CACHING which enables all caching modes. > > So I end up with, for example, my System memory BOs having > TTM_PL_FLAG_CACHED not set (though they also don't have > TTM_PL_FLAG_UNCACHED) and TTM_PL_FLAG_WC. > > We don't seem to use the man->default_caching (which will have > TTM_PL_FLAG_CACHED) unless there is no matching bit at all between the > proposed placement and the existing caching mode. > > Now this is a problem for several reason that I can think of: > > - On a number of powerpc platforms, such as all our server 64-bit one > for example, it's actually illegal to map system memory non-cached. The > system is fully cache coherent for all possible DMA originators (that we > care about at least) and mapping memory non-cachable while it's mapped > cachable in the linear mapping can cause nasty cache paradox which, when > detected by HW, can checkstop the system. > > - A similar issue exists, afaik, on ARM >= v7, so anything mapped > non-cachable must be removed from the linear mapping explicitly since > otherwise it can be speculatively prefetched into the cache. > > - I don't know about x86, but even then, it looks quite sub-optimal to > map the memory backing of the BOs and access it using a WC rather than a > cachable mapping attribute. Last time I tested, (and it seems like Michel is on the same track), writing with the CPU to write-combined memory was substantially faster than writing to cached memory, with the additional side-effect that CPU caches are left unpolluted. Moreover (although only tested on Intel's embedded chipsets), texturing from cpu-cache-coherent PCI memory was a real GPU performance hog compared to texturing from non-snooped memory. Hence, whenever a buffer could be classified as GPU-read-only (or almost at least), it should be placed in write-combined memory. > > Now, some folks on IRC mentioned that there might be reasons for the > current behaviour as to not change the caching attributes when going > in/out of the GTT on Intel, I don't know how that relates and how that > works, but maybe that should be enforced by having a different placement > mask specifically on those chipsets. > > Dave, should we change the various PCI drivers for generally coherent > devices such that the System memory type doesn't allow placements > without CACHED attribute ? Or at least on coherent platforms ? How do > detect that ? Should we have a TTM helper to establish the default > memory placement attributes that "normal PCI" drivers call to set that > up so we can have all the necessary arch ifdefs in one single place, at > least for "classic PCI/PCIe" stuff (AGP might need additional tweaks) ? > > Non-PCI and "special" drivers like Intel can use a different set of > placement attributes to represent the requirements of those specific > platforms (mostly thinking of embedded ARM here which under some > circumstances might actually require non-cached mappings). > Or am I missing another part of the puzzle ? > > As it-is, things are broken for me even for dumb drivers, and I suspect > to a large extent with radeon and nouveau too, though in some case we > might get away with it most of the time ... until the machine locks up > for some unexplainable reason... This might cause problems on existing > distros such as RHEL7 with our radeon adapters even. > > Any suggestion of what's the best approach to fix it ? I'm happy to > produce the patches but I'm not that familiar with the TTM so I would > like to make sure I'm the right track first :-) I dislike the approach of rewriting placements. In some cases I think it won't even work, because placements are declared 'static const' What I'd suggest is instead to intercept the driver response from init_mem_type() and filter out undesired caching modes from available_caching and default_caching, perhaps also looking at whether the memory type is mappable or not. This should have the additional benefit of working everywhere, and if a caching mode is selected that's not available on the platform, you'll simply get an error. (I guess?) /Thomas > > Cheers, > Ben. > > > _______________________________________________ > dri-devel mailing list > dri-devel@lists.freedesktop.org > http://lists.freedesktop.org/mailman/listinfo/dri-devel From mboxrd@z Thu Jan 1 00:00:00 1970 From: Thomas Hellstrom Subject: Re: TTM placement & caching issue/questions Date: Thu, 4 Sep 2014 09:44:04 +0200 Message-ID: <54081844.7000604@vmware.com> References: <1409789547.30640.136.camel@pasglop> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1409789547.30640.136.camel@pasglop> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: linuxppc-dev-bounces+glppe-linuxppc-embedded-2=m.gmane.org@lists.ozlabs.org Sender: "Linuxppc-dev" To: Benjamin Herrenschmidt Cc: Jerome Glisse , linuxppc-dev@ozlabs.org, Michel Danzer , dri-devel@lists.freedesktop.org List-Id: dri-devel@lists.freedesktop.org SGkhCgpMZXQgbWUgdHJ5IHRvIGJyaW5nIHNvbWUgY2xhcml0eSBhbmQgc3VnZ2VzdGlvbnMgaW50 byB0aGlzLgoKT24gMDkvMDQvMjAxNCAwMjoxMiBBTSwgQmVuamFtaW4gSGVycmVuc2NobWlkdCB3 cm90ZToKPiBIaSBmb2xrcyAhCj4KPiBJJ3ZlIGJlZW4gdHJhY2tpbmcgZG93biBzb21lIHByb2Js ZW1zIHdpdGggdGhlIHJlY2VudCBEUkkgb24gcG93ZXJwYyBhbmQKPiBzdHVtYmxlZCB1cG9uIHNv bWV0aGluZyB0aGF0IGRvZXNuJ3QgbG9vayByaWdodCwgYW5kIG5vdCBuZWNlc3NhcmlseQo+IG9u bHkgZm9yIHVzLgo+Cj4gTm93IGl0J3MgcG9zc2libGUgdGhhdCBJIGhhdmVuJ3QgZnVsbHkgdW5k ZXJzdG9vZCB0aGUgY29kZSBoZXJlIGFuZCBJCj4gYWxzbyBkb24ndCBrbm93IHRvIHdoYXQgZXh0 ZW50IHNvbWUgb2YgdGhhdCBiZWhhdmlvdXIgaXMgbmVjZXNzYXJ5IGZvcgo+IHNvbWUgcGxhdGZv cm1zIHN1Y2ggYXMgSW50ZWwgR1RUIGJpdHMuCj4KPiBXaGF0IEkndmUgb2JzZXJ2ZWQgd2l0aCBh IHNpbXBsZS9kdW1iIChubyBETUEpIGRyaXZlciBsaWtlIEFTVCAoYnV0IHRoaXMKPiBwcm9iYWJs eSBoYXBwZW5zIG1vcmUgZ2VuZXJhbGx5KSBpcyB0aGF0IHdoZW4gZXZpY3RpbmcgYSBCTyBmcm9t IFZSQU0KPiBpbnRvIFN5c3RlbSBtZW1vcnksIHRoZSBUVE0gdHJpZXMgdG8gcHJlc2VydmUgdGhl IGV4aXN0aW5nIGNhY2hpbmcKPiBhdHRyaWJ1dGVzIG9mIHRoZSBWUkFNIG9iamVjdC4KPgo+ID5G cm9tIHdoYXQgSSBjYW4gdGVsbCwgd2UgZW5kIHVwIHdpdGggZ29pbmcgZnJvbSBWUkFNIHRvIFN5 c3RlbSBtZW1vcnkKPiB0eXBlLCBhbmQgd2UgZXZlbnR1YWxseSBjYWxsIHR0bV9ib19zZWxlY3Rf Y2FjaGluZygpIHRvIHNlbGVjdCB0aGUKPiBjYWNoaW5nIG9wdGlvbiBmb3IgdGhlIHRhcmdldC4K Pgo+IFRoaXMgd2lsbCwgZnJvbSB3aGF0IEkgY2FuIHRlbGwsIHRyeSB0byB1c2UgdGhlIHNhbWUg Y2FjaGluZyBtb2RlIGFzIHRoZQo+IG9yaWdpbmFsIG9iamVjdDoKPgo+IAlpZiAoKGN1cl9wbGFj ZW1lbnQgJiBjYWNoaW5nKSAhPSAwKQo+IAkJcmVzdWx0IHw9IChjdXJfcGxhY2VtZW50ICYgY2Fj aGluZyk7Cj4KPiBBbmQgY3VyX3BsYWNlbWVudCBjb21lcyBmcm9tIGJvLT5tZW0ucGxhY2VtZW50 IHdoaWNoIGFzIGZhciBhcyBJIGNhbgo+IHRlbGwgaXMgYmFzZWQgb24gdGhlIHBsYWNlbWVudCBh cnJheSB3aGljaCB0aGUgZHJpdmVycyBzZXQgdXAuCgpUaGlzIG9yaWdpbmF0ZXMgZnJvbSB0aGUg ZmFjdCB0aGF0IHdoZW4gZXZpY3RpbmcgR1RUIG1lbW9yeSwgb24geDg2IGl0J3MKdW5uZWNlc3Nh cnkgYW5kIHVuZGVzaXJhYmxlIHRvIHN3aXRjaCBjYWNoaW5nIG1vZGUgd2hlbiBnb2luZyB0byBz eXN0ZW0uCgo+Cj4gTm93IHRoZXkgdGVuZCB0byB1bmlmb3JtbHkgc2V0dXAgdGhlIHBsYWNlbWVu dCBmb3IgU3lzdGVtIG1lbW9yeSBhcwo+IFRUTV9QTF9NQVNLX0NBQ0hJTkcgd2hpY2ggZW5hYmxl cyBhbGwgY2FjaGluZyBtb2Rlcy4KPgo+IFNvIEkgZW5kIHVwIHdpdGgsIGZvciBleGFtcGxlLCBt eSBTeXN0ZW0gbWVtb3J5IEJPcyBoYXZpbmcKPiBUVE1fUExfRkxBR19DQUNIRUQgbm90IHNldCAo dGhvdWdoIHRoZXkgYWxzbyBkb24ndCBoYXZlCj4gVFRNX1BMX0ZMQUdfVU5DQUNIRUQpIGFuZCBU VE1fUExfRkxBR19XQy4KPgo+IFdlIGRvbid0IHNlZW0gdG8gdXNlIHRoZSBtYW4tPmRlZmF1bHRf Y2FjaGluZyAod2hpY2ggd2lsbCBoYXZlCj4gVFRNX1BMX0ZMQUdfQ0FDSEVEKSB1bmxlc3MgdGhl cmUgaXMgbm8gbWF0Y2hpbmcgYml0IGF0IGFsbCBiZXR3ZWVuIHRoZQo+IHByb3Bvc2VkIHBsYWNl bWVudCBhbmQgdGhlIGV4aXN0aW5nIGNhY2hpbmcgbW9kZS4KPgo+IE5vdyB0aGlzIGlzIGEgcHJv YmxlbSBmb3Igc2V2ZXJhbCByZWFzb24gdGhhdCBJIGNhbiB0aGluayBvZjoKPgo+ICAtIE9uIGEg bnVtYmVyIG9mIHBvd2VycGMgcGxhdGZvcm1zLCBzdWNoIGFzIGFsbCBvdXIgc2VydmVyIDY0LWJp dCBvbmUKPiBmb3IgZXhhbXBsZSwgaXQncyBhY3R1YWxseSBpbGxlZ2FsIHRvIG1hcCBzeXN0ZW0g bWVtb3J5IG5vbi1jYWNoZWQuIFRoZQo+IHN5c3RlbSBpcyBmdWxseSBjYWNoZSBjb2hlcmVudCBm b3IgYWxsIHBvc3NpYmxlIERNQSBvcmlnaW5hdG9ycyAodGhhdCB3ZQo+IGNhcmUgYWJvdXQgYXQg bGVhc3QpIGFuZCBtYXBwaW5nIG1lbW9yeSBub24tY2FjaGFibGUgd2hpbGUgaXQncyBtYXBwZWQK PiBjYWNoYWJsZSBpbiB0aGUgbGluZWFyIG1hcHBpbmcgY2FuIGNhdXNlIG5hc3R5IGNhY2hlIHBh cmFkb3ggd2hpY2gsIHdoZW4KPiBkZXRlY3RlZCBieSBIVywgY2FuIGNoZWNrc3RvcCB0aGUgc3lz dGVtLgo+Cj4gIC0gQSBzaW1pbGFyIGlzc3VlIGV4aXN0cywgYWZhaWssIG9uIEFSTSA+PSB2Nywg c28gYW55dGhpbmcgbWFwcGVkCj4gbm9uLWNhY2hhYmxlIG11c3QgYmUgcmVtb3ZlZCBmcm9tIHRo ZSBsaW5lYXIgbWFwcGluZyBleHBsaWNpdGx5IHNpbmNlCj4gb3RoZXJ3aXNlIGl0IGNhbiBiZSBz cGVjdWxhdGl2ZWx5IHByZWZldGNoZWQgaW50byB0aGUgY2FjaGUuCj4KPiAgLSBJIGRvbid0IGtu b3cgYWJvdXQgeDg2LCBidXQgZXZlbiB0aGVuLCBpdCBsb29rcyBxdWl0ZSBzdWItb3B0aW1hbCB0 bwo+IG1hcCB0aGUgbWVtb3J5IGJhY2tpbmcgb2YgdGhlIEJPcyBhbmQgYWNjZXNzIGl0IHVzaW5n IGEgV0MgcmF0aGVyIHRoYW4gYQo+IGNhY2hhYmxlIG1hcHBpbmcgYXR0cmlidXRlLgoKTGFzdCB0 aW1lIEkgdGVzdGVkLCAoYW5kIGl0IHNlZW1zIGxpa2UgTWljaGVsIGlzIG9uIHRoZSBzYW1lIHRy YWNrKSwKd3JpdGluZyB3aXRoIHRoZSBDUFUgdG8gd3JpdGUtY29tYmluZWQgbWVtb3J5IHdhcyBz dWJzdGFudGlhbGx5IGZhc3Rlcgp0aGFuIHdyaXRpbmcgdG8gY2FjaGVkIG1lbW9yeSwgd2l0aCB0 aGUgYWRkaXRpb25hbCBzaWRlLWVmZmVjdCB0aGF0IENQVQpjYWNoZXMgYXJlIGxlZnQgdW5wb2xs dXRlZC4KCk1vcmVvdmVyIChhbHRob3VnaCBvbmx5IHRlc3RlZCBvbiBJbnRlbCdzIGVtYmVkZGVk IGNoaXBzZXRzKSwgdGV4dHVyaW5nCmZyb20gY3B1LWNhY2hlLWNvaGVyZW50IFBDSSBtZW1vcnkg d2FzIGEgcmVhbCBHUFUgcGVyZm9ybWFuY2UgaG9nCmNvbXBhcmVkIHRvIHRleHR1cmluZyBmcm9t IG5vbi1zbm9vcGVkIG1lbW9yeS4gSGVuY2UsIHdoZW5ldmVyIGEgYnVmZmVyCmNvdWxkIGJlIGNs YXNzaWZpZWQgYXMgR1BVLXJlYWQtb25seSAob3IgYWxtb3N0IGF0IGxlYXN0KSwgaXQgc2hvdWxk IGJlCnBsYWNlZCBpbiB3cml0ZS1jb21iaW5lZCBtZW1vcnkuCgo+Cj4gTm93LCBzb21lIGZvbGtz IG9uIElSQyBtZW50aW9uZWQgdGhhdCB0aGVyZSBtaWdodCBiZSByZWFzb25zIGZvciB0aGUKPiBj dXJyZW50IGJlaGF2aW91ciBhcyB0byBub3QgY2hhbmdlIHRoZSBjYWNoaW5nIGF0dHJpYnV0ZXMg d2hlbiBnb2luZwo+IGluL291dCBvZiB0aGUgR1RUIG9uIEludGVsLCBJIGRvbid0IGtub3cgaG93 IHRoYXQgcmVsYXRlcyBhbmQgaG93IHRoYXQKPiB3b3JrcywgYnV0IG1heWJlIHRoYXQgc2hvdWxk IGJlIGVuZm9yY2VkIGJ5IGhhdmluZyBhIGRpZmZlcmVudCBwbGFjZW1lbnQKPiBtYXNrIHNwZWNp ZmljYWxseSBvbiB0aG9zZSBjaGlwc2V0cy4KPgo+IERhdmUsIHNob3VsZCB3ZSBjaGFuZ2UgdGhl IHZhcmlvdXMgUENJIGRyaXZlcnMgZm9yIGdlbmVyYWxseSBjb2hlcmVudAo+IGRldmljZXMgc3Vj aCB0aGF0IHRoZSBTeXN0ZW0gbWVtb3J5IHR5cGUgZG9lc24ndCBhbGxvdyBwbGFjZW1lbnRzCj4g d2l0aG91dCBDQUNIRUQgYXR0cmlidXRlID8gT3IgYXQgbGVhc3Qgb24gY29oZXJlbnQgcGxhdGZv cm1zID8gSG93IGRvCj4gZGV0ZWN0IHRoYXQgPyBTaG91bGQgd2UgaGF2ZSBhIFRUTSBoZWxwZXIg dG8gZXN0YWJsaXNoIHRoZSBkZWZhdWx0Cj4gbWVtb3J5IHBsYWNlbWVudCBhdHRyaWJ1dGVzIHRo YXQgIm5vcm1hbCBQQ0kiIGRyaXZlcnMgY2FsbCB0byBzZXQgdGhhdAo+IHVwIHNvIHdlIGNhbiBo YXZlIGFsbCB0aGUgbmVjZXNzYXJ5IGFyY2ggaWZkZWZzIGluIG9uZSBzaW5nbGUgcGxhY2UsIGF0 Cj4gbGVhc3QgZm9yICJjbGFzc2ljIFBDSS9QQ0llIiBzdHVmZiAoQUdQIG1pZ2h0IG5lZWQgYWRk aXRpb25hbCB0d2Vha3MpID8KPgo+IE5vbi1QQ0kgYW5kICJzcGVjaWFsIiBkcml2ZXJzIGxpa2Ug SW50ZWwgY2FuIHVzZSBhIGRpZmZlcmVudCBzZXQgb2YKPiBwbGFjZW1lbnQgYXR0cmlidXRlcyB0 byByZXByZXNlbnQgdGhlIHJlcXVpcmVtZW50cyBvZiB0aG9zZSBzcGVjaWZpYwo+IHBsYXRmb3Jt cyAobW9zdGx5IHRoaW5raW5nIG9mIGVtYmVkZGVkIEFSTSBoZXJlIHdoaWNoIHVuZGVyIHNvbWUK PiBjaXJjdW1zdGFuY2VzIG1pZ2h0IGFjdHVhbGx5IHJlcXVpcmUgbm9uLWNhY2hlZCBtYXBwaW5n cykuCj4gT3IgYW0gSSBtaXNzaW5nIGFub3RoZXIgcGFydCBvZiB0aGUgcHV6emxlID8KPgo+IEFz IGl0LWlzLCB0aGluZ3MgYXJlIGJyb2tlbiBmb3IgbWUgZXZlbiBmb3IgZHVtYiBkcml2ZXJzLCBh bmQgSSBzdXNwZWN0Cj4gdG8gYSBsYXJnZSBleHRlbnQgd2l0aCByYWRlb24gYW5kIG5vdXZlYXUg dG9vLCB0aG91Z2ggaW4gc29tZSBjYXNlIHdlCj4gbWlnaHQgZ2V0IGF3YXkgd2l0aCBpdCBtb3N0 IG9mIHRoZSB0aW1lIC4uLiB1bnRpbCB0aGUgbWFjaGluZSBsb2NrcyB1cAo+IGZvciBzb21lIHVu ZXhwbGFpbmFibGUgcmVhc29uLi4uIFRoaXMgbWlnaHQgY2F1c2UgcHJvYmxlbXMgb24gZXhpc3Rp bmcKPiBkaXN0cm9zIHN1Y2ggYXMgUkhFTDcgd2l0aCBvdXIgcmFkZW9uIGFkYXB0ZXJzIGV2ZW4u Cj4KPiBBbnkgc3VnZ2VzdGlvbiBvZiB3aGF0J3MgdGhlIGJlc3QgYXBwcm9hY2ggdG8gZml4IGl0 ID8gSSdtIGhhcHB5IHRvCj4gcHJvZHVjZSB0aGUgcGF0Y2hlcyBidXQgSSdtIG5vdCB0aGF0IGZh bWlsaWFyIHdpdGggdGhlIFRUTSBzbyBJIHdvdWxkCj4gbGlrZSB0byBtYWtlIHN1cmUgSSdtIHRo ZSByaWdodCB0cmFjayBmaXJzdCA6LSkKCkkgZGlzbGlrZSB0aGUgYXBwcm9hY2ggb2YgcmV3cml0 aW5nIHBsYWNlbWVudHMuIEluIHNvbWUgY2FzZXMgSSB0aGluayBpdAp3b24ndCBldmVuIHdvcmss IGJlY2F1c2UgcGxhY2VtZW50cyBhcmUgZGVjbGFyZWQgJ3N0YXRpYyBjb25zdCcKCldoYXQgSSdk IHN1Z2dlc3QgaXMgaW5zdGVhZCB0byBpbnRlcmNlcHQgdGhlIGRyaXZlciByZXNwb25zZSBmcm9t CmluaXRfbWVtX3R5cGUoKSBhbmQgZmlsdGVyIG91dCB1bmRlc2lyZWQgY2FjaGluZyBtb2RlcyBm cm9tCmF2YWlsYWJsZV9jYWNoaW5nIGFuZCBkZWZhdWx0X2NhY2hpbmcsIHBlcmhhcHMgYWxzbyBs b29raW5nIGF0IHdoZXRoZXIKdGhlIG1lbW9yeSB0eXBlIGlzIG1hcHBhYmxlIG9yIG5vdC4gVGhp cyBzaG91bGQgaGF2ZSB0aGUgYWRkaXRpb25hbApiZW5lZml0IG9mIHdvcmtpbmcgZXZlcnl3aGVy ZSwgYW5kIGlmIGEgY2FjaGluZyBtb2RlIGlzIHNlbGVjdGVkIHRoYXQncwpub3QgYXZhaWxhYmxl IG9uIHRoZSBwbGF0Zm9ybSwgeW91J2xsIHNpbXBseSBnZXQgYW4gZXJyb3IuIChJIGd1ZXNzPykK Ci9UaG9tYXMKCgo+Cj4gQ2hlZXJzLAo+IEJlbi4KPgo+Cj4gX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX18KPiBkcmktZGV2ZWwgbWFpbGluZyBsaXN0Cj4gZHJp LWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwo+IGh0dHA6Ly9saXN0cy5mcmVlZGVza3RvcC5v cmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwKCl9fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fCkxpbnV4cHBjLWRldiBtYWlsaW5nIGxpc3QKTGludXhwcGMt ZGV2QGxpc3RzLm96bGFicy5vcmcKaHR0cHM6Ly9saXN0cy5vemxhYnMub3JnL2xpc3RpbmZvL2xp bnV4cHBjLWRldg==