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=-2.1 required=3.0 tests=DKIM_INVALID,DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS, USER_AGENT_SANE_1 autolearn=no 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 7381BC3F2CE for ; Mon, 16 Mar 2020 10:20:45 +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 43D8A20724 for ; Mon, 16 Mar 2020 10:20:45 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=ideasonboard.com header.i=@ideasonboard.com header.b="Vnl4jbf2" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 43D8A20724 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=ideasonboard.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 2EB6C6E3CB; Mon, 16 Mar 2020 10:20:43 +0000 (UTC) Received: from perceval.ideasonboard.com (perceval.ideasonboard.com [213.167.242.64]) by gabe.freedesktop.org (Postfix) with ESMTPS id ECDEC6E3CB for ; Mon, 16 Mar 2020 10:20:40 +0000 (UTC) Received: from pendragon.ideasonboard.com (81-175-216-236.bb.dnainternet.fi [81.175.216.236]) by perceval.ideasonboard.com (Postfix) with ESMTPSA id C442FA3B; Mon, 16 Mar 2020 11:20:38 +0100 (CET) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=ideasonboard.com; s=mail; t=1584354039; bh=tLX3goQbNsnImE5g/YMruPCGZHm6gq1Gzi1bCITnAoU=; h=Date:From:To:Cc:Subject:References:In-Reply-To:From; b=Vnl4jbf2JDY0mHWu42x2aIpmUtDLR7TSzfAU7iENacIY7RAQNhewPLlESJib9/86j R4gfvvupSqQ53g3TfeZTcRDRanIzrnrtcS/SGxmMy+CYJXWNbK2Rgr9qKPRmJpF1Ug q7pOARZskY+LxmGrcrnslRI+i5kKyAqkU0ipP1f4= Date: Mon, 16 Mar 2020 12:20:34 +0200 From: Laurent Pinchart To: Nicolas Dufresne Subject: Re: Plumbing explicit synchronization through the Linux ecosystem Message-ID: <20200316102034.GA30883@pendragon.ideasonboard.com> References: <33d1749d876a83416c44671efcb37c74f87d1bd4.camel@ndufresne.ca> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <33d1749d876a83416c44671efcb37c74f87d1bd4.camel@ndufresne.ca> User-Agent: Mutt/1.10.1 (2018-07-13) 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: Daniel Vetter , xorg-devel , Maling list - DRI developers , "wayland-devel @ lists . freedesktop . org" , Discussion of the development of and with GStreamer , Jason Ekstrand , ML mesa-dev , linux-media@vger.kernel.org Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" T24gV2VkLCBNYXIgMTEsIDIwMjAgYXQgMDQ6MTg6NTVQTSAtMDQwMCwgTmljb2xhcyBEdWZyZXNu ZSB3cm90ZToKPiAoSSBrbm93IEknbSBnb2luZyB0byBiZSBzcGFtbWVkIGJ5IHNvIG1hbnkgbWFp bGluZyBsaXN0IC4uLikKPiAKPiBMZSBtZXJjcmVkaSAxMSBtYXJzIDIwMjAgw6AgMTQ6MjEgLTA1 MDAsIEphc29uIEVrc3RyYW5kIGEgw6ljcml0IDoKPiA+IE9uIFdlZCwgTWFyIDExLCAyMDIwIGF0 IDEyOjMxIFBNIEphc29uIEVrc3RyYW5kIDxqYXNvbkBqbGVrc3RyYW5kLm5ldD4gd3JvdGU6Cj4g PiA+IEFsbCwKPiA+ID4gCj4gPiA+IFNvcnJ5IGZvciBjYXN0aW5nIHN1Y2ggYSBicm9hZCBuZXQg d2l0aCB0aGlzIG9uZS4gSSdtIHN1cmUgbW9zdCBwZW9wbGUKPiA+ID4gd2hvIHJlcGx5IHdpbGwg Z2V0IGF0IGxlYXN0IG9uZSBtYWlsaW5nIGxpc3QgcmVqZWN0aW9uLiAgSG93ZXZlciwgdGhpcwo+ ID4gPiBpcyBhbiBpc3N1ZSB0aGF0IGFmZmVjdHMgYSBMT1Qgb2YgY29tcG9uZW50cyBhbmQgdGhh dCdzIHdoeSBpdCdzCj4gPiA+IHRob3JueSB0byBiZWdpbiB3aXRoLiAgUGxlYXNlIHBhcmRvbiB0 aGUgbGVuZ3RoIG9mIHRoaXMgZS1tYWlsIGFzCj4gPiA+IHdlbGw7IEkgcHJvbWlzZSB0aGVyZSdz IGEgY29uY3JldGUgcG9pbnQvcHJvcG9zYWwgYXQgdGhlIGVuZC4KPiA+ID4gCj4gPiA+IAo+ID4g PiBFeHBsaWNpdCBzeW5jaHJvbml6YXRpb24gaXMgdGhlIGZ1dHVyZSBvZiBncmFwaGljcyBhbmQg bWVkaWEuICBBdAo+ID4gPiBsZWFzdCwgdGhhdCBzZWVtcyB0byBiZSB0aGUgY29uc2Vuc3VzIGFt b25nIGFsbCB0aGUgZ3JhcGhpY3MgcGVvcGxlCj4gPiA+IEkndmUgdGFsa2VkIHRvLiAgSSBoYWQg YSBjaGF0IHdpdGggb25lIG9mIHRoZSBsZWFkIEFuZHJvaWQgZ3JhcGhpY3MKPiA+ID4gZW5naW5l ZXJzIHJlY2VudGx5IHdobyB0b2xkIG1lIHRoYXQgZG9pbmcgZXhwbGljaXQgc3luYyBmcm9tIHRo ZSBzdGFydAo+ID4gPiB3YXMgb25lIG9mIHRoZSBiZXN0IGVuZ2luZWVyaW5nIGRlY2lzaW9ucyBB bmRyb2lkIGV2ZXIgbWFkZS4gIEl0J3MKPiA+ID4gYWxzbyB0aGUgZGlyZWN0aW9uIGJlaW5nIHRh a2VuIGJ5IG1vcmUgbW9kZXJuIEFQSXMgc3VjaCBhcyBWdWxrYW4uCj4gPiA+IAo+ID4gPiAKPiA+ ID4gIyMgV2hhdCBhcmUgaW1wbGljaXQgYW5kIGV4cGxpY2l0IHN5bmNocm9uaXphdGlvbj8KPiA+ ID4gCj4gPiA+IEZvciB0aG9zZSB0aGF0IGFyZW4ndCBmYW1pbGlhciB3aXRoIHRoaXMgc3BhY2Us IEdQVXMsIG1lZGlhIGVuY29kZXJzLAo+ID4gPiBldGMuIGFyZSBtYXNzaXZlbHkgcGFyYWxsZWwg YW5kIHN5bmNocm9uaXphdGlvbiBvZiBzb21lIGZvcm0gaXMKPiA+ID4gcmVxdWlyZWQgdG8gZW5z dXJlIHRoYXQgZXZlcnl0aGluZyBoYXBwZW5zIGluIHRoZSByaWdodCBvcmRlciBhbmQKPiA+ID4g YXZvaWQgZGF0YSByYWNlcy4gIEltcGxpY2l0IHN5bmNocm9uaXphdGlvbiBpcyB3aGVuIGJpdHMg b2Ygd29yayAoM0QsCj4gPiA+IGNvbXB1dGUsIHZpZGVvIGVuY29kZSwgZXRjLikgYXJlIGltcGxp Y2l0bHkgYmFzZWQgb24gdGhlIGFic29sdXRlCj4gPiA+IENQVS10aW1lIG9yZGVyIGluIHdoaWNo IEFQSSBjYWxscyBvY2N1ci4gIEV4cGxpY2l0IHN5bmNocm9uaXphdGlvbiBpcwo+ID4gPiB3aGVu IHRoZSBjbGllbnQgKHdoYXRldmVyIHRoYXQgbWVhbnMgaW4gYW55IGdpdmVuIGNvbnRleHQpIHBy b3ZpZGVzCj4gPiA+IHRoZSBkZXBlbmRlbmN5IGdyYXBoIGV4cGxpY2l0bHkgdmlhIHNvbWUgc29y dCBvZiBzeW5jaHJvbml6YXRpb24KPiA+ID4gcHJpbWl0aXZlcy4gIElmIHlvdSdyZSBzdGlsbCBj b25mdXNlZCwgY29uc2lkZXIgdGhlIGZvbGxvd2luZwo+ID4gPiBleGFtcGxlczoKPiA+ID4gCj4g PiA+IFdpdGggT3BlbkdMIGFuZCBFR0wsIGFsbW9zdCBldmVyeXRoaW5nIGlzIGltcGxpY2l0IHN5 bmMuICBTYXkgeW91IGhhdmUKPiA+ID4gdHdvIE9wZW5HTCBjb250ZXh0cyBzaGFyaW5nIGFuIGlt YWdlIHdoZXJlIG9uZSB3cml0ZXMgdG8gaXQgYW5kIHRoZQo+ID4gPiBvdGhlciB0ZXh0dXJlcyBm cm9tIGl0LiAgVGhlIHdheSB0aGUgT3BlbkdMIHNwZWMgd29ya3MsIHRoZSBjbGllbnQgaGFzCj4g PiA+IHRvIG1ha2UgdGhlIEFQSSBjYWxscyB0byByZW5kZXIgdG8gdGhlIGltYWdlIGJlZm9yZSAo aW4gQ1BVIHRpbWUpIGl0Cj4gPiA+IG1ha2VzIHRoZSBBUEkgY2FsbHMgd2hpY2ggdGV4dHVyZSBm cm9tIHRoZSBpbWFnZS4gIEFzIGxvbmcgYXMgaXQgZG9lcwo+ID4gPiB0aGlzIChhbmQgbWF5YmUg aW5zZXJ0cyBhIGdsRmx1c2g/KSwgdGhlIGRyaXZlciB3aWxsIGVuc3VyZSB0aGF0IHRoZQo+ID4g PiByZW5kZXJpbmcgY29tcGxldGVzIGJlZm9yZSB0aGUgdGV4dHVyaW5nIGhhcHBlbnMgYW5kIHlv dSBnZXQgY29ycmVjdAo+ID4gPiBjb250ZW50cy4KPiA+ID4gCj4gPiA+IEltcGxpY2l0IHN5bmNo cm9uaXphdGlvbiBjYW4gYWxzbyBoYXBwZW4gYWNyb3NzIHByb2Nlc3Nlcy4gIFdheWxhbmQsCj4g PiA+IGZvciBpbnN0YW5jZSwgaXMgY3VycmVudGx5IGJ1aWx0IG9uIGltcGxpY2l0IHN5bmMgd2hl cmUgdGhlIGNsaWVudAo+ID4gPiBkb2VzIHRoZWlyIHJlbmRlcmluZyBhbmQgdGhlbiBkb2VzIGEg aGFuZC1vZmYgKHZpYSB3bF9zdXJmYWNlOjpjb21taXQpCj4gPiA+IHRvIHRlbGwgdGhlIGNvbXBv c2l0b3IgaXQncyBkb25lIGF0IHdoaWNoIHBvaW50IHRoZSBjb21wb3NpdG9yIGNhbiBub3cKPiA+ ID4gdGV4dHVyZSBmcm9tIHRoZSBzdXJmYWNlLiAgVGhlIGhhbmQtb2ZmIGVuc3VyZXMgdGhhdCB0 aGUgY2xpZW50J3MKPiA+ID4gT3BlbkdMIEFQSSBjYWxscyBoYXBwZW4gYmVmb3JlIHRoZSBzZXJ2 ZXIncyBPcGVuR0wgQVBJIGNhbGxzLgo+ID4gPiAKPiA+ID4gQSBnb29kIGV4YW1wbGUgb2YgZXhw bGljaXQgc3luY2hyb25pemF0aW9uIGlzIHRoZSBWdWxrYW4gQVBJLiAgVGhlcmUsCj4gPiA+IGEg Y2xpZW50IChvciBtdWx0aXBsZSBjbGllbnRzKSBjYW4gc2ltdWx0YW5lb3VzbHkgYnVpbGQgY29t bWFuZAo+ID4gPiBidWZmZXJzIGluIGRpZmZlcmVudCB0aHJlYWRzIHdoZXJlIG9uZSBvZiB0aG9z ZSBjb21tYW5kIGJ1ZmZlcnMKPiA+ID4gcmVuZGVycyB0byBhbiBpbWFnZSBhbmQgdGhlIG90aGVy IHRleHR1cmVzIGZyb20gaXQgYW5kIHRoZW4gc3VibWl0Cj4gPiA+IGJvdGggb2YgdGhlbSBhdCB0 aGUgc2FtZSB0aW1lIHdpdGggaW5zdHJ1Y3Rpb25zIHRvIHRoZSBkcml2ZXIgZm9yCj4gPiA+IHdo aWNoIG9yZGVyIHRvIGV4ZWN1dGUgdGhlbSBpbi4gIFRoZSBleGVjdXRpb24gb3JkZXIgaXMgZGVz Y3JpYmVkIHZpYQo+ID4gPiB0aGUgVmtTZW1hcGhvcmUgcHJpbWl0aXZlLiAgV2l0aCB0aGUgbmV3 IFZLX0tIUl90aW1lbGluZV9zZW1hcGhvcmUKPiA+ID4gZXh0ZW5zaW9uLCB5b3UgY2FuIGV2ZW4g c3VibWl0IHRoZSB3b3JrIHdoaWNoIGRvZXMgdGhlIHRleHR1cmluZwo+ID4gPiBCRUZPUkUgdGhl IHdvcmsgd2hpY2ggZG9lcyB0aGUgcmVuZGVyaW5nIGFuZCB0aGUgZHJpdmVyIHdpbGwgc29ydCBp dAo+ID4gPiBvdXQuCj4gPiA+IAo+ID4gPiBUaGUgIzEgcHJvYmxlbSB3aXRoIGltcGxpY2l0IHN5 bmNocm9uaXphdGlvbiAod2hpY2ggZXhwbGljaXQgc29sdmVzKQo+ID4gPiBpcyB0aGF0IGl0IGxl YWRzIHRvIGEgbG90IG9mIG92ZXItc3luY2hyb25pemF0aW9uIGJvdGggaW4gY2xpZW50IHNwYWNl Cj4gPiA+IGFuZCBpbiBkcml2ZXIvZGV2aWNlIHNwYWNlLiAgVGhlIGNsaWVudCBoYXMgdG8gc3lu Y2hyb25pemUgYSBsb3QgbW9yZQo+ID4gPiBiZWNhdXNlIGl0IGhhcyB0byBlbnN1cmUgdGhhdCB0 aGUgQVBJIGNhbGxzIGhhcHBlbiBpbiBhIHBhcnRpY3VsYXIKPiA+ID4gb3JkZXIuICBUaGUgZHJp dmVyL2RldmljZSBoYXZlIHRvIHN5bmNocm9uaXplIGEgbG90IG1vcmUgYmVjYXVzZSB0aGV5Cj4g PiA+IG5ldmVyIGtub3cgd2hhdCBpcyBnb2luZyB0byBlbmQgdXAgYmVpbmcgYSBzeW5jaHJvbml6 YXRpb24gcG9pbnQgYXMgYW4KPiA+ID4gQVBJIGNhbGwgb24gYW5vdGhlciB0aHJlYWQvcHJvY2Vz cyBtYXkgb2NjdXIgYXQgYW55IHRpbWUuICBBcyB3ZSBtb3ZlCj4gPiA+IHRvIG1vcmUgYW5kIG1v cmUgbXVsdGktdGhyZWFkZWQgcHJvZ3JhbW1pbmcgdGhpcyBzeW5jaHJvbml6YXRpb24gKG9uCj4g PiA+IHRoZSBjbGllbnQtc2lkZSBlc3BlY2lhbGx5KSBiZWNvbWVzIG1vcmUgYW5kIG1vcmUgcGFp bmZ1bC4KPiA+ID4gCj4gPiA+IAo+ID4gPiAjIyBDdXJyZW50IHN0YXR1cyBpbiBMaW51eAo+ID4g PiAKPiA+ID4gSW1wbGljaXQgc3luY2hyb25pemF0aW9uIGluIExpbnV4IHdvcmtzIHZpYSBhIHRo ZSBrZXJuZWwncyBpbnRlcm5hbAo+ID4gPiBkbWFfYnVmIGFuZCBkbWFfZmVuY2UgZGF0YSBzdHJ1 Y3R1cmVzLiAgQSBkbWFfZmVuY2UgaXMgYSB0aW55IG9iamVjdAo+ID4gPiB3aGljaCByZXByZXNl bnRzIHRoZSAiZG9uZSIgc3RhdHVzIGZvciBzb21lIGJpdCBvZiB3b3JrLiAgVHlwaWNhbGx5LAo+ ID4gPiBkbWFfZmVuY2VzIGFyZSBjcmVhdGVkIGFzIGEgYnktcHJvZHVjdCBvZiBzb21lb25lIHN1 Ym1pdHRpbmcgc29tZSBiaXQKPiA+ID4gb2Ygd29yayAoc2F5LCAzRCByZW5kZXJpbmcpIHRvIHRo ZSBrZXJuZWwuICBUaGUgZG1hX2J1ZiBvYmplY3QgaGFzIGEKPiA+ID4gc2V0IG9mIGRtYV9mZW5j ZXMgb24gaXQgcmVwcmVzZW50aW5nIHNoYXJlZCAocmVhZCkgYW5kIGV4Y2x1c2l2ZQo+ID4gPiAo d3JpdGUpIGFjY2VzcyB0byB0aGUgb2JqZWN0LiAgV2hlbiB3b3JrIGlzIHN1Ym1pdHRlZCB3aGlj aCwgZm9yCj4gPiA+IGluc3RhbmNlIHJlbmRlcnMgdG8gdGhlIGRtYV9idWYsIGl0J3MgcXVldWVk IHdhaXRpbmcgb24gYWxsIHRoZSBmZW5jZXMKPiA+ID4gb24gdGhlIGRtYV9idWYgYW5kIGFuZCBh IGRtYV9mZW5jZSBpcyBjcmVhdGVkIHJlcHJlc2VudGluZyB0aGUgZW5kIG9mCj4gPiA+IHNhaWQg cmVuZGVyaW5nIHdvcmsgYW5kIGl0J3MgaW5zdGFsbGVkIGFzIHRoZSBkbWFfYnVmJ3MgZXhjbHVz aXZlCj4gPiA+IGZlbmNlLiAgVGhpcyB3YXksIHRoZSBrZXJuZWwgY2FuIG1hbmFnZSBhbGwgaXRz IGludGVybmFsIHF1ZXVlcyAoM0QKPiA+ID4gcmVuZGVyaW5nLCBkaXNwbGF5LCB2aWRlbyBlbmNv ZGUsIGV0Yy4pIGFuZCBrbm93IHdoaWNoIHRoaW5ncyB0bwo+ID4gPiBzdWJtaXQgaW4gd2hhdCBv cmRlci4KPiA+ID4gCj4gPiA+IEZvciB0aGUgbGFzdCBmZXcgeWVhcnMsIHdlJ3ZlIGhhZCBzeW5j X2ZpbGUgaW4gdGhlIGtlcm5lbCBhbmQgaXQncwo+ID4gPiBwbHVtYmVkIGludG8gc29tZSBkcml2 ZXJzLiAgQSBzeW5jX2ZpbGUgaXMganVzdCBhIHdyYXBwZXIgYXJvdW5kIGEKPiA+ID4gc2luZ2xl IGRtYV9mZW5jZS4gIEEgc3luY19maWxlIGlzIHR5cGljYWxseSBjcmVhdGVkIGFzIGEgYnktcHJv ZHVjdCBvZgo+ID4gPiBzdWJtaXR0aW5nIHdvcmsgKDNELCBjb21wdXRlLCBldGMuKSB0byB0aGUg a2VybmVsIGFuZCBpcyBzaWduYWxlZCB3aGVuCj4gPiA+IHRoYXQgd29yayBjb21wbGV0ZXMuICBX aGVuIGEgc3luY19maWxlIGlzIGNyZWF0ZWQsIGl0IGlzIGd1YXJhbnRlZWQgYnkKPiA+ID4gdGhl IGtlcm5lbCB0aGF0IGl0IHdpbGwgYmVjb21lIHNpZ25hbGVkIGluIGZpbml0ZSB0aW1lIGFuZCwg b25jZSBpdCdzCj4gPiA+IHNpZ25hbGVkLCBpdCByZW1haW5zIHNpZ25hbGVkIGZvciB0aGUgcmVz dCBvZiB0aW1lLiAgQSBzeW5jX2ZpbGUgaXMKPiA+ID4gcmVwcmVzZW50ZWQgaW4gVUFQSXMgYXMg YSBmaWxlIGRlc2NyaXB0b3IgYW5kIGNhbiBiZSB1c2VkIHdpdGggbm9ybWFsCj4gPiA+IGZpbGUg QVBJcyBzdWNoIGFzIGR1cCgpLiAgSXQgY2FuIGJlIHBhc3NlZCBpbnRvIGFub3RoZXIgVUFQSSB3 aGljaAo+ID4gPiBkb2VzIHNvbWUgYml0IG9mIHF1ZXVlJ2Qgd29yayBhbmQgdGhlIHN1Ym1pdHRl ZCB3b3JrIHdpbGwgd2FpdCBmb3IgdGhlCj4gPiA+IHN5bmNfZmlsZSB0byBiZSB0cmlnZ2VyZWQg YmVmb3JlIGV4ZWN1dGluZy4gIEEgc3luY19maWxlIGFsc28gc3VwcG9ydHMKPiA+ID4gcG9sbCgp IGlmICB5b3Ugd2FudCB0byB3YWl0IG9uIGl0IG1hbnVhbGx5Lgo+ID4gPiAKPiA+ID4gVW5mb3J0 dW5hdGVseSwgc3luY19maWxlIGlzIG5vdCBicm9hZGx5IHVzZWQgYW5kIG5vdCBhbGwga2VybmVs IEdQVQo+ID4gPiBkcml2ZXJzIHN1cHBvcnQgaXQuICBIZXJlJ3MgYSB2ZXJ5IHF1aWNrIG92ZXJ2 aWV3IG9mIG15IHVuZGVyc3RhbmRpbmcKPiA+ID4gb2YgdGhlIHN0YXR1cyBvZiB2YXJpb3VzIGNv bXBvbmVudHMgKEkgZG9uJ3Qga25vdyB0aGUgc3RhdHVzIG9mCj4gPiA+IGFueXRoaW5nIGluIHRo ZSBtZWRpYSB3b3JsZCk6Cj4gPiA+IAo+ID4gPiAgLSBWdWxrYW46IEV4cGxpY2l0IHN5bmNocm9u aXphdGlvbiBhbGwgdGhlIHdheSBidXQgd2UgaGF2ZSB0byBnbwo+ID4gPiBpbXBsaWNpdCBhcyBz b29uIGFzIHdlIGludGVyYWN0IHdpdGggYSB3aW5kb3ctc3lzdGVtLiAgVnVsa2FuIGhhcyBBUElz Cj4gPiA+IHRvIGltcG9ydC9leHBvcnQgc3luY19maWxlcyB0by9mcm9tIGl0J3MgVmtTZW1hcGhv cmUgYW5kIFZrRmVuY2UKPiA+ID4gc3luY2hyb25pemF0aW9uIHByaW1pdGl2ZXMuCj4gPiA+ICAt IE9wZW5HTDogSW1wbGljaXQgYWxsIHRoZSB3YXkuICBUaGVyZSBhcmUgc29tZSBFR0wgZXh0ZW5z aW9ucyB0bwo+ID4gPiBlbmFibGUgc29tZSBmb3JtcyBvZiBleHBsaWNpdCBzeW5jIHZpYSBzeW5j X2ZpbGUgYnV0IE9wZW5HTCBpdHNlbGYgaXMKPiA+ID4gc3RpbGwgaW1wbGljaXQuCj4gPiA+ICAt IFdheWxhbmQ6IEN1cnJlbnRseSBkZXBlbmRzIG9uIGltcGxpY2l0IHN5bmMgaW4gdGhlIGtlcm5l bCAoYWNjZXNzZWQKPiA+ID4gdmlhIEVHTC9PcGVuR0wpLiAgVGhlcmUgaXMgYW4gdW5zdGFibGUg ZXh0ZW5zaW9uIHRvIGFsbG93IHBhc3NpbmcKPiA+ID4gc3luY19maWxlcyBhcm91bmQgYnV0IGl0 J3MgcXVlc3Rpb25hYmxlIGhvdyB1c2VmdWwgaXQgaXMgcmlnaHQgbm93Cj4gPiA+IChtb3JlIG9u IHRoYXQgbGF0ZXIpLgo+ID4gPiAgLSBYMTE6IFdpdGggcHJlc2VudCwgaXQgaGFzIHRoZXNlICJl eHBsaWNpdCIgZmVuY2Ugb2JqZWN0cyBidXQKPiA+ID4gdGhleSdyZSBhbHdheXMgYSBzaG1mZW5j ZSB3aGljaCBsZXRzIHRoZSBYIHNlcnZlciBhbmQgY2xpZW50IGRvIGEKPiA+ID4gdXNlcnNwYWNl IENQVS1zaWRlIGhhbmQtb2ZmIHdpdGhvdXQgZ29pbmcgb3ZlciB0aGUgc29ja2V0IChhbmQKPiA+ ID4gcm91bmQtdHJpcHBpbmcgdGhyb3VnaCB0aGUga2VybmVsKS4gIEhvd2V2ZXIsIHRoZSBvbmx5 IHRoaW5nIHRoYXQKPiA+ID4gZmVuY2UgZG9lcyBpcyBvcmRlciB0aGUgT3BlbkdMIEFQSSBjYWxs cyBpbiB0aGUgY2xpZW50IGFuZCBzZXJ2ZXIgYW5kCj4gPiA+IHRoZSByZWFsIHN5bmNocm9uaXph dGlvbiBpcyBzdGlsbCBpbXBsaWNpdC4KPiA+ID4gIC0gbGludXgvaTkxNS9nZW06IEZ1bGx5IHN1 cHBvcnRzIHVzaW5nIHN5bmNfZmlsZSBvciBzeW5jb2JqIGZvciBleHBsaWNpdAo+ID4gPiBzeW5j Lgo+ID4gPiAgLSBsaW51eC9hbWRncHU6IFN1cHBvcnRzIHN5bmNfZmlsZSBhbmQgc3luY29iaiBi dXQgaXQgc3RpbGwKPiA+ID4gaW1wbGljaXRseSBzeW5jcyBzb21ldGltZXMgZHVlIHRvIGl0J3Mg aW50ZXJuYWwgbWVtb3J5IHJlc2lkZW5jeQo+ID4gPiBoYW5kbGluZyB3aGljaCBjYW4gbGVhZCB0 byBvdmVyLXN5bmNocm9uaXphdGlvbi4KPiA+ID4gIC0gS01TOiBJbXBsaWNpdCBzeW5jIGFsbCB0 aGUgd2F5LiAgVGhlcmUgYXJlIG5vIEtNUyBBUElzIHdoaWNoIHRha2UKPiA+ID4gZXhwbGljaXQg c3luYyBwcmltaXRpdmVzLgo+ID4gCj4gPiBDb3JyZWN0aW9uOiAgQXBwYXJlbnRseSwgSSBtaXNz ZWQgc29tZSB0aGluZ3MuICBJZiB5b3UgdXNlIGF0b21pYywgS01TCj4gPiBkb2VzIGhhdmUgZXhw bGljaXQgaW4tIGFuZCBvdXQtZmVuY2VzLiAgTm9uLWF0b21pYyB1c2VycyAoZS5nLiBYMTEpCj4g PiBhcmUgc3RpbGwgaW4gdHJvdWJsZSBidXQgbW9zdCBXYXlsYW5kIGNvbXBvc2l0b3JzIHVzZSBh dG9taWMgdGhlc2UKPiA+IGRheXMKPiA+IAo+ID4gPiAgLSB2NGw6ID8/Pwo+ID4gPiAgLSBnc3Ry ZWFtZXI6ID8/Pwo+ID4gPiAgLSBNZWRpYSBBUElzIHN1Y2ggYXMgdmFhcGkgZXRjLjogID8/Pwo+ IAo+IEdTdHJlYW1lciBpcyBjb25zdW1lciBmb3IgVjRMMiwgVkFBUEkgYW5kIG90aGVyIHN0dWZm LiBVc2luZyBhc3luY2hyb25vdXMgYnVmZmVyCj4gc3luY2hyb25pc2F0aW9uIGlzIHNvbWV0aGlu ZyB3ZSBkbyBhbHJlYWR5IHdpdGggR0wgKGV2ZW4gaWYgbGltaXRlZCkuIFdlIHBsYWNlCj4gR0xT eW5jIG9iamVjdCBpbiB0aGUgcGlwZWxpbmUgYW5kIGF0dGFjaCB0aGF0IG9uIHJlbGF0ZWQgR3N0 QnVmZmVyLiBXZSB3YWl0IG9uCj4gdGhlc2UgR0xTeW5jIGFzIGxhdGUgYXMgcG9zc2libGUgKG9y IHN1cGVyc2VlZCB0aGUgc3luYyBpZiB3ZSBxdWV1ZSBtb3JlIHdvcmsKPiBpbnRvIHRoZSBzYW1l IEdMIGNvbnRleHQpLiBUaGF0IHJlcXVpcmVzIGEgc3BlY2lhbCBtb2RlIG9mIG9wZXJhdGlvbiBv ZiBjb3Vyc2UuCj4gV2UgZG9uJ3QgdXN1YWxseSBsaWtlIG1ha2luZyBsYXp5IGJsb2NraW5nIGNh bGwgaW1wbGljaXQsIGFzIGl0IHRlbmRzIHRvIGNhdXNlCj4gcmFuZG9tIGlzc3Vlcy4gSWYgd2Ug bmVlZCB0byB3YWl0LCB3ZSB0aGluayBpdCdzIGJldHRlciB0byB3YWl0IGludCBoZSBtb2R1bGUK PiB0aGF0IGlzIHJlc3BvbnNpYmxlLCBzbyBpbiBnZW5lcmFsLCB3ZSB0cnkgdG8gbmVnb3RpYXRl IGFuZCBmYWxsYmFjayBsb2NhbGx5Cj4gKGl0J3MgcGx1Z2luIGJhc2UsIHNvIHRoaXMgY2FuIGJl IHJlYWxseSBtZXNzeSBvdGhlcndpc2UpLgo+IAo+IFNvIGJhc2ljYWxseSB0aGlzIHByb2JsZW0g bmVlZHMgdG8gYmUgc29sdmVkIGluIFY0TDIsIFZBQVBJIGFuZCBvdGhlciBsb3dlcgo+IGxldmVs IEFQSXMgZmlyc3QuIFdlIG5lZWQgQVBJIHRoYXQgcHJvdmlkZXMgdXMgdGhlc2UgZmVuY2UgKGlu IG9yIG91dCksIGFuZCB0aGVuCj4gd2UgY2FuIGNvbnNpZGVyIHVzaW5nIHRoZW0uIEZvciBWNEwy LCB0aGVyZSB3YXMgYW4gYXR0ZW1wdCwgYnV0IGl0IHdhcyBhIGJpdCBvZgo+IGEgbWlzcy1maXQu IFlvdXIgcHJvcG9zYWwgY291bGQgd29yaywgbmVlZCB0byBiZSB0ZXN0ZWQgSSBndWVzcywgYnV0 IGl0IGRvZXMgbm90Cj4gc29sdmUgc29tZSBvZiBvdGhlciBpc3N1ZXMgdGhhdCB3YXMgZGlzY3Vz c2VkLiBOb3RhYmx5IGZvciBjYW1lcmEgY2FwdHVyZSwgd2VyZQo+IHRoZSBIVyB0aW1lc3RhbXAg aXMgY2FwdHVyZSBhYm91dCBhdCB0aGUgc2FtZSB0aW1lIHRoZSBmcmFtZSBpcyByZWFkeS4gQnV0 IHRoZQo+IHRpbWVzdGFtcCBpcyBub3QgcGFydCBvZiB0aGUgcGF5bGFvZCwgc28geW91IG5lZWQg YW4gZW50aXJlIEFQSSBhc3luY2hyb25vdXNseQo+IGRlbGl2ZXIgdGhhdCBtZXRhZGF0YS4gSXQn cyB0aGUgYmlnZ2VzdCBwYWluIHBvaW50IEkndmUgZm91bmQsIHN1Y2ggYW4gQVBJIHdvdWxkCj4g YmUgcXVpdGUgaW52YXNpdmUgb3IgaWYgbWFkZSByZWFsbHkgZ2VuZXJpYywgbWlnaHQganVzdCBu ZXZlciBiZSBhZG9wdGVkIHdpZGVseQo+IGVub3VnaC4KCkFub3RoZXIgaXNzdWUgaXMgdGhhdCBW NEwyIGRvZXNuJ3Qgb2ZmZXIgYW55IGd1YXJhbnRlZSBvbiBqb2Igb3JkZXJpbmcuCldoZW4geW91 IHF1ZXVlIG11bHRpcGxlIGJ1ZmZlcnMgZm9yIGNhbWVyYSBjYXB0dXJlIGZvciBpbnN0YW5jZSwg eW91CmRvbid0IGtub3cgdW50aWwgY2FwdHVyZSBjb21wbGV0ZSBpbiB3aGljaCBidWZmZXIgdGhl IGZyYW1lIGhhcyBiZWVuCmNhcHR1cmVkLiBJbiB0aGUgbm9ybWFsIGNhc2UgYnVmZmVycyBhcmUg cHJvY2Vzc2VkIGluIHNlcXVlbmNlLCBidXQgaWYKYW4gZXJyb3Igb2NjdXJzIGR1cmluZyBjYXB0 dXJlLCB0aGV5IGNhbiBiZSByZWN5Y2xlZCBpbnRlcm5hbGx5IGFuZCBwdXQKdG8gdGhlIGJhY2sg b2YgdGhlIHF1ZXVlLiBVbmxlc3MgSSdtIG1pc3Rha2VuLCB0aGlzIHByb2JsZW0gYWxzbyBleGlz dHMKd2l0aCBzdGF0ZWZ1bCBjb2RlY3MuIEFuZCBpZiB5b3UgZG9uJ3Qga25vdyBpbiBhZHZhbmNl IHdoaWNoIGJ1ZmZlciB5b3UKd2lsbCByZWNlaXZlIGZyb20gdGhlIGRldmljZSwgdGhlIHVzZWZ1 bG5lc3Mgb2YgZmVuY2VzIGJlY29tZXMgdmVyeQpxdWVzdGlvbmFibGUgOi0pCgo+IFRoZXJlIGlz IG90aGVyIGVsZW1lbnRzIHRoYXQgd291bGQgaW1wbGVtZW50IGZlbmNpbmcsIG5vdGFibHkga21z c2luaywgYnV0IG5vCj4gb25lIGFjdHVhbGx5IGRhcmVkIHBvcnRpbmcgaXQgdG8gYXRvbWljIEtN Uywgc28gY2xlYXJseSB0aGVyZSBpcyB2ZXJ5IGxpdHRsZQo+IGNvbXVuaXR5IGludGVyZXN0LiBn bGltYWdzaW5rIGNvdWxkIGNsZWFybHkgYmVuaWZpdC4gUmlnaHQgbm93IGlmIHdlIGltcG9ydCBh Cj4gRE1BQnVmLCBhbmQgdGhhdCB0aGlzIERNQWJ1ZiBpcyB1c2VkIGZvciByZW5kZXIsIGEgaW1w bGljaXQgZmVuY2UgaXMgYXR0YWNoZWQsCj4gd2hpY2ggd2UgYXJlIHVuYXdhcmUuIFBoaWxpcHBl IFphYmJlbCBpcyB3b3JraW5nIG9uIGEgcGF0Y2gsIHNvIFY0TDIgUUJVRiB3b3VsZAo+IHdhaXQs IGJ1dCB3YWl0aW5nIGluIFFCVUYgaXMgbm90IGFsbG93ZWQgaWYgT19OT05CTE9DSyB3YXMgc2V0 ICh3aGljaCBHU3RyZWFtZXIKPiB1c2VzKSwgc28gdGhlbiB0aGUgb3BlcmF0aW9uIHdpbGwganVz dCBmYWlsIHdoZXJlIGl0IHdvcmtlZCBiZWZvcmUgKGJyZWFraW5nCj4gdXNlcnNwYWNlKS4gSWYg aXQgd2FzIGFuIGV4cGxjaXQgZmVuY2UsIHdlIGNvdWxkIGhhbmRsZSB0aGF0IGluIEdTdHJlYW1l cgo+IGNsZWFubHkgYXMgd2UgZG8gZm9yIG5ldyBBUElzLgo+IAo+ID4gPiAjIyBDaGlja2VuIGFu ZCBlZ2cgcHJvYmxlbXMKPiA+ID4gCj4gPiA+IE9rLCB0aGlzIGlzIHdoZXJlIGl0IHN0YXJ0cyBn ZXR0aW5nIGRlcHJlc3NpbmcuICBJIG1hZGUgdGhlIGNsYWltCj4gPiA+IGFib3ZlIHRoYXQgV2F5 bGFuZCBoYXMgYW4gZXhwbGljaXQgc3luY2hyb25pemF0aW9uIHByb3RvY29sIHRoYXQncyBvZgo+ ID4gPiBxdWVzdGlvbmFibGUgdXNlZnVsbmVzcy4gIEkgd291bGQgY2xhaW0gdGhhdCBiYXNpY2Fs bHkgYW55IGJpdCBvZgo+ID4gPiBwbHVtYmluZyB3ZSBkbyB0aHJvdWdoIHdpbmRvdyBzeXN0ZW1z IGlzIGN1cnJlbnRseSBvZiBxdWVzdGlvbmFibGUKPiA+ID4gdXNlZnVsbmVzcy4gIFdoeT8KPiA+ ID4gCj4gPiA+IEZyb20gbXkgcGVyc3BlY3RpdmUsIGFzIGEgVnVsa2FuIGRyaXZlciBkZXZlbG9w ZXIsIEkgaGF2ZSB0byBkZWFsIHdpdGgKPiA+ID4gdGhlIGZhY3QgdGhhdCBWdWxrYW4gaXMgYW4g ZXhwbGljaXQgc3luYyBBUEkgYnV0IFdheWxhbmQgYW5kIFgxMQo+ID4gPiBhcmVuJ3QuICBVbmZv cnR1bmF0ZWx5LCB0aGUgV2F5bGFuZCBleHRlbnNpb24gc29sdmVzIHplcm8gcHJvYmxlbXMgZm9y Cj4gPiA+IG1lIGJlY2F1c2UgSSBjYW4ndCByZWFsbHkgdXNlIGl0IHVubGVzcyBpdCdzIGltcGxl bWVudGVkIGluIGFsbCBvZiB0aGUKPiA+ID4gY29tcG9zaXRvcnMuICBVbnRpbCBldmVyeSBXYXls YW5kIGNvbXBvc2l0b3IgSSBjYXJlIGFib3V0IG15IHVzZXJzCj4gPiA+IGJlaW5nIGFibGUgdG8g dXNlICh3aGljaCBpcyBiYXNpY2FsbHkgYWxsIG9mIHRoZW0pIHN1cHBvcnRzIHRoZQo+ID4gPiBl eHRlbnNpb24sIEkgaGF2ZSB0byBjb250aW51ZSBjYXJyeSBhcm91bmQgbXkgcGlsZSBvZiBoYWNr cyB0byBrZWVwCj4gPiA+IGltcGxpY2l0IHN5bmMgYW5kIFZ1bGthbiB3b3JraW5nIG5pY2VseSB0 b2dldGhlci4KPiA+ID4gCj4gPiA+IEZyb20gdGhlIHBlcnNwZWN0aXZlIG9mIGEgV2F5bGFuZCBj b21wb3NpdG9yIChJIHVzZWQgdG8gcGxheSBpbiB0aGlzCj4gPiA+IHNwYWNlKSwgdGhleSdkIGxv dmUgdG8gaW1wbGVtZW50IHRoZSBuZXcgZXhwbGljaXQgc3luYyBleHRlbnNpb24gYnV0Cj4gPiA+ IGNhbid0LiAgU3VyZSwgdGhleSBjb3VsZCB3aXJlIHVwIHRoZSBleHRlbnNpb24sIGJ1dCB0aGUg bW9tZW50IHRoZXkgZ28KPiA+ID4gdG8gZmxpcCBhIGNsaWVudCBidWZmZXIgdG8gdGhlIHNjcmVl biBkaXJlY3RseSwgdGhleSBkaXNjb3ZlciB0aGF0IEtNUwo+ID4gPiBkb2Vzbid0IHN1cHBvcnQg YW55IGV4cGxpY2l0IHN5bmMgQVBJcy4KPiA+IAo+ID4gQXMgcGVyIHRoZSBhYm92ZSBjb3JyZWN0 aW9uLCBXYXlsYW5kIGNvbXBvc2l0b3JzIGFyZW4ndCBuZWFybHkgYXMgYmFkCj4gPiBvZmYgYXMg SSBpbml0aWFsbHkgdGhvdWdodC4gIFRoZXJlIG1heSBzdGlsbCBiZSB3ZWlyZCBzY3JlZW4gY2Fw dHVyZQo+ID4gY2FzZXMgYnV0IHRoZSBub3JtYWwgY2FzZXMgb2YgY29tcG9zaXRpbmcgYW5kIGRp c3BsYXlpbmcgdmlhCj4gPiBLTVMvYXRvbWljIHNob3VsZCBiZSBpbiByZWFzb25hYmx5IGdvb2Qg c2hhcGUuCj4gPiAKPiA+ID4gU28sIHllcywgdGhleSBjYW4gdGVjaG5pY2FsbHkKPiA+ID4gaW1w bGVtZW50IHRoZSBleHRlbnNpb24gYXNzdW1pbmcgdGhlIEVHTCBzdGFjayB0aGV5J3JlIHJ1bm5p bmcgb24gaGFzCj4gPiA+IHRoZSBzeW5jX2ZpbGUgZXh0ZW5zaW9ucyBidXQgYW55IGNsaWVudCBi dWZmZXJzIHdoaWNoIGNvbWUgaW4gdXNpbmcKPiA+ID4gdGhlIGV4cGxpY2l0IHN5bmMgV2F5bGFu ZCBleHRlbnNpb24gaGF2ZSB0byBiZSBjb21wb3NpdGVkIGFuZCBjYW4ndCBiZQo+ID4gPiBzY2Fu bmVkIG91dCBkaXJlY3RseS4gIEFzIGEgM0QgZHJpdmVyIGRldmVsb3BlciwgSSBhYnNvbHV0ZWx5 IGRvbid0Cj4gPiA+IHdhbnQgY29tcG9zaXRvcnMgZG9pbmcgdGhhdCBiZWNhdXNlIG15IHVzZXJz IHdpbGwgY29tcGxhaW4gYWJvdXQKPiA+ID4gcGVyZm9ybWFuY2UgaXNzdWVzIGR1ZSB0byB0aGUg ZXh0cmEgYmxpdC4KPiA+ID4gCj4gPiA+IE9rLCBzbyBsZXQncyBzYXkgd2UgZ2V0IEtNUyB3aXJl ZCB1cCB3aXRoIGltcGxpY2l0IHN5bmMuICBUaGF0IHNvbHZlcwo+ID4gPiBhbGwgb3VyIHByb2Js ZW1zLCByaWdodD8gIEl0IGRvZXMsIHJpZ2h0IHVwIHVudGlsIHNvbWVvbmUgZGVjaWRlcyB0aGF0 Cj4gPiA+IHRoZXkgd2FuIHRvIHNjcmVlbiBjYXB0dXJlIHRoZWlyIFdheWxhbmQgc2Vzc2lvbiB2 aWEgc29tZSBoYXJkd2FyZQo+ID4gPiBtZWRpYSBlbmNvZGVyIHRoYXQgZG9lc24ndCBzdXBwb3J0 IGV4cGxpY2l0IHN5bmMuICBOb3cgd2UgaGF2ZSB0bwo+ID4gPiBwbHVtYiBpdCBhbGwgdGhlIHdh eSB0aHJvdWdoIHRoZSBtZWRpYSBzdGFjaywgZ3N0cmVhbWVyLCBldGMuICBHcmVhdCwKPiA+ID4g c28gbGV0J3MgZG8gdGhhdCEgIE9oLCBidXQgZ3N0cmVhbWVyIHdvbid0IHdhbnQgdG8gcGx1bWIg aXQgdGhyb3VnaAo+ID4gPiB1bnRpbCB0aGV5J3JlIGd1YXJhbnRlZWQgdGhhdCB0aGV5IGNhbiB1 c2UgZXhwbGljaXQgc3luYyB3aGVuCj4gPiA+IGRpc3BsYXlpbmcgb24gWDExIG9yIFdheWxhbmQu ICBBcmUgeW91IHNlZWluZyB0aGUgcHJvYmxlbT8KPiA+ID4gCj4gPiA+IFRvIG1ha2UgbWF0dGVy cyB3b3JzZSwgc2luY2UgbW9zdCB0aGluZ3MgYXJlIGRvaW5nIGltcGxpY2l0Cj4gPiA+IHN5bmNo cm9uaXphdGlvbiB0b2RheSwgaXQncyByZWFsbHkgZWFzeSB0byBnZXQgeW91ciBleHBsaWNpdAo+ ID4gPiBzeW5jaHJvbml6YXRpb24gd3JvbmcgYW5kIG5ldmVyIG5vdGljZS4gIElmIHlvdSBmb3Jn ZXQgdG8gcGFzcyBhCj4gPiA+IHN5bmNfZmlsZSBpbnRvIG9uZSBwbGFjZSAoc2F5IHlvdSBuZXZl ciBub3RpY2UgS01TIGRvZXNuJ3Qgc3VwcG9ydAo+ID4gPiB0aGVtKSwgaXQgd2lsbCBwcm9iYWJs eSB3b3JrIGFueXdheSB0aGFua3MgdG8gYWxsIHRoZSBpbXBsaWNpdCBzeW5jCj4gPiA+IHRoYXQn cyBnb2luZyBvbiBlbHNld2hlcmUuCj4gPiA+IAo+ID4gPiBTbywgY2xlYXJseSwgd2UgYWxsIG5l ZWQgdG8gZ28gd3JpdGUgcGlsZXMgb2YgY29kZSB0aGF0IHdlIGNhbid0Cj4gPiA+IGFjdHVhbGx5 IHByb3Blcmx5IHRlc3QgdW50aWwgZXZlcnlvbmUgZWxzZSBoYXMgd3JpdHRlbiB0aGVpciBwaWVj ZSBhbmQKPiA+ID4gdGhlbiB3ZSB1c2UgZXhwbGljaXQgc3luYyBpZiBhbmQgb25seSBpZiBhbGwg Y29tcG9uZW50cyBzdXBwb3J0IGl0Lgo+ID4gPiBSZWFsbHk/ICBXZSdyZSBnb2luZyB0byBkbyBt dWx0aXBsZSB5ZWFycyBvZiBkZXZlbG9wbWVudCBhbmQgdGhlbiBqdXN0Cj4gPiA+IGhvcGUgaXQg d29ya3Mgd2hlbiB3ZSBmaW5hbGx5IGZsaXAgdGhlIHN3aXRjaD8gIFRoYXQgZG9lc24ndCBzb3Vu ZAo+ID4gPiBsaWtlIGEgZ29vZCBwbGFuIHRvIG1lLgo+ID4gPiAKPiA+ID4gCj4gPiA+ICMjIEEg cHJvcG9zYWw6IEltcGxpY2l0IGFuZCBleHBsaWNpdCBzeW5jIHRvZ2V0aGVyCj4gPiA+IAo+ID4g PiBIb3cgdG8gc29sdmUgYWxsIHRoZXNlIGNoaWNrZW4tYW5kLWVnZyBwcm9ibGVtcyBpcyBzb21l dGhpbmcgSSd2ZSBiZWVuCj4gPiA+IGdpdmluZyBxdWl0ZSBhIGJpdCBvZiB0aG91Z2h0IChhbmQg dGFsa2luZyB3aXRoIG1hbnkgb3RoZXJzIGFib3V0KSBpbgo+ID4gPiB0aGUgbGFzdCBjb3VwbGUg b2YgeWVhcnMuICBPbmUgbW90aXZhdGlvbiBmb3IgdGhpcyBpcyB0aGF0IHdlIGhhdmUgdG8KPiA+ ID4gZGVhbCB3aXRoIGEgbWlzbWF0Y2ggaW4gVnVsa2FuLiAgQW5vdGhlciBtb3RpdmF0aW9uIGlz IHRoYXQgSSdtCj4gPiA+IGJlY29taW5nIGluY3JlYXNpbmdseSB1bmhhcHB5IHdpdGggdGhlIHdh eSB0aGF0IHN5bmNocm9uaXphdGlvbiwKPiA+ID4gbWVtb3J5IHJlc2lkZW5jeSwgYW5kIGNvbW1h bmQgc3VibWlzc2lvbiBhcmUgaW5oZXJlbnRseSBpbnRlcnR3aW5lZCBpbgo+ID4gPiBpOTE1IGFu ZCB3b3VsZCBsaWtlIHRvIGJyZWFrIHRoaW5ncyBhcGFydC4gIFRvd2FyZHMgdGhhdCBlbmQsIEkg aGF2ZQo+ID4gPiBhbiBhY3R1YWwgcHJvcG9zYWwuCj4gPiA+IAo+ID4gPiBBIGNvdXBsZSB3ZWVr cyBhZ28sIEkgc2VudCBhIHNlcmllcyBvZiBwYXRjaGVzIHRvIHRoZSBkcmktZGV2ZWwKPiA+ID4g bWFpbGluZyBsaXN0IHdoaWNoIGFkZHMgYSBwYWlyIG9mIG5ldyBpb2N0bHMgdG8gZG1hLWJ1ZiB3 aGljaCBhbGxvdwo+ID4gPiB1c2Vyc3BhY2UgdG8gbWFudWFsbHkgaW1wb3J0IG9yIGV4cG9ydCBh IHN5bmNfZmlsZSBmcm9tIGEgZG1hLWJ1Zi4KPiA+ID4gVGhlIGlkZWEgaXMgdGhhdCBzb21ldGhp bmcgbGlrZSBhIFdheWxhbmQgY29tcG9zaXRvciBjYW4gc3dpdGNoIHRvCj4gPiA+IDEwMCUgZXhw bGljaXQgc3luYyBpbnRlcm5hbGx5IG9uY2UgdGhlIGlvY3RsIGlzIGF2YWlsYWJsZS4gIElmIGl0 IGdldHMKPiA+ID4gYnVmZmVycyBpbiBmcm9tIGEgY2xpZW50IHRoYXQgZG9lc24ndCB1c2UgdGhl IGV4cGxpY2l0IHN5bmMgZXh0ZW5zaW9uLAo+ID4gPiBpdCBjYW4gcHVsbCBhIHN5bmNfZmlsZSBm cm9tIHRoZSBkbWEtYnVmIGFuZCB1c2UgdGhhdCBleGFjdGx5IGFzIGl0Cj4gPiA+IHdvdWxkIGEg c3luY19maWxlIHBhc3NlZCB2aWEgdGhlIGV4cGxpY2l0IHN5bmMgZXh0ZW5zaW9uLiAgV2hlbiBp dAo+ID4gPiBnb2VzIHRvIHNjYW4gb3V0IGEgdXNlciBidWZmZXIgYW5kIGRpc2NvdmVycyB0aGF0 IEtNUyBkb2Vzbid0IGFjY2VwdAo+ID4gPiBzeW5jX2ZpbGVzIChvciBpZiBpdCB0cmllcyB0byB1 c2UgdGhhdCBwZXNreSBtZWRpYSBlbmNvZGVyIG5vIG9uZSBoYXMKPiA+ID4gY29udmVydGVkKSwg aXQgY2FuIHRha2UgaXQncyBzeW5jX2ZpbGUgZm9yIGRpc3BsYXkgYW5kIHN0dWZmIGl0IGludG8K PiA+ID4gdGhlIGRtYS1idWYgYmVmb3JlIGhhbmRpbmcgaXQgdG8gS01TLgo+ID4gPiAKPiA+ID4g QWxvbmcgd2l0aCB0aGUga2VybmVsIHBhdGNoZXMsIEkndmUgYWxzbyBpbXBsZW1lbnRlZCBzdXBw b3J0IGZvciB0aGlzCj4gPiA+IGluIHRoZSBWdWxrYW4gV1NJIGNvZGUgdXNlZCBieSBBTlYgYW5k IFJBRFYuICBXaXRoIHRob3NlIHBhdGNoZXMsIHRoZQo+ID4gPiBvbmx5IHJlcXVpcmVtZW50IG9u IHRoZSBWdWxrYW4gZHJpdmVycyBpcyB0aGF0IHlvdSBiZSBhYmxlIHRvIGV4cG9ydAo+ID4gPiBh bnkgVmtTZW1hcGhvcmUgYXMgYSBzeW5jX2ZpbGUgYW5kIHRlbXBvcmFyaWx5IGltcG9ydCBhIHN5 bmNfZmlsZSBpbnRvCj4gPiA+IGFueSBWa0ZlbmNlIG9yIFZrU2VtYXBob3JlLiAgQXMgbG9uZyBh cyB0aGF0IHdvcmtzLCB0aGUgY29yZSBWdWxrYW4KPiA+ID4gZHJpdmVyIG9ubHkgZXZlciBzZWVz IGV4cGxpY2l0IHN5bmNocm9uaXphdGlvbiB2aWEgc3luY19maWxlLiAgVGhlIFdTSQo+ID4gPiBj b2RlIHVzZXMgdGhlc2UgbmV3IGlvY3RscyB0byB0cmFuc2xhdGUgdGhlIGltcGxpY2l0IHN5bmMg b2YgWDExIGFuZAo+ID4gPiBXYXlsYW5kIHRvIHRoZSBleHBsaWNpdCBzeW5jIHRoZSBWdWxrYW4g ZHJpdmVyIHdhbnRzLgo+ID4gPiAKPiA+ID4gSSdtIGhvcGluZyAoYW5kIGhlcmUncyB3aGVyZSBJ IHdhbnQgYSBzYW5pdHkgY2hlY2spIHRoYXQgYSBzaW1wbGUgQVBJCj4gPiA+IGxpa2UgdGhpcyB3 aWxsIGFsbG93IHVzIHRvIGZpbmFsbHkgc3RhcnQgbW92aW5nIHRoZSBMaW51eCBlY29zeXN0ZW0K PiA+ID4gb3ZlciB0byBleHBsaWNpdCBzeW5jaHJvbml6YXRpb24gb25lIHBpZWNlIGF0IGEgdGlt ZSBpbiBhIHdheSB0aGF0J3MKPiA+ID4gYWN0dWFsbHkgY29ycmVjdC4gIChObyBXYXlsYW5kIGV4 cGxpY2l0IHN5bmMgd2l0aCBjb21wb3NpdG9ycyBob3BpbmcKPiA+ID4gS01TIG1hZ2ljYWxseSB3 b3JrcyBldmVuIHRob3VnaCBpdCBkb2Vzbid0IGhhdmUgYSBzeW5jX2ZpbGUgQVBJLikKPiA+ID4g T25jZSBzb21lIHBpZWNlcyBpbiB0aGUgZWNvc3lzdGVtIHN0YXJ0IG1vdmluZywgdGhlcmUgd2ls bCBiZQo+ID4gPiBtb3RpdmF0aW9uIHRvIHN0YXJ0IG1vdmluZyBvdGhlcnMgYW5kIG1heWJlIHdl IGNhbiBhY3R1YWxseSBidWlsZCB0aGUKPiA+ID4gbW9tZW50dW0gdG8gZ2V0IG1vc3QgZXZlcnl0 aGluZyBjb252ZXJ0ZWQuCj4gPiA+IAo+ID4gPiBGb3IgcmVmZXJlbmNlLCB5b3UgY2FuIGZpbmQg dGhlIGtlcm5lbCBSRkMgcGF0Y2hlcyBhbmQgbWVzYSBNUiBoZXJlOgo+ID4gPiAKPiA+ID4gaHR0 cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvYXJjaGl2ZXMvZHJpLWRldmVsLzIwMjAtTWFyY2gv MjU4ODMzLmh0bWwKPiA+ID4gCj4gPiA+IGh0dHBzOi8vZ2l0bGFiLmZyZWVkZXNrdG9wLm9yZy9t ZXNhL21lc2EvLS9tZXJnZV9yZXF1ZXN0cy80MDM3Cj4gPiA+IAo+ID4gPiBBdCB0aGlzIHBvaW50 LCBJIHdlbGNvbWUgeW91ciB0aG91Z2h0cywgY29tbWVudHMsIG9iamVjdGlvbnMsIGFuZAo+ID4g PiBtYXliZSBldmVuIGhlbHAvcmV2aWV3LiA6LSkKPiA+ID4gCj4gPiA+IC0tSmFzb24gRWtzdHJh bmQKPiAKCi0tIApSZWdhcmRzLAoKTGF1cmVudCBQaW5jaGFydApfX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1k ZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcv bWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK 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=-2.4 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,MAILING_LIST_MULTI,SPF_HELO_NONE, SPF_PASS,USER_AGENT_SANE_1 autolearn=no 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 2D5FCC0044D for ; Mon, 16 Mar 2020 10:20:43 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id D4F022071C for ; Mon, 16 Mar 2020 10:20:42 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=ideasonboard.com header.i=@ideasonboard.com header.b="Vnl4jbf2" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1730545AbgCPKUm (ORCPT ); Mon, 16 Mar 2020 06:20:42 -0400 Received: from perceval.ideasonboard.com ([213.167.242.64]:34802 "EHLO perceval.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1730497AbgCPKUm (ORCPT ); Mon, 16 Mar 2020 06:20:42 -0400 Received: from pendragon.ideasonboard.com (81-175-216-236.bb.dnainternet.fi [81.175.216.236]) by perceval.ideasonboard.com (Postfix) with ESMTPSA id C442FA3B; Mon, 16 Mar 2020 11:20:38 +0100 (CET) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=ideasonboard.com; s=mail; t=1584354039; bh=tLX3goQbNsnImE5g/YMruPCGZHm6gq1Gzi1bCITnAoU=; h=Date:From:To:Cc:Subject:References:In-Reply-To:From; b=Vnl4jbf2JDY0mHWu42x2aIpmUtDLR7TSzfAU7iENacIY7RAQNhewPLlESJib9/86j R4gfvvupSqQ53g3TfeZTcRDRanIzrnrtcS/SGxmMy+CYJXWNbK2Rgr9qKPRmJpF1Ug q7pOARZskY+LxmGrcrnslRI+i5kKyAqkU0ipP1f4= Date: Mon, 16 Mar 2020 12:20:34 +0200 From: Laurent Pinchart To: Nicolas Dufresne Cc: Jason Ekstrand , ML mesa-dev , Discussion of the development of and with GStreamer , "wayland-devel @ lists . freedesktop . org" , xorg-devel , Maling list - DRI developers , linux-media@vger.kernel.org, Dave Airlie , Daniel Vetter , Bas Nieuwenhuizen , Daniel Stone Subject: Re: Plumbing explicit synchronization through the Linux ecosystem Message-ID: <20200316102034.GA30883@pendragon.ideasonboard.com> References: <33d1749d876a83416c44671efcb37c74f87d1bd4.camel@ndufresne.ca> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <33d1749d876a83416c44671efcb37c74f87d1bd4.camel@ndufresne.ca> User-Agent: Mutt/1.10.1 (2018-07-13) Sender: linux-media-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-media@vger.kernel.org On Wed, Mar 11, 2020 at 04:18:55PM -0400, Nicolas Dufresne wrote: > (I know I'm going to be spammed by so many mailing list ...) > > Le mercredi 11 mars 2020 à 14:21 -0500, Jason Ekstrand a écrit : > > On Wed, Mar 11, 2020 at 12:31 PM Jason Ekstrand wrote: > > > All, > > > > > > Sorry for casting such a broad net with this one. I'm sure most people > > > who reply will get at least one mailing list rejection. However, this > > > is an issue that affects a LOT of components and that's why it's > > > thorny to begin with. Please pardon the length of this e-mail as > > > well; I promise there's a concrete point/proposal at the end. > > > > > > > > > Explicit synchronization is the future of graphics and media. At > > > least, that seems to be the consensus among all the graphics people > > > I've talked to. I had a chat with one of the lead Android graphics > > > engineers recently who told me that doing explicit sync from the start > > > was one of the best engineering decisions Android ever made. It's > > > also the direction being taken by more modern APIs such as Vulkan. > > > > > > > > > ## What are implicit and explicit synchronization? > > > > > > For those that aren't familiar with this space, GPUs, media encoders, > > > etc. are massively parallel and synchronization of some form is > > > required to ensure that everything happens in the right order and > > > avoid data races. Implicit synchronization is when bits of work (3D, > > > compute, video encode, etc.) are implicitly based on the absolute > > > CPU-time order in which API calls occur. Explicit synchronization is > > > when the client (whatever that means in any given context) provides > > > the dependency graph explicitly via some sort of synchronization > > > primitives. If you're still confused, consider the following > > > examples: > > > > > > With OpenGL and EGL, almost everything is implicit sync. Say you have > > > two OpenGL contexts sharing an image where one writes to it and the > > > other textures from it. The way the OpenGL spec works, the client has > > > to make the API calls to render to the image before (in CPU time) it > > > makes the API calls which texture from the image. As long as it does > > > this (and maybe inserts a glFlush?), the driver will ensure that the > > > rendering completes before the texturing happens and you get correct > > > contents. > > > > > > Implicit synchronization can also happen across processes. Wayland, > > > for instance, is currently built on implicit sync where the client > > > does their rendering and then does a hand-off (via wl_surface::commit) > > > to tell the compositor it's done at which point the compositor can now > > > texture from the surface. The hand-off ensures that the client's > > > OpenGL API calls happen before the server's OpenGL API calls. > > > > > > A good example of explicit synchronization is the Vulkan API. There, > > > a client (or multiple clients) can simultaneously build command > > > buffers in different threads where one of those command buffers > > > renders to an image and the other textures from it and then submit > > > both of them at the same time with instructions to the driver for > > > which order to execute them in. The execution order is described via > > > the VkSemaphore primitive. With the new VK_KHR_timeline_semaphore > > > extension, you can even submit the work which does the texturing > > > BEFORE the work which does the rendering and the driver will sort it > > > out. > > > > > > The #1 problem with implicit synchronization (which explicit solves) > > > is that it leads to a lot of over-synchronization both in client space > > > and in driver/device space. The client has to synchronize a lot more > > > because it has to ensure that the API calls happen in a particular > > > order. The driver/device have to synchronize a lot more because they > > > never know what is going to end up being a synchronization point as an > > > API call on another thread/process may occur at any time. As we move > > > to more and more multi-threaded programming this synchronization (on > > > the client-side especially) becomes more and more painful. > > > > > > > > > ## Current status in Linux > > > > > > Implicit synchronization in Linux works via a the kernel's internal > > > dma_buf and dma_fence data structures. A dma_fence is a tiny object > > > which represents the "done" status for some bit of work. Typically, > > > dma_fences are created as a by-product of someone submitting some bit > > > of work (say, 3D rendering) to the kernel. The dma_buf object has a > > > set of dma_fences on it representing shared (read) and exclusive > > > (write) access to the object. When work is submitted which, for > > > instance renders to the dma_buf, it's queued waiting on all the fences > > > on the dma_buf and and a dma_fence is created representing the end of > > > said rendering work and it's installed as the dma_buf's exclusive > > > fence. This way, the kernel can manage all its internal queues (3D > > > rendering, display, video encode, etc.) and know which things to > > > submit in what order. > > > > > > For the last few years, we've had sync_file in the kernel and it's > > > plumbed into some drivers. A sync_file is just a wrapper around a > > > single dma_fence. A sync_file is typically created as a by-product of > > > submitting work (3D, compute, etc.) to the kernel and is signaled when > > > that work completes. When a sync_file is created, it is guaranteed by > > > the kernel that it will become signaled in finite time and, once it's > > > signaled, it remains signaled for the rest of time. A sync_file is > > > represented in UAPIs as a file descriptor and can be used with normal > > > file APIs such as dup(). It can be passed into another UAPI which > > > does some bit of queue'd work and the submitted work will wait for the > > > sync_file to be triggered before executing. A sync_file also supports > > > poll() if you want to wait on it manually. > > > > > > Unfortunately, sync_file is not broadly used and not all kernel GPU > > > drivers support it. Here's a very quick overview of my understanding > > > of the status of various components (I don't know the status of > > > anything in the media world): > > > > > > - Vulkan: Explicit synchronization all the way but we have to go > > > implicit as soon as we interact with a window-system. Vulkan has APIs > > > to import/export sync_files to/from it's VkSemaphore and VkFence > > > synchronization primitives. > > > - OpenGL: Implicit all the way. There are some EGL extensions to > > > enable some forms of explicit sync via sync_file but OpenGL itself is > > > still implicit. > > > - Wayland: Currently depends on implicit sync in the kernel (accessed > > > via EGL/OpenGL). There is an unstable extension to allow passing > > > sync_files around but it's questionable how useful it is right now > > > (more on that later). > > > - X11: With present, it has these "explicit" fence objects but > > > they're always a shmfence which lets the X server and client do a > > > userspace CPU-side hand-off without going over the socket (and > > > round-tripping through the kernel). However, the only thing that > > > fence does is order the OpenGL API calls in the client and server and > > > the real synchronization is still implicit. > > > - linux/i915/gem: Fully supports using sync_file or syncobj for explicit > > > sync. > > > - linux/amdgpu: Supports sync_file and syncobj but it still > > > implicitly syncs sometimes due to it's internal memory residency > > > handling which can lead to over-synchronization. > > > - KMS: Implicit sync all the way. There are no KMS APIs which take > > > explicit sync primitives. > > > > Correction: Apparently, I missed some things. If you use atomic, KMS > > does have explicit in- and out-fences. Non-atomic users (e.g. X11) > > are still in trouble but most Wayland compositors use atomic these > > days > > > > > - v4l: ??? > > > - gstreamer: ??? > > > - Media APIs such as vaapi etc.: ??? > > GStreamer is consumer for V4L2, VAAPI and other stuff. Using asynchronous buffer > synchronisation is something we do already with GL (even if limited). We place > GLSync object in the pipeline and attach that on related GstBuffer. We wait on > these GLSync as late as possible (or superseed the sync if we queue more work > into the same GL context). That requires a special mode of operation of course. > We don't usually like making lazy blocking call implicit, as it tends to cause > random issues. If we need to wait, we think it's better to wait int he module > that is responsible, so in general, we try to negotiate and fallback locally > (it's plugin base, so this can be really messy otherwise). > > So basically this problem needs to be solved in V4L2, VAAPI and other lower > level APIs first. We need API that provides us these fence (in or out), and then > we can consider using them. For V4L2, there was an attempt, but it was a bit of > a miss-fit. Your proposal could work, need to be tested I guess, but it does not > solve some of other issues that was discussed. Notably for camera capture, were > the HW timestamp is capture about at the same time the frame is ready. But the > timestamp is not part of the paylaod, so you need an entire API asynchronously > deliver that metadata. It's the biggest pain point I've found, such an API would > be quite invasive or if made really generic, might just never be adopted widely > enough. Another issue is that V4L2 doesn't offer any guarantee on job ordering. When you queue multiple buffers for camera capture for instance, you don't know until capture complete in which buffer the frame has been captured. In the normal case buffers are processed in sequence, but if an error occurs during capture, they can be recycled internally and put to the back of the queue. Unless I'm mistaken, this problem also exists with stateful codecs. And if you don't know in advance which buffer you will receive from the device, the usefulness of fences becomes very questionable :-) > There is other elements that would implement fencing, notably kmssink, but no > one actually dared porting it to atomic KMS, so clearly there is very little > comunity interest. glimagsink could clearly benifit. Right now if we import a > DMABuf, and that this DMAbuf is used for render, a implicit fence is attached, > which we are unaware. Philippe Zabbel is working on a patch, so V4L2 QBUF would > wait, but waiting in QBUF is not allowed if O_NONBLOCK was set (which GStreamer > uses), so then the operation will just fail where it worked before (breaking > userspace). If it was an explcit fence, we could handle that in GStreamer > cleanly as we do for new APIs. > > > > ## Chicken and egg problems > > > > > > Ok, this is where it starts getting depressing. I made the claim > > > above that Wayland has an explicit synchronization protocol that's of > > > questionable usefulness. I would claim that basically any bit of > > > plumbing we do through window systems is currently of questionable > > > usefulness. Why? > > > > > > From my perspective, as a Vulkan driver developer, I have to deal with > > > the fact that Vulkan is an explicit sync API but Wayland and X11 > > > aren't. Unfortunately, the Wayland extension solves zero problems for > > > me because I can't really use it unless it's implemented in all of the > > > compositors. Until every Wayland compositor I care about my users > > > being able to use (which is basically all of them) supports the > > > extension, I have to continue carry around my pile of hacks to keep > > > implicit sync and Vulkan working nicely together. > > > > > > From the perspective of a Wayland compositor (I used to play in this > > > space), they'd love to implement the new explicit sync extension but > > > can't. Sure, they could wire up the extension, but the moment they go > > > to flip a client buffer to the screen directly, they discover that KMS > > > doesn't support any explicit sync APIs. > > > > As per the above correction, Wayland compositors aren't nearly as bad > > off as I initially thought. There may still be weird screen capture > > cases but the normal cases of compositing and displaying via > > KMS/atomic should be in reasonably good shape. > > > > > So, yes, they can technically > > > implement the extension assuming the EGL stack they're running on has > > > the sync_file extensions but any client buffers which come in using > > > the explicit sync Wayland extension have to be composited and can't be > > > scanned out directly. As a 3D driver developer, I absolutely don't > > > want compositors doing that because my users will complain about > > > performance issues due to the extra blit. > > > > > > Ok, so let's say we get KMS wired up with implicit sync. That solves > > > all our problems, right? It does, right up until someone decides that > > > they wan to screen capture their Wayland session via some hardware > > > media encoder that doesn't support explicit sync. Now we have to > > > plumb it all the way through the media stack, gstreamer, etc. Great, > > > so let's do that! Oh, but gstreamer won't want to plumb it through > > > until they're guaranteed that they can use explicit sync when > > > displaying on X11 or Wayland. Are you seeing the problem? > > > > > > To make matters worse, since most things are doing implicit > > > synchronization today, it's really easy to get your explicit > > > synchronization wrong and never notice. If you forget to pass a > > > sync_file into one place (say you never notice KMS doesn't support > > > them), it will probably work anyway thanks to all the implicit sync > > > that's going on elsewhere. > > > > > > So, clearly, we all need to go write piles of code that we can't > > > actually properly test until everyone else has written their piece and > > > then we use explicit sync if and only if all components support it. > > > Really? We're going to do multiple years of development and then just > > > hope it works when we finally flip the switch? That doesn't sound > > > like a good plan to me. > > > > > > > > > ## A proposal: Implicit and explicit sync together > > > > > > How to solve all these chicken-and-egg problems is something I've been > > > giving quite a bit of thought (and talking with many others about) in > > > the last couple of years. One motivation for this is that we have to > > > deal with a mismatch in Vulkan. Another motivation is that I'm > > > becoming increasingly unhappy with the way that synchronization, > > > memory residency, and command submission are inherently intertwined in > > > i915 and would like to break things apart. Towards that end, I have > > > an actual proposal. > > > > > > A couple weeks ago, I sent a series of patches to the dri-devel > > > mailing list which adds a pair of new ioctls to dma-buf which allow > > > userspace to manually import or export a sync_file from a dma-buf. > > > The idea is that something like a Wayland compositor can switch to > > > 100% explicit sync internally once the ioctl is available. If it gets > > > buffers in from a client that doesn't use the explicit sync extension, > > > it can pull a sync_file from the dma-buf and use that exactly as it > > > would a sync_file passed via the explicit sync extension. When it > > > goes to scan out a user buffer and discovers that KMS doesn't accept > > > sync_files (or if it tries to use that pesky media encoder no one has > > > converted), it can take it's sync_file for display and stuff it into > > > the dma-buf before handing it to KMS. > > > > > > Along with the kernel patches, I've also implemented support for this > > > in the Vulkan WSI code used by ANV and RADV. With those patches, the > > > only requirement on the Vulkan drivers is that you be able to export > > > any VkSemaphore as a sync_file and temporarily import a sync_file into > > > any VkFence or VkSemaphore. As long as that works, the core Vulkan > > > driver only ever sees explicit synchronization via sync_file. The WSI > > > code uses these new ioctls to translate the implicit sync of X11 and > > > Wayland to the explicit sync the Vulkan driver wants. > > > > > > I'm hoping (and here's where I want a sanity check) that a simple API > > > like this will allow us to finally start moving the Linux ecosystem > > > over to explicit synchronization one piece at a time in a way that's > > > actually correct. (No Wayland explicit sync with compositors hoping > > > KMS magically works even though it doesn't have a sync_file API.) > > > Once some pieces in the ecosystem start moving, there will be > > > motivation to start moving others and maybe we can actually build the > > > momentum to get most everything converted. > > > > > > For reference, you can find the kernel RFC patches and mesa MR here: > > > > > > https://lists.freedesktop.org/archives/dri-devel/2020-March/258833.html > > > > > > https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/4037 > > > > > > At this point, I welcome your thoughts, comments, objections, and > > > maybe even help/review. :-) > > > > > > --Jason Ekstrand > -- Regards, Laurent Pinchart