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=-14.3 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,HK_RANDOM_FROM,INCLUDES_CR_TRAILER, INCLUDES_PATCH,MAILING_LIST_MULTI,NICE_REPLY_A,SPF_HELO_NONE,SPF_PASS, URIBL_BLOCKED,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 54671C4707F for ; Thu, 27 May 2021 15:01:32 +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 18EAA6128D for ; Thu, 27 May 2021 15:01:32 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 18EAA6128D Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linux.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 4EC6B6F3FD; Thu, 27 May 2021 15:01:26 +0000 (UTC) Received: from mga07.intel.com (mga07.intel.com [134.134.136.100]) by gabe.freedesktop.org (Postfix) with ESMTPS id 83A966E7DD; Thu, 27 May 2021 15:01:24 +0000 (UTC) IronPort-SDR: QhwtIUGWJK6VH+SmWp8oQHQUaAiFQi1Z8J8KlKl7+K6gwJpKyEcQxEUKeoddH8w63XOStof59+ xpfDxS+3DiKQ== X-IronPort-AV: E=McAfee;i="6200,9189,9996"; a="266641664" X-IronPort-AV: E=Sophos;i="5.82,334,1613462400"; d="scan'208";a="266641664" Received: from fmsmga001.fm.intel.com ([10.253.24.23]) by orsmga105.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 27 May 2021 08:01:13 -0700 IronPort-SDR: VaMqt0T4ci2OaEAWwgOHGv9Wte7r1lt1cswe3MBKnddHYjQqCO8tVe69gXJfZGElFPsm9iB3Ma Gr/OKYKIgCDw== X-IronPort-AV: E=Sophos;i="5.82,334,1613462400"; d="scan'208";a="547941040" Received: from amoses-mobl1.ger.corp.intel.com (HELO [10.213.211.53]) ([10.213.211.53]) by fmsmga001-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 27 May 2021 08:01:10 -0700 To: Matthew Brost , intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org References: <20210526233357.9165-1-matthew.brost@intel.com> <20210526233357.9165-3-matthew.brost@intel.com> From: Tvrtko Ursulin Organization: Intel Corporation UK Plc Message-ID: <5d46472d-3dc2-0484-5a1f-4b36eecc11f6@linux.intel.com> Date: Thu, 27 May 2021 16:01:08 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101 Thunderbird/78.8.1 MIME-Version: 1.0 In-Reply-To: <20210526233357.9165-3-matthew.brost@intel.com> Content-Language: en-US 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: jason.ekstrand@intel.com, mesa-dev@lists.freedesktop.org, christian.koenig@amd.com, daniel.vetter@intel.com, carl.zhang@intel.com Content-Transfer-Encoding: base64 Content-Type: text/plain; charset="utf-8"; Format="flowed" Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" Ck9uIDI3LzA1LzIwMjEgMDA6MzMsIE1hdHRoZXcgQnJvc3Qgd3JvdGU6Cj4gQWRkIGVudHJ5IGZv ciBpOTE1IG5ldyBwYXJhbGxlbCBzdWJtaXNzaW9uIHVBUEkgcGxhbi4KPiAKPiB2MjoKPiAgIChE YW5pZWwgVmV0dGVyKToKPiAgICAtIEV4cGFuZCBsb2dpY2FsIG9yZGVyIGV4cGxhaW5hdGlvbgo+ ICAgIC0gQWRkIGR1bW15IGhlYWRlcgo+ICAgIC0gT25seSBhbGxvdyBOIEJCcyBpbiBleGVjYnVm IElPQ1RMCj4gICAgLSBDb25maWd1cmUgcGFyYWxsZWwgc3VibWlzc2lvbiBwZXIgc2xvdCBub3Qg cGVyIGdlbSBjb250ZXh0Cj4gdjM6Cj4gICAoTWFyY2luIMWabHVzYXJ6KToKPiAgICAtIExvdCdz IG9mIHR5cG9zIC8gYmFkIGVuZ2xpc2ggZml4ZWQKPiAgIChUdnJ0a28gVXJzdWxpbik6Cj4gICAg LSBDb25zaXN0ZW50IHBzZXVkbyBjb2RlLCBjbGVhbiB1cCB3b3JkaW5nIGluIGRlc2NyaXB0aW9u cwo+IAo+IENjOiBUdnJ0a28gVXJzdWxpbiA8dHZydGtvLnVyc3VsaW5AaW50ZWwuY29tPgo+IENj OiBUb255IFllIDx0b255LnllQGludGVsLmNvbT4KPiBDQzogQ2FybCBaaGFuZyA8Y2FybC56aGFu Z0BpbnRlbC5jb20+Cj4gQ2M6IERhbmllbCBWZXR0ZXIgPGRhbmllbC52ZXR0ZXJAaW50ZWwuY29t Pgo+IENjOiBKYXNvbiBFa3N0cmFuZCA8amFzb25Aamxla3N0cmFuZC5uZXQ+Cj4gU2lnbmVkLW9m Zi1ieTogTWF0dGhldyBCcm9zdCA8bWF0dGhldy5icm9zdEBpbnRlbC5jb20+Cj4gLS0tCj4gICBE b2N1bWVudGF0aW9uL2dwdS9yZmMvaTkxNV9wYXJhbGxlbF9leGVjYnVmLmggfCAxNDUgKysrKysr KysrKysrKysrKysrCj4gICBEb2N1bWVudGF0aW9uL2dwdS9yZmMvaTkxNV9zY2hlZHVsZXIucnN0 ICAgICAgfCAgNTUgKysrKysrLQo+ICAgMiBmaWxlcyBjaGFuZ2VkLCAxOTggaW5zZXJ0aW9ucygr KSwgMiBkZWxldGlvbnMoLSkKPiAgIGNyZWF0ZSBtb2RlIDEwMDY0NCBEb2N1bWVudGF0aW9uL2dw dS9yZmMvaTkxNV9wYXJhbGxlbF9leGVjYnVmLmgKPiAKPiBkaWZmIC0tZ2l0IGEvRG9jdW1lbnRh dGlvbi9ncHUvcmZjL2k5MTVfcGFyYWxsZWxfZXhlY2J1Zi5oIGIvRG9jdW1lbnRhdGlvbi9ncHUv cmZjL2k5MTVfcGFyYWxsZWxfZXhlY2J1Zi5oCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiBpbmRl eCAwMDAwMDAwMDAwMDAuLjIwZGUyMDZlM2FiNAo+IC0tLSAvZGV2L251bGwKPiArKysgYi9Eb2N1 bWVudGF0aW9uL2dwdS9yZmMvaTkxNV9wYXJhbGxlbF9leGVjYnVmLmgKPiBAQCAtMCwwICsxLDE0 NSBAQAo+ICsjZGVmaW5lIEk5MTVfQ09OVEVYVF9FTkdJTkVTX0VYVF9QQVJBTExFTF9TVUJNSVQg MiAvKiBzZWUgaTkxNV9jb250ZXh0X2VuZ2luZXNfcGFyYWxsZWxfc3VibWl0ICovCj4gKwo+ICsv Kgo+ICsgKiBpOTE1X2NvbnRleHRfZW5naW5lc19wYXJhbGxlbF9zdWJtaXQ6Cj4gKyAqCj4gKyAq IFNldHVwIGEgc2xvdCBpbiB0aGUgY29udGV4dCBlbmdpbmUgbWFwIHRvIGFsbG93IG11bHRpcGxl IEJCcyB0byBiZSBzdWJtaXR0ZWQKPiArICogaW4gYSBzaW5nbGUgZXhlY2J1ZiBJT0NUTC4gVGhv c2UgQkJzIHdpbGwgdGhlbiBiZSBzY2hlZHVsZWQgdG8gcnVuIG9uIHRoZSBHUFUKPiArICogaW4g cGFyYWxsZWwuIE11bHRpcGxlIGhhcmR3YXJlIGNvbnRleHRzIGFyZSBjcmVhdGVkIGludGVybmFs bHkgaW4gdGhlIGk5MTUKPiArICogcnVuIHRoZXNlIEJCcy4gT25jZSBhIHNsb3QgaXMgY29uZmln dXJlZCBmb3IgTiBCQnMgb25seSBOIEJCcyBjYW4gYmUKPiArICogc3VibWl0dGVkIGluIGVhY2gg ZXhlY2J1ZiBJT0NUTCBhbmQgdGhpcyBpcyBpbXBsaWNpdCBiZWhhdmlvciBlLmcuIFRoZSB1c2Vy CgoiaS5lLiB0aGUgdXNlciIgSSB0aGluay4KCj4gKyAqIGRvZXNuJ3QgdGVsbCB0aGUgZXhlY2J1 ZiBJT0NUTCB0aGVyZSBhcmUgTiBCQnMsIHRoZSBleGVjYnVmIElPQ1RMIGtub3cgaG93Cgprbm93 cwoKPiArICogbWFueSBCQnMgdGhlcmUgYXJlIGJhc2VkIG9uIHRoZSBzbG90cyBjb25maWd1cmF0 aW9uLiBUaGUgTiBCQnMgYXJlIHRoZSBsYXN0IE4KCiJzbG90J3MiID8gT3IgbWF5YmUgYmV0dGVy IGZ1bGx5IHF1YWxpZmllZCBhcyAiZW5naW5lIG1hcCBzbG90Ij8KCj4gKyAqIGJ1ZmZlciBvYmpl Y3RzIGZvciBmaXJzdCBOIGlmIEk5MTVfRVhFQ19CQVRDSF9GSVJTVCBpcyBzZXQuCgpzL2Zvci9v ci8KCj4gKyAqCj4gKyAqIFRoZXJlIGFyZSB0d28gY3VycmVudGx5IGRlZmluZWQgd2F5cyB0byBj b250cm9sIHRoZSBwbGFjZW1lbnQgb2YgdGhlCj4gKyAqIGhhcmR3YXJlIGNvbnRleHRzIG9uIHBo eXNpY2FsIGVuZ2luZXM6IGRlZmF1bHQgYmVoYXZpb3IgKG5vIGZsYWdzKSBhbmQKPiArICogSTkx NV9QQVJBTExFTF9JTVBMSUNJVF9CT05EUyAoYSBmbGFnKS4gTW9yZSBmbGFncyBtYXkgYmUgYWRk ZWQgdGhlIGluIHRoZQo+ICsgKiBmdXR1cmUgYXMgbmV3IGhhcmR3YXJlIC8gdXNlIGNhc2VzIGFy aXNlLiBEZXRhaWxzIG9mIGhvdyB0byB1c2UgdGhpcwo+ICsgKiBpbnRlcmZhY2UgYWJvdmUgdGhl IGZsYWdzIGZpZWxkIGluIHRoaXMgc3RydWN0dXJlLgoKImFyZSBhYm92ZSIsICJjYW4gYmUgZm91 bmQgYWJvdmUiID8KCj4gKyAqCj4gKyAqIFJldHVybnMgLUVJTlZBTCBpZiBoYXJkd2FyZSBjb250 ZXh0IHBsYWNlbWVudCBjb25maWd1cmF0aW9uIGlzIGludmFsaWQgb3IgaWYKPiArICogdGhlIHBs YWNlbWVudCBjb25maWd1cmF0aW9uIGlzbid0IHN1cHBvcnRlZCBvbiB0aGUgcGxhdGZvcm0gLyBz dWJtaXNzaW9uCj4gKyAqIGludGVyZmFjZS4KPiArICogUmV0dXJucyAtRU5PREVWIGlmIGV4dGVu c2lvbiBpc24ndCBzdXBwb3J0ZWQgb24gdGhlIHBsYXRmb3JtIC8gc3VibWlzc2lvbgo+ICsgKiBp bnRlZmFjZS4KPiArICovCj4gK3N0cnVjdCBpOTE1X2NvbnRleHRfZW5naW5lc19wYXJhbGxlbF9z dWJtaXQgewo+ICsJc3RydWN0IGk5MTVfdXNlcl9leHRlbnNpb24gYmFzZTsKPiArCj4gKwlfX3Ux NiBlbmdpbmVfaW5kZXg7CS8qIHNsb3QgZm9yIHBhcmFsbGVsIGVuZ2luZSAqLwo+ICsJX191MTYg d2lkdGg7CQkvKiBudW1iZXIgb2YgY29udGV4dHMgcGVyIHBhcmFsbGVsIGVuZ2luZSAqLwo+ICsJ X191MTYgbnVtX3NpYmxpbmdzOwkvKiBudW1iZXIgb2Ygc2libGluZ3MgcGVyIGNvbnRleHQgKi8K PiArCV9fdTE2IG1iejE2Owo+ICsvKgo+ICsgKiBEZWZhdWx0IHBsYWNlbWVudCBiZWhhdmlvciAo Y3VycmVudGx5IHVuc3VwcG9ydGVkKToKPiArICoKPiArICogQWxsb3cgQkJzIHRvIGJlIHBsYWNl ZCBvbiBhbnkgYXZhaWxhYmxlIGVuZ2luZSBpbnN0YW5jZS4gSW4gdGhpcyBjYXNlIGVhY2gKPiAr ICogY29udGV4dCdzIGVuZ2luZSBtYXNrIGluZGljYXRlcyB3aGVyZSB0aGF0IGNvbnRleHQgY2Fu IGJlIHBsYWNlZC4gSXQgaXMKCkNvbnRleHQgZG9lcyBub3QgaGF2ZSBhbiBlbmdpbmUgbWFzayBp biB0aGUgdWFwaSBzbyBJJ2QgZXhwbGFpbiB0aGlzIGluIAp0ZXJtcyBvZiBsaXN0IG9mIGVuZ2lu ZXMuCgo+ICsgKiBpbXBsaWVkIGluIHRoaXMgbW9kZSB0aGF0IGFsbCBjb250ZXh0cyBoYXZlIG11 dHVhbCBleGNsdXNpdmUgcGxhY2VtZW50LgoKbXV0dWFsbHkKCj4gKyAqIGUuZy4gSWYgb25lIGNv bnRleHQgaXMgcnVubmluZyBDU1hbMF0gbm8gb3RoZXIgY29udGV4dHMgY2FuIHJ1biBvbiBDU1hb MF0pLgoKcy9JZi9pZiwgSSB0aGluay4KCkkgZG9uJ3QgZmluZCBDU1hbMF0gcmVhZGFibGUgbm9y IEkgdGhpbmsgaW50cm9kdWNpbmcgY3N4IGFzIGEgdGVybSBpcyAKZGVzaXJhYmxlLiBMb3dlcmNh c2UgY3M8bj4gKGxpa2UgY3MwKSBpcyB3aGF0IEkgd291bGQgcHJlZmVyIGZvciBib3RoIApyZWFk YWJpbGl0eSBhbmQgbGlrZWx5IGNzID0gY29tbWFuZCBzdHJlYW1lciBjb3VsZCBiZSBtb3JlIG9i dmlvdXMgd2hhdCAKaXQgaXMuIE5hbWluZyBsaWtlIHJjczAgKHByZWZpeC1jcy1udW1iZXIpIGFu ZCBzaW1pbGFyIGFyZSBleHBvc2VkIGluIAprZXJuZWwgbG9ncyBhbmQgZXJyb3Igc3RhdGUgd2hp bGUgY3N4W10gKGNzLXN1ZmZpeC1udW1iZXIpIGFyZSBub3QgYXQgYWxsLgoKSW4gcGxhY2VtZW50 IGV4YW1wbGVzIEkgd291bGQgcmVmcmFpbiBmcm9tIHVzaW5nIGFueSBwcmVmaXhlcy9zdWZmaXhl cyAKdG8gZGVzaWduYXRlIGVuZ2luZSBjbGFzc2VzIGFuZCBqdXN0IHNheSBjczAvY3MxLCBtZW50 aW9uaW5nIHRoZSAKc2FtZS9taXhlZCBjbGFzcyByZXF1aXJlbWVudCBzZXBhcmF0ZWx5IGluIHRo ZSBub3RlcyBpZiBhcHBsaWNhYmxlLgoKPiArICoKPiArICogRXhhbXBsZSAxIHBzZXVkbyBjb2Rl Ogo+ICsgKiBDU1gsWVtOXSA9IGdlbmVyaWMgZW5naW5lIGNsYXNzIFggb3IgWSwgbG9naWNhbCBp bnN0YW5jZSBOCj4gKyAqIElOVkFMSUQgPSBJOTE1X0VOR0lORV9DTEFTU19JTlZBTElELCBJOTE1 X0VOR0lORV9DTEFTU19JTlZBTElEX05PTkUKPiArICogc2V0X2VuZ2luZXMoSU5WQUxJRCkKPiAr ICogc2V0X3BhcmFsbGVsKGVuZ2luZV9pbmRleD0wLCB3aWR0aD0yLCBudW1fc2libGluZ3M9MiwK PiArICoJCWVuZ2luZXM9Q1NYWzBdLENTWFsxXSxDU1lbMF0sQ1NZWzFdKQo+ICsgKgo+ICsgKiBS ZXN1bHRzIGluIHRoZSBmb2xsb3dpbmcgdmFsaWQgcGxhY2VtZW50czoKPiArICogQ1NYWzBdLCBD U1lbMF0KPiArICogQ1NYWzBdLCBDU1lbMV0KPiArICogQ1NYWzFdLCBDU1lbMF0KPiArICogQ1NY WzFdLCBDU1lbMV0KPiArICoKPiArICogVGhpcyBjYW4gYWxzbyBiZSB0aG91Z2h0IG9mIGFzIDIg dmlydHVhbCBlbmdpbmVzIGRlc2NyaWJlZCBieSAyLUQgYXJyYXkgaW4KPiArICogdGhlIGVuZ2lu ZXMgdGhlIGZpZWxkOgoKT25lIHRoZSB0b28gbWFueS4KCj4gKyAqIFZFWzBdID0gQ1NYWzBdLCBD U1hbMV0KPiArICogVkVbMV0gPSBDU1lbMF0sIENTWVsxXQo+ICsgKgo+ICsgKiBFeGFtcGxlIDIg cHNldWRvIGNvZGU6Cj4gKyAqIENTWFtZXSA9IGdlbmVyaWMgZW5naW5lIG9mIHNhbWUgY2xhc3Mg WCwgbG9naWNhbCBpbnN0YW5jZSBOCj4gKyAqIElOVkFMSUQgPSBJOTE1X0VOR0lORV9DTEFTU19J TlZBTElELCBJOTE1X0VOR0lORV9DTEFTU19JTlZBTElEX05PTkUKPiArICogc2V0X2VuZ2luZXMo SU5WQUxJRCkKPiArICogc2V0X3BhcmFsbGVsKGVuZ2luZV9pbmRleD0wLCB3aWR0aD0yLCBudW1f c2libGluZ3M9MywKPiArICoJCWVuZ2luZXM9Q1NYWzBdLENTWFsxXSxDU1hbMl0sQ1NYWzBdLENT WFsxXSxDU1hbMl0pCj4gKyAqCj4gKyAqIFJlc3VsdHMgaW4gdGhlIGZvbGxvd2luZyB2YWxpZCBw bGFjZW1lbnRzOgo+ICsgKiBDU1hbMF0sIENTWFsxXQo+ICsgKiBDU1hbMF0sIENTWFsyXQo+ICsg KiBDU1hbMV0sIENTWFswXQo+ICsgKiBDU1hbMV0sIENTWFsyXQo+ICsgKiBDU1hbMl0sIENTWFsw XQo+ICsgKiBDU1hbMl0sIENTWFsxXQo+ICsgKgo+ICsgKiBUaGlzIGNhbiBhbHNvIGJlIHRob3Vn aHQgb2YgYXMgMiB2aXJ0dWFsIGVuZ2luZXMgZGVzY3JpYmVkIGJ5IDItRCBhcnJheSBpbgo+ICsg KiB0aGUgZW5naW5lcyB0aGUgZmllbGQ6Cj4gKyAqIFZFWzBdID0gQ1NYWzBdLCBDU1hbMV0sIENT WFsyXQo+ICsgKiBWRVsxXSA9IENTWFswXSwgQ1NYWzFdLCBDU1hbMl0KPiArCj4gKyAqIFRoaXMg ZW5hYmxlcyBhIHVzZSBjYXNlIHdoZXJlIGFsbCBlbmdpbmVzIGFyZSBjcmVhdGVkIGVxdWFsbHks IHdlIGRvbid0IGNhcmUKPiArICogd2hlcmUgdGhleSBhcmUgc2NoZWR1bGVkLCB3ZSBqdXN0IHdh bnQgYSBjZXJ0YWluIG51bWJlciBvZiByZXNvdXJjZXMsIGZvcgo+ICsgKiB0aG9zZSByZXNvdXJj ZXMgdG8gYmUgc2NoZWR1bGVkIGluIHBhcmFsbGVsLCBhbmQgcG9zc2libHkgYWNyb3NzIG11bHRp cGxlCj4gKyAqIGVuZ2luZSBjbGFzc2VzLgo+ICsgKi8KPiArCj4gKy8qCj4gKyAqIEk5MTVfUEFS QUxMRUxfSU1QTElDSVRfQk9ORFMgLSBDcmVhdGUgaW1wbGljaXQgYm9uZHMgYmV0d2VlbiBlYWNo IGNvbnRleHQuCj4gKyAqIEVhY2ggY29udGV4dCBtdXN0IGhhdmUgdGhlIHNhbWUgbnVtYmVyIG9m IHNpYmxpbmcgYW5kIGJvbmRzIGFyZSBpbXBsaWNpdGx5CgpzaWJsaW5ncwoKPiArICogY3JlYXRl ZCBiZXR3ZWVuIGVhY2ggc2V0IG9mIHNpYmxpbmdzLgo+ICsgKgo+ICsgKiBFeGFtcGxlIDEgcHNl dWRvIGNvZGU6Cj4gKyAqIENTWFtOXSA9IGdlbmVyaWMgZW5naW5lIG9mIHNhbWUgY2xhc3MgWCwg bG9naWNhbCBpbnN0YW5jZSBOCj4gKyAqIElOVkFMSUQgPSBJOTE1X0VOR0lORV9DTEFTU19JTlZB TElELCBJOTE1X0VOR0lORV9DTEFTU19JTlZBTElEX05PTkUKPiArICogc2V0X2VuZ2luZXMoSU5W QUxJRCkKPiArICogc2V0X3BhcmFsbGVsKGVuZ2luZV9pbmRleD0wLCB3aWR0aD0yLCBudW1fc2li bGluZ3M9MSwKPiArICoJCWVuZ2luZXM9Q1NYWzBdLENTWFsxXSwgZmxhZ3M9STkxNV9QQVJBTExF TF9JTVBMSUNJVF9CT05EUykKPiArICoKPiArICogUmVzdWx0cyBpbiB0aGUgZm9sbG93aW5nIHZh bGlkIHBsYWNlbWVudHM6Cj4gKyAqIENTWFswXSwgQ1NYWzFdCj4gKyAqCj4gKyAqIEV4YW1wbGUg MiBwc2V1ZG8gY29kZToKPiArICogQ1NYW05dID0gZ2VuZXJpYyBlbmdpbmUgb2Ygc2FtZSBjbGFz cyBYLCBsb2dpY2FsIGluc3RhbmNlIE4KPiArICogSU5WQUxJRCA9IEk5MTVfRU5HSU5FX0NMQVNT X0lOVkFMSUQsIEk5MTVfRU5HSU5FX0NMQVNTX0lOVkFMSURfTk9ORQo+ICsgKiBzZXRfZW5naW5l cyhJTlZBTElEKQo+ICsgKiBzZXRfcGFyYWxsZWwoZW5naW5lX2luZGV4PTAsIHdpZHRoPTIsIG51 bV9zaWJsaW5ncz0yLAo+ICsgKgkJZW5naW5lcz1DU1hbMF0sQ1NYWzJdLENTWFsxXSxDU1hbM10s Cj4gKyAqCQlmbGFncz1JOTE1X1BBUkFMTEVMX0lNUExJQ0lUX0JPTkRTKQo+ICsgKgo+ICsgKiBS ZXN1bHRzIGluIHRoZSBmb2xsb3dpbmcgdmFsaWQgcGxhY2VtZW50czoKPiArICogQ1NYWzBdLCBD U1hbMV0KPiArICogQ1NYWzJdLCBDU1hbM10KPiArICoKPiArICogVGhpcyBjYW4gYWxzbyBiZSB0 aG91Z2h0IG9mIGFzIDIgdmlydHVhbCBlbmdpbmVzIGRlc2NyaWJlZCBieSAyLUQgYXJyYXkgaW4K PiArICogdGhlIGVuZ2luZXMgdGhlIGZpZWxkIHdpdGggYm9uZHMgcGxhY2VkIGJldHdlZW4gZWFj aCBpbmRleCBvZiB0aGUgdmlydHVhbAo+ICsgKiBlbmdpbmVzLiBlLmcuIENTWFswXSBpcyBib25k ZWQgdG8gQ1NYWzFdLCBDU1hbMl0gaXMgYm9uZGVkIHRvIENTWFszXS4KPiArICogVkVbMF0gPSBD U1hbMF0sIENTWFsyXQo+ICsgKiBWRVsxXSA9IENTWFsxXSwgQ1NYWzNdCj4gKyAqCj4gKyAqIFRo aXMgZW5hYmxlcyBhIHVzZSBjYXNlIHdoZXJlIGFsbCBlbmdpbmVzIGFyZSBub3QgZXF1YWwgYW5k IGNlcnRhaW4gcGxhY2VtZW50Cj4gKyAqIHJ1bGVzIGFyZSByZXF1aXJlZCAoaS5lLiBzcGxpdC1m cmFtZSByZXF1aXJlcyBhbGwgY29udGV4dHMgdG8gYmUgcGxhY2VkIGluIGEKPiArICogbG9naWNh bGx5IGNvbnRpZ3VvdXMgb3JkZXIgb24gdGhlIFZDUyBlbmdpbmVzIG9uIGdlbjExKyBwbGF0Zm9y bXMpLiBUaGlzIHVzZQo+ICsgKiBjYXNlIChsb2dpY2FsbHkgY29udGlndW91cyBwbGFjZW1lbnQs IHdpdGhpbiBhIHNpbmdsZSBlbmdpbmUgY2xhc3MpIGlzCgpBZ2FpbiwgSSB3b3VsZG4ndCB1c2Ug dGhlIHRlcm0gbG9naWNhbGx5IGNvbnRpZ3VvdXMgaGVyZSBiZWNhdXNlIGxvZ2ljYWwgCmluc3Rh bmNlIG51bWJlcmluZyBpc24ndCB1c2VkIGluIGNsYXNzOmluc3RhbmNlIGFkZHJlc3NpbmcgYXMg dXNlZCBpbiAKZW5naW5lIG1hcHMuCgo+ICsgKiBzdXBwb3J0ZWQgd2hlbiB1c2luZyBHdUMgc3Vi bWlzc2lvbi4gRXhlY2xpc3QgbW9kZSBjb3VsZCBzdXBwb3J0IGFsbCBwb3NzaWJsZQo+ICsgKiBi b25kaW5nIGNvbmZpZ3VyYXRpb25zIGJ1dCBjdXJyZW50bHkgZG9lc24ndCBzdXBwb3J0IHRoaXMg ZXh0ZW5zaW9uLgo+ICsgKi8KPiArI2RlZmluZSBJOTE1X1BBUkFMTEVMX0lNUExJQ0lUX0JPTkRT CQkJKDEgPDwgMCkKPiArLyoKPiArICogRG8gbm90IGFsbG93IEJCcyB0byBiZSBwcmVlbXB0ZWQg bWlkIEJCIHJhdGhlciBpbnNlcnQgY29vcmRpbmF0ZWQgcHJlZW1wdGlvbgo+ICsgKiBwb2ludHMg b24gYWxsIGhhcmR3YXJlIGNvbnRleHRzIGJldHdlZW4gZWFjaCBzZXQgb2YgQkJzLiBBbiBleGFt cGxlIHVzZSBjYXNlCj4gKyAqIG9mIHRoaXMgZmVhdHVyZSBpcyBzcGxpdC1mcmFtZSBvbiBnZW4x MSsgaGFyZHdhcmUuCj4gKyAqLwo+ICsjZGVmaW5lIEk5MTVfUEFSQUxMRUxfTk9fUFJFRU1QVF9N SURfQkFUQ0gJCSgxIDw8IDEpCj4gKyNkZWZpbmUgX19JOTE1X1BBUkFMTEVMX1VOS05PV05fRkxB R1MJKC0oSTkxNV9QQVJBTExFTF9OT19QUkVFTVBUX01JRF9CQVRDSCA8PCAxKSkKPiArCV9fdTY0 IGZsYWdzOwkJLyogYWxsIHVuZGVmaW5lZCBmbGFncyBtdXN0IGJlIHplcm8gKi8KPiArCV9fdTY0 IG1iejY0WzNdOwkJLyogcmVzZXJ2ZWQgZm9yIGZ1dHVyZSB1c2U7IG11c3QgYmUgemVybyAqLwo+ ICsKPiArCS8qCj4gKwkgKiAyLUQgYXJyYXkgb2YgZW5naW5lcwo+ICsJICoKPiArCSAqIHdpZHRo IChpKSAqIG51bV9zaWJsaW5ncyAoaikgaW4gbGVuZ3RoCj4gKwkgKiBpbmRleCA9IGogKyBpICog bnVtX3NpYmxpbmdzCgplbmdpbmVzW11bXSA9IHsKICAgLyogQ2hhbm5lbCAwIHBvc3NpYmxlIGVu Z2luZXM6ICovIHsgY3MwLCBjczIgfSwKICAgLyogQ2hhbm5lbCAxIHBvc3NpYmxlIGVuZ2luZXM6 ICovIHsgY3MxLCBjczMgfSwKfTsKCldvdWxkIHRoaXMgYmUgYWNjdXJhdGUgYW5kIGRlc2NyaXB0 aXZlIG9uIHRvcCBvZiB0aGUgZm9ybXVsYT8gQWx0aG91Z2ggSSAKYW0gbm90IHRvbyBoYXBweSB3 aXRoIHRoZSB0ZXJtIGNoYW5uZWwgd2l0aG91dCBmaXJzdCBleHBsYWluaW5nIGhvdyB3ZSAKYXJl IGdvaW5nIHRvIGNhbGwgcGFyYWxsZWwgc3RyZWFtcyB3aXRoaW4gYSB3aWRlIGNvbnRleHQuCgo+ ICsJICovCj4gKwlzdHJ1Y3QgaTkxNV9lbmdpbmVfY2xhc3NfaW5zdGFuY2UgZW5naW5lc1swXTsK PiArfSBfX2F0dHJpYnV0ZV9fICgocGFja2VkKSk7Cj4gKwo+IGRpZmYgLS1naXQgYS9Eb2N1bWVu dGF0aW9uL2dwdS9yZmMvaTkxNV9zY2hlZHVsZXIucnN0IGIvRG9jdW1lbnRhdGlvbi9ncHUvcmZj L2k5MTVfc2NoZWR1bGVyLnJzdAo+IGluZGV4IDdmYWE0NmNkZTA4OC4uMDI1NGMwNGQzNGJlIDEw MDY0NAo+IC0tLSBhL0RvY3VtZW50YXRpb24vZ3B1L3JmYy9pOTE1X3NjaGVkdWxlci5yc3QKPiAr KysgYi9Eb2N1bWVudGF0aW9uL2dwdS9yZmMvaTkxNV9zY2hlZHVsZXIucnN0Cj4gQEAgLTIzLDcg KzIzLDcgQEAgaTkxNSB3aXRoIHRoZSBEUk0gc2NoZWR1bGVyIGlzOgo+ICAgCSAgc2V2ZXJlIGRl c2lnbiBpc3N1ZXMgaW4gZ2VuZXJhbCwgd2hpY2ggaXMgd2h5IHdlIHdhbnQgdG8gcmV0aXJlIGl0 IG5vCj4gICAJICBtYXR0ZXIgd2hhdAo+ICAgCSogTmV3IHVBUEkgYWRkcyBJOTE1X0NPTlRFWFRf RU5HSU5FU19FWFRfUEFSQUxMRUwgY29udGV4dCBzZXR1cCBzdGVwCj4gLQkgIHdoaWNoIGNvbmZp Z3VyZXMgYSBzbG90IHdpdGggTiBjb250ZXh0cwo+ICsJICB3aGljaCBjb25maWd1cmVzIGEgc2xv dCB3aXRoIE4gY29udGV4dHMKPiAgIAkqIEFmdGVyIEk5MTVfQ09OVEVYVF9FTkdJTkVTX0VYVF9Q QVJBTExFTCBhIHVzZXIgY2FuIHN1Ym1pdCBOIGJhdGNoZXMgdG8KPiAgIAkgIGEgc2xvdCBpbiBh IHNpbmdsZSBleGVjYnVmIElPQ1RMIGFuZCB0aGUgYmF0Y2hlcyBydW4gb24gdGhlIEdQVSBpbgo+ ICAgCSAgcGFyYWxsbGVsCj4gQEAgLTgyLDQgKzgyLDU1IEBAIGh0dHBzOi8vc3BlYy5vbmVhcGku Y29tL2xldmVsLXplcm8vbGF0ZXN0L2NvcmUvYXBpLmh0bWwjemUtY29tbWFuZC1xdWV1ZS1wcmlv cml0Cj4gICAKPiAgIE5ldyBwYXJhbGxlbCBzdWJtaXNzaW9uIHVBUEkKPiAgID09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KPiAtRGV0YWlscyB0byBjb21lIGluIGEgZm9sbG93aW5nIHBhdGNo Lgo+ICtUaGUgZXhpc3RpbmcgYm9uZGluZyB1QVBJIGlzIGNvbXBsZXRlbHkgYnJva2VuIHdpdGgg R3VDIHN1Ym1pc3Npb24gYmVjYXVzZQo+ICt3aGV0aGVyIGEgc3VibWlzc2lvbiBpcyBhIHNpbmds ZSBjb250ZXh0IHN1Ym1pdCBvciBwYXJhbGxlbCBzdWJtaXQgaXNuJ3Qga25vd24KPiArdW50aWwg ZXhlY2J1ZiB0aW1lIGFjdGl2YXRlZCB2aWEgdGhlIEk5MTVfU1VCTUlUX0ZFTkNFLiBUbyBzdWJt aXQgbXVsdGlwbGUKPiArY29udGV4dHMgaW4gcGFyYWxsZWwgd2l0aCB0aGUgR3VDIHRoZSBjb250 ZXh0IG11c3QgYmUgZXhwbGljaXRseSByZWdpc3RlcmVkIHdpdGgKPiArTiBjb250ZXh0cyBhbmQg YWxsIE4gY29udGV4dHMgbXVzdCBiZSBzdWJtaXR0ZWQgaW4gYSBzaW5nbGUgY29tbWFuZCB0byB0 aGUgR3VDLgo+ICtUaGUgR3VDIGludGVyZmFjZXMgZG8gbm90IHN1cHBvcnQgZHluYW1pY2FsbHkg Y2hhbmdpbmcgYmV0d2VlbiBOIGNvbnRleHRzIGFzIHRoZQo+ICtib25kaW5nIHVBUEkgZG9lcy4g SGVuY2UgdGhlIG5lZWQgZm9yIGEgbmV3IHBhcmFsbGVsIHN1Ym1pc3Npb24gaW50ZXJmYWNlLiBB bHNvCj4gK3RoZSBsZWdhY3kgYm9uZGluZyB1QVBJIGlzIHF1aXRlIGNvbmZ1c2luZyBhbmQgbm90 IGludHVpdGl2ZSBhdCBhbGwuCgpJdCdzIG5vdCB0aGF0IGNvbmZ1c2luZyByZWFsbHkuIElmIHdl IGhhZCBhZGRlZCBtdWx0aS1iYXRjaCBleGVjYnVmIGZyb20gCnRoZSBzdGFydCBubyBvbmUgd291 bGQgYmUgdGFsa2luZyBhYm91dCBib25kcyB0b2RheS4KCj4gKwo+ICtUaGUgbmV3IHBhcmFsbGVs IHN1Ym1pc3Npb24gdUFQSSBjb25zaXN0cyBvZiAzIHBhcnRzOgo+ICsKPiArKiBFeHBvcnQgZW5n aW5lcyBsb2dpY2FsIG1hcHBpbmcKPiArKiBBICdzZXRfcGFyYWxsZWwnIGV4dGVuc2lvbiB0byBj b25maWd1cmUgY29udGV4dHMgZm9yIHBhcmFsbGVsCj4gKyAgc3VibWlzc2lvbgo+ICsqIEV4dGVu ZCBleGVjYnVmMiBJT0NUTCB0byBzdXBwb3J0IHN1Ym1pdHRpbmcgTiBCQnMgaW4gYSBzaW5nbGUg SU9DVEwKPiArCj4gK0V4cG9ydCBlbmdpbmVzIGxvZ2ljYWwgbWFwcGluZwo+ICstLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0KPiArQ2VydGFpbiB1c2UgY2FzZXMgcmVxdWlyZSBCQnMgdG8g YmUgcGxhY2VkIG9uIGVuZ2luZSBpbnN0YW5jZXMgaW4gbG9naWNhbCBvcmRlcgo+ICsoZS5nLiBz cGxpdC1mcmFtZSBvbiBnZW4xMSspLiBUaGUgbG9naWNhbCBtYXBwaW5nIG9mIGVuZ2luZSBpbnN0 YW5jZXMgY2FuIGNoYW5nZQo+ICtiYXNlZCBvbiBmdXNpbmcuIFJhdGhlciB0aGFuIG1ha2luZyBV TURzIGJlIGF3YXJlIG9mIGZ1c2luZywgc2ltcGx5IGV4cG9zZSB0aGUKPiArbG9naWNhbCBtYXBw aW5nIHdpdGggdGhlIGV4aXN0aW5nIHF1ZXJ5IGVuZ2luZSBpbmZvIElPQ1RMLiBBbHNvIHRoZSBH dUMKPiArc3VibWlzc2lvbiBpbnRlcmZhY2UgY3VycmVudGx5IG9ubHkgc3VwcG9ydHMgc3VibWl0 dGluZyBtdWx0aXBsZSBjb250ZXh0cyB0bwo+ICtlbmdpbmVzIGluIGxvZ2ljYWwgb3JkZXIgd2hp Y2ggaXMgYSBuZXcgcmVxdWlyZW1lbnQgY29tcGFyZWQgdG8gZXhlY2xpc3RzLgo+ICtMYXN0bHks IGFsbCBjdXJyZW50IHBsYXRmb3JtcyBoYXZlIGF0IG1vc3QgMiBlbmdpbmUgaW5zdGFuY2VzIGFu ZCB0aGUgbG9naWNhbAo+ICtvcmRlciBpcyB0aGUgc2FtZSBhcyB1QVBJIG9yZGVyLiBUaGlzIHdp bGwgY2hhbmdlIG9uIHBsYXRmb3JtcyB3aXRoIG1vcmUgdGhhbiAyCj4gK2VuZ2luZSBpbnN0YW5j ZXMuCj4gKwo+ICtBIHNpbmdsZSBiaXQgd2lsbCBiZSBhZGRlZCB0byBkcm1faTkxNV9lbmdpbmVf aW5mby5mbGFncyBpbmRpY2F0aW5nIHRoYXQgdGhlCj4gK2xvZ2ljYWwgaW5zdGFuY2UgaGFzIGJl ZW4gcmV0dXJuZWQgYW5kIGEgbmV3IGZpZWxkLAo+ICtkcm1faTkxNV9lbmdpbmVfaW5mby5sb2dp Y2FsX2luc3RhbmNlLCByZXR1cm5zIHRoZSBsb2dpY2FsIGluc3RhbmNlLgo+ICsKPiArQSAnc2V0 X3BhcmFsbGVsJyBleHRlbnNpb24gdG8gY29uZmlndXJlIGNvbnRleHRzIGZvciBwYXJhbGxlbCBz dWJtaXNzaW9uCj4gKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQo+ICtUaGUgJ3NldF9wYXJhbGxlbCcgZXh0ZW5z aW9uIGNvbmZpZ3VyZXMgYSBzbG90IGZvciBwYXJhbGxlbCBzdWJtaXNzaW9uIG9mIE4gQkJzLgo+ ICtJdCBpcyBzZXR1cCBzdGVwIHRoYXQgc2hvdWxkIGJlIGNhbGxlZCBiZWZvcmUgdXNpbmcgYW55 IG9mIHRoZSBjb250ZXh0cy4gU2VlCgphIHNldHVwIHN0ZXAKCnMvYW55IG9mIHRoZSBjb250ZXh0 L3RoZSBjb250ZXh0LyA/Cgo+ICtJOTE1X0NPTlRFWFRfRU5HSU5FU19FWFRfTE9BRF9CQUxBTkNF IG9yIEk5MTVfQ09OVEVYVF9FTkdJTkVTX0VYVF9CT05EIGZvcgo+ICtzaW1pbGFyIGV4aXN0aW5n IGV4YW1wbGVzLiBPbmNlIGEgc2xvdCBpcyBjb25maWd1cmVkIGZvciBwYXJhbGxlbCBzdWJtaXNz aW9uIHRoZQo+ICtleGVjYnVmMiBJT0NUTCBjYW4gYmUgY2FsbGVkIHN1Ym1pdHRpbmcgTiBCQnMg aW4gYSBzaW5nbGUgSU9DVEwuIEluaXRpYWxseSBvbmx5Cj4gK3N1cHBvcnQgR3VDIHN1Ym1pc3Np b24uIEV4ZWNsaXN0IHN1cHBvcnQgY2FuIGJlIGFkZGVkIGxhdGVyIGlmIG5lZWRlZC4KCnN1cHBv cnRzCgpleGVjbGlzdHMKCj4gKwo+ICtBZGQgSTkxNV9DT05URVhUX0VOR0lORVNfRVhUX1BBUkFM TEVMX1NVQk1JVCBhbmQKPiAraTkxNV9jb250ZXh0X2VuZ2luZXNfcGFyYWxsZWxfc3VibWl0IHRv IHRoZSB1QVBJIHRvIGltcGxlbWVudCB0aGlzIGV4dGVuc2lvbi4KPiArCj4gK0V4dGVuZCBleGVj YnVmMiBJT0NUTCB0byBzdXBwb3J0IHN1Ym1pdHRpbmcgTiBCQnMgaW4gYSBzaW5nbGUgSU9DVEwK PiArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLQo+ICtDb250ZXh0cyB0aGF0IGhhdmUgYmVlbiBjb25maWd1cmVkIHdpdGgg dGhlICdzZXRfcGFyYWxsZWwnIGV4dGVuc2lvbiBhcmUgYWxsb3dlZAoKcy9hcmUgYWxsb3dlZC9j YW4gb25seS8KCj4gK3RvIHN1Ym1pdCBOIEJCcyBpbiBhIHNpbmdsZSBleGVjYnVmMiBJT0NUTC4g VGhlIEJCcyBhcmUgZWl0aGVyIHRoZSBsYXN0IE4KPiArb2JqZWN0cyBpbiB0aGUgZHJtX2k5MTVf Z2VtX2V4ZWNfb2JqZWN0MiBsaXN0IG9yIHRoZSBmaXJzdCBOIGlmCj4gK0k5MTVfRVhFQ19CQVRD SF9GSVJTVCBpcyBzZXQuIFRoZSBudW1iZXIgb2YgQkJzIGlzIGltcGxpY3QgYmFzZWQgb24gdGhl IHNsb3QKCmltcGxpY2l0Cgo+ICtzdWJtaXR0ZWQgYW5kIGhvdyBpdCBoYXMgYmVlbiBjb25maWd1 cmVkIGJ5ICdzZXRfcGFyYWxsZWwnIG9yIG90aGVyIGV4dGVuc2lvbnMuCj4gK05vIHVBUEkgY2hh bmdlcyBhcmUgcmVxdWlyZWQgdG8gZXhlY2J1ZjIgSU9DVEwuCj4gCgpSZWdhcmRzLAoKVHZydGtv Cl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCkludGVsLWdm eCBtYWlsaW5nIGxpc3QKSW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xp c3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2ludGVsLWdmeAo= 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=-14.3 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,HK_RANDOM_FROM,INCLUDES_CR_TRAILER, INCLUDES_PATCH,MAILING_LIST_MULTI,NICE_REPLY_A,SPF_HELO_NONE,SPF_PASS, URIBL_BLOCKED,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 CF6A4C47089 for ; Thu, 27 May 2021 15:01:26 +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 855D36128D for ; Thu, 27 May 2021 15:01:26 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 855D36128D Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linux.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 D0DD76F400; Thu, 27 May 2021 15:01:25 +0000 (UTC) Received: from mga07.intel.com (mga07.intel.com [134.134.136.100]) by gabe.freedesktop.org (Postfix) with ESMTPS id 83A966E7DD; Thu, 27 May 2021 15:01:24 +0000 (UTC) IronPort-SDR: QhwtIUGWJK6VH+SmWp8oQHQUaAiFQi1Z8J8KlKl7+K6gwJpKyEcQxEUKeoddH8w63XOStof59+ xpfDxS+3DiKQ== X-IronPort-AV: E=McAfee;i="6200,9189,9996"; a="266641664" X-IronPort-AV: E=Sophos;i="5.82,334,1613462400"; d="scan'208";a="266641664" Received: from fmsmga001.fm.intel.com ([10.253.24.23]) by orsmga105.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 27 May 2021 08:01:13 -0700 IronPort-SDR: VaMqt0T4ci2OaEAWwgOHGv9Wte7r1lt1cswe3MBKnddHYjQqCO8tVe69gXJfZGElFPsm9iB3Ma Gr/OKYKIgCDw== X-IronPort-AV: E=Sophos;i="5.82,334,1613462400"; d="scan'208";a="547941040" Received: from amoses-mobl1.ger.corp.intel.com (HELO [10.213.211.53]) ([10.213.211.53]) by fmsmga001-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 27 May 2021 08:01:10 -0700 Subject: Re: [Intel-gfx] [RFC PATCH 2/2] drm/doc/rfc: i915 new parallel submission uAPI plan To: Matthew Brost , intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org References: <20210526233357.9165-1-matthew.brost@intel.com> <20210526233357.9165-3-matthew.brost@intel.com> From: Tvrtko Ursulin Organization: Intel Corporation UK Plc Message-ID: <5d46472d-3dc2-0484-5a1f-4b36eecc11f6@linux.intel.com> Date: Thu, 27 May 2021 16:01:08 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101 Thunderbird/78.8.1 MIME-Version: 1.0 In-Reply-To: <20210526233357.9165-3-matthew.brost@intel.com> Content-Type: text/plain; charset=utf-8; format=flowed Content-Language: en-US Content-Transfer-Encoding: 8bit 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: jason.ekstrand@intel.com, mesa-dev@lists.freedesktop.org, christian.koenig@amd.com, daniel.vetter@intel.com, carl.zhang@intel.com Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" On 27/05/2021 00:33, 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: > + * > + * 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 "i.e. the user" I think. > + * doesn't tell the execbuf IOCTL there are N BBs, the execbuf IOCTL know how knows > + * many BBs there are based on the slots configuration. The N BBs are the last N "slot's" ? Or maybe better fully qualified as "engine map slot"? > + * 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. "are above", "can be found above" ? > + * > + * 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 */ > + __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 Context does not have an engine mask in the uapi so I'd explain this in terms of list of engines. > + * implied in this mode that all contexts have mutual exclusive placement. mutually > + * e.g. If one context is running CSX[0] no other contexts can run on CSX[0]). s/If/if, I think. I don't find CSX[0] readable nor I think introducing csx as a term is desirable. Lowercase cs (like cs0) is what I would prefer for both readability and likely cs = command streamer could be more obvious what it is. Naming like rcs0 (prefix-cs-number) and similar are exposed in kernel logs and error state while csx[] (cs-suffix-number) are not at all. In placement examples I would refrain from using any prefixes/suffixes to designate engine classes and just say cs0/cs1, mentioning the same/mixed class requirement separately in the notes if applicable. > + * > + * 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: One the too many. > + * 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. > + */ > + > +/* > + * I915_PARALLEL_IMPLICIT_BONDS - Create implicit bonds between each context. > + * Each context must have the same number of sibling and bonds are implicitly siblings > + * 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 Again, I wouldn't use the term logically contiguous here because logical instance numbering isn't used in class:instance addressing as used in engine maps. > + * 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) > +#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 engines[][] = { /* Channel 0 possible engines: */ { cs0, cs2 }, /* Channel 1 possible engines: */ { cs1, cs3 }, }; Would this be accurate and descriptive on top of the formula? Although I am not too happy with the term channel without first explaining how we are going to call parallel streams within a wide context. > + */ > + 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. It's not that confusing really. If we had added multi-batch execbuf from the start no one would be talking about bonds today. > + > +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 a setup step s/any of the context/the context/ ? > +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. supports execlists > + > +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 s/are allowed/can only/ > +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 implicit > +submitted and how it has been configured by 'set_parallel' or other extensions. > +No uAPI changes are required to execbuf2 IOCTL. > Regards, Tvrtko