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=-13.6 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS 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 F33B1C48BE5 for ; Thu, 17 Jun 2021 16:47:02 +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 996C760E0B for ; Thu, 17 Jun 2021 16:47:02 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 996C760E0B Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=ffwll.ch 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 3FA176E93E; Thu, 17 Jun 2021 16:46:55 +0000 (UTC) Received: from mail-wm1-x336.google.com (mail-wm1-x336.google.com [IPv6:2a00:1450:4864:20::336]) by gabe.freedesktop.org (Postfix) with ESMTPS id 115D16E0F4 for ; Thu, 17 Jun 2021 16:46:53 +0000 (UTC) Received: by mail-wm1-x336.google.com with SMTP id k42so1981378wms.0 for ; Thu, 17 Jun 2021 09:46:53 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ffwll.ch; s=google; h=date:from:to:cc:subject:message-id:references:mime-version :content-disposition:content-transfer-encoding:in-reply-to; bh=i0pKnFJo7pj8mPbGYx1AyiMRcemtKNLbi0gD6SO3z7Y=; b=WS/0uBaD/7bmIekXaWzT7I0adA82ZTjqCcrYmkLcP0EHmuR8hhcc3E0r+jzY7Nd03b z1MGKImFRpVJEQk4bEePkL9g1NFi9VeBX3fMIca4+yr7D3tTZy5/I5rX9AOeqyAeruAo MeBJXF/jnDnlGaL5ztaPocu74tlhx0nxcFDGo= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:date:from:to:cc:subject:message-id:references :mime-version:content-disposition:content-transfer-encoding :in-reply-to; bh=i0pKnFJo7pj8mPbGYx1AyiMRcemtKNLbi0gD6SO3z7Y=; b=KWDdAgEvK8kOjNFLo7BBjteoUCwfrmaKS6v5xbSr7/ZG/KWapJVJITkqHId4aMqYee YCmjHGZtnAkF+lqGqr0KKtEIfrmtG9sZqUAJiwxyv7wL51Gs/vKlBUI4GUqNNYBKsgVB QDaR0OJT67J12acGqC3ZAuB0OD3iNDJ4zSSKShXdM/iGe6XwYgiCqvZHOgHYa7NFvQMU kaoWPAvls2FGiQNQE/q6w8EiGF7U9t283mdhTY2RSdDU7cIFHQA+CLZDjrWtbt5AAtYX B8VBsrMt8FnD0OZHFptNR2BnJIShiVQFsGpp/aHdBQE33fcqFTsQHHOC4wBa8aUobeG7 TO/Q== X-Gm-Message-State: AOAM533YOeAKkF/coUqd/wcEqzBL/OpNqKFdSOUoq602IWH7jUSaT0v7 rL2N62NWsgThwxwbYFsNYdxBXA== X-Google-Smtp-Source: ABdhPJxLH/IoGYfyyR0m/buczMjMQdD7n4LMJHr7TKoQ7vpUI9NpZ+aiE9tuJ44IPIaDMfE30A76zQ== X-Received: by 2002:a7b:c7da:: with SMTP id z26mr6307500wmk.29.1623948411674; Thu, 17 Jun 2021 09:46:51 -0700 (PDT) Received: from phenom.ffwll.local ([2a02:168:57f4:0:efd0:b9e5:5ae6:c2fa]) by smtp.gmail.com with ESMTPSA id z12sm5993592wrw.97.2021.06.17.09.46.49 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 17 Jun 2021 09:46:50 -0700 (PDT) Date: Thu, 17 Jun 2021 18:46:48 +0200 From: Daniel Vetter To: Matthew Brost Subject: Re: [Intel-gfx] [RFC PATCH 2/2] drm/doc/rfc: i915 new parallel submission uAPI plan Message-ID: 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: <20210611195029.GA4388@sdutt-i7> X-Operating-System: Linux phenom 5.10.0-7-amd64 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" Sorry I'm behind on mails ... 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). > > > > + * 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. The NO_PREEMPT I think makes some sense to keep to make this part explicit. Either way on that is fine with me. > > 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. 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=-13.6 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS 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 7D6E7C2B9F4 for ; Thu, 17 Jun 2021 16:47:01 +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 17FB060FE9 for ; Thu, 17 Jun 2021 16:47:01 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 17FB060FE9 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=ffwll.ch 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 DA90B6E8B6; Thu, 17 Jun 2021 16:46:54 +0000 (UTC) Received: from mail-wm1-x32e.google.com (mail-wm1-x32e.google.com [IPv6:2a00:1450:4864:20::32e]) by gabe.freedesktop.org (Postfix) with ESMTPS id 0998A6E8B6 for ; Thu, 17 Jun 2021 16:46:53 +0000 (UTC) Received: by mail-wm1-x32e.google.com with SMTP id y13-20020a1c4b0d0000b02901c20173e165so4111100wma.0 for ; Thu, 17 Jun 2021 09:46:53 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ffwll.ch; s=google; h=date:from:to:cc:subject:message-id:references:mime-version :content-disposition:content-transfer-encoding:in-reply-to; bh=i0pKnFJo7pj8mPbGYx1AyiMRcemtKNLbi0gD6SO3z7Y=; b=WS/0uBaD/7bmIekXaWzT7I0adA82ZTjqCcrYmkLcP0EHmuR8hhcc3E0r+jzY7Nd03b z1MGKImFRpVJEQk4bEePkL9g1NFi9VeBX3fMIca4+yr7D3tTZy5/I5rX9AOeqyAeruAo MeBJXF/jnDnlGaL5ztaPocu74tlhx0nxcFDGo= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:date:from:to:cc:subject:message-id:references :mime-version:content-disposition:content-transfer-encoding :in-reply-to; bh=i0pKnFJo7pj8mPbGYx1AyiMRcemtKNLbi0gD6SO3z7Y=; b=BqB1TVLIGjgwHrGEOBSESV06PEIlkiEAgnnJIz3YlOPCbHErsKc1IFZ12xOr45UjfN Gec77MOJwfc0OJgCHD4oqVW6+3c19PQsgowwb82ruwcDpTdS6zHQtgTaHwODyMNraeuF vIBSkm/x3aJhpWSEdUBMwKxHfQETmK6x4Uw0Fc4IXnyZHuQTSo1ucUhIGlYbT4b+RmkL H7UJUKyfQuQfitsRNohS2G+xXFphNLsmbMFsmEzWHfnd/QtOTMO/DA2Apn/U/FSRO9H7 owlBtFuKGgdIAOb06iZZDzeutRgohQTvDn/CLlZwYgTcBM6E2pBZlf/QpJh51hoaX2EM Q7rw== X-Gm-Message-State: AOAM532hZ/IuRMub+SFPGnRf8OdJPD3ho5SftzyDJ8RFrc7aT8l57YmY j5YOitNb8I5AxqjsApyKk3NkLw== X-Google-Smtp-Source: ABdhPJxLH/IoGYfyyR0m/buczMjMQdD7n4LMJHr7TKoQ7vpUI9NpZ+aiE9tuJ44IPIaDMfE30A76zQ== X-Received: by 2002:a7b:c7da:: with SMTP id z26mr6307500wmk.29.1623948411674; Thu, 17 Jun 2021 09:46:51 -0700 (PDT) Received: from phenom.ffwll.local ([2a02:168:57f4:0:efd0:b9e5:5ae6:c2fa]) by smtp.gmail.com with ESMTPSA id z12sm5993592wrw.97.2021.06.17.09.46.49 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 17 Jun 2021 09:46:50 -0700 (PDT) Date: Thu, 17 Jun 2021 18:46:48 +0200 From: Daniel Vetter To: Matthew Brost Message-ID: 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: <20210611195029.GA4388@sdutt-i7> X-Operating-System: Linux phenom 5.10.0-7-amd64 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" U29ycnkgSSdtIGJlaGluZCBvbiBtYWlscyAgLi4uCgpPbiBGcmksIEp1biAxMSwgMjAyMSBhdCAx Mjo1MDoyOVBNIC0wNzAwLCBNYXR0aGV3IEJyb3N0IHdyb3RlOgo+IE9uIEZyaSwgSnVuIDA0LCAy MDIxIGF0IDA3OjU5OjA1UE0gKzAyMDAsIERhbmllbCBWZXR0ZXIgd3JvdGU6Cj4gPiBPbiBXZWQs IE1heSAyNiwgMjAyMSBhdCAwNDozMzo1N1BNIC0wNzAwLCBNYXR0aGV3IEJyb3N0IHdyb3RlOgo+ ID4gPiBBZGQgZW50cnkgZm9yIGk5MTUgbmV3IHBhcmFsbGVsIHN1Ym1pc3Npb24gdUFQSSBwbGFu Lgo+ID4gPiAKPiA+ID4gdjI6Cj4gPiA+ICAoRGFuaWVsIFZldHRlcik6Cj4gPiA+ICAgLSBFeHBh bmQgbG9naWNhbCBvcmRlciBleHBsYWluYXRpb24KPiA+ID4gICAtIEFkZCBkdW1teSBoZWFkZXIK PiA+ID4gICAtIE9ubHkgYWxsb3cgTiBCQnMgaW4gZXhlY2J1ZiBJT0NUTAo+ID4gPiAgIC0gQ29u ZmlndXJlIHBhcmFsbGVsIHN1Ym1pc3Npb24gcGVyIHNsb3Qgbm90IHBlciBnZW0gY29udGV4dAo+ ID4gPiB2MzoKPiA+ID4gIChNYXJjaW4gxZpsdXNhcnopOgo+ID4gPiAgIC0gTG90J3Mgb2YgdHlw b3MgLyBiYWQgZW5nbGlzaCBmaXhlZAo+ID4gPiAgKFR2cnRrbyBVcnN1bGluKToKPiA+ID4gICAt IENvbnNpc3RlbnQgcHNldWRvIGNvZGUsIGNsZWFuIHVwIHdvcmRpbmcgaW4gZGVzY3JpcHRpb25z Cj4gPiA+IAo+ID4gPiBDYzogVHZydGtvIFVyc3VsaW4gPHR2cnRrby51cnN1bGluQGludGVsLmNv bT4KPiA+ID4gQ2M6IFRvbnkgWWUgPHRvbnkueWVAaW50ZWwuY29tPgo+ID4gPiBDQzogQ2FybCBa aGFuZyA8Y2FybC56aGFuZ0BpbnRlbC5jb20+Cj4gPiA+IENjOiBEYW5pZWwgVmV0dGVyIDxkYW5p ZWwudmV0dGVyQGludGVsLmNvbT4KPiA+ID4gQ2M6IEphc29uIEVrc3RyYW5kIDxqYXNvbkBqbGVr c3RyYW5kLm5ldD4KPiA+ID4gU2lnbmVkLW9mZi1ieTogTWF0dGhldyBCcm9zdCA8bWF0dGhldy5i cm9zdEBpbnRlbC5jb20+Cj4gPiA+IC0tLQo+ID4gPiAgRG9jdW1lbnRhdGlvbi9ncHUvcmZjL2k5 MTVfcGFyYWxsZWxfZXhlY2J1Zi5oIHwgMTQ1ICsrKysrKysrKysrKysrKysrKwo+ID4gPiAgRG9j dW1lbnRhdGlvbi9ncHUvcmZjL2k5MTVfc2NoZWR1bGVyLnJzdCAgICAgIHwgIDU1ICsrKysrKy0K PiA+ID4gIDIgZmlsZXMgY2hhbmdlZCwgMTk4IGluc2VydGlvbnMoKyksIDIgZGVsZXRpb25zKC0p Cj4gPiA+ICBjcmVhdGUgbW9kZSAxMDA2NDQgRG9jdW1lbnRhdGlvbi9ncHUvcmZjL2k5MTVfcGFy YWxsZWxfZXhlY2J1Zi5oCj4gPiA+IAo+ID4gPiBkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9n cHUvcmZjL2k5MTVfcGFyYWxsZWxfZXhlY2J1Zi5oIGIvRG9jdW1lbnRhdGlvbi9ncHUvcmZjL2k5 MTVfcGFyYWxsZWxfZXhlY2J1Zi5oCj4gPiA+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gPiA+IGlu ZGV4IDAwMDAwMDAwMDAwMC4uMjBkZTIwNmUzYWI0Cj4gPiA+IC0tLSAvZGV2L251bGwKPiA+ID4g KysrIGIvRG9jdW1lbnRhdGlvbi9ncHUvcmZjL2k5MTVfcGFyYWxsZWxfZXhlY2J1Zi5oCj4gPiA+ IEBAIC0wLDAgKzEsMTQ1IEBACj4gPiA+ICsjZGVmaW5lIEk5MTVfQ09OVEVYVF9FTkdJTkVTX0VY VF9QQVJBTExFTF9TVUJNSVQgMiAvKiBzZWUgaTkxNV9jb250ZXh0X2VuZ2luZXNfcGFyYWxsZWxf c3VibWl0ICovCj4gPiA+ICsKPiA+ID4gKy8qCj4gPiA+ICsgKiBpOTE1X2NvbnRleHRfZW5naW5l c19wYXJhbGxlbF9zdWJtaXQ6Cj4gPiAKPiA+IFNvIHRoZSBpZGVhIGlzIHRvIG1ha2UgdGhlc2Ug a2VybmVsZG9jIGFuZCBwdWxsIHRoZW0gaW50byB0aGUgcmZjIHNlY3Rpb24uCj4gPiBUaGVuIHdo ZW4gd2UgbWVyZ2UsIG1vdmUgdGhlbSB0byB0aGUgcmVhbCB1YXBpIHNlY3Rpb24sIGxpa2Ugd2hh dCBNYXR0IGhhcwo+ID4gZG9uZSBmb3IgbG1lbS4KPiA+IAo+IAo+IFllcCwgd2lsbCBmaXggaW4g bmV4dCByZXYuCj4gCj4gPiA+ICsgKgo+ID4gPiArICogU2V0dXAgYSBzbG90IGluIHRoZSBjb250 ZXh0IGVuZ2luZSBtYXAgdG8gYWxsb3cgbXVsdGlwbGUgQkJzIHRvIGJlIHN1Ym1pdHRlZAo+ID4g PiArICogaW4gYSBzaW5nbGUgZXhlY2J1ZiBJT0NUTC4gVGhvc2UgQkJzIHdpbGwgdGhlbiBiZSBz Y2hlZHVsZWQgdG8gcnVuIG9uIHRoZSBHUFUKPiA+ID4gKyAqIGluIHBhcmFsbGVsLiBNdWx0aXBs ZSBoYXJkd2FyZSBjb250ZXh0cyBhcmUgY3JlYXRlZCBpbnRlcm5hbGx5IGluIHRoZSBpOTE1Cj4g PiA+ICsgKiBydW4gdGhlc2UgQkJzLiBPbmNlIGEgc2xvdCBpcyBjb25maWd1cmVkIGZvciBOIEJC cyBvbmx5IE4gQkJzIGNhbiBiZQo+ID4gPiArICogc3VibWl0dGVkIGluIGVhY2ggZXhlY2J1ZiBJ T0NUTCBhbmQgdGhpcyBpcyBpbXBsaWNpdCBiZWhhdmlvciBlLmcuIFRoZSB1c2VyCj4gPiA+ICsg KiBkb2Vzbid0IHRlbGwgdGhlIGV4ZWNidWYgSU9DVEwgdGhlcmUgYXJlIE4gQkJzLCB0aGUgZXhl Y2J1ZiBJT0NUTCBrbm93IGhvdwo+ID4gPiArICogbWFueSBCQnMgdGhlcmUgYXJlIGJhc2VkIG9u IHRoZSBzbG90cyBjb25maWd1cmF0aW9uLiBUaGUgTiBCQnMgYXJlIHRoZSBsYXN0IE4KPiA+ID4g KyAqIGJ1ZmZlciBvYmplY3RzIGZvciBmaXJzdCBOIGlmIEk5MTVfRVhFQ19CQVRDSF9GSVJTVCBp cyBzZXQuCj4gPiAKPiA+IHMvZm9yL29yLwo+ID4gCj4gPiA+ICsgKgo+ID4gPiArICogVGhlcmUg YXJlIHR3byBjdXJyZW50bHkgZGVmaW5lZCB3YXlzIHRvIGNvbnRyb2wgdGhlIHBsYWNlbWVudCBv ZiB0aGUKPiA+ID4gKyAqIGhhcmR3YXJlIGNvbnRleHRzIG9uIHBoeXNpY2FsIGVuZ2luZXM6IGRl ZmF1bHQgYmVoYXZpb3IgKG5vIGZsYWdzKSBhbmQKPiA+ID4gKyAqIEk5MTVfUEFSQUxMRUxfSU1Q TElDSVRfQk9ORFMgKGEgZmxhZykuIE1vcmUgZmxhZ3MgbWF5IGJlIGFkZGVkIHRoZSBpbiB0aGUK PiA+ID4gKyAqIGZ1dHVyZSBhcyBuZXcgaGFyZHdhcmUgLyB1c2UgY2FzZXMgYXJpc2UuIERldGFp bHMgb2YgaG93IHRvIHVzZSB0aGlzCj4gPiA+ICsgKiBpbnRlcmZhY2UgYWJvdmUgdGhlIGZsYWdz IGZpZWxkIGluIHRoaXMgc3RydWN0dXJlLgo+ID4gPiArICoKPiA+ID4gKyAqIFJldHVybnMgLUVJ TlZBTCBpZiBoYXJkd2FyZSBjb250ZXh0IHBsYWNlbWVudCBjb25maWd1cmF0aW9uIGlzIGludmFs aWQgb3IgaWYKPiA+ID4gKyAqIHRoZSBwbGFjZW1lbnQgY29uZmlndXJhdGlvbiBpc24ndCBzdXBw b3J0ZWQgb24gdGhlIHBsYXRmb3JtIC8gc3VibWlzc2lvbgo+ID4gPiArICogaW50ZXJmYWNlLgo+ ID4gPiArICogUmV0dXJucyAtRU5PREVWIGlmIGV4dGVuc2lvbiBpc24ndCBzdXBwb3J0ZWQgb24g dGhlIHBsYXRmb3JtIC8gc3VibWlzc2lvbgo+ID4gPiArICogaW50ZWZhY2UuCj4gPiA+ICsgKi8K PiA+ID4gK3N0cnVjdCBpOTE1X2NvbnRleHRfZW5naW5lc19wYXJhbGxlbF9zdWJtaXQgewo+ID4g PiArCXN0cnVjdCBpOTE1X3VzZXJfZXh0ZW5zaW9uIGJhc2U7Cj4gPiA+ICsKPiA+ID4gKwlfX3Ux NiBlbmdpbmVfaW5kZXg7CS8qIHNsb3QgZm9yIHBhcmFsbGVsIGVuZ2luZSAqLwo+ID4gCj4gPiBL ZXJuZWwgZG9jIGhlcmUgZm9yIHRoZSBpbmxpbmUgY29tbWVudHMgdG9vLgo+ID4KPiAKPiBZZXAu Cj4gIAo+ID4gPiArCV9fdTE2IHdpZHRoOwkJLyogbnVtYmVyIG9mIGNvbnRleHRzIHBlciBwYXJh bGxlbCBlbmdpbmUgKi8KPiA+ID4gKwlfX3UxNiBudW1fc2libGluZ3M7CS8qIG51bWJlciBvZiBz aWJsaW5ncyBwZXIgY29udGV4dCAqLwo+ID4gPiArCV9fdTE2IG1iejE2Owo+ID4gPiArLyoKPiA+ ID4gKyAqIERlZmF1bHQgcGxhY2VtZW50IGJlaGF2aW9yIChjdXJyZW50bHkgdW5zdXBwb3J0ZWQp Ogo+ID4gPiArICoKPiA+ID4gKyAqIEFsbG93IEJCcyB0byBiZSBwbGFjZWQgb24gYW55IGF2YWls YWJsZSBlbmdpbmUgaW5zdGFuY2UuIEluIHRoaXMgY2FzZSBlYWNoCj4gPiA+ICsgKiBjb250ZXh0 J3MgZW5naW5lIG1hc2sgaW5kaWNhdGVzIHdoZXJlIHRoYXQgY29udGV4dCBjYW4gYmUgcGxhY2Vk LiBJdCBpcwo+ID4gPiArICogaW1wbGllZCBpbiB0aGlzIG1vZGUgdGhhdCBhbGwgY29udGV4dHMg aGF2ZSBtdXR1YWwgZXhjbHVzaXZlIHBsYWNlbWVudC4KPiA+ID4gKyAqIGUuZy4gSWYgb25lIGNv bnRleHQgaXMgcnVubmluZyBDU1hbMF0gbm8gb3RoZXIgY29udGV4dHMgY2FuIHJ1biBvbiBDU1hb MF0pLgo+ID4gPiArICoKPiA+ID4gKyAqIEV4YW1wbGUgMSBwc2V1ZG8gY29kZToKPiA+ID4gKyAq IENTWCxZW05dID0gZ2VuZXJpYyBlbmdpbmUgY2xhc3MgWCBvciBZLCBsb2dpY2FsIGluc3RhbmNl IE4KPiA+ID4gKyAqIElOVkFMSUQgPSBJOTE1X0VOR0lORV9DTEFTU19JTlZBTElELCBJOTE1X0VO R0lORV9DTEFTU19JTlZBTElEX05PTkUKPiA+ID4gKyAqIHNldF9lbmdpbmVzKElOVkFMSUQpCj4g PiA+ICsgKiBzZXRfcGFyYWxsZWwoZW5naW5lX2luZGV4PTAsIHdpZHRoPTIsIG51bV9zaWJsaW5n cz0yLAo+ID4gPiArICoJCWVuZ2luZXM9Q1NYWzBdLENTWFsxXSxDU1lbMF0sQ1NZWzFdKQo+ID4g PiArICoKPiA+ID4gKyAqIFJlc3VsdHMgaW4gdGhlIGZvbGxvd2luZyB2YWxpZCBwbGFjZW1lbnRz Ogo+ID4gPiArICogQ1NYWzBdLCBDU1lbMF0KPiA+ID4gKyAqIENTWFswXSwgQ1NZWzFdCj4gPiA+ ICsgKiBDU1hbMV0sIENTWVswXQo+ID4gPiArICogQ1NYWzFdLCBDU1lbMV0KPiA+ID4gKyAqCj4g PiA+ICsgKiBUaGlzIGNhbiBhbHNvIGJlIHRob3VnaHQgb2YgYXMgMiB2aXJ0dWFsIGVuZ2luZXMg ZGVzY3JpYmVkIGJ5IDItRCBhcnJheSBpbgo+ID4gPiArICogdGhlIGVuZ2luZXMgdGhlIGZpZWxk Ogo+ID4gPiArICogVkVbMF0gPSBDU1hbMF0sIENTWFsxXQo+ID4gPiArICogVkVbMV0gPSBDU1lb MF0sIENTWVsxXQo+ID4gPiArICoKPiA+ID4gKyAqIEV4YW1wbGUgMiBwc2V1ZG8gY29kZToKPiA+ ID4gKyAqIENTWFtZXSA9IGdlbmVyaWMgZW5naW5lIG9mIHNhbWUgY2xhc3MgWCwgbG9naWNhbCBp bnN0YW5jZSBOCj4gPiA+ICsgKiBJTlZBTElEID0gSTkxNV9FTkdJTkVfQ0xBU1NfSU5WQUxJRCwg STkxNV9FTkdJTkVfQ0xBU1NfSU5WQUxJRF9OT05FCj4gPiA+ICsgKiBzZXRfZW5naW5lcyhJTlZB TElEKQo+ID4gPiArICogc2V0X3BhcmFsbGVsKGVuZ2luZV9pbmRleD0wLCB3aWR0aD0yLCBudW1f c2libGluZ3M9MywKPiA+ID4gKyAqCQllbmdpbmVzPUNTWFswXSxDU1hbMV0sQ1NYWzJdLENTWFsw XSxDU1hbMV0sQ1NYWzJdKQo+ID4gPiArICoKPiA+ID4gKyAqIFJlc3VsdHMgaW4gdGhlIGZvbGxv d2luZyB2YWxpZCBwbGFjZW1lbnRzOgo+ID4gPiArICogQ1NYWzBdLCBDU1hbMV0KPiA+ID4gKyAq IENTWFswXSwgQ1NYWzJdCj4gPiA+ICsgKiBDU1hbMV0sIENTWFswXQo+ID4gPiArICogQ1NYWzFd LCBDU1hbMl0KPiA+ID4gKyAqIENTWFsyXSwgQ1NYWzBdCj4gPiA+ICsgKiBDU1hbMl0sIENTWFsx XQo+ID4gPiArICoKPiA+ID4gKyAqIFRoaXMgY2FuIGFsc28gYmUgdGhvdWdodCBvZiBhcyAyIHZp cnR1YWwgZW5naW5lcyBkZXNjcmliZWQgYnkgMi1EIGFycmF5IGluCj4gPiA+ICsgKiB0aGUgZW5n aW5lcyB0aGUgZmllbGQ6Cj4gPiA+ICsgKiBWRVswXSA9IENTWFswXSwgQ1NYWzFdLCBDU1hbMl0K PiA+ID4gKyAqIFZFWzFdID0gQ1NYWzBdLCBDU1hbMV0sIENTWFsyXQo+ID4gPiArCj4gPiA+ICsg KiBUaGlzIGVuYWJsZXMgYSB1c2UgY2FzZSB3aGVyZSBhbGwgZW5naW5lcyBhcmUgY3JlYXRlZCBl cXVhbGx5LCB3ZSBkb24ndCBjYXJlCj4gPiA+ICsgKiB3aGVyZSB0aGV5IGFyZSBzY2hlZHVsZWQs IHdlIGp1c3Qgd2FudCBhIGNlcnRhaW4gbnVtYmVyIG9mIHJlc291cmNlcywgZm9yCj4gPiA+ICsg KiB0aG9zZSByZXNvdXJjZXMgdG8gYmUgc2NoZWR1bGVkIGluIHBhcmFsbGVsLCBhbmQgcG9zc2li bHkgYWNyb3NzIG11bHRpcGxlCj4gPiA+ICsgKiBlbmdpbmUgY2xhc3Nlcy4KPiA+ID4gKyAqLwo+ ID4gPiArCj4gPiA+ICsvKgo+ID4gCj4gPiBXb3VsZCBiZSBnb29kIHRvIGFsc28gbW92ZSB0aGlz IGludG8gdGhlIGtlcm5lbGRvYyAobWF5YmUgYWRkIGxhYmVsbGVkCj4gPiBsaXN0IGZvciBmbGFn cyBvciBzbykgc28gaXQgc2hvd3MgdXAgaW4gdGhlIHJlbmRlciBvdXRwdXQuCj4gPgo+IAo+IFN1 cmUuIEkgbmVlZCBmaWd1cmUgb3V0IHZpZXcgdGhlIGtlcm5lbCBkb2MgbG9jYWxseSBiZWZvcmUg bXkgbmV4dCBhbmQgbWFrZSBzdXJlCj4gZXZlcnl0aGluZyBsb29rcyByaWdodC4KCiQgbWFrZSBo dG1sZG9jcwoKT3V0cHV0IGlzIGluIERvY3VtZW50YXRpb24vb3V0cHV0L2dwdS9pbmRleC5odG1s ICh0byBnZXQgdGhlcmUgbW9yZQpkaXJlY3RseSkuCgo+ICAKPiA+ID4gKyAqIEk5MTVfUEFSQUxM RUxfSU1QTElDSVRfQk9ORFMgLSBDcmVhdGUgaW1wbGljaXQgYm9uZHMgYmV0d2VlbiBlYWNoIGNv bnRleHQuCj4gPiA+ICsgKiBFYWNoIGNvbnRleHQgbXVzdCBoYXZlIHRoZSBzYW1lIG51bWJlciBv ZiBzaWJsaW5nIGFuZCBib25kcyBhcmUgaW1wbGljaXRseQo+ID4gPiArICogY3JlYXRlZCBiZXR3 ZWVuIGVhY2ggc2V0IG9mIHNpYmxpbmdzLgo+ID4gPiArICoKPiA+ID4gKyAqIEV4YW1wbGUgMSBw c2V1ZG8gY29kZToKPiA+ID4gKyAqIENTWFtOXSA9IGdlbmVyaWMgZW5naW5lIG9mIHNhbWUgY2xh c3MgWCwgbG9naWNhbCBpbnN0YW5jZSBOCj4gPiA+ICsgKiBJTlZBTElEID0gSTkxNV9FTkdJTkVf Q0xBU1NfSU5WQUxJRCwgSTkxNV9FTkdJTkVfQ0xBU1NfSU5WQUxJRF9OT05FCj4gPiA+ICsgKiBz ZXRfZW5naW5lcyhJTlZBTElEKQo+ID4gPiArICogc2V0X3BhcmFsbGVsKGVuZ2luZV9pbmRleD0w LCB3aWR0aD0yLCBudW1fc2libGluZ3M9MSwKPiA+ID4gKyAqCQllbmdpbmVzPUNTWFswXSxDU1hb MV0sIGZsYWdzPUk5MTVfUEFSQUxMRUxfSU1QTElDSVRfQk9ORFMpCj4gPiA+ICsgKgo+ID4gPiAr ICogUmVzdWx0cyBpbiB0aGUgZm9sbG93aW5nIHZhbGlkIHBsYWNlbWVudHM6Cj4gPiA+ICsgKiBD U1hbMF0sIENTWFsxXQo+ID4gPiArICoKPiA+ID4gKyAqIEV4YW1wbGUgMiBwc2V1ZG8gY29kZToK PiA+ID4gKyAqIENTWFtOXSA9IGdlbmVyaWMgZW5naW5lIG9mIHNhbWUgY2xhc3MgWCwgbG9naWNh bCBpbnN0YW5jZSBOCj4gPiA+ICsgKiBJTlZBTElEID0gSTkxNV9FTkdJTkVfQ0xBU1NfSU5WQUxJ RCwgSTkxNV9FTkdJTkVfQ0xBU1NfSU5WQUxJRF9OT05FCj4gPiA+ICsgKiBzZXRfZW5naW5lcyhJ TlZBTElEKQo+ID4gPiArICogc2V0X3BhcmFsbGVsKGVuZ2luZV9pbmRleD0wLCB3aWR0aD0yLCBu dW1fc2libGluZ3M9MiwKPiA+ID4gKyAqCQllbmdpbmVzPUNTWFswXSxDU1hbMl0sQ1NYWzFdLENT WFszXSwKPiA+ID4gKyAqCQlmbGFncz1JOTE1X1BBUkFMTEVMX0lNUExJQ0lUX0JPTkRTKQo+ID4g PiArICoKPiA+ID4gKyAqIFJlc3VsdHMgaW4gdGhlIGZvbGxvd2luZyB2YWxpZCBwbGFjZW1lbnRz Ogo+ID4gPiArICogQ1NYWzBdLCBDU1hbMV0KPiA+ID4gKyAqIENTWFsyXSwgQ1NYWzNdCj4gPiA+ ICsgKgo+ID4gPiArICogVGhpcyBjYW4gYWxzbyBiZSB0aG91Z2h0IG9mIGFzIDIgdmlydHVhbCBl bmdpbmVzIGRlc2NyaWJlZCBieSAyLUQgYXJyYXkgaW4KPiA+ID4gKyAqIHRoZSBlbmdpbmVzIHRo ZSBmaWVsZCB3aXRoIGJvbmRzIHBsYWNlZCBiZXR3ZWVuIGVhY2ggaW5kZXggb2YgdGhlIHZpcnR1 YWwKPiA+ID4gKyAqIGVuZ2luZXMuIGUuZy4gQ1NYWzBdIGlzIGJvbmRlZCB0byBDU1hbMV0sIENT WFsyXSBpcyBib25kZWQgdG8gQ1NYWzNdLgo+ID4gPiArICogVkVbMF0gPSBDU1hbMF0sIENTWFsy XQo+ID4gPiArICogVkVbMV0gPSBDU1hbMV0sIENTWFszXQo+ID4gPiArICoKPiA+ID4gKyAqIFRo aXMgZW5hYmxlcyBhIHVzZSBjYXNlIHdoZXJlIGFsbCBlbmdpbmVzIGFyZSBub3QgZXF1YWwgYW5k IGNlcnRhaW4gcGxhY2VtZW50Cj4gPiA+ICsgKiBydWxlcyBhcmUgcmVxdWlyZWQgKGkuZS4gc3Bs aXQtZnJhbWUgcmVxdWlyZXMgYWxsIGNvbnRleHRzIHRvIGJlIHBsYWNlZCBpbiBhCj4gPiA+ICsg KiBsb2dpY2FsbHkgY29udGlndW91cyBvcmRlciBvbiB0aGUgVkNTIGVuZ2luZXMgb24gZ2VuMTEr IHBsYXRmb3JtcykuIFRoaXMgdXNlCj4gPiA+ICsgKiBjYXNlIChsb2dpY2FsbHkgY29udGlndW91 cyBwbGFjZW1lbnQsIHdpdGhpbiBhIHNpbmdsZSBlbmdpbmUgY2xhc3MpIGlzCj4gPiA+ICsgKiBz dXBwb3J0ZWQgd2hlbiB1c2luZyBHdUMgc3VibWlzc2lvbi4gRXhlY2xpc3QgbW9kZSBjb3VsZCBz dXBwb3J0IGFsbCBwb3NzaWJsZQo+ID4gPiArICogYm9uZGluZyBjb25maWd1cmF0aW9ucyBidXQg Y3VycmVudGx5IGRvZXNuJ3Qgc3VwcG9ydCB0aGlzIGV4dGVuc2lvbi4KPiA+ID4gKyAqLwo+ID4g PiArI2RlZmluZSBJOTE1X1BBUkFMTEVMX0lNUExJQ0lUX0JPTkRTCQkJKDEgPDwgMCkKPiA+ID4g Ky8qCj4gPiA+ICsgKiBEbyBub3QgYWxsb3cgQkJzIHRvIGJlIHByZWVtcHRlZCBtaWQgQkIgcmF0 aGVyIGluc2VydCBjb29yZGluYXRlZCBwcmVlbXB0aW9uCj4gPiA+ICsgKiBwb2ludHMgb24gYWxs IGhhcmR3YXJlIGNvbnRleHRzIGJldHdlZW4gZWFjaCBzZXQgb2YgQkJzLiBBbiBleGFtcGxlIHVz ZSBjYXNlCj4gPiA+ICsgKiBvZiB0aGlzIGZlYXR1cmUgaXMgc3BsaXQtZnJhbWUgb24gZ2VuMTEr IGhhcmR3YXJlLgo+ID4gPiArICovCj4gPiA+ICsjZGVmaW5lIEk5MTVfUEFSQUxMRUxfTk9fUFJF RU1QVF9NSURfQkFUQ0gJCSgxIDw8IDEpCj4gPiAKPiA+IFNvIEkgZ2V0IHRoZSBoaXN0b3J5IG5v dyBiZWhpbmQgdGhpcywgYnV0IEkgdGhpbmsgc3BlY2lmeWluZyBmbGFncyBmb3IgdGhlCj4gPiBv bmx5IGJlaGF2aW91ciB5b3UgY2FuIGdldCBhbmQgdGhlIG9ubHkgYmVoYXZpb3VyIHRoYXQgdXNl cnNwYWNlIGFza3MgZm9yCj4gPiBpcyBzaWxseS4KPiA+IAo+ID4gSSB0aGluayB3ZSBzaG91bGQg anVzdCBtb3ZlIHRoZSBhY3R1YWwgYmVoYXZpb3VyIHNwZWMgaW50byB0aGUga2VybmVsZG9jLAo+ ID4gYXMgaW4gInRoaXMgaXMgdGhlIGJvbmRpbmcgeW91IGdldCIgYW5kICJkdWUgdG8gaHcvZncg bGltaXRhdGlvbnMgdGhlc2UKPiA+IHdvcmtsb2FkcyB3aWxsIGJlIG5vbi1wcmVlbXB0YWJsZSIg YW5kIGNhbGwgaXQgYSBkYXkuIFRyeWluZyB0byBndWVzcwo+ID4gZnV0dXJlIG5lZWRzIGFuZCBz cGVjaWZ5aW5nIHRoZW0sIHdpdGhvdXQga25vd2luZyB0aG9zZSBmdXR1cmUgbmVlZHMKPiA+IHBy ZWNpc2VseSwgbXVjaCBsZXNzIGhhdmluZyBhbiBpbXBsZW1lbnRhdGlvbiwganVzdCBuZXZlciB3 b3JrcyBvdXQKPiA+IHJlYWxseS4KPiA+Cj4gCj4gU28gbm8gZmxhZ3M/IE9yIGp1c3QgdGhlIGRl ZmF1bHQgYmVoYXZpb3IgaXMgSTkxNV9QQVJBTExFTF9JTVBMSUNJVF9CT05EUyB8Cj4gSTkxNV9Q QVJBTExFTF9OT19QUkVFTVBUX01JRF9CQVRDSCBmb3Igbm93LCB0aGUgZmxhZ3MgYXJlIHVudXNl ZCwgYnV0IGNvdWxkIGJlCj4gdXNlZCBpbiB0aGUgZnV0dXJlIGlmIG5lZWRlZD8KClRoZSBpbXBs aWNpdF9ib25kcyBJIHRoaW5rIHNob3VsZCBiZSBqdXN0IHRoZSBkZWZhdWx0LCB3ZSBjYW4gYWRk IGZsYWdzCmZvciB0aGUgb3RoZXIgc3R1ZmYgd2hlbiBpdCBleGlzdC4KClRoZSBOT19QUkVFTVBU IEkgdGhpbmsgbWFrZXMgc29tZSBzZW5zZSB0byBrZWVwIHRvIG1ha2UgdGhpcyBwYXJ0CmV4cGxp Y2l0LiBFaXRoZXIgd2F5IG9uIHRoYXQgaXMgZmluZSB3aXRoIG1lLgoKPiA+IEkgZGlzY3Vzc2Vk IHRoaXMgYSBiaXQgd2l0aCBKYXNvbiwgYW5kIGhlJ3Mgc3VnZ2VzdGVkIHRoaXMgbWFrZXMgc2Vu c2UgYXMKPiA+IGEgZW5naW5lIGZsYWcsIGJ1dCBkZWZpbml0ZWx5IG5vdCBvbiB0aGUgcGFyYWxs ZWwgZXh0ZW5zaW9uLiBCdXQgc2luY2Ugd2UKPiAKPiBOb3Qgc3VyZSB3aGF0IHlvdSBtZWFuIGJ5 IGFuIGVuZ2luZSBmbGFncy4gVGhpcyBpcyBhIHBlciBjb250ZXh0IGNvbmNlcHQuCgpPaCwgSSBn dWVzcyB0aGlzIGlzIG1vcmUgZmFsbG91dCBmcm9tIHRoZSBjb252ZXJzaW9uIGZyb20gaGF2aW5n IHRoZQplbnRpcmUgZ2VtIGNvbnRleHQgYXMgdGhlIHBhcmFsbGVsIHN1Ym1pdCB2ZWhpY2xlIHRv IGEgdmlydHVhbCBlbmdpbmUuCgpJZiB3ZSBkbyBoYXZlIHRoZW0gYXMgZmxhZ3MsIHRoZXkgbmVl ZCB0byBiZSBvbiB0aGF0IHZpcnR1YWwgZW5naW5lLCBub3QKb24gdGhlIG92ZXJhbGwgZ2VtIGNv bnRleHQgY29udGFpbmVyIHRoaW5nLiBBdCB0aGF0IHBvaW50IHRoZXkgZG9uJ3QKZXhhY3RseSBt YXRjaCB1cCB0aGUgZXhpc3RpbmcgcHJlZW1wdCBmbGFnIHdlIGhhdmUgKG9uIHRoZSBjb250ZXh0 KSwgc28KbWF5YmUgd2Ugc2hvdWxkIGp1c3QgbWFrZSB0aGlzIGltcGxpZWQgKGJ1dCBvZmMgZG9j dW1lbnRlZCkgYmVoYXZpb3VyLgoKQ2hlZXJzLCBEYW5pZWwKCj4gCj4gPiBkb24ndCBoYXZlIGEg bmVlZCBmb3IgcGlja2luZyBhIG5vbi1kZWZhdWx0IHZhbHVlIGp1c3QgZXh0cmEgd29yay4KPiA+ IAo+ID4gPiArI2RlZmluZSBfX0k5MTVfUEFSQUxMRUxfVU5LTk9XTl9GTEFHUwkoLShJOTE1X1BB UkFMTEVMX05PX1BSRUVNUFRfTUlEX0JBVENIIDw8IDEpKQo+ID4gPiArCV9fdTY0IGZsYWdzOwkJ LyogYWxsIHVuZGVmaW5lZCBmbGFncyBtdXN0IGJlIHplcm8gKi8KPiA+ID4gKwlfX3U2NCBtYno2 NFszXTsJCS8qIHJlc2VydmVkIGZvciBmdXR1cmUgdXNlOyBtdXN0IGJlIHplcm8gKi8KPiA+ID4g Kwo+ID4gPiArCS8qCj4gPiA+ICsJICogMi1EIGFycmF5IG9mIGVuZ2luZXMKPiA+ID4gKwkgKgo+ ID4gPiArCSAqIHdpZHRoIChpKSAqIG51bV9zaWJsaW5ncyAoaikgaW4gbGVuZ3RoCj4gPiA+ICsJ ICogaW5kZXggPSBqICsgaSAqIG51bV9zaWJsaW5ncwo+ID4gPiArCSAqLwo+ID4gPiArCXN0cnVj dCBpOTE1X2VuZ2luZV9jbGFzc19pbnN0YW5jZSBlbmdpbmVzWzBdOwo+ID4gPiArfSBfX2F0dHJp YnV0ZV9fICgocGFja2VkKSk7Cj4gPiA+ICsKPiA+ID4gZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRp b24vZ3B1L3JmYy9pOTE1X3NjaGVkdWxlci5yc3QgYi9Eb2N1bWVudGF0aW9uL2dwdS9yZmMvaTkx NV9zY2hlZHVsZXIucnN0Cj4gPiA+IGluZGV4IDdmYWE0NmNkZTA4OC4uMDI1NGMwNGQzNGJlIDEw MDY0NAo+ID4gPiAtLS0gYS9Eb2N1bWVudGF0aW9uL2dwdS9yZmMvaTkxNV9zY2hlZHVsZXIucnN0 Cj4gPiA+ICsrKyBiL0RvY3VtZW50YXRpb24vZ3B1L3JmYy9pOTE1X3NjaGVkdWxlci5yc3QKPiA+ ID4gQEAgLTIzLDcgKzIzLDcgQEAgaTkxNSB3aXRoIHRoZSBEUk0gc2NoZWR1bGVyIGlzOgo+ID4g PiAgCSAgc2V2ZXJlIGRlc2lnbiBpc3N1ZXMgaW4gZ2VuZXJhbCwgd2hpY2ggaXMgd2h5IHdlIHdh bnQgdG8gcmV0aXJlIGl0IG5vCj4gPiA+ICAJICBtYXR0ZXIgd2hhdAo+ID4gPiAgCSogTmV3IHVB UEkgYWRkcyBJOTE1X0NPTlRFWFRfRU5HSU5FU19FWFRfUEFSQUxMRUwgY29udGV4dCBzZXR1cCBz dGVwCj4gPiA+IC0JICB3aGljaCBjb25maWd1cmVzIGEgc2xvdCB3aXRoIE4gY29udGV4dHMgCj4g PiA+ICsJICB3aGljaCBjb25maWd1cmVzIGEgc2xvdCB3aXRoIE4gY29udGV4dHMKPiA+ID4gIAkq IEFmdGVyIEk5MTVfQ09OVEVYVF9FTkdJTkVTX0VYVF9QQVJBTExFTCBhIHVzZXIgY2FuIHN1Ym1p dCBOIGJhdGNoZXMgdG8KPiA+ID4gIAkgIGEgc2xvdCBpbiBhIHNpbmdsZSBleGVjYnVmIElPQ1RM IGFuZCB0aGUgYmF0Y2hlcyBydW4gb24gdGhlIEdQVSBpbgo+ID4gPiAgCSAgcGFyYWxsbGVsCj4g PiA+IEBAIC04Miw0ICs4Miw1NSBAQCBodHRwczovL3NwZWMub25lYXBpLmNvbS9sZXZlbC16ZXJv L2xhdGVzdC9jb3JlL2FwaS5odG1sI3plLWNvbW1hbmQtcXVldWUtcHJpb3JpdAo+ID4gPiAgCj4g PiA+ICBOZXcgcGFyYWxsZWwgc3VibWlzc2lvbiB1QVBJCj4gPiA+ICA9PT09PT09PT09PT09PT09 PT09PT09PT09PT09Cj4gPiA+IC1EZXRhaWxzIHRvIGNvbWUgaW4gYSBmb2xsb3dpbmcgcGF0Y2gu Cj4gPiA+ICtUaGUgZXhpc3RpbmcgYm9uZGluZyB1QVBJIGlzIGNvbXBsZXRlbHkgYnJva2VuIHdp dGggR3VDIHN1Ym1pc3Npb24gYmVjYXVzZQo+ID4gPiArd2hldGhlciBhIHN1Ym1pc3Npb24gaXMg YSBzaW5nbGUgY29udGV4dCBzdWJtaXQgb3IgcGFyYWxsZWwgc3VibWl0IGlzbid0IGtub3duCj4g PiA+ICt1bnRpbCBleGVjYnVmIHRpbWUgYWN0aXZhdGVkIHZpYSB0aGUgSTkxNV9TVUJNSVRfRkVO Q0UuIFRvIHN1Ym1pdCBtdWx0aXBsZQo+ID4gPiArY29udGV4dHMgaW4gcGFyYWxsZWwgd2l0aCB0 aGUgR3VDIHRoZSBjb250ZXh0IG11c3QgYmUgZXhwbGljaXRseSByZWdpc3RlcmVkIHdpdGgKPiA+ ID4gK04gY29udGV4dHMgYW5kIGFsbCBOIGNvbnRleHRzIG11c3QgYmUgc3VibWl0dGVkIGluIGEg c2luZ2xlIGNvbW1hbmQgdG8gdGhlIEd1Qy4KPiA+ID4gK1RoZSBHdUMgaW50ZXJmYWNlcyBkbyBu b3Qgc3VwcG9ydCBkeW5hbWljYWxseSBjaGFuZ2luZyBiZXR3ZWVuIE4gY29udGV4dHMgYXMgdGhl Cj4gPiA+ICtib25kaW5nIHVBUEkgZG9lcy4gSGVuY2UgdGhlIG5lZWQgZm9yIGEgbmV3IHBhcmFs bGVsIHN1Ym1pc3Npb24gaW50ZXJmYWNlLiBBbHNvCj4gPiA+ICt0aGUgbGVnYWN5IGJvbmRpbmcg dUFQSSBpcyBxdWl0ZSBjb25mdXNpbmcgYW5kIG5vdCBpbnR1aXRpdmUgYXQgYWxsLgo+ID4gCj4g PiBXZSBzaG91bGQgYWRkIGhlcmUgdGhhdCAiRnVydGhlcm1vcmUgSTkxNV9TVUJNSVRfRkVOQ0Ug aXMgYnkgZGVzaWduIGEKPiA+IGZ1dHVyZSBmZW5jZSwgc28gbm90IHJlYWxseSBzb21ldGhpbmcg d2Ugc2hvdWxkIGNvbnRpbnVlIHRvIHN1cHBvcnQuIgo+ID4gCj4gPiA+ICsKPiA+ID4gK1RoZSBu ZXcgcGFyYWxsZWwgc3VibWlzc2lvbiB1QVBJIGNvbnNpc3RzIG9mIDMgcGFydHM6Cj4gPiA+ICsK PiA+ID4gKyogRXhwb3J0IGVuZ2luZXMgbG9naWNhbCBtYXBwaW5nCj4gPiA+ICsqIEEgJ3NldF9w YXJhbGxlbCcgZXh0ZW5zaW9uIHRvIGNvbmZpZ3VyZSBjb250ZXh0cyBmb3IgcGFyYWxsZWwKPiA+ ID4gKyAgc3VibWlzc2lvbgo+ID4gPiArKiBFeHRlbmQgZXhlY2J1ZjIgSU9DVEwgdG8gc3VwcG9y dCBzdWJtaXR0aW5nIE4gQkJzIGluIGEgc2luZ2xlIElPQ1RMCj4gPiA+ICsKPiA+ID4gK0V4cG9y dCBlbmdpbmVzIGxvZ2ljYWwgbWFwcGluZwo+ID4gPiArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tCj4gPiA+ICtDZXJ0YWluIHVzZSBjYXNlcyByZXF1aXJlIEJCcyB0byBiZSBwbGFjZWQg b24gZW5naW5lIGluc3RhbmNlcyBpbiBsb2dpY2FsIG9yZGVyCj4gPiA+ICsoZS5nLiBzcGxpdC1m cmFtZSBvbiBnZW4xMSspLiBUaGUgbG9naWNhbCBtYXBwaW5nIG9mIGVuZ2luZSBpbnN0YW5jZXMg Y2FuIGNoYW5nZQo+ID4gPiArYmFzZWQgb24gZnVzaW5nLiBSYXRoZXIgdGhhbiBtYWtpbmcgVU1E cyBiZSBhd2FyZSBvZiBmdXNpbmcsIHNpbXBseSBleHBvc2UgdGhlCj4gPiA+ICtsb2dpY2FsIG1h cHBpbmcgd2l0aCB0aGUgZXhpc3RpbmcgcXVlcnkgZW5naW5lIGluZm8gSU9DVEwuIEFsc28gdGhl IEd1Qwo+ID4gPiArc3VibWlzc2lvbiBpbnRlcmZhY2UgY3VycmVudGx5IG9ubHkgc3VwcG9ydHMg c3VibWl0dGluZyBtdWx0aXBsZSBjb250ZXh0cyB0bwo+ID4gPiArZW5naW5lcyBpbiBsb2dpY2Fs IG9yZGVyIHdoaWNoIGlzIGEgbmV3IHJlcXVpcmVtZW50IGNvbXBhcmVkIHRvIGV4ZWNsaXN0cy4K PiA+ID4gK0xhc3RseSwgYWxsIGN1cnJlbnQgcGxhdGZvcm1zIGhhdmUgYXQgbW9zdCAyIGVuZ2lu ZSBpbnN0YW5jZXMgYW5kIHRoZSBsb2dpY2FsCj4gPiA+ICtvcmRlciBpcyB0aGUgc2FtZSBhcyB1 QVBJIG9yZGVyLiBUaGlzIHdpbGwgY2hhbmdlIG9uIHBsYXRmb3JtcyB3aXRoIG1vcmUgdGhhbiAy Cj4gPiA+ICtlbmdpbmUgaW5zdGFuY2VzLgo+ID4gPiArCj4gPiA+ICtBIHNpbmdsZSBiaXQgd2ls bCBiZSBhZGRlZCB0byBkcm1faTkxNV9lbmdpbmVfaW5mby5mbGFncyBpbmRpY2F0aW5nIHRoYXQg dGhlCj4gPiA+ICtsb2dpY2FsIGluc3RhbmNlIGhhcyBiZWVuIHJldHVybmVkIGFuZCBhIG5ldyBm aWVsZCwKPiA+ID4gK2RybV9pOTE1X2VuZ2luZV9pbmZvLmxvZ2ljYWxfaW5zdGFuY2UsIHJldHVy bnMgdGhlIGxvZ2ljYWwgaW5zdGFuY2UuCj4gPiA+ICsKPiA+ID4gK0EgJ3NldF9wYXJhbGxlbCcg ZXh0ZW5zaW9uIHRvIGNvbmZpZ3VyZSBjb250ZXh0cyBmb3IgcGFyYWxsZWwgc3VibWlzc2lvbgo+ ID4gPiArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tCj4gPiA+ICtUaGUgJ3NldF9wYXJhbGxlbCcgZXh0ZW5zaW9u IGNvbmZpZ3VyZXMgYSBzbG90IGZvciBwYXJhbGxlbCBzdWJtaXNzaW9uIG9mIE4gQkJzLgo+ID4g PiArSXQgaXMgc2V0dXAgc3RlcCB0aGF0IHNob3VsZCBiZSBjYWxsZWQgYmVmb3JlIHVzaW5nIGFu eSBvZiB0aGUgY29udGV4dHMuIFNlZQo+ID4gCj4gPiAJCXMvc2hvdWxkL211c3QvCj4gPiAKPiA+ IFdlJ3ZlIG1hZGUgaXQgYSBDVFhfQ1JFQVRFX0VYVCBleHRlbnNpb24sIHNvIHJlYWxseSB5b3Ug ZG9uJ3QgaGF2ZSBhCj4gPiBjaG9pY2UgYW55bW9yZSA6LSkKPiAKPiBSaWdodCwgdGhpcyBjYW4g b25seSBiZSBjYWxsZWQgYXQgY29udGV4dCBjcmVhdGlvbi4KPiAKPiA+IAo+ID4gPiArSTkxNV9D T05URVhUX0VOR0lORVNfRVhUX0xPQURfQkFMQU5DRSBvciBJOTE1X0NPTlRFWFRfRU5HSU5FU19F WFRfQk9ORCBmb3IKPiA+ID4gK3NpbWlsYXIgZXhpc3RpbmcgZXhhbXBsZXMuIE9uY2UgYSBzbG90 IGlzIGNvbmZpZ3VyZWQgZm9yIHBhcmFsbGVsIHN1Ym1pc3Npb24gdGhlCj4gPiA+ICtleGVjYnVm MiBJT0NUTCBjYW4gYmUgY2FsbGVkIHN1Ym1pdHRpbmcgTiBCQnMgaW4gYSBzaW5nbGUgSU9DVEwu IEluaXRpYWxseSBvbmx5Cj4gPiA+ICtzdXBwb3J0IEd1QyBzdWJtaXNzaW9uLiBFeGVjbGlzdCBz dXBwb3J0IGNhbiBiZSBhZGRlZCBsYXRlciBpZiBuZWVkZWQuCj4gPiA+ICsKPiA+ID4gK0FkZCBJ OTE1X0NPTlRFWFRfRU5HSU5FU19FWFRfUEFSQUxMRUxfU1VCTUlUIGFuZAo+ID4gPiAraTkxNV9j b250ZXh0X2VuZ2luZXNfcGFyYWxsZWxfc3VibWl0IHRvIHRoZSB1QVBJIHRvIGltcGxlbWVudCB0 aGlzIGV4dGVuc2lvbi4KPiA+ID4gKwo+ID4gPiArRXh0ZW5kIGV4ZWNidWYyIElPQ1RMIHRvIHN1 cHBvcnQgc3VibWl0dGluZyBOIEJCcyBpbiBhIHNpbmdsZSBJT0NUTAo+ID4gPiArLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LQo+ID4gPiArQ29udGV4dHMgdGhhdCBoYXZlIGJlZW4gY29uZmlndXJlZCB3aXRoIHRoZSAnc2V0 X3BhcmFsbGVsJyBleHRlbnNpb24gYXJlIGFsbG93ZWQKPiA+ID4gK3RvIHN1Ym1pdCBOIEJCcyBp biBhIHNpbmdsZSBleGVjYnVmMiBJT0NUTC4gVGhlIEJCcyBhcmUgZWl0aGVyIHRoZSBsYXN0IE4K PiA+ID4gK29iamVjdHMgaW4gdGhlIGRybV9pOTE1X2dlbV9leGVjX29iamVjdDIgbGlzdCBvciB0 aGUgZmlyc3QgTiBpZgo+ID4gPiArSTkxNV9FWEVDX0JBVENIX0ZJUlNUIGlzIHNldC4gVGhlIG51 bWJlciBvZiBCQnMgaXMgaW1wbGljdCBiYXNlZCBvbiB0aGUgc2xvdAo+ID4gPiArc3VibWl0dGVk IGFuZCBob3cgaXQgaGFzIGJlZW4gY29uZmlndXJlZCBieSAnc2V0X3BhcmFsbGVsJyBvciBvdGhl ciBleHRlbnNpb25zLgo+ID4gPiArTm8gdUFQSSBjaGFuZ2VzIGFyZSByZXF1aXJlZCB0byBleGVj YnVmMiBJT0NUTC4KPiA+IAo+ID4gQWRkZCBoZXJlIHRoZSBrZXJuZWxkb2MgaW5jbHVkZSBmb3Ig eW91ciBoZWFkZXIuCj4gPgo+IAo+IFN1cmUuCj4gCj4gTWF0dAo+ICAKPiA+IEFzaWRlIGZyb20g dGhlIGNvbW1lbnRzIGJ5IGFuZCBsYXJnZSB0aGlzIGxvb2tzIGdvb2QuIFRoZSBtYWluIGludGVy ZmFjZQo+ID4gYXQgbGVhc3QgaXMgY2xlYXIgYW5kIHdhcnRzLWZyZWUuCj4gPiAKPiA+IEFja2Vk LWJ5OiBEYW5pZWwgVmV0dGVyIDxkYW5pZWwudmV0dGVyQGZmd2xsLmNoPgo+ID4gCj4gPiA+IC0t IAo+ID4gPiAyLjI4LjAKPiA+ID4gCj4gPiA+IF9fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fCj4gPiA+IEludGVsLWdmeCBtYWlsaW5nIGxpc3QKPiA+ID4gSW50 ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwo+ID4gPiBodHRwczovL2xpc3RzLmZyZWVkZXNr dG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2ludGVsLWdmeAo+ID4gCj4gPiAtLSAKPiA+IERhbmll bCBWZXR0ZXIKPiA+IFNvZnR3YXJlIEVuZ2luZWVyLCBJbnRlbCBDb3Jwb3JhdGlvbgo+ID4gaHR0 cDovL2Jsb2cuZmZ3bGwuY2gKCi0tIApEYW5pZWwgVmV0dGVyClNvZnR3YXJlIEVuZ2luZWVyLCBJ bnRlbCBDb3Jwb3JhdGlvbgpodHRwOi8vYmxvZy5mZndsbC5jaApfX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fXwpJbnRlbC1nZnggbWFpbGluZyBsaXN0CkludGVs LWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcv bWFpbG1hbi9saXN0aW5mby9pbnRlbC1nZngK