From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-15.3 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_SANE_1 autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id B184EC2B9F4 for ; Thu, 17 Jun 2021 17:34:34 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 804F26109E for ; Thu, 17 Jun 2021 17:34:34 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 804F26109E Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=intel.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=dri-devel-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 602C36E96C; Thu, 17 Jun 2021 17:34:31 +0000 (UTC) Received: from mga09.intel.com (mga09.intel.com [134.134.136.24]) by gabe.freedesktop.org (Postfix) with ESMTPS id E4A816E96B; Thu, 17 Jun 2021 17:34:29 +0000 (UTC) IronPort-SDR: jFXn8RMqW0oimEIVDYrrYzrlr+XZGSGS+J8BK7MqvLzzLQcYbbMLEtojz0Ql89buODQaJau+BH XSxB1m7xqa8A== X-IronPort-AV: E=McAfee;i="6200,9189,10018"; a="206371081" X-IronPort-AV: E=Sophos;i="5.83,281,1616482800"; d="scan'208";a="206371081" Received: from orsmga001.jf.intel.com ([10.7.209.18]) by orsmga102.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 17 Jun 2021 10:34:29 -0700 IronPort-SDR: DlOPMmyNVYAowlC8WaYxIawMDbdtlBpCEGrGTE4Vf67tJPcziApjAyBrGWXhifiHcz9ubVG+sv 6WqvcVBosleQ== X-IronPort-AV: E=Sophos;i="5.83,281,1616482800"; d="scan'208";a="485364222" Received: from unknown (HELO sdutt-i7) ([10.165.21.147]) by orsmga001-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 17 Jun 2021 10:34:28 -0700 Date: Thu, 17 Jun 2021 10:27:41 -0700 From: Matthew Brost To: Daniel Vetter Subject: Re: [Intel-gfx] [RFC PATCH 2/2] drm/doc/rfc: i915 new parallel submission uAPI plan Message-ID: <20210617172741.GA14678@sdutt-i7> References: <20210526233357.9165-1-matthew.brost@intel.com> <20210526233357.9165-3-matthew.brost@intel.com> <20210611195029.GA4388@sdutt-i7> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: User-Agent: Mutt/1.9.4 (2018-02-28) X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org, carl.zhang@intel.com, jason.ekstrand@intel.com, daniel.vetter@intel.com, mesa-dev@lists.freedesktop.org, christian.koenig@amd.com Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" On Thu, Jun 17, 2021 at 06:46:48PM +0200, Daniel Vetter wrote: > Sorry I'm behind on mails ... > Aren't we all. > On Fri, Jun 11, 2021 at 12:50:29PM -0700, Matthew Brost wrote: > > On Fri, Jun 04, 2021 at 07:59:05PM +0200, Daniel Vetter wrote: > > > On Wed, May 26, 2021 at 04:33:57PM -0700, Matthew Brost wrote: > > > > Add entry for i915 new parallel submission uAPI plan. > > > > > > > > v2: > > > > (Daniel Vetter): > > > > - Expand logical order explaination > > > > - Add dummy header > > > > - Only allow N BBs in execbuf IOCTL > > > > - Configure parallel submission per slot not per gem context > > > > v3: > > > > (Marcin Ślusarz): > > > > - Lot's of typos / bad english fixed > > > > (Tvrtko Ursulin): > > > > - Consistent pseudo code, clean up wording in descriptions > > > > > > > > Cc: Tvrtko Ursulin > > > > Cc: Tony Ye > > > > CC: Carl Zhang > > > > Cc: Daniel Vetter > > > > Cc: Jason Ekstrand > > > > Signed-off-by: Matthew Brost > > > > --- > > > > Documentation/gpu/rfc/i915_parallel_execbuf.h | 145 ++++++++++++++++++ > > > > Documentation/gpu/rfc/i915_scheduler.rst | 55 ++++++- > > > > 2 files changed, 198 insertions(+), 2 deletions(-) > > > > create mode 100644 Documentation/gpu/rfc/i915_parallel_execbuf.h > > > > > > > > diff --git a/Documentation/gpu/rfc/i915_parallel_execbuf.h b/Documentation/gpu/rfc/i915_parallel_execbuf.h > > > > new file mode 100644 > > > > index 000000000000..20de206e3ab4 > > > > --- /dev/null > > > > +++ b/Documentation/gpu/rfc/i915_parallel_execbuf.h > > > > @@ -0,0 +1,145 @@ > > > > +#define I915_CONTEXT_ENGINES_EXT_PARALLEL_SUBMIT 2 /* see i915_context_engines_parallel_submit */ > > > > + > > > > +/* > > > > + * i915_context_engines_parallel_submit: > > > > > > So the idea is to make these kerneldoc and pull them into the rfc section. > > > Then when we merge, move them to the real uapi section, like what Matt has > > > done for lmem. > > > > > > > Yep, will fix in next rev. > > > > > > + * > > > > + * Setup a slot in the context engine map to allow multiple BBs to be submitted > > > > + * in a single execbuf IOCTL. Those BBs will then be scheduled to run on the GPU > > > > + * in parallel. Multiple hardware contexts are created internally in the i915 > > > > + * run these BBs. Once a slot is configured for N BBs only N BBs can be > > > > + * submitted in each execbuf IOCTL and this is implicit behavior e.g. The user > > > > + * doesn't tell the execbuf IOCTL there are N BBs, the execbuf IOCTL know how > > > > + * many BBs there are based on the slots configuration. The N BBs are the last N > > > > + * buffer objects for first N if I915_EXEC_BATCH_FIRST is set. > > > > > > s/for/or/ > > > > > > > + * > > > > + * There are two currently defined ways to control the placement of the > > > > + * hardware contexts on physical engines: default behavior (no flags) and > > > > + * I915_PARALLEL_IMPLICIT_BONDS (a flag). More flags may be added the in the > > > > + * future as new hardware / use cases arise. Details of how to use this > > > > + * interface above the flags field in this structure. > > > > + * > > > > + * Returns -EINVAL if hardware context placement configuration is invalid or if > > > > + * the placement configuration isn't supported on the platform / submission > > > > + * interface. > > > > + * Returns -ENODEV if extension isn't supported on the platform / submission > > > > + * inteface. > > > > + */ > > > > +struct i915_context_engines_parallel_submit { > > > > + struct i915_user_extension base; > > > > + > > > > + __u16 engine_index; /* slot for parallel engine */ > > > > > > Kernel doc here for the inline comments too. > > > > > > > Yep. > > > > > > + __u16 width; /* number of contexts per parallel engine */ > > > > + __u16 num_siblings; /* number of siblings per context */ > > > > + __u16 mbz16; > > > > +/* > > > > + * Default placement behavior (currently unsupported): > > > > + * > > > > + * Allow BBs to be placed on any available engine instance. In this case each > > > > + * context's engine mask indicates where that context can be placed. It is > > > > + * implied in this mode that all contexts have mutual exclusive placement. > > > > + * e.g. If one context is running CSX[0] no other contexts can run on CSX[0]). > > > > + * > > > > + * Example 1 pseudo code: > > > > + * CSX,Y[N] = generic engine class X or Y, logical instance N > > > > + * INVALID = I915_ENGINE_CLASS_INVALID, I915_ENGINE_CLASS_INVALID_NONE > > > > + * set_engines(INVALID) > > > > + * set_parallel(engine_index=0, width=2, num_siblings=2, > > > > + * engines=CSX[0],CSX[1],CSY[0],CSY[1]) > > > > + * > > > > + * Results in the following valid placements: > > > > + * CSX[0], CSY[0] > > > > + * CSX[0], CSY[1] > > > > + * CSX[1], CSY[0] > > > > + * CSX[1], CSY[1] > > > > + * > > > > + * This can also be thought of as 2 virtual engines described by 2-D array in > > > > + * the engines the field: > > > > + * VE[0] = CSX[0], CSX[1] > > > > + * VE[1] = CSY[0], CSY[1] > > > > + * > > > > + * Example 2 pseudo code: > > > > + * CSX[Y] = generic engine of same class X, logical instance N > > > > + * INVALID = I915_ENGINE_CLASS_INVALID, I915_ENGINE_CLASS_INVALID_NONE > > > > + * set_engines(INVALID) > > > > + * set_parallel(engine_index=0, width=2, num_siblings=3, > > > > + * engines=CSX[0],CSX[1],CSX[2],CSX[0],CSX[1],CSX[2]) > > > > + * > > > > + * Results in the following valid placements: > > > > + * CSX[0], CSX[1] > > > > + * CSX[0], CSX[2] > > > > + * CSX[1], CSX[0] > > > > + * CSX[1], CSX[2] > > > > + * CSX[2], CSX[0] > > > > + * CSX[2], CSX[1] > > > > + * > > > > + * This can also be thought of as 2 virtual engines described by 2-D array in > > > > + * the engines the field: > > > > + * VE[0] = CSX[0], CSX[1], CSX[2] > > > > + * VE[1] = CSX[0], CSX[1], CSX[2] > > > > + > > > > + * This enables a use case where all engines are created equally, we don't care > > > > + * where they are scheduled, we just want a certain number of resources, for > > > > + * those resources to be scheduled in parallel, and possibly across multiple > > > > + * engine classes. > > > > + */ > > > > + > > > > +/* > > > > > > Would be good to also move this into the kerneldoc (maybe add labelled > > > list for flags or so) so it shows up in the render output. > > > > > > > Sure. I need figure out view the kernel doc locally before my next and make sure > > everything looks right. > > $ make htmldocs > > Output is in Documentation/output/gpu/index.html (to get there more > directly). > I've figured this out, next rev of docs looks good to me. > > > > > > + * I915_PARALLEL_IMPLICIT_BONDS - Create implicit bonds between each context. > > > > + * Each context must have the same number of sibling and bonds are implicitly > > > > + * created between each set of siblings. > > > > + * > > > > + * Example 1 pseudo code: > > > > + * CSX[N] = generic engine of same class X, logical instance N > > > > + * INVALID = I915_ENGINE_CLASS_INVALID, I915_ENGINE_CLASS_INVALID_NONE > > > > + * set_engines(INVALID) > > > > + * set_parallel(engine_index=0, width=2, num_siblings=1, > > > > + * engines=CSX[0],CSX[1], flags=I915_PARALLEL_IMPLICIT_BONDS) > > > > + * > > > > + * Results in the following valid placements: > > > > + * CSX[0], CSX[1] > > > > + * > > > > + * Example 2 pseudo code: > > > > + * CSX[N] = generic engine of same class X, logical instance N > > > > + * INVALID = I915_ENGINE_CLASS_INVALID, I915_ENGINE_CLASS_INVALID_NONE > > > > + * set_engines(INVALID) > > > > + * set_parallel(engine_index=0, width=2, num_siblings=2, > > > > + * engines=CSX[0],CSX[2],CSX[1],CSX[3], > > > > + * flags=I915_PARALLEL_IMPLICIT_BONDS) > > > > + * > > > > + * Results in the following valid placements: > > > > + * CSX[0], CSX[1] > > > > + * CSX[2], CSX[3] > > > > + * > > > > + * This can also be thought of as 2 virtual engines described by 2-D array in > > > > + * the engines the field with bonds placed between each index of the virtual > > > > + * engines. e.g. CSX[0] is bonded to CSX[1], CSX[2] is bonded to CSX[3]. > > > > + * VE[0] = CSX[0], CSX[2] > > > > + * VE[1] = CSX[1], CSX[3] > > > > + * > > > > + * This enables a use case where all engines are not equal and certain placement > > > > + * rules are required (i.e. split-frame requires all contexts to be placed in a > > > > + * logically contiguous order on the VCS engines on gen11+ platforms). This use > > > > + * case (logically contiguous placement, within a single engine class) is > > > > + * supported when using GuC submission. Execlist mode could support all possible > > > > + * bonding configurations but currently doesn't support this extension. > > > > + */ > > > > +#define I915_PARALLEL_IMPLICIT_BONDS (1 << 0) > > > > +/* > > > > + * Do not allow BBs to be preempted mid BB rather insert coordinated preemption > > > > + * points on all hardware contexts between each set of BBs. An example use case > > > > + * of this feature is split-frame on gen11+ hardware. > > > > + */ > > > > +#define I915_PARALLEL_NO_PREEMPT_MID_BATCH (1 << 1) > > > > > > So I get the history now behind this, but I think specifying flags for the > > > only behaviour you can get and the only behaviour that userspace asks for > > > is silly. > > > > > > I think we should just move the actual behaviour spec into the kerneldoc, > > > as in "this is the bonding you get" and "due to hw/fw limitations these > > > workloads will be non-preemptable" and call it a day. Trying to guess > > > future needs and specifying them, without knowing those future needs > > > precisely, much less having an implementation, just never works out > > > really. > > > > > > > So no flags? Or just the default behavior is I915_PARALLEL_IMPLICIT_BONDS | > > I915_PARALLEL_NO_PREEMPT_MID_BATCH for now, the flags are unused, but could be > > used in the future if needed? > > The implicit_bonds I think should be just the default, we can add flags > for the other stuff when it exist. > Yep, next rev this is the default. > The NO_PREEMPT I think makes some sense to keep to make this part > explicit. Either way on that is fine with me. > Ok, my next rev made this the default behavior. Either way, not a big deal or enough to respin this DoC as it is only the DoC. We can make a choice on the NO_PREEMPT when the code lands. > > > I discussed this a bit with Jason, and he's suggested this makes sense as > > > a engine flag, but definitely not on the parallel extension. But since we > > > > Not sure what you mean by an engine flags. This is a per context concept. > > Oh, I guess this is more fallout from the conversion from having the > entire gem context as the parallel submit vehicle to a virtual engine. > > If we do have them as flags, they need to be on that virtual engine, not > on the overall gem context container thing. At that point they don't > exactly match up the existing preempt flag we have (on the context), so > maybe we should just make this implied (but ofc documented) behaviour. > Got it. Matt > Cheers, Daniel > > > > > > don't have a need for picking a non-default value just extra work. > > > > > > > +#define __I915_PARALLEL_UNKNOWN_FLAGS (-(I915_PARALLEL_NO_PREEMPT_MID_BATCH << 1)) > > > > + __u64 flags; /* all undefined flags must be zero */ > > > > + __u64 mbz64[3]; /* reserved for future use; must be zero */ > > > > + > > > > + /* > > > > + * 2-D array of engines > > > > + * > > > > + * width (i) * num_siblings (j) in length > > > > + * index = j + i * num_siblings > > > > + */ > > > > + struct i915_engine_class_instance engines[0]; > > > > +} __attribute__ ((packed)); > > > > + > > > > diff --git a/Documentation/gpu/rfc/i915_scheduler.rst b/Documentation/gpu/rfc/i915_scheduler.rst > > > > index 7faa46cde088..0254c04d34be 100644 > > > > --- a/Documentation/gpu/rfc/i915_scheduler.rst > > > > +++ b/Documentation/gpu/rfc/i915_scheduler.rst > > > > @@ -23,7 +23,7 @@ i915 with the DRM scheduler is: > > > > severe design issues in general, which is why we want to retire it no > > > > matter what > > > > * New uAPI adds I915_CONTEXT_ENGINES_EXT_PARALLEL context setup step > > > > - which configures a slot with N contexts > > > > + which configures a slot with N contexts > > > > * After I915_CONTEXT_ENGINES_EXT_PARALLEL a user can submit N batches to > > > > a slot in a single execbuf IOCTL and the batches run on the GPU in > > > > paralllel > > > > @@ -82,4 +82,55 @@ https://spec.oneapi.com/level-zero/latest/core/api.html#ze-command-queue-priorit > > > > > > > > New parallel submission uAPI > > > > ============================ > > > > -Details to come in a following patch. > > > > +The existing bonding uAPI is completely broken with GuC submission because > > > > +whether a submission is a single context submit or parallel submit isn't known > > > > +until execbuf time activated via the I915_SUBMIT_FENCE. To submit multiple > > > > +contexts in parallel with the GuC the context must be explicitly registered with > > > > +N contexts and all N contexts must be submitted in a single command to the GuC. > > > > +The GuC interfaces do not support dynamically changing between N contexts as the > > > > +bonding uAPI does. Hence the need for a new parallel submission interface. Also > > > > +the legacy bonding uAPI is quite confusing and not intuitive at all. > > > > > > We should add here that "Furthermore I915_SUBMIT_FENCE is by design a > > > future fence, so not really something we should continue to support." > > > > > > > + > > > > +The new parallel submission uAPI consists of 3 parts: > > > > + > > > > +* Export engines logical mapping > > > > +* A 'set_parallel' extension to configure contexts for parallel > > > > + submission > > > > +* Extend execbuf2 IOCTL to support submitting N BBs in a single IOCTL > > > > + > > > > +Export engines logical mapping > > > > +------------------------------ > > > > +Certain use cases require BBs to be placed on engine instances in logical order > > > > +(e.g. split-frame on gen11+). The logical mapping of engine instances can change > > > > +based on fusing. Rather than making UMDs be aware of fusing, simply expose the > > > > +logical mapping with the existing query engine info IOCTL. Also the GuC > > > > +submission interface currently only supports submitting multiple contexts to > > > > +engines in logical order which is a new requirement compared to execlists. > > > > +Lastly, all current platforms have at most 2 engine instances and the logical > > > > +order is the same as uAPI order. This will change on platforms with more than 2 > > > > +engine instances. > > > > + > > > > +A single bit will be added to drm_i915_engine_info.flags indicating that the > > > > +logical instance has been returned and a new field, > > > > +drm_i915_engine_info.logical_instance, returns the logical instance. > > > > + > > > > +A 'set_parallel' extension to configure contexts for parallel submission > > > > +------------------------------------------------------------------------ > > > > +The 'set_parallel' extension configures a slot for parallel submission of N BBs. > > > > +It is setup step that should be called before using any of the contexts. See > > > > > > s/should/must/ > > > > > > We've made it a CTX_CREATE_EXT extension, so really you don't have a > > > choice anymore :-) > > > > Right, this can only be called at context creation. > > > > > > > > > +I915_CONTEXT_ENGINES_EXT_LOAD_BALANCE or I915_CONTEXT_ENGINES_EXT_BOND for > > > > +similar existing examples. Once a slot is configured for parallel submission the > > > > +execbuf2 IOCTL can be called submitting N BBs in a single IOCTL. Initially only > > > > +support GuC submission. Execlist support can be added later if needed. > > > > + > > > > +Add I915_CONTEXT_ENGINES_EXT_PARALLEL_SUBMIT and > > > > +i915_context_engines_parallel_submit to the uAPI to implement this extension. > > > > + > > > > +Extend execbuf2 IOCTL to support submitting N BBs in a single IOCTL > > > > +------------------------------------------------------------------- > > > > +Contexts that have been configured with the 'set_parallel' extension are allowed > > > > +to submit N BBs in a single execbuf2 IOCTL. The BBs are either the last N > > > > +objects in the drm_i915_gem_exec_object2 list or the first N if > > > > +I915_EXEC_BATCH_FIRST is set. The number of BBs is implict based on the slot > > > > +submitted and how it has been configured by 'set_parallel' or other extensions. > > > > +No uAPI changes are required to execbuf2 IOCTL. > > > > > > Addd here the kerneldoc include for your header. > > > > > > > Sure. > > > > Matt > > > > > Aside from the comments by and large this looks good. The main interface > > > at least is clear and warts-free. > > > > > > Acked-by: Daniel Vetter > > > > > > > -- > > > > 2.28.0 > > > > > > > > _______________________________________________ > > > > Intel-gfx mailing list > > > > Intel-gfx@lists.freedesktop.org > > > > https://lists.freedesktop.org/mailman/listinfo/intel-gfx > > > > > > -- > > > Daniel Vetter > > > Software Engineer, Intel Corporation > > > http://blog.ffwll.ch > > -- > Daniel Vetter > Software Engineer, Intel Corporation > http://blog.ffwll.ch From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-15.3 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_SANE_1 autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 1465EC49361 for ; Thu, 17 Jun 2021 17:34:37 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id BF4E06109E for ; Thu, 17 Jun 2021 17:34:36 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org BF4E06109E Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=intel.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=intel-gfx-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 8119F6E96D; Thu, 17 Jun 2021 17:34:31 +0000 (UTC) Received: from mga09.intel.com (mga09.intel.com [134.134.136.24]) by gabe.freedesktop.org (Postfix) with ESMTPS id E4A816E96B; Thu, 17 Jun 2021 17:34:29 +0000 (UTC) IronPort-SDR: jFXn8RMqW0oimEIVDYrrYzrlr+XZGSGS+J8BK7MqvLzzLQcYbbMLEtojz0Ql89buODQaJau+BH XSxB1m7xqa8A== X-IronPort-AV: E=McAfee;i="6200,9189,10018"; a="206371081" X-IronPort-AV: E=Sophos;i="5.83,281,1616482800"; d="scan'208";a="206371081" Received: from orsmga001.jf.intel.com ([10.7.209.18]) by orsmga102.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 17 Jun 2021 10:34:29 -0700 IronPort-SDR: DlOPMmyNVYAowlC8WaYxIawMDbdtlBpCEGrGTE4Vf67tJPcziApjAyBrGWXhifiHcz9ubVG+sv 6WqvcVBosleQ== X-IronPort-AV: E=Sophos;i="5.83,281,1616482800"; d="scan'208";a="485364222" Received: from unknown (HELO sdutt-i7) ([10.165.21.147]) by orsmga001-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 17 Jun 2021 10:34:28 -0700 Date: Thu, 17 Jun 2021 10:27:41 -0700 From: Matthew Brost To: Daniel Vetter Message-ID: <20210617172741.GA14678@sdutt-i7> References: <20210526233357.9165-1-matthew.brost@intel.com> <20210526233357.9165-3-matthew.brost@intel.com> <20210611195029.GA4388@sdutt-i7> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: User-Agent: Mutt/1.9.4 (2018-02-28) Subject: Re: [Intel-gfx] [RFC PATCH 2/2] drm/doc/rfc: i915 new parallel submission uAPI plan X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org, carl.zhang@intel.com, jason.ekstrand@intel.com, daniel.vetter@intel.com, mesa-dev@lists.freedesktop.org, christian.koenig@amd.com Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" T24gVGh1LCBKdW4gMTcsIDIwMjEgYXQgMDY6NDY6NDhQTSArMDIwMCwgRGFuaWVsIFZldHRlciB3 cm90ZToKPiBTb3JyeSBJJ20gYmVoaW5kIG9uIG1haWxzICAuLi4KPiAKCkFyZW4ndCB3ZSBhbGwu Cgo+IE9uIEZyaSwgSnVuIDExLCAyMDIxIGF0IDEyOjUwOjI5UE0gLTA3MDAsIE1hdHRoZXcgQnJv c3Qgd3JvdGU6Cj4gPiBPbiBGcmksIEp1biAwNCwgMjAyMSBhdCAwNzo1OTowNVBNICswMjAwLCBE YW5pZWwgVmV0dGVyIHdyb3RlOgo+ID4gPiBPbiBXZWQsIE1heSAyNiwgMjAyMSBhdCAwNDozMzo1 N1BNIC0wNzAwLCBNYXR0aGV3IEJyb3N0IHdyb3RlOgo+ID4gPiA+IEFkZCBlbnRyeSBmb3IgaTkx NSBuZXcgcGFyYWxsZWwgc3VibWlzc2lvbiB1QVBJIHBsYW4uCj4gPiA+ID4gCj4gPiA+ID4gdjI6 Cj4gPiA+ID4gIChEYW5pZWwgVmV0dGVyKToKPiA+ID4gPiAgIC0gRXhwYW5kIGxvZ2ljYWwgb3Jk ZXIgZXhwbGFpbmF0aW9uCj4gPiA+ID4gICAtIEFkZCBkdW1teSBoZWFkZXIKPiA+ID4gPiAgIC0g T25seSBhbGxvdyBOIEJCcyBpbiBleGVjYnVmIElPQ1RMCj4gPiA+ID4gICAtIENvbmZpZ3VyZSBw YXJhbGxlbCBzdWJtaXNzaW9uIHBlciBzbG90IG5vdCBwZXIgZ2VtIGNvbnRleHQKPiA+ID4gPiB2 MzoKPiA+ID4gPiAgKE1hcmNpbiDFmmx1c2Fyeik6Cj4gPiA+ID4gICAtIExvdCdzIG9mIHR5cG9z IC8gYmFkIGVuZ2xpc2ggZml4ZWQKPiA+ID4gPiAgKFR2cnRrbyBVcnN1bGluKToKPiA+ID4gPiAg IC0gQ29uc2lzdGVudCBwc2V1ZG8gY29kZSwgY2xlYW4gdXAgd29yZGluZyBpbiBkZXNjcmlwdGlv bnMKPiA+ID4gPiAKPiA+ID4gPiBDYzogVHZydGtvIFVyc3VsaW4gPHR2cnRrby51cnN1bGluQGlu dGVsLmNvbT4KPiA+ID4gPiBDYzogVG9ueSBZZSA8dG9ueS55ZUBpbnRlbC5jb20+Cj4gPiA+ID4g Q0M6IENhcmwgWmhhbmcgPGNhcmwuemhhbmdAaW50ZWwuY29tPgo+ID4gPiA+IENjOiBEYW5pZWwg VmV0dGVyIDxkYW5pZWwudmV0dGVyQGludGVsLmNvbT4KPiA+ID4gPiBDYzogSmFzb24gRWtzdHJh bmQgPGphc29uQGpsZWtzdHJhbmQubmV0Pgo+ID4gPiA+IFNpZ25lZC1vZmYtYnk6IE1hdHRoZXcg QnJvc3QgPG1hdHRoZXcuYnJvc3RAaW50ZWwuY29tPgo+ID4gPiA+IC0tLQo+ID4gPiA+ICBEb2N1 bWVudGF0aW9uL2dwdS9yZmMvaTkxNV9wYXJhbGxlbF9leGVjYnVmLmggfCAxNDUgKysrKysrKysr KysrKysrKysrCj4gPiA+ID4gIERvY3VtZW50YXRpb24vZ3B1L3JmYy9pOTE1X3NjaGVkdWxlci5y c3QgICAgICB8ICA1NSArKysrKystCj4gPiA+ID4gIDIgZmlsZXMgY2hhbmdlZCwgMTk4IGluc2Vy dGlvbnMoKyksIDIgZGVsZXRpb25zKC0pCj4gPiA+ID4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBEb2N1 bWVudGF0aW9uL2dwdS9yZmMvaTkxNV9wYXJhbGxlbF9leGVjYnVmLmgKPiA+ID4gPiAKPiA+ID4g PiBkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9ncHUvcmZjL2k5MTVfcGFyYWxsZWxfZXhlY2J1 Zi5oIGIvRG9jdW1lbnRhdGlvbi9ncHUvcmZjL2k5MTVfcGFyYWxsZWxfZXhlY2J1Zi5oCj4gPiA+ ID4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiA+ID4gPiBpbmRleCAwMDAwMDAwMDAwMDAuLjIwZGUy MDZlM2FiNAo+ID4gPiA+IC0tLSAvZGV2L251bGwKPiA+ID4gPiArKysgYi9Eb2N1bWVudGF0aW9u L2dwdS9yZmMvaTkxNV9wYXJhbGxlbF9leGVjYnVmLmgKPiA+ID4gPiBAQCAtMCwwICsxLDE0NSBA QAo+ID4gPiA+ICsjZGVmaW5lIEk5MTVfQ09OVEVYVF9FTkdJTkVTX0VYVF9QQVJBTExFTF9TVUJN SVQgMiAvKiBzZWUgaTkxNV9jb250ZXh0X2VuZ2luZXNfcGFyYWxsZWxfc3VibWl0ICovCj4gPiA+ ID4gKwo+ID4gPiA+ICsvKgo+ID4gPiA+ICsgKiBpOTE1X2NvbnRleHRfZW5naW5lc19wYXJhbGxl bF9zdWJtaXQ6Cj4gPiA+IAo+ID4gPiBTbyB0aGUgaWRlYSBpcyB0byBtYWtlIHRoZXNlIGtlcm5l bGRvYyBhbmQgcHVsbCB0aGVtIGludG8gdGhlIHJmYyBzZWN0aW9uLgo+ID4gPiBUaGVuIHdoZW4g d2UgbWVyZ2UsIG1vdmUgdGhlbSB0byB0aGUgcmVhbCB1YXBpIHNlY3Rpb24sIGxpa2Ugd2hhdCBN YXR0IGhhcwo+ID4gPiBkb25lIGZvciBsbWVtLgo+ID4gPiAKPiA+IAo+ID4gWWVwLCB3aWxsIGZp eCBpbiBuZXh0IHJldi4KPiA+IAo+ID4gPiA+ICsgKgo+ID4gPiA+ICsgKiBTZXR1cCBhIHNsb3Qg aW4gdGhlIGNvbnRleHQgZW5naW5lIG1hcCB0byBhbGxvdyBtdWx0aXBsZSBCQnMgdG8gYmUgc3Vi bWl0dGVkCj4gPiA+ID4gKyAqIGluIGEgc2luZ2xlIGV4ZWNidWYgSU9DVEwuIFRob3NlIEJCcyB3 aWxsIHRoZW4gYmUgc2NoZWR1bGVkIHRvIHJ1biBvbiB0aGUgR1BVCj4gPiA+ID4gKyAqIGluIHBh cmFsbGVsLiBNdWx0aXBsZSBoYXJkd2FyZSBjb250ZXh0cyBhcmUgY3JlYXRlZCBpbnRlcm5hbGx5 IGluIHRoZSBpOTE1Cj4gPiA+ID4gKyAqIHJ1biB0aGVzZSBCQnMuIE9uY2UgYSBzbG90IGlzIGNv bmZpZ3VyZWQgZm9yIE4gQkJzIG9ubHkgTiBCQnMgY2FuIGJlCj4gPiA+ID4gKyAqIHN1Ym1pdHRl ZCBpbiBlYWNoIGV4ZWNidWYgSU9DVEwgYW5kIHRoaXMgaXMgaW1wbGljaXQgYmVoYXZpb3IgZS5n LiBUaGUgdXNlcgo+ID4gPiA+ICsgKiBkb2Vzbid0IHRlbGwgdGhlIGV4ZWNidWYgSU9DVEwgdGhl cmUgYXJlIE4gQkJzLCB0aGUgZXhlY2J1ZiBJT0NUTCBrbm93IGhvdwo+ID4gPiA+ICsgKiBtYW55 IEJCcyB0aGVyZSBhcmUgYmFzZWQgb24gdGhlIHNsb3RzIGNvbmZpZ3VyYXRpb24uIFRoZSBOIEJC cyBhcmUgdGhlIGxhc3QgTgo+ID4gPiA+ICsgKiBidWZmZXIgb2JqZWN0cyBmb3IgZmlyc3QgTiBp ZiBJOTE1X0VYRUNfQkFUQ0hfRklSU1QgaXMgc2V0Lgo+ID4gPiAKPiA+ID4gcy9mb3Ivb3IvCj4g PiA+IAo+ID4gPiA+ICsgKgo+ID4gPiA+ICsgKiBUaGVyZSBhcmUgdHdvIGN1cnJlbnRseSBkZWZp bmVkIHdheXMgdG8gY29udHJvbCB0aGUgcGxhY2VtZW50IG9mIHRoZQo+ID4gPiA+ICsgKiBoYXJk d2FyZSBjb250ZXh0cyBvbiBwaHlzaWNhbCBlbmdpbmVzOiBkZWZhdWx0IGJlaGF2aW9yIChubyBm bGFncykgYW5kCj4gPiA+ID4gKyAqIEk5MTVfUEFSQUxMRUxfSU1QTElDSVRfQk9ORFMgKGEgZmxh ZykuIE1vcmUgZmxhZ3MgbWF5IGJlIGFkZGVkIHRoZSBpbiB0aGUKPiA+ID4gPiArICogZnV0dXJl IGFzIG5ldyBoYXJkd2FyZSAvIHVzZSBjYXNlcyBhcmlzZS4gRGV0YWlscyBvZiBob3cgdG8gdXNl IHRoaXMKPiA+ID4gPiArICogaW50ZXJmYWNlIGFib3ZlIHRoZSBmbGFncyBmaWVsZCBpbiB0aGlz IHN0cnVjdHVyZS4KPiA+ID4gPiArICoKPiA+ID4gPiArICogUmV0dXJucyAtRUlOVkFMIGlmIGhh cmR3YXJlIGNvbnRleHQgcGxhY2VtZW50IGNvbmZpZ3VyYXRpb24gaXMgaW52YWxpZCBvciBpZgo+ ID4gPiA+ICsgKiB0aGUgcGxhY2VtZW50IGNvbmZpZ3VyYXRpb24gaXNuJ3Qgc3VwcG9ydGVkIG9u IHRoZSBwbGF0Zm9ybSAvIHN1Ym1pc3Npb24KPiA+ID4gPiArICogaW50ZXJmYWNlLgo+ID4gPiA+ ICsgKiBSZXR1cm5zIC1FTk9ERVYgaWYgZXh0ZW5zaW9uIGlzbid0IHN1cHBvcnRlZCBvbiB0aGUg cGxhdGZvcm0gLyBzdWJtaXNzaW9uCj4gPiA+ID4gKyAqIGludGVmYWNlLgo+ID4gPiA+ICsgKi8K PiA+ID4gPiArc3RydWN0IGk5MTVfY29udGV4dF9lbmdpbmVzX3BhcmFsbGVsX3N1Ym1pdCB7Cj4g PiA+ID4gKwlzdHJ1Y3QgaTkxNV91c2VyX2V4dGVuc2lvbiBiYXNlOwo+ID4gPiA+ICsKPiA+ID4g PiArCV9fdTE2IGVuZ2luZV9pbmRleDsJLyogc2xvdCBmb3IgcGFyYWxsZWwgZW5naW5lICovCj4g PiA+IAo+ID4gPiBLZXJuZWwgZG9jIGhlcmUgZm9yIHRoZSBpbmxpbmUgY29tbWVudHMgdG9vLgo+ ID4gPgo+ID4gCj4gPiBZZXAuCj4gPiAgCj4gPiA+ID4gKwlfX3UxNiB3aWR0aDsJCS8qIG51bWJl ciBvZiBjb250ZXh0cyBwZXIgcGFyYWxsZWwgZW5naW5lICovCj4gPiA+ID4gKwlfX3UxNiBudW1f c2libGluZ3M7CS8qIG51bWJlciBvZiBzaWJsaW5ncyBwZXIgY29udGV4dCAqLwo+ID4gPiA+ICsJ X191MTYgbWJ6MTY7Cj4gPiA+ID4gKy8qCj4gPiA+ID4gKyAqIERlZmF1bHQgcGxhY2VtZW50IGJl aGF2aW9yIChjdXJyZW50bHkgdW5zdXBwb3J0ZWQpOgo+ID4gPiA+ICsgKgo+ID4gPiA+ICsgKiBB bGxvdyBCQnMgdG8gYmUgcGxhY2VkIG9uIGFueSBhdmFpbGFibGUgZW5naW5lIGluc3RhbmNlLiBJ biB0aGlzIGNhc2UgZWFjaAo+ID4gPiA+ICsgKiBjb250ZXh0J3MgZW5naW5lIG1hc2sgaW5kaWNh dGVzIHdoZXJlIHRoYXQgY29udGV4dCBjYW4gYmUgcGxhY2VkLiBJdCBpcwo+ID4gPiA+ICsgKiBp bXBsaWVkIGluIHRoaXMgbW9kZSB0aGF0IGFsbCBjb250ZXh0cyBoYXZlIG11dHVhbCBleGNsdXNp dmUgcGxhY2VtZW50Lgo+ID4gPiA+ICsgKiBlLmcuIElmIG9uZSBjb250ZXh0IGlzIHJ1bm5pbmcg Q1NYWzBdIG5vIG90aGVyIGNvbnRleHRzIGNhbiBydW4gb24gQ1NYWzBdKS4KPiA+ID4gPiArICoK PiA+ID4gPiArICogRXhhbXBsZSAxIHBzZXVkbyBjb2RlOgo+ID4gPiA+ICsgKiBDU1gsWVtOXSA9 IGdlbmVyaWMgZW5naW5lIGNsYXNzIFggb3IgWSwgbG9naWNhbCBpbnN0YW5jZSBOCj4gPiA+ID4g KyAqIElOVkFMSUQgPSBJOTE1X0VOR0lORV9DTEFTU19JTlZBTElELCBJOTE1X0VOR0lORV9DTEFT U19JTlZBTElEX05PTkUKPiA+ID4gPiArICogc2V0X2VuZ2luZXMoSU5WQUxJRCkKPiA+ID4gPiAr ICogc2V0X3BhcmFsbGVsKGVuZ2luZV9pbmRleD0wLCB3aWR0aD0yLCBudW1fc2libGluZ3M9MiwK PiA+ID4gPiArICoJCWVuZ2luZXM9Q1NYWzBdLENTWFsxXSxDU1lbMF0sQ1NZWzFdKQo+ID4gPiA+ ICsgKgo+ID4gPiA+ICsgKiBSZXN1bHRzIGluIHRoZSBmb2xsb3dpbmcgdmFsaWQgcGxhY2VtZW50 czoKPiA+ID4gPiArICogQ1NYWzBdLCBDU1lbMF0KPiA+ID4gPiArICogQ1NYWzBdLCBDU1lbMV0K PiA+ID4gPiArICogQ1NYWzFdLCBDU1lbMF0KPiA+ID4gPiArICogQ1NYWzFdLCBDU1lbMV0KPiA+ ID4gPiArICoKPiA+ID4gPiArICogVGhpcyBjYW4gYWxzbyBiZSB0aG91Z2h0IG9mIGFzIDIgdmly dHVhbCBlbmdpbmVzIGRlc2NyaWJlZCBieSAyLUQgYXJyYXkgaW4KPiA+ID4gPiArICogdGhlIGVu Z2luZXMgdGhlIGZpZWxkOgo+ID4gPiA+ICsgKiBWRVswXSA9IENTWFswXSwgQ1NYWzFdCj4gPiA+ ID4gKyAqIFZFWzFdID0gQ1NZWzBdLCBDU1lbMV0KPiA+ID4gPiArICoKPiA+ID4gPiArICogRXhh bXBsZSAyIHBzZXVkbyBjb2RlOgo+ID4gPiA+ICsgKiBDU1hbWV0gPSBnZW5lcmljIGVuZ2luZSBv ZiBzYW1lIGNsYXNzIFgsIGxvZ2ljYWwgaW5zdGFuY2UgTgo+ID4gPiA+ICsgKiBJTlZBTElEID0g STkxNV9FTkdJTkVfQ0xBU1NfSU5WQUxJRCwgSTkxNV9FTkdJTkVfQ0xBU1NfSU5WQUxJRF9OT05F Cj4gPiA+ID4gKyAqIHNldF9lbmdpbmVzKElOVkFMSUQpCj4gPiA+ID4gKyAqIHNldF9wYXJhbGxl bChlbmdpbmVfaW5kZXg9MCwgd2lkdGg9MiwgbnVtX3NpYmxpbmdzPTMsCj4gPiA+ID4gKyAqCQll bmdpbmVzPUNTWFswXSxDU1hbMV0sQ1NYWzJdLENTWFswXSxDU1hbMV0sQ1NYWzJdKQo+ID4gPiA+ ICsgKgo+ID4gPiA+ICsgKiBSZXN1bHRzIGluIHRoZSBmb2xsb3dpbmcgdmFsaWQgcGxhY2VtZW50 czoKPiA+ID4gPiArICogQ1NYWzBdLCBDU1hbMV0KPiA+ID4gPiArICogQ1NYWzBdLCBDU1hbMl0K PiA+ID4gPiArICogQ1NYWzFdLCBDU1hbMF0KPiA+ID4gPiArICogQ1NYWzFdLCBDU1hbMl0KPiA+ ID4gPiArICogQ1NYWzJdLCBDU1hbMF0KPiA+ID4gPiArICogQ1NYWzJdLCBDU1hbMV0KPiA+ID4g PiArICoKPiA+ID4gPiArICogVGhpcyBjYW4gYWxzbyBiZSB0aG91Z2h0IG9mIGFzIDIgdmlydHVh bCBlbmdpbmVzIGRlc2NyaWJlZCBieSAyLUQgYXJyYXkgaW4KPiA+ID4gPiArICogdGhlIGVuZ2lu ZXMgdGhlIGZpZWxkOgo+ID4gPiA+ICsgKiBWRVswXSA9IENTWFswXSwgQ1NYWzFdLCBDU1hbMl0K PiA+ID4gPiArICogVkVbMV0gPSBDU1hbMF0sIENTWFsxXSwgQ1NYWzJdCj4gPiA+ID4gKwo+ID4g PiA+ICsgKiBUaGlzIGVuYWJsZXMgYSB1c2UgY2FzZSB3aGVyZSBhbGwgZW5naW5lcyBhcmUgY3Jl YXRlZCBlcXVhbGx5LCB3ZSBkb24ndCBjYXJlCj4gPiA+ID4gKyAqIHdoZXJlIHRoZXkgYXJlIHNj aGVkdWxlZCwgd2UganVzdCB3YW50IGEgY2VydGFpbiBudW1iZXIgb2YgcmVzb3VyY2VzLCBmb3IK PiA+ID4gPiArICogdGhvc2UgcmVzb3VyY2VzIHRvIGJlIHNjaGVkdWxlZCBpbiBwYXJhbGxlbCwg YW5kIHBvc3NpYmx5IGFjcm9zcyBtdWx0aXBsZQo+ID4gPiA+ICsgKiBlbmdpbmUgY2xhc3Nlcy4K PiA+ID4gPiArICovCj4gPiA+ID4gKwo+ID4gPiA+ICsvKgo+ID4gPiAKPiA+ID4gV291bGQgYmUg Z29vZCB0byBhbHNvIG1vdmUgdGhpcyBpbnRvIHRoZSBrZXJuZWxkb2MgKG1heWJlIGFkZCBsYWJl bGxlZAo+ID4gPiBsaXN0IGZvciBmbGFncyBvciBzbykgc28gaXQgc2hvd3MgdXAgaW4gdGhlIHJl bmRlciBvdXRwdXQuCj4gPiA+Cj4gPiAKPiA+IFN1cmUuIEkgbmVlZCBmaWd1cmUgb3V0IHZpZXcg dGhlIGtlcm5lbCBkb2MgbG9jYWxseSBiZWZvcmUgbXkgbmV4dCBhbmQgbWFrZSBzdXJlCj4gPiBl dmVyeXRoaW5nIGxvb2tzIHJpZ2h0Lgo+IAo+ICQgbWFrZSBodG1sZG9jcwo+IAo+IE91dHB1dCBp cyBpbiBEb2N1bWVudGF0aW9uL291dHB1dC9ncHUvaW5kZXguaHRtbCAodG8gZ2V0IHRoZXJlIG1v cmUKPiBkaXJlY3RseSkuCj4gCgpJJ3ZlIGZpZ3VyZWQgdGhpcyBvdXQsIG5leHQgcmV2IG9mIGRv Y3MgbG9va3MgZ29vZCB0byBtZS4KCj4gPiAgCj4gPiA+ID4gKyAqIEk5MTVfUEFSQUxMRUxfSU1Q TElDSVRfQk9ORFMgLSBDcmVhdGUgaW1wbGljaXQgYm9uZHMgYmV0d2VlbiBlYWNoIGNvbnRleHQu Cj4gPiA+ID4gKyAqIEVhY2ggY29udGV4dCBtdXN0IGhhdmUgdGhlIHNhbWUgbnVtYmVyIG9mIHNp YmxpbmcgYW5kIGJvbmRzIGFyZSBpbXBsaWNpdGx5Cj4gPiA+ID4gKyAqIGNyZWF0ZWQgYmV0d2Vl biBlYWNoIHNldCBvZiBzaWJsaW5ncy4KPiA+ID4gPiArICoKPiA+ID4gPiArICogRXhhbXBsZSAx IHBzZXVkbyBjb2RlOgo+ID4gPiA+ICsgKiBDU1hbTl0gPSBnZW5lcmljIGVuZ2luZSBvZiBzYW1l IGNsYXNzIFgsIGxvZ2ljYWwgaW5zdGFuY2UgTgo+ID4gPiA+ICsgKiBJTlZBTElEID0gSTkxNV9F TkdJTkVfQ0xBU1NfSU5WQUxJRCwgSTkxNV9FTkdJTkVfQ0xBU1NfSU5WQUxJRF9OT05FCj4gPiA+ ID4gKyAqIHNldF9lbmdpbmVzKElOVkFMSUQpCj4gPiA+ID4gKyAqIHNldF9wYXJhbGxlbChlbmdp bmVfaW5kZXg9MCwgd2lkdGg9MiwgbnVtX3NpYmxpbmdzPTEsCj4gPiA+ID4gKyAqCQllbmdpbmVz PUNTWFswXSxDU1hbMV0sIGZsYWdzPUk5MTVfUEFSQUxMRUxfSU1QTElDSVRfQk9ORFMpCj4gPiA+ ID4gKyAqCj4gPiA+ID4gKyAqIFJlc3VsdHMgaW4gdGhlIGZvbGxvd2luZyB2YWxpZCBwbGFjZW1l bnRzOgo+ID4gPiA+ICsgKiBDU1hbMF0sIENTWFsxXQo+ID4gPiA+ICsgKgo+ID4gPiA+ICsgKiBF eGFtcGxlIDIgcHNldWRvIGNvZGU6Cj4gPiA+ID4gKyAqIENTWFtOXSA9IGdlbmVyaWMgZW5naW5l IG9mIHNhbWUgY2xhc3MgWCwgbG9naWNhbCBpbnN0YW5jZSBOCj4gPiA+ID4gKyAqIElOVkFMSUQg PSBJOTE1X0VOR0lORV9DTEFTU19JTlZBTElELCBJOTE1X0VOR0lORV9DTEFTU19JTlZBTElEX05P TkUKPiA+ID4gPiArICogc2V0X2VuZ2luZXMoSU5WQUxJRCkKPiA+ID4gPiArICogc2V0X3BhcmFs bGVsKGVuZ2luZV9pbmRleD0wLCB3aWR0aD0yLCBudW1fc2libGluZ3M9MiwKPiA+ID4gPiArICoJ CWVuZ2luZXM9Q1NYWzBdLENTWFsyXSxDU1hbMV0sQ1NYWzNdLAo+ID4gPiA+ICsgKgkJZmxhZ3M9 STkxNV9QQVJBTExFTF9JTVBMSUNJVF9CT05EUykKPiA+ID4gPiArICoKPiA+ID4gPiArICogUmVz dWx0cyBpbiB0aGUgZm9sbG93aW5nIHZhbGlkIHBsYWNlbWVudHM6Cj4gPiA+ID4gKyAqIENTWFsw XSwgQ1NYWzFdCj4gPiA+ID4gKyAqIENTWFsyXSwgQ1NYWzNdCj4gPiA+ID4gKyAqCj4gPiA+ID4g KyAqIFRoaXMgY2FuIGFsc28gYmUgdGhvdWdodCBvZiBhcyAyIHZpcnR1YWwgZW5naW5lcyBkZXNj cmliZWQgYnkgMi1EIGFycmF5IGluCj4gPiA+ID4gKyAqIHRoZSBlbmdpbmVzIHRoZSBmaWVsZCB3 aXRoIGJvbmRzIHBsYWNlZCBiZXR3ZWVuIGVhY2ggaW5kZXggb2YgdGhlIHZpcnR1YWwKPiA+ID4g PiArICogZW5naW5lcy4gZS5nLiBDU1hbMF0gaXMgYm9uZGVkIHRvIENTWFsxXSwgQ1NYWzJdIGlz IGJvbmRlZCB0byBDU1hbM10uCj4gPiA+ID4gKyAqIFZFWzBdID0gQ1NYWzBdLCBDU1hbMl0KPiA+ ID4gPiArICogVkVbMV0gPSBDU1hbMV0sIENTWFszXQo+ID4gPiA+ICsgKgo+ID4gPiA+ICsgKiBU aGlzIGVuYWJsZXMgYSB1c2UgY2FzZSB3aGVyZSBhbGwgZW5naW5lcyBhcmUgbm90IGVxdWFsIGFu ZCBjZXJ0YWluIHBsYWNlbWVudAo+ID4gPiA+ICsgKiBydWxlcyBhcmUgcmVxdWlyZWQgKGkuZS4g c3BsaXQtZnJhbWUgcmVxdWlyZXMgYWxsIGNvbnRleHRzIHRvIGJlIHBsYWNlZCBpbiBhCj4gPiA+ ID4gKyAqIGxvZ2ljYWxseSBjb250aWd1b3VzIG9yZGVyIG9uIHRoZSBWQ1MgZW5naW5lcyBvbiBn ZW4xMSsgcGxhdGZvcm1zKS4gVGhpcyB1c2UKPiA+ID4gPiArICogY2FzZSAobG9naWNhbGx5IGNv bnRpZ3VvdXMgcGxhY2VtZW50LCB3aXRoaW4gYSBzaW5nbGUgZW5naW5lIGNsYXNzKSBpcwo+ID4g PiA+ICsgKiBzdXBwb3J0ZWQgd2hlbiB1c2luZyBHdUMgc3VibWlzc2lvbi4gRXhlY2xpc3QgbW9k ZSBjb3VsZCBzdXBwb3J0IGFsbCBwb3NzaWJsZQo+ID4gPiA+ICsgKiBib25kaW5nIGNvbmZpZ3Vy YXRpb25zIGJ1dCBjdXJyZW50bHkgZG9lc24ndCBzdXBwb3J0IHRoaXMgZXh0ZW5zaW9uLgo+ID4g PiA+ICsgKi8KPiA+ID4gPiArI2RlZmluZSBJOTE1X1BBUkFMTEVMX0lNUExJQ0lUX0JPTkRTCQkJ KDEgPDwgMCkKPiA+ID4gPiArLyoKPiA+ID4gPiArICogRG8gbm90IGFsbG93IEJCcyB0byBiZSBw cmVlbXB0ZWQgbWlkIEJCIHJhdGhlciBpbnNlcnQgY29vcmRpbmF0ZWQgcHJlZW1wdGlvbgo+ID4g PiA+ICsgKiBwb2ludHMgb24gYWxsIGhhcmR3YXJlIGNvbnRleHRzIGJldHdlZW4gZWFjaCBzZXQg b2YgQkJzLiBBbiBleGFtcGxlIHVzZSBjYXNlCj4gPiA+ID4gKyAqIG9mIHRoaXMgZmVhdHVyZSBp cyBzcGxpdC1mcmFtZSBvbiBnZW4xMSsgaGFyZHdhcmUuCj4gPiA+ID4gKyAqLwo+ID4gPiA+ICsj ZGVmaW5lIEk5MTVfUEFSQUxMRUxfTk9fUFJFRU1QVF9NSURfQkFUQ0gJCSgxIDw8IDEpCj4gPiA+ IAo+ID4gPiBTbyBJIGdldCB0aGUgaGlzdG9yeSBub3cgYmVoaW5kIHRoaXMsIGJ1dCBJIHRoaW5r IHNwZWNpZnlpbmcgZmxhZ3MgZm9yIHRoZQo+ID4gPiBvbmx5IGJlaGF2aW91ciB5b3UgY2FuIGdl dCBhbmQgdGhlIG9ubHkgYmVoYXZpb3VyIHRoYXQgdXNlcnNwYWNlIGFza3MgZm9yCj4gPiA+IGlz IHNpbGx5Lgo+ID4gPiAKPiA+ID4gSSB0aGluayB3ZSBzaG91bGQganVzdCBtb3ZlIHRoZSBhY3R1 YWwgYmVoYXZpb3VyIHNwZWMgaW50byB0aGUga2VybmVsZG9jLAo+ID4gPiBhcyBpbiAidGhpcyBp cyB0aGUgYm9uZGluZyB5b3UgZ2V0IiBhbmQgImR1ZSB0byBody9mdyBsaW1pdGF0aW9ucyB0aGVz ZQo+ID4gPiB3b3JrbG9hZHMgd2lsbCBiZSBub24tcHJlZW1wdGFibGUiIGFuZCBjYWxsIGl0IGEg ZGF5LiBUcnlpbmcgdG8gZ3Vlc3MKPiA+ID4gZnV0dXJlIG5lZWRzIGFuZCBzcGVjaWZ5aW5nIHRo ZW0sIHdpdGhvdXQga25vd2luZyB0aG9zZSBmdXR1cmUgbmVlZHMKPiA+ID4gcHJlY2lzZWx5LCBt dWNoIGxlc3MgaGF2aW5nIGFuIGltcGxlbWVudGF0aW9uLCBqdXN0IG5ldmVyIHdvcmtzIG91dAo+ ID4gPiByZWFsbHkuCj4gPiA+Cj4gPiAKPiA+IFNvIG5vIGZsYWdzPyBPciBqdXN0IHRoZSBkZWZh dWx0IGJlaGF2aW9yIGlzIEk5MTVfUEFSQUxMRUxfSU1QTElDSVRfQk9ORFMgfAo+ID4gSTkxNV9Q QVJBTExFTF9OT19QUkVFTVBUX01JRF9CQVRDSCBmb3Igbm93LCB0aGUgZmxhZ3MgYXJlIHVudXNl ZCwgYnV0IGNvdWxkIGJlCj4gPiB1c2VkIGluIHRoZSBmdXR1cmUgaWYgbmVlZGVkPwo+IAo+IFRo ZSBpbXBsaWNpdF9ib25kcyBJIHRoaW5rIHNob3VsZCBiZSBqdXN0IHRoZSBkZWZhdWx0LCB3ZSBj YW4gYWRkIGZsYWdzCj4gZm9yIHRoZSBvdGhlciBzdHVmZiB3aGVuIGl0IGV4aXN0Lgo+CgpZZXAs IG5leHQgcmV2IHRoaXMgaXMgdGhlIGRlZmF1bHQuCiAKPiBUaGUgTk9fUFJFRU1QVCBJIHRoaW5r IG1ha2VzIHNvbWUgc2Vuc2UgdG8ga2VlcCB0byBtYWtlIHRoaXMgcGFydAo+IGV4cGxpY2l0LiBF aXRoZXIgd2F5IG9uIHRoYXQgaXMgZmluZSB3aXRoIG1lLgo+IAoKT2ssIG15IG5leHQgcmV2IG1h ZGUgdGhpcyB0aGUgZGVmYXVsdCBiZWhhdmlvci4gRWl0aGVyIHdheSwgbm90IGEgYmlnCmRlYWwg b3IgZW5vdWdoIHRvIHJlc3BpbiB0aGlzIERvQyBhcyBpdCBpcyBvbmx5IHRoZSBEb0MuIFdlIGNh biBtYWtlIGEKY2hvaWNlIG9uIHRoZSBOT19QUkVFTVBUIHdoZW4gdGhlIGNvZGUgbGFuZHMuIAoK PiA+ID4gSSBkaXNjdXNzZWQgdGhpcyBhIGJpdCB3aXRoIEphc29uLCBhbmQgaGUncyBzdWdnZXN0 ZWQgdGhpcyBtYWtlcyBzZW5zZSBhcwo+ID4gPiBhIGVuZ2luZSBmbGFnLCBidXQgZGVmaW5pdGVs eSBub3Qgb24gdGhlIHBhcmFsbGVsIGV4dGVuc2lvbi4gQnV0IHNpbmNlIHdlCj4gPiAKPiA+IE5v dCBzdXJlIHdoYXQgeW91IG1lYW4gYnkgYW4gZW5naW5lIGZsYWdzLiBUaGlzIGlzIGEgcGVyIGNv bnRleHQgY29uY2VwdC4KPiAKPiBPaCwgSSBndWVzcyB0aGlzIGlzIG1vcmUgZmFsbG91dCBmcm9t IHRoZSBjb252ZXJzaW9uIGZyb20gaGF2aW5nIHRoZQo+IGVudGlyZSBnZW0gY29udGV4dCBhcyB0 aGUgcGFyYWxsZWwgc3VibWl0IHZlaGljbGUgdG8gYSB2aXJ0dWFsIGVuZ2luZS4KPiAKPiBJZiB3 ZSBkbyBoYXZlIHRoZW0gYXMgZmxhZ3MsIHRoZXkgbmVlZCB0byBiZSBvbiB0aGF0IHZpcnR1YWwg ZW5naW5lLCBub3QKPiBvbiB0aGUgb3ZlcmFsbCBnZW0gY29udGV4dCBjb250YWluZXIgdGhpbmcu IEF0IHRoYXQgcG9pbnQgdGhleSBkb24ndAo+IGV4YWN0bHkgbWF0Y2ggdXAgdGhlIGV4aXN0aW5n IHByZWVtcHQgZmxhZyB3ZSBoYXZlIChvbiB0aGUgY29udGV4dCksIHNvCj4gbWF5YmUgd2Ugc2hv dWxkIGp1c3QgbWFrZSB0aGlzIGltcGxpZWQgKGJ1dCBvZmMgZG9jdW1lbnRlZCkgYmVoYXZpb3Vy Lgo+IAoKR290IGl0LgoKTWF0dAoKPiBDaGVlcnMsIERhbmllbAo+IAo+ID4gCj4gPiA+IGRvbid0 IGhhdmUgYSBuZWVkIGZvciBwaWNraW5nIGEgbm9uLWRlZmF1bHQgdmFsdWUganVzdCBleHRyYSB3 b3JrLgo+ID4gPiAKPiA+ID4gPiArI2RlZmluZSBfX0k5MTVfUEFSQUxMRUxfVU5LTk9XTl9GTEFH UwkoLShJOTE1X1BBUkFMTEVMX05PX1BSRUVNUFRfTUlEX0JBVENIIDw8IDEpKQo+ID4gPiA+ICsJ X191NjQgZmxhZ3M7CQkvKiBhbGwgdW5kZWZpbmVkIGZsYWdzIG11c3QgYmUgemVybyAqLwo+ID4g PiA+ICsJX191NjQgbWJ6NjRbM107CQkvKiByZXNlcnZlZCBmb3IgZnV0dXJlIHVzZTsgbXVzdCBi ZSB6ZXJvICovCj4gPiA+ID4gKwo+ID4gPiA+ICsJLyoKPiA+ID4gPiArCSAqIDItRCBhcnJheSBv ZiBlbmdpbmVzCj4gPiA+ID4gKwkgKgo+ID4gPiA+ICsJICogd2lkdGggKGkpICogbnVtX3NpYmxp bmdzIChqKSBpbiBsZW5ndGgKPiA+ID4gPiArCSAqIGluZGV4ID0gaiArIGkgKiBudW1fc2libGlu Z3MKPiA+ID4gPiArCSAqLwo+ID4gPiA+ICsJc3RydWN0IGk5MTVfZW5naW5lX2NsYXNzX2luc3Rh bmNlIGVuZ2luZXNbMF07Cj4gPiA+ID4gK30gX19hdHRyaWJ1dGVfXyAoKHBhY2tlZCkpOwo+ID4g PiA+ICsKPiA+ID4gPiBkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9ncHUvcmZjL2k5MTVfc2No ZWR1bGVyLnJzdCBiL0RvY3VtZW50YXRpb24vZ3B1L3JmYy9pOTE1X3NjaGVkdWxlci5yc3QKPiA+ ID4gPiBpbmRleCA3ZmFhNDZjZGUwODguLjAyNTRjMDRkMzRiZSAxMDA2NDQKPiA+ID4gPiAtLS0g YS9Eb2N1bWVudGF0aW9uL2dwdS9yZmMvaTkxNV9zY2hlZHVsZXIucnN0Cj4gPiA+ID4gKysrIGIv RG9jdW1lbnRhdGlvbi9ncHUvcmZjL2k5MTVfc2NoZWR1bGVyLnJzdAo+ID4gPiA+IEBAIC0yMyw3 ICsyMyw3IEBAIGk5MTUgd2l0aCB0aGUgRFJNIHNjaGVkdWxlciBpczoKPiA+ID4gPiAgCSAgc2V2 ZXJlIGRlc2lnbiBpc3N1ZXMgaW4gZ2VuZXJhbCwgd2hpY2ggaXMgd2h5IHdlIHdhbnQgdG8gcmV0 aXJlIGl0IG5vCj4gPiA+ID4gIAkgIG1hdHRlciB3aGF0Cj4gPiA+ID4gIAkqIE5ldyB1QVBJIGFk ZHMgSTkxNV9DT05URVhUX0VOR0lORVNfRVhUX1BBUkFMTEVMIGNvbnRleHQgc2V0dXAgc3RlcAo+ ID4gPiA+IC0JICB3aGljaCBjb25maWd1cmVzIGEgc2xvdCB3aXRoIE4gY29udGV4dHMgCj4gPiA+ ID4gKwkgIHdoaWNoIGNvbmZpZ3VyZXMgYSBzbG90IHdpdGggTiBjb250ZXh0cwo+ID4gPiA+ICAJ KiBBZnRlciBJOTE1X0NPTlRFWFRfRU5HSU5FU19FWFRfUEFSQUxMRUwgYSB1c2VyIGNhbiBzdWJt aXQgTiBiYXRjaGVzIHRvCj4gPiA+ID4gIAkgIGEgc2xvdCBpbiBhIHNpbmdsZSBleGVjYnVmIElP Q1RMIGFuZCB0aGUgYmF0Y2hlcyBydW4gb24gdGhlIEdQVSBpbgo+ID4gPiA+ICAJICBwYXJhbGxs ZWwKPiA+ID4gPiBAQCAtODIsNCArODIsNTUgQEAgaHR0cHM6Ly9zcGVjLm9uZWFwaS5jb20vbGV2 ZWwtemVyby9sYXRlc3QvY29yZS9hcGkuaHRtbCN6ZS1jb21tYW5kLXF1ZXVlLXByaW9yaXQKPiA+ ID4gPiAgCj4gPiA+ID4gIE5ldyBwYXJhbGxlbCBzdWJtaXNzaW9uIHVBUEkKPiA+ID4gPiAgPT09 PT09PT09PT09PT09PT09PT09PT09PT09PQo+ID4gPiA+IC1EZXRhaWxzIHRvIGNvbWUgaW4gYSBm b2xsb3dpbmcgcGF0Y2guCj4gPiA+ID4gK1RoZSBleGlzdGluZyBib25kaW5nIHVBUEkgaXMgY29t cGxldGVseSBicm9rZW4gd2l0aCBHdUMgc3VibWlzc2lvbiBiZWNhdXNlCj4gPiA+ID4gK3doZXRo ZXIgYSBzdWJtaXNzaW9uIGlzIGEgc2luZ2xlIGNvbnRleHQgc3VibWl0IG9yIHBhcmFsbGVsIHN1 Ym1pdCBpc24ndCBrbm93bgo+ID4gPiA+ICt1bnRpbCBleGVjYnVmIHRpbWUgYWN0aXZhdGVkIHZp YSB0aGUgSTkxNV9TVUJNSVRfRkVOQ0UuIFRvIHN1Ym1pdCBtdWx0aXBsZQo+ID4gPiA+ICtjb250 ZXh0cyBpbiBwYXJhbGxlbCB3aXRoIHRoZSBHdUMgdGhlIGNvbnRleHQgbXVzdCBiZSBleHBsaWNp dGx5IHJlZ2lzdGVyZWQgd2l0aAo+ID4gPiA+ICtOIGNvbnRleHRzIGFuZCBhbGwgTiBjb250ZXh0 cyBtdXN0IGJlIHN1Ym1pdHRlZCBpbiBhIHNpbmdsZSBjb21tYW5kIHRvIHRoZSBHdUMuCj4gPiA+ ID4gK1RoZSBHdUMgaW50ZXJmYWNlcyBkbyBub3Qgc3VwcG9ydCBkeW5hbWljYWxseSBjaGFuZ2lu ZyBiZXR3ZWVuIE4gY29udGV4dHMgYXMgdGhlCj4gPiA+ID4gK2JvbmRpbmcgdUFQSSBkb2VzLiBI ZW5jZSB0aGUgbmVlZCBmb3IgYSBuZXcgcGFyYWxsZWwgc3VibWlzc2lvbiBpbnRlcmZhY2UuIEFs c28KPiA+ID4gPiArdGhlIGxlZ2FjeSBib25kaW5nIHVBUEkgaXMgcXVpdGUgY29uZnVzaW5nIGFu ZCBub3QgaW50dWl0aXZlIGF0IGFsbC4KPiA+ID4gCj4gPiA+IFdlIHNob3VsZCBhZGQgaGVyZSB0 aGF0ICJGdXJ0aGVybW9yZSBJOTE1X1NVQk1JVF9GRU5DRSBpcyBieSBkZXNpZ24gYQo+ID4gPiBm dXR1cmUgZmVuY2UsIHNvIG5vdCByZWFsbHkgc29tZXRoaW5nIHdlIHNob3VsZCBjb250aW51ZSB0 byBzdXBwb3J0LiIKPiA+ID4gCj4gPiA+ID4gKwo+ID4gPiA+ICtUaGUgbmV3IHBhcmFsbGVsIHN1 Ym1pc3Npb24gdUFQSSBjb25zaXN0cyBvZiAzIHBhcnRzOgo+ID4gPiA+ICsKPiA+ID4gPiArKiBF eHBvcnQgZW5naW5lcyBsb2dpY2FsIG1hcHBpbmcKPiA+ID4gPiArKiBBICdzZXRfcGFyYWxsZWwn IGV4dGVuc2lvbiB0byBjb25maWd1cmUgY29udGV4dHMgZm9yIHBhcmFsbGVsCj4gPiA+ID4gKyAg c3VibWlzc2lvbgo+ID4gPiA+ICsqIEV4dGVuZCBleGVjYnVmMiBJT0NUTCB0byBzdXBwb3J0IHN1 Ym1pdHRpbmcgTiBCQnMgaW4gYSBzaW5nbGUgSU9DVEwKPiA+ID4gPiArCj4gPiA+ID4gK0V4cG9y dCBlbmdpbmVzIGxvZ2ljYWwgbWFwcGluZwo+ID4gPiA+ICstLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0KPiA+ID4gPiArQ2VydGFpbiB1c2UgY2FzZXMgcmVxdWlyZSBCQnMgdG8gYmUgcGxh Y2VkIG9uIGVuZ2luZSBpbnN0YW5jZXMgaW4gbG9naWNhbCBvcmRlcgo+ID4gPiA+ICsoZS5nLiBz cGxpdC1mcmFtZSBvbiBnZW4xMSspLiBUaGUgbG9naWNhbCBtYXBwaW5nIG9mIGVuZ2luZSBpbnN0 YW5jZXMgY2FuIGNoYW5nZQo+ID4gPiA+ICtiYXNlZCBvbiBmdXNpbmcuIFJhdGhlciB0aGFuIG1h a2luZyBVTURzIGJlIGF3YXJlIG9mIGZ1c2luZywgc2ltcGx5IGV4cG9zZSB0aGUKPiA+ID4gPiAr bG9naWNhbCBtYXBwaW5nIHdpdGggdGhlIGV4aXN0aW5nIHF1ZXJ5IGVuZ2luZSBpbmZvIElPQ1RM LiBBbHNvIHRoZSBHdUMKPiA+ID4gPiArc3VibWlzc2lvbiBpbnRlcmZhY2UgY3VycmVudGx5IG9u bHkgc3VwcG9ydHMgc3VibWl0dGluZyBtdWx0aXBsZSBjb250ZXh0cyB0bwo+ID4gPiA+ICtlbmdp bmVzIGluIGxvZ2ljYWwgb3JkZXIgd2hpY2ggaXMgYSBuZXcgcmVxdWlyZW1lbnQgY29tcGFyZWQg dG8gZXhlY2xpc3RzLgo+ID4gPiA+ICtMYXN0bHksIGFsbCBjdXJyZW50IHBsYXRmb3JtcyBoYXZl IGF0IG1vc3QgMiBlbmdpbmUgaW5zdGFuY2VzIGFuZCB0aGUgbG9naWNhbAo+ID4gPiA+ICtvcmRl ciBpcyB0aGUgc2FtZSBhcyB1QVBJIG9yZGVyLiBUaGlzIHdpbGwgY2hhbmdlIG9uIHBsYXRmb3Jt cyB3aXRoIG1vcmUgdGhhbiAyCj4gPiA+ID4gK2VuZ2luZSBpbnN0YW5jZXMuCj4gPiA+ID4gKwo+ ID4gPiA+ICtBIHNpbmdsZSBiaXQgd2lsbCBiZSBhZGRlZCB0byBkcm1faTkxNV9lbmdpbmVfaW5m by5mbGFncyBpbmRpY2F0aW5nIHRoYXQgdGhlCj4gPiA+ID4gK2xvZ2ljYWwgaW5zdGFuY2UgaGFz IGJlZW4gcmV0dXJuZWQgYW5kIGEgbmV3IGZpZWxkLAo+ID4gPiA+ICtkcm1faTkxNV9lbmdpbmVf aW5mby5sb2dpY2FsX2luc3RhbmNlLCByZXR1cm5zIHRoZSBsb2dpY2FsIGluc3RhbmNlLgo+ID4g PiA+ICsKPiA+ID4gPiArQSAnc2V0X3BhcmFsbGVsJyBleHRlbnNpb24gdG8gY29uZmlndXJlIGNv bnRleHRzIGZvciBwYXJhbGxlbCBzdWJtaXNzaW9uCj4gPiA+ID4gKy0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQo+ ID4gPiA+ICtUaGUgJ3NldF9wYXJhbGxlbCcgZXh0ZW5zaW9uIGNvbmZpZ3VyZXMgYSBzbG90IGZv ciBwYXJhbGxlbCBzdWJtaXNzaW9uIG9mIE4gQkJzLgo+ID4gPiA+ICtJdCBpcyBzZXR1cCBzdGVw IHRoYXQgc2hvdWxkIGJlIGNhbGxlZCBiZWZvcmUgdXNpbmcgYW55IG9mIHRoZSBjb250ZXh0cy4g U2VlCj4gPiA+IAo+ID4gPiAJCXMvc2hvdWxkL211c3QvCj4gPiA+IAo+ID4gPiBXZSd2ZSBtYWRl IGl0IGEgQ1RYX0NSRUFURV9FWFQgZXh0ZW5zaW9uLCBzbyByZWFsbHkgeW91IGRvbid0IGhhdmUg YQo+ID4gPiBjaG9pY2UgYW55bW9yZSA6LSkKPiA+IAo+ID4gUmlnaHQsIHRoaXMgY2FuIG9ubHkg YmUgY2FsbGVkIGF0IGNvbnRleHQgY3JlYXRpb24uCj4gPiAKPiA+ID4gCj4gPiA+ID4gK0k5MTVf Q09OVEVYVF9FTkdJTkVTX0VYVF9MT0FEX0JBTEFOQ0Ugb3IgSTkxNV9DT05URVhUX0VOR0lORVNf RVhUX0JPTkQgZm9yCj4gPiA+ID4gK3NpbWlsYXIgZXhpc3RpbmcgZXhhbXBsZXMuIE9uY2UgYSBz bG90IGlzIGNvbmZpZ3VyZWQgZm9yIHBhcmFsbGVsIHN1Ym1pc3Npb24gdGhlCj4gPiA+ID4gK2V4 ZWNidWYyIElPQ1RMIGNhbiBiZSBjYWxsZWQgc3VibWl0dGluZyBOIEJCcyBpbiBhIHNpbmdsZSBJ T0NUTC4gSW5pdGlhbGx5IG9ubHkKPiA+ID4gPiArc3VwcG9ydCBHdUMgc3VibWlzc2lvbi4gRXhl Y2xpc3Qgc3VwcG9ydCBjYW4gYmUgYWRkZWQgbGF0ZXIgaWYgbmVlZGVkLgo+ID4gPiA+ICsKPiA+ ID4gPiArQWRkIEk5MTVfQ09OVEVYVF9FTkdJTkVTX0VYVF9QQVJBTExFTF9TVUJNSVQgYW5kCj4g PiA+ID4gK2k5MTVfY29udGV4dF9lbmdpbmVzX3BhcmFsbGVsX3N1Ym1pdCB0byB0aGUgdUFQSSB0 byBpbXBsZW1lbnQgdGhpcyBleHRlbnNpb24uCj4gPiA+ID4gKwo+ID4gPiA+ICtFeHRlbmQgZXhl Y2J1ZjIgSU9DVEwgdG8gc3VwcG9ydCBzdWJtaXR0aW5nIE4gQkJzIGluIGEgc2luZ2xlIElPQ1RM Cj4gPiA+ID4gKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0KPiA+ID4gPiArQ29udGV4dHMgdGhhdCBoYXZlIGJlZW4gY29u ZmlndXJlZCB3aXRoIHRoZSAnc2V0X3BhcmFsbGVsJyBleHRlbnNpb24gYXJlIGFsbG93ZWQKPiA+ ID4gPiArdG8gc3VibWl0IE4gQkJzIGluIGEgc2luZ2xlIGV4ZWNidWYyIElPQ1RMLiBUaGUgQkJz IGFyZSBlaXRoZXIgdGhlIGxhc3QgTgo+ID4gPiA+ICtvYmplY3RzIGluIHRoZSBkcm1faTkxNV9n ZW1fZXhlY19vYmplY3QyIGxpc3Qgb3IgdGhlIGZpcnN0IE4gaWYKPiA+ID4gPiArSTkxNV9FWEVD X0JBVENIX0ZJUlNUIGlzIHNldC4gVGhlIG51bWJlciBvZiBCQnMgaXMgaW1wbGljdCBiYXNlZCBv biB0aGUgc2xvdAo+ID4gPiA+ICtzdWJtaXR0ZWQgYW5kIGhvdyBpdCBoYXMgYmVlbiBjb25maWd1 cmVkIGJ5ICdzZXRfcGFyYWxsZWwnIG9yIG90aGVyIGV4dGVuc2lvbnMuCj4gPiA+ID4gK05vIHVB UEkgY2hhbmdlcyBhcmUgcmVxdWlyZWQgdG8gZXhlY2J1ZjIgSU9DVEwuCj4gPiA+IAo+ID4gPiBB ZGRkIGhlcmUgdGhlIGtlcm5lbGRvYyBpbmNsdWRlIGZvciB5b3VyIGhlYWRlci4KPiA+ID4KPiA+ IAo+ID4gU3VyZS4KPiA+IAo+ID4gTWF0dAo+ID4gIAo+ID4gPiBBc2lkZSBmcm9tIHRoZSBjb21t ZW50cyBieSBhbmQgbGFyZ2UgdGhpcyBsb29rcyBnb29kLiBUaGUgbWFpbiBpbnRlcmZhY2UKPiA+ ID4gYXQgbGVhc3QgaXMgY2xlYXIgYW5kIHdhcnRzLWZyZWUuCj4gPiA+IAo+ID4gPiBBY2tlZC1i eTogRGFuaWVsIFZldHRlciA8ZGFuaWVsLnZldHRlckBmZndsbC5jaD4KPiA+ID4gCj4gPiA+ID4g LS0gCj4gPiA+ID4gMi4yOC4wCj4gPiA+ID4gCj4gPiA+ID4gX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX18KPiA+ID4gPiBJbnRlbC1nZnggbWFpbGluZyBsaXN0 Cj4gPiA+ID4gSW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwo+ID4gPiA+IGh0dHBzOi8v bGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vaW50ZWwtZ2Z4Cj4gPiA+IAo+ ID4gPiAtLSAKPiA+ID4gRGFuaWVsIFZldHRlcgo+ID4gPiBTb2Z0d2FyZSBFbmdpbmVlciwgSW50 ZWwgQ29ycG9yYXRpb24KPiA+ID4gaHR0cDovL2Jsb2cuZmZ3bGwuY2gKPiAKPiAtLSAKPiBEYW5p ZWwgVmV0dGVyCj4gU29mdHdhcmUgRW5naW5lZXIsIEludGVsIENvcnBvcmF0aW9uCj4gaHR0cDov L2Jsb2cuZmZ3bGwuY2gKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX18KSW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJbnRlbC1nZnhAbGlzdHMuZnJlZWRlc2t0b3Au b3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vaW50ZWwt Z2Z4Cg==