From mboxrd@z Thu Jan 1 00:00:00 1970 From: Matt Roper Subject: Re: [PATCH v4 0/6] Finally fix watermarks Date: Fri, 29 Jul 2016 13:41:26 -0700 Message-ID: <20160729204126.GU32025@intel.com> References: <1469554483-24999-1-git-send-email-cpaul@redhat.com> <20160729000352.GR32025@intel.com> <20160729093905.GU4329@intel.com> <1469818089.23735.32.camel@redhat.com> <20160729192620.GK4329@intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Content-Disposition: inline In-Reply-To: <20160729192620.GK4329@intel.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= Cc: Daniel Vetter , intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org T24gRnJpLCBKdWwgMjksIDIwMTYgYXQgMTA6MjY6MjBQTSArMDMwMCwgVmlsbGUgU3lyasOkbMOk IHdyb3RlOgo+IE9uIEZyaSwgSnVsIDI5LCAyMDE2IGF0IDAyOjQ4OjA5UE0gLTA0MDAsIEx5dWRl IHdyb3RlOgo+ID4gU28gSSd2ZSBiZWVuIHdvcmtpbmcgb24gdHJ5aW5nIHRvIGZpeCB0aGlzIGVu dGlyZWx5IGFnYWluIChlLmcuIHdyaXRpbmcKPiA+IHRoZSBkZGIgcHJvcGVybHkpLCBzaW5jZSBm cm9tIGJ1ZyByZXBvcnRzIGl0IHN0aWxsIGRvZXNuJ3Qgc291bmQgbGlrZQo+ID4gd2UndmUgZ290 IGVub3VnaCB3b3JrYXJvdW5kcyB0byBtYWtlIHRoaXMgdG9sZXJhYmxlLiBJJ3ZlIHNob3duIHRo aXMgdG8KPiA+IG1hdHQgcm9wZXIsIGJ1dCBJIHNob3VsZCBwcm9iYWJseSBwb3N0IHdoYXQgSSd2 ZSBiZWVuIHRyeWluZyB0byBkbyBmb3IKPiA+IHlvdSBhcyB3ZWxsLgo+ID4gCj4gPiBTbyB0aGUg YXBwcm9hY2ggSSBjYW1lIHVwIHdpdGggaXMgaGVyZQo+ID4gCj4gPiBodHRwczovL2dpdGh1Yi5j b20vbHl1ZGUvbGludXgvdHJlZS93aXAvc2tsLWZpeC13bXMtdjVyMgo+ID4gCj4gPiBNeSBhcHBy b2FjaCBkaWZmZXJzIGEgbGl0dGxlIGJpdCBmcm9tIHdoYXQgdGhlIGJzcGVjIHJlY29tbWVuZHMs IGJ1dCBJCj4gPiB0aGluayBpdCdzIGdvaW5nIHRvIGJlIGEgYml0IGVhc2llciB0byBpbXBsZW1l bnQuIEF0IHRoZSBlbmQgb2YgYWxsIHRoZQo+ID4gY2hhbmdlcyBJJ20gYXR0ZW1wdGluZyBpdCBz aG91bGQgbG9vayBsaWtlIHRoaXM6Cj4gPiAKPiA+ICAqIFdlIG5vIGxvbmdlciBoYXZlIGEgZ2xv YmFsIHdhdGVybWFyayB1cGRhdGUgZm9yIHNrbAo+ID4gICogQSBuZXcgaG9vayBjYWxsZWQgInVw ZGF0ZV9kZGJzIiBpcyBhZGRlZCB0byBpOTE1X2Rpc3BsYXlfZnVuY3MuIFRoaXMKPiA+ICAgIGdl dHMgY2FsbGVkIGluIGludGVsX2F0b21pY19jb21taXRfdGFpbCgpIGFmdGVyIHdlJ3ZlIGRpc2Fi bGVkIGFueQo+ID4gICAgQ1JUQ3MgdGhhdCBuZWVkZWQgZGlzYWJsaW5nLCBhbmQgYmVmb3JlIHdl IGJlZ2luIGVuYWJsaW5nL3VwZGF0aW5nCj4gPiAgICBDUlRDcwo+ID4gICogQmVjYXVzZSBwaXBl IGRkYiBhbGxvY2F0aW9ucyAobm90IHRoZSBpbm5lci1waXBlIGRkYiBhbGxvY2F0aW9ucwo+ID4g ICAgdGhhdCBhcHBseSB0byBlYWNoIHBpcGUncyBwbGFuZXMpIG9ubHkgY2hhbmdlIHdoaWxlCj4g PiAgICBlbmFibGluZy9kaXNhYmxpbmcgY3J0Y3M6Cj4gPiAgICAgKiBQYXNzIDE6IEZpbmQgd2hp Y2ggcGlwZSdzIG5ldyBkZGIgYWxsb2NhdGlvbiB3b24ndCBvdmVybGFwIHdpdGgKPiA+ICAgICAg IGFub3RoZXIgcGlwZSdzIHByZXZpb3VzIGFsbG9jYXRpb24sIGFuZCB1cGRhdGUgdGhhdCBwaXBl IGZpcnN0Cj4gPiAgICAgKiBQYXNzIDI6IFVwZGF0ZSB0aGUgYWxsb2NhdGlvbiBvZiB0aGUgcmVt YWluaW5nIHBpcGUKPiA+IAo+ID4gSGVyZSdzIGFuIGlsbHVzdHJhdGlvbiBvZiB3aGF0IHRoaXMg bG9va3MgbGlrZS4gUGFydHMgb2YgdGhlIGRkYiBub3QKPiA+IGJlaW5nIHVzZWQgYnkgYW55IENS VENzIGFyZSBtYXJrZWQgb3V0IHdpdGggJ3gnczoKPiA+IAo+ID4gV2l0aCBwaXBlIEEgZW5hYmxl ZCwgd2UgZW5hYmxlIHBpcGUgQjoKPiA+IEluaXRpYWwgRERCOiDCoCDCoHwgwqAgwqAgwqAgwqAg wqAgQSDCoCDCoCDCoCDCoCDCoCB8Cj4gPiB1cGRhdGVfZGRiczogwqAgwqB8IMKgIMKgIEEgwqAg wqAgfHh4eHh4eHh4eHh4fCBQYXNzIDEKPiA+IEVuYWJsZSBwaXBlIEI6IMKgfCDCoCDCoCBBIMKg IMKgIHwgwqAgwqAgQiDCoCDCoCB8Cj4gPiAKPiA+IFdpdGggcGlwZXMgQiBhbmQgQSBhY3RpdmUs IHdlIGVuYWJsZSBwaXBlIEM6Cj4gPiAKPiA+IEluaXRpYWwgRERCOiDCoCDCoHwgwqAgwqAgQiDC oCDCoCB8IMKgIMKgIEEgwqAgwqAgfAo+ID4gdXBkYXRlX2RkYnM6IMKgIMKgfCDCoCBCIMKgIHx4 eHh8IMKgIMKgIEEgwqAgwqAgfCBQYXNzIDEKPiA+IHVwZGF0ZV9kZGJzOiDCoCDCoHwgwqAgQiDC oCB8IMKgIEEgwqAgfHh4eHh4eHh8IFBhc3MgMgo+ID4gRW5hYmxlIHBpcGUgQzogwqB8IMKgIEIg wqAgfCDCoCBBIMKgIHwgwqAgQyDCoCB8Cj4gPiAKPiA+IFdpdGggcGlwZXMgQSwgQiwgYW5kIEMg YWN0aXZlLCB3ZSBkaXNhYmxlIEI6Cj4gPiBJbml0aWFsIEREQjogwqAgwqB8IMKgIEEgwqAgfCDC oCBCIMKgIHwgwqAgQyDCoCB8Cj4gPiBEaXNhYmxlIHBpcGUgQjogfCDCoCBBIMKgIHx4eHh4eHh4 fCDCoCBDIMKgIHwKPiA+IHVwZGF0ZV9kZGJzOiDCoCDCoHwgwqAgwqAgQSDCoCDCoCB8IMKgIMKg IEMgwqAgwqAgfCBQYXNzIDEKPiA+IFNpbmNlIG5laXRoZXIgcGlwZSdzIG5ldyBhbGxvY2F0aW9u IG92ZXJsYXBwZWQsIHdlIHNraXAgcGFzcyAyCj4gPiAKPiA+IEFub3RoZXIgYWxsb2NhdGlvbiB3 aXRoIEEsIEIsIGFuZCBDIGFjdGl2ZSwgZGlzYWJsaW5nIEE6Cj4gPiBJbml0aWFsIEREQjogwqAg wqB8IMKgIEEgwqAgfCDCoCBCIMKgIHwgwqAgQyDCoCB8Cj4gPiBEaXNhYmxlIHBpcGUgQTogfHh4 eHh4eHh8IMKgIEIgwqAgfCDCoCBDIMKgIHwKPiA+IHVwZGF0ZV9kZGJzOiDCoCDCoHwgwqAgwqAg QiDCoCDCoCB8eHh4fCDCoCBDIMKgIHwgUGFzcyAxCj4gPiB1cGRhdGVfZGRiczogwqAgwqB8IMKg IMKgIEIgwqAgwqAgfCDCoCDCoCBDIMKgIMKgIHwgUGFzcyAyCj4gPiAKPiA+IFRoaXMgc2hvdWxk IGVuc3VyZSB3ZSBjYW4gYWx3YXlzIG1vdmUgYXJvdW5kIHRoZSBhbGxvY2F0aW9ucyBvZiBwaXBl cwo+ID4gd2l0aG91dCB0aGVtIGV2ZXIgb3ZlcmxhcHBpbmcgYW5kIGV4cGxvZGluZy4KPiAKPiBU aGF0J3Mgd2hhdCB0aGUgY3VycmVudCBmbHVzaCB0aGluZyBkb2VzLCBvciBhdCBsZWFzdCB0aGF0 IHdoYXQgaXQgdXNlZAo+IHRvIGRvIGF0IGxlYXN0LiBOb3Qgc3VyZSBpdCdzIHJlYWxseSBkb2lu ZyBpdCBhbnltb3JlLCBidXQgSSdtIHByZXR0eQo+IHN1cmUgdGhlIG9yZGVyIGluIHdoaWNoIGl0 IGRpZCB0aGluZ3Mgd2FzIHNvdW5kIGF0IHNvbWUgcG9pbnQuCj4gCj4gPiAKPiA+IFRoaXMgYnJh bmNoIGRvZXNuJ3QgZW50aXJlbHkgZml4IHVuZGVycnVuIGlzc3VlcywgYnV0IEknbSBtb3N0bHkg c3VyZQo+ID4gdGhhdCdzIHRoZSBmYXVsdCBvZiBzdGlsbCBub3QgaGF2aW5nIHJlbW92ZWQgdGhl IGdsb2JhbCB3bSB1cGRhdGUgaG9vawo+ID4geWV0ICh3aGljaCBpcyBsZWFkaW5nIHRvIGFkZGl0 aW9uYWwgcGlwZSBmbHVzaGVzIGluIHBsYWNlcyB0aGV5Cj4gPiBzaG91bGRuJ3QgYmUpOgo+IAo+ IFdlbGwgaXQgc2hvdWxkIGJhc2ljYWxseSBib2lsIGRvd24gdG8gcy91cGRhdGVfd20vdXBkYXRl X2RkYi8KPiBPbmx5IEREQiByZWFsbG9jYXRpb24gcmVhbGx5IHdhcnJhbnRzIGEgZ2xvYmFsIGhv b2suIEV2ZXJ5dGhpbmcgZWxzZQo+IHNob3VsZCBiZSBoYW5kbGVkIHZpYSBwZXItY3J0YyBob29r cywgb24gYWxsIHBsYXRmb3Jtcy4KCkkgZG9uJ3QgdGhpbmsgd2Ugd2FudCBldmVuIHVwZGF0ZV9k ZGIuICBXZSB3YW50ICpjYWxjdWxhdGVfZGRiKiB0byBiZSBhCmdsb2JhbCBob29rIGR1cmluZyB0 aGUgYXRvbWljIGNoZWNrIHBoYXNlIChhbmQgd2UgZG8gaGF2ZSB0aGF0IHRvZGF5KSwKYnV0IHdo ZW4gd2UgZ2V0IGFyb3VuZCB0byB0aGUgY29tbWl0IHBoYXNlIGFuZCBzdGFydCB3cml0aW5nIHN0 dWZmIHRvCmhhcmR3YXJlLCB3ZSB3YW50IHRvIHByb2dyYW0gdGhlIHBlci1waXBlIEREQiBlbnRy aWVzIGF0IHRoZSBzYW1lIHRpbWUKd2UgcHJvZ3JhbSB0aGUgV00ncyBhbmQgcmVndWxhciBwbGFu ZSByZWdpc3RlcnMgKHNpbmNlIHRoZXkgc2hvdWxkIGJlCmRvdWJsZSBidWZmZXJlZCBhbmQgZmx1 c2hlZCBvdXQgdGhlIHNhbWUgd2F5KS4gIFdlIGp1c3QgbmVlZCB0byBtYWtlCnN1cmUgdGhhdCB0 aGUgb3JkZXIgd2UgcHJvY2VzcyBwaXBlcyBpbiBmb2xsb3dzIHRoZSBzcGVjaWFsIGZsdXNoaW5n CnJ1bGVzIG5vdGVkIGFib3ZlLCB3aGljaCBpcyB3aGF0IG15IHBzZXVkby1wYXRjaGVzIHdlcmUg dHJ5aW5nIHRvCmRlc2NyaWJlLgoKPiAKPiA+IAo+ID4gaHR0cHM6Ly9naXRodWIuY29tL2x5dWRl L2xpbnV4L3RyZWUvd2lwL3NrbC1maXgtd21zLXY1cjIKPiA+IAo+ID4gQXMgZm9yIHVwZGF0aW5n IGlubmVyLXBpcGUgZGRiIGFsbG9jYXRpb25zIGZvciBlYWNoIHBsYW5lIG9uIGEgcGlwZSwgd2UK PiA+IHNob3VsZCBiZSBhYmxlIHRvIGp1c3QgZG8gdGhhdCBhdCB0aGUgc2FtZSB0aW1lIHdlIHVw ZGF0ZSBlYWNoIHBpcGUncwo+ID4gd2F0ZXJtYXJrcwo+IAo+IFllcy4KPiAKPiBOb25lIG9mIHRo YXQgY2hhbmdlcyB3aGF0IEkgc2FpZCBiZWZvcmUgdGhvdWdoLiBFaXRoZXIgeW91IG5lZWQgdG8K PiBsb2NrIGRvd24gZXZlcnl0aGluZyB3aGVuIHRoZSBEREIgbmVlZHMgdG8gYmUgcmVwYXJ0aXRp b25lZCwgb3IgeW91Cj4gZG8gd2hhdCBJIG91dGxpbmVkIGluIHRoZSBwcmV2aW91cyBtYWlsLiBP dGhlcndpc2UgYSBwbGFuZSB1cGRhdGUKPiBldGMuIGhhcHBlbmluZyBpbiBwYXJhbGxlbCB3aWxs IHN0aWxsIGJsb3cgdXAgb24gYWNjb3VudCBvZiB0aGUgRERCCj4gc3RhdGUgY2hhbmdpbmcgdW5k ZXJuZWF0aCB0aGUgcGxhbmUgdXBkYXRlIHNvbWV3aGVyZSBiZXR3ZWVuIGNvbXB1dGUKPiBhbmQg Y29tbWl0LiBJIGNhbid0IHJlYWxseSB0aGluayBvZiB0aGlyZCBvcHRpb24gdGhhdCB3b3VsZCB3 b3JrLgoKWWVwLCBJIGFncmVlIHdpdGggYWxsIG9mIHRoaXMgYXMgd2VsbCAoYW5kIHdlIGRvIGxv Y2sgZXZlcnl0aGluZyBkb3duCnRvZGF5IGZvciBleGFjdGx5IHRoaXMgcmVhc29uKS4gIEl0J3Mg dW5mb3J0dW5hdGUgdGhhdCB3ZSBuZWVkIGEKQktMLXN0eWxlIG1lY2hhbmlzbSBmb3IgdGhlIERE QiwgYnV0IGFzIEkgbm90ZWQgaW4gdGhlIG90aGVyIG1lc3NhZ2UsCnVzaW5nIGZpeGVkIHByZS1w YXJ0aXRpb25pbmcgZm9yIGxldmVsIDAgYnJlYWtzIHRvbyBtYW55IGFkZGl0aW9uYWwgdXNlCmNh c2VzLiAgOi0oCgoKTWF0dAoKPiAKPiA+IAo+ID4gTGV0IG1lIGtub3cgd2hhdCB5b3UgdGhpbmsK PiA+IAlMeXVkZQo+ID4gCj4gPiBPbiBGcmksIDIwMTYtMDctMjkgYXQgMTI6MzkgKzAzMDAsIFZp bGxlIFN5cmrDpGzDpCB3cm90ZToKPiA+ID4gT24gVGh1LCBKdWwgMjgsIDIwMTYgYXQgMDU6MDM6 NTJQTSAtMDcwMCwgTWF0dCBSb3BlciB3cm90ZToKPiA+ID4gPiAKPiA+ID4gPiBUaGlzIGlzIGNv bXBsZXRlbHkgdW50ZXN0ZWQgKGFuZCBwcm9iYWJseSBob3JyaWJseSBicm9rZW4vYnVnZ3kpLAo+ ID4gPiA+IGJ1dAo+ID4gPiA+IGhlcmUncyBhIHF1aWNrIG1vY2t1cCBvZiB0aGUgZ2VuZXJhbCBh cHByb2FjaCBJIHdhcyB0aGlua2luZyBmb3IKPiA+ID4gPiBlbnN1cmluZyBEREIgJiBXTSdzIGNh biBiZSB1cGRhdGVkIHRvZ2V0aGVyIHdoaWxlIGVuc3VyaW5nIHRoZQo+ID4gPiA+IHRocmVlLXN0 ZXAgcGlwZSBmbHVzaGluZyBwcm9jZXNzIGlzIGhvbm9yZWQ6Cj4gPiA+ID4gCj4gPiA+ID4gwqDC oMKgwqDCoMKgwqDCoGh0dHBzOi8vZ2l0aHViLmNvbS9tYXR0cm9wZS9rZXJuZWwvY29tbWl0cy9l eHBlcmltZW50YWwvbHl1Cj4gPiA+ID4gZGVfZGRiCj4gPiA+ID4gCj4gPiA+ID4gQmFzaWNhbGx5 IHRoZSBpZGVhIGlzIHRvIHRha2Ugbm90ZSBvZiB3aGF0J3MgaGFwcGVuaW5nIHRvIHRoZQo+ID4g PiA+IHBpcGUncyBEREIKPiA+ID4gPiBhbGxvY2F0aW9uIChzaHJpbmtpbmcsIGdyb3dpbmcsIHVu Y2hhbmdlZCwgZXRjLikgZHVyaW5nIHRoZSBhdG9taWMKPiA+ID4gPiBjaGVjawo+ID4gPiA+IHBo YXNlOwo+ID4gPiAKPiA+ID4gRGlkbid0IGxvb2sgdG9vIGNsb3NlbHksIGJ1dCBJIHRoaW5rIHlv dSBjYW4ndCBhY3R1YWxseSBkbyB0aGF0Cj4gPiA+IHVubGVzcwo+ID4gPiB5b3UgbG9jayBhbGwg dGhlIGNydGNzIHdoZW5ldmVyIHRoZSBudW1iZXIgb2YgYWN0aXZlIHBpcGVzIGlzIGdvaW5kCj4g PiA+IHRvCj4gPiA+IGNoYW5nZS4gTWVhbmluZyB3ZSdkIGVzc2VudGlhbGx5IGJlIGJhY2sgdG8g dGhlIG9uZS1iaWctbW9kZXNldC1sb2NrCj4gPiA+IGFwcG9yYWNoLCB3aGljaCB3aWxsIGNhdXNl IG1pc3NlZCBmbGlwcyBhbmQgd2hhbm90IG9uIHRoZSBvdGhlcgo+ID4gPiBwaXBlcy4KPiA+ID4g Cj4gPiA+IFRoZSBhbHRlcm5hdGl2ZSBJIHRoaW5rIHdvdWxkIGNvbnNpc3Qgb2Y6Cj4gPiA+IC0g bWFrZSBzdXJlIGxldmVsIDAgd2F0ZXJtYXJrIG5ldmVyIGV4Y2VlZHMgdG90YWxfZGRiX3NpemUv bWF4X3BpcGVzLAo+ID4gPiDCoCBzbyB0aGF0IGEgbW9kZXNldCBkb2Vzbid0IGhhdmUgdG8gY2Fy ZSBhYm91dCB0aGUgd21zIGZvciB0aGUgb3RoZXIKPiA+ID4gwqAgcGlwZXMgbm90IGZpdHRpbmcg aW4KPiA+ID4gLSBsZXZlbCAxKyB3YXRlcm1hcmtzIHdvdWxkIGJlIGNoZWNrZWQgYWdhaW5zdCB0 b3RhbF9kZGJfc2l6ZQo+ID4gPiAtIHByb3RlY3QgdGhlIHBsYW5lL3BpcGUgY29tbWl0IHdpdGgg dGhlIHdtIG11dGV4IHdoZW5ldmVyIHRoZSB3bXMKPiA+ID4gwqAgbmVlZCB0byBiZSByZXByb2dy YW1tZWQKPiA+ID4gLSBrZWVwIHRoZSBmbHVzaF93bSB0aGluZyBhcm91bmQgZm9yIHRoZSBjYXNl IHdoZW4gZGRiIHNpemUgZG9lcyBnZXQKPiA+ID4gwqAgY2hhbmdlZCwgcHJvdGVjdCBpdCB3aXRo IHRoZSB3bSBsb2NrCj4gPiA+IC0gd2hlbiBwcm9ncmFtbWluZyB3bXMsIHdlIHdpbGwgZmlyc3Qg ZmlsdGVyIG91dCBhbnkgbGV2ZWwgdGhhdAo+ID4gPiDCoCBkb2Vzbid0IGZpdCBpbiB3aXRoIHRo ZSBjdXJyZW50IGRkYiBzaXplLCBhbmQgdGhlbiBwcm9ncmFtIHRoZQo+ID4gPiDCoCByZXN0IGlu Cj4gPiA+IC0gcG90ZW50aWFsbHkgaW50cm9kdWNlIHBlci1waXBlIHdtIGxvY2tzIGlmIHRoZSBv bmUgYmlnIGxvY2sgbG9va3MKPiA+ID4gwqAgbGlrZSBhbiBpc3N1ZSwgd2hpY2ggaXQgbWlnaHQg aWYgdGhlIGZsdXNoX3dtIGhvbGRzIGl0IGFsbCB0aGUgd2F5Cj4gPiA+IMKgIHRocm91Z2gKPiA+ ID4gCj4gPiA+ID4gCj4gPiA+ID4gdGhlbiBkdXJpbmcgdGhlIGNvbW1pdCBwaGFzZSwgd2UgbG9v cCBvdmVyIHRoZSBDUlRDJ3MgdGhyZWUgdGltZXMKPiA+ID4gPiBpbnN0ZWFkIG9mIGp1c3Qgb25j ZSwgYnV0IG9ubHkgb3BlcmF0ZSBvbiBhIHN1YnNldCBvZiB0aGUgQ1JUQydzIGluCj4gPiA+ID4g ZWFjaAo+ID4gPiA+IGxvb3AuwqDCoFdoaWxlIG9wZXJhdGluZyBvbiBlYWNoIENSVEMsIHRoZSBw bGFuZSwgV00sIGFuZCBEREIgYWxsIGdldAo+ID4gPiA+IHByb2dyYW1tZWQgdG9nZXRoZXIgYW5k IGhhdmUgYSBzaW5nbGUgZmx1c2ggZm9yIGFsbCB0aHJlZS4KPiA+ID4gPiAKPiA+ID4gPiAKPiA+ ID4gPiAKPiA+ID4gPiAKPiA+ID4gPiBNYXR0Cj4gPiA+ID4gCj4gPiA+ID4gT24gVHVlLCBKdWwg MjYsIDIwMTYgYXQgMDE6MzQ6MzZQTSAtMDQwMCwgTHl1ZGUgd3JvdGU6Cj4gPiA+ID4gPiAKPiA+ ID4gPiA+IExhdGVzdCB2ZXJzaW9uIG9mIGh0dHBzOi8vbGttbC5vcmcvbGttbC8yMDE2LzcvMjYv MjkwIC4gUmVzZW5kaW5nCj4gPiA+ID4gPiB0aGUgd2hvbGUKPiA+ID4gPiA+IHRoaW5nIHRvIGtl ZXAgaXQgaW4gb25lIHBsYWNlLgo+ID4gPiA+ID4gCj4gPiA+ID4gPiBMeXVkZSAoNSk6Cj4gPiA+ ID4gPiDCoCBkcm0vaTkxNS9za2w6IEFkZCBzdXBwb3J0IGZvciB0aGUgU0FHViwgZml4IHVuZGVy cnVuIGhhbmdzCj4gPiA+ID4gPiDCoCBkcm0vaTkxNS9za2w6IE9ubHkgZmx1c2ggcGlwZXMgd2hl biB3ZSBjaGFuZ2UgdGhlIGRkYgo+ID4gPiA+ID4gYWxsb2NhdGlvbgo+ID4gPiA+ID4gwqAgZHJt L2k5MTUvc2tsOiBGaXggZXh0cmEgd2hpdGVzcGFjZSBpbiBza2xfZmx1c2hfd21fdmFsdWVzKCkK PiA+ID4gPiA+IMKgIGRybS9pOTE1L3NrbDogVXBkYXRlIHBsYW5lIHdhdGVybWFya3MgYXRvbWlj YWxseSBkdXJpbmcgcGxhbmUKPiA+ID4gPiA+IHVwZGF0ZXMKPiA+ID4gPiA+IMKgIGRybS9pOTE1 L3NrbDogQWx3YXlzIHdhaXQgZm9yIHBpcGVzIHRvIHVwZGF0ZSBhZnRlciBhIGZsdXNoCj4gPiA+ ID4gPiAKPiA+ID4gPiA+IE1hdHQgUm9wZXIgKDEpOgo+ID4gPiA+ID4gwqAgZHJtL2k5MTUvZ2Vu OTogT25seSBjb3B5IFdNIHJlc3VsdHMgZm9yIGNoYW5nZWQgcGlwZXMgdG8gc2tsX2h3Cj4gPiA+ ID4gPiAKPiA+ID4gPiA+IMKgZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuaMKgwqDCoMKg wqDCoHzCoMKgwqAzICsKPiA+ID4gPiA+IMKgZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9yZWcu aMKgwqDCoMKgwqDCoHzCoMKgwqA1ICsKPiA+ID4gPiA+IMKgZHJpdmVycy9ncHUvZHJtL2k5MTUv aW50ZWxfZGlzcGxheS5jIHzCoMKgMjQgKysrKwo+ID4gPiA+ID4gwqBkcml2ZXJzL2dwdS9kcm0v aTkxNS9pbnRlbF9kcnYuaMKgwqDCoMKgwqB8wqDCoMKgNCArCj4gPiA+ID4gPiDCoGRyaXZlcnMv Z3B1L2RybS9pOTE1L2ludGVsX3BtLmPCoMKgwqDCoMKgwqB8IDI0MAo+ID4gPiA+ID4gKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKy0tLS0KPiA+ID4gPiA+IMKgZHJpdmVycy9ncHUvZHJt L2k5MTUvaW50ZWxfc3ByaXRlLmPCoMKgfMKgwqDCoDIgKwo+ID4gPiA+ID4gwqA2IGZpbGVzIGNo YW5nZWQsIDI1NSBpbnNlcnRpb25zKCspLCAyMyBkZWxldGlvbnMoLSkKPiA+ID4gPiA+IAo+ID4g PiA+ID4gLS3CoAo+ID4gPiA+ID4gMi43LjQKPiA+ID4gPiA+IAo+ID4gPiA+ID4gX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KPiA+ID4gPiA+IEludGVsLWdm eCBtYWlsaW5nIGxpc3QKPiA+ID4gPiA+IEludGVsLWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcK PiA+ID4gPiA+IGh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8v aW50ZWwtZ2Z4Cj4gPiA+ID4gCj4gPiA+ID4gLS3CoAo+ID4gPiA+IE1hdHQgUm9wZXIKPiA+ID4g PiBHcmFwaGljcyBTb2Z0d2FyZSBFbmdpbmVlcgo+ID4gPiA+IElvVEcgUGxhdGZvcm0gRW5hYmxp bmcgJiBEZXZlbG9wbWVudAo+ID4gPiA+IEludGVsIENvcnBvcmF0aW9uCj4gPiA+ID4gKDkxNikg MzU2LTI3OTUKPiA+ID4gCj4gPiAtLSAKPiA+IENoZWVycywKPiA+IAlMeXVkZQo+IAo+IC0tIAo+ IFZpbGxlIFN5cmrDpGzDpAo+IEludGVsIE9UQwoKLS0gCk1hdHQgUm9wZXIKR3JhcGhpY3MgU29m dHdhcmUgRW5naW5lZXIKSW9URyBQbGF0Zm9ybSBFbmFibGluZyAmIERldmVsb3BtZW50CkludGVs IENvcnBvcmF0aW9uCig5MTYpIDM1Ni0yNzk1Cl9fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fCkludGVsLWdmeCBtYWlsaW5nIGxpc3QKSW50ZWwtZ2Z4QGxpc3Rz LmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xp c3RpbmZvL2ludGVsLWdmeAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753862AbcG2Uli (ORCPT ); Fri, 29 Jul 2016 16:41:38 -0400 Received: from mga02.intel.com ([134.134.136.20]:25435 "EHLO mga02.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753729AbcG2Ul3 (ORCPT ); Fri, 29 Jul 2016 16:41:29 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.28,441,1464678000"; d="scan'208";a="1031718681" Date: Fri, 29 Jul 2016 13:41:26 -0700 From: Matt Roper To: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= Cc: Lyude , intel-gfx@lists.freedesktop.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, Daniel Vetter Subject: Re: [Intel-gfx] [PATCH v4 0/6] Finally fix watermarks Message-ID: <20160729204126.GU32025@intel.com> References: <1469554483-24999-1-git-send-email-cpaul@redhat.com> <20160729000352.GR32025@intel.com> <20160729093905.GU4329@intel.com> <1469818089.23735.32.camel@redhat.com> <20160729192620.GK4329@intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=iso-8859-1 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20160729192620.GK4329@intel.com> User-Agent: Mutt/1.5.20 (2009-06-14) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Fri, Jul 29, 2016 at 10:26:20PM +0300, Ville Syrjälä wrote: > On Fri, Jul 29, 2016 at 02:48:09PM -0400, Lyude wrote: > > So I've been working on trying to fix this entirely again (e.g. writing > > the ddb properly), since from bug reports it still doesn't sound like > > we've got enough workarounds to make this tolerable. I've shown this to > > matt roper, but I should probably post what I've been trying to do for > > you as well. > > > > So the approach I came up with is here > > > > https://github.com/lyude/linux/tree/wip/skl-fix-wms-v5r2 > > > > My approach differs a little bit from what the bspec recommends, but I > > think it's going to be a bit easier to implement. At the end of all the > > changes I'm attempting it should look like this: > > > > * We no longer have a global watermark update for skl > > * A new hook called "update_ddbs" is added to i915_display_funcs. This > > gets called in intel_atomic_commit_tail() after we've disabled any > > CRTCs that needed disabling, and before we begin enabling/updating > > CRTCs > > * Because pipe ddb allocations (not the inner-pipe ddb allocations > > that apply to each pipe's planes) only change while > > enabling/disabling crtcs: > > * Pass 1: Find which pipe's new ddb allocation won't overlap with > > another pipe's previous allocation, and update that pipe first > > * Pass 2: Update the allocation of the remaining pipe > > > > Here's an illustration of what this looks like. Parts of the ddb not > > being used by any CRTCs are marked out with 'x's: > > > > With pipe A enabled, we enable pipe B: > > Initial DDB:    |           A           | > > update_ddbs:    |     A     |xxxxxxxxxxx| Pass 1 > > Enable pipe B:  |     A     |     B     | > > > > With pipes B and A active, we enable pipe C: > > > > Initial DDB:    |     B     |     A     | > > update_ddbs:    |   B   |xxx|     A     | Pass 1 > > update_ddbs:    |   B   |   A   |xxxxxxx| Pass 2 > > Enable pipe C:  |   B   |   A   |   C   | > > > > With pipes A, B, and C active, we disable B: > > Initial DDB:    |   A   |   B   |   C   | > > Disable pipe B: |   A   |xxxxxxx|   C   | > > update_ddbs:    |     A     |     C     | Pass 1 > > Since neither pipe's new allocation overlapped, we skip pass 2 > > > > Another allocation with A, B, and C active, disabling A: > > Initial DDB:    |   A   |   B   |   C   | > > Disable pipe A: |xxxxxxx|   B   |   C   | > > update_ddbs:    |     B     |xxx|   C   | Pass 1 > > update_ddbs:    |     B     |     C     | Pass 2 > > > > This should ensure we can always move around the allocations of pipes > > without them ever overlapping and exploding. > > That's what the current flush thing does, or at least that what it used > to do at least. Not sure it's really doing it anymore, but I'm pretty > sure the order in which it did things was sound at some point. > > > > > This branch doesn't entirely fix underrun issues, but I'm mostly sure > > that's the fault of still not having removed the global wm update hook > > yet (which is leading to additional pipe flushes in places they > > shouldn't be): > > Well it should basically boil down to s/update_wm/update_ddb/ > Only DDB reallocation really warrants a global hook. Everything else > should be handled via per-crtc hooks, on all platforms. I don't think we want even update_ddb. We want *calculate_ddb* to be a global hook during the atomic check phase (and we do have that today), but when we get around to the commit phase and start writing stuff to hardware, we want to program the per-pipe DDB entries at the same time we program the WM's and regular plane registers (since they should be double buffered and flushed out the same way). We just need to make sure that the order we process pipes in follows the special flushing rules noted above, which is what my pseudo-patches were trying to describe. > > > > > https://github.com/lyude/linux/tree/wip/skl-fix-wms-v5r2 > > > > As for updating inner-pipe ddb allocations for each plane on a pipe, we > > should be able to just do that at the same time we update each pipe's > > watermarks > > Yes. > > None of that changes what I said before though. Either you need to > lock down everything when the DDB needs to be repartitioned, or you > do what I outlined in the previous mail. Otherwise a plane update > etc. happening in parallel will still blow up on account of the DDB > state changing underneath the plane update somewhere between compute > and commit. I can't really think of third option that would work. Yep, I agree with all of this as well (and we do lock everything down today for exactly this reason). It's unfortunate that we need a BKL-style mechanism for the DDB, but as I noted in the other message, using fixed pre-partitioning for level 0 breaks too many additional use cases. :-( Matt > > > > > Let me know what you think > > Lyude > > > > On Fri, 2016-07-29 at 12:39 +0300, Ville Syrjälä wrote: > > > On Thu, Jul 28, 2016 at 05:03:52PM -0700, Matt Roper wrote: > > > > > > > > This is completely untested (and probably horribly broken/buggy), > > > > but > > > > here's a quick mockup of the general approach I was thinking for > > > > ensuring DDB & WM's can be updated together while ensuring the > > > > three-step pipe flushing process is honored: > > > > > > > >         https://github.com/mattrope/kernel/commits/experimental/lyu > > > > de_ddb > > > > > > > > Basically the idea is to take note of what's happening to the > > > > pipe's DDB > > > > allocation (shrinking, growing, unchanged, etc.) during the atomic > > > > check > > > > phase; > > > > > > Didn't look too closely, but I think you can't actually do that > > > unless > > > you lock all the crtcs whenever the number of active pipes is goind > > > to > > > change. Meaning we'd essentially be back to the one-big-modeset-lock > > > apporach, which will cause missed flips and whanot on the other > > > pipes. > > > > > > The alternative I think would consist of: > > > - make sure level 0 watermark never exceeds total_ddb_size/max_pipes, > > >   so that a modeset doesn't have to care about the wms for the other > > >   pipes not fitting in > > > - level 1+ watermarks would be checked against total_ddb_size > > > - protect the plane/pipe commit with the wm mutex whenever the wms > > >   need to be reprogrammed > > > - keep the flush_wm thing around for the case when ddb size does get > > >   changed, protect it with the wm lock > > > - when programming wms, we will first filter out any level that > > >   doesn't fit in with the current ddb size, and then program the > > >   rest in > > > - potentially introduce per-pipe wm locks if the one big lock looks > > >   like an issue, which it might if the flush_wm holds it all the way > > >   through > > > > > > > > > > > then during the commit phase, we loop over the CRTC's three times > > > > instead of just once, but only operate on a subset of the CRTC's in > > > > each > > > > loop.  While operating on each CRTC, the plane, WM, and DDB all get > > > > programmed together and have a single flush for all three. > > > > > > > > > > > > > > > > > > > > Matt > > > > > > > > On Tue, Jul 26, 2016 at 01:34:36PM -0400, Lyude wrote: > > > > > > > > > > Latest version of https://lkml.org/lkml/2016/7/26/290 . Resending > > > > > the whole > > > > > thing to keep it in one place. > > > > > > > > > > Lyude (5): > > > > >   drm/i915/skl: Add support for the SAGV, fix underrun hangs > > > > >   drm/i915/skl: Only flush pipes when we change the ddb > > > > > allocation > > > > >   drm/i915/skl: Fix extra whitespace in skl_flush_wm_values() > > > > >   drm/i915/skl: Update plane watermarks atomically during plane > > > > > updates > > > > >   drm/i915/skl: Always wait for pipes to update after a flush > > > > > > > > > > Matt Roper (1): > > > > >   drm/i915/gen9: Only copy WM results for changed pipes to skl_hw > > > > > > > > > >  drivers/gpu/drm/i915/i915_drv.h      |   3 + > > > > >  drivers/gpu/drm/i915/i915_reg.h      |   5 + > > > > >  drivers/gpu/drm/i915/intel_display.c |  24 ++++ > > > > >  drivers/gpu/drm/i915/intel_drv.h     |   4 + > > > > >  drivers/gpu/drm/i915/intel_pm.c      | 240 > > > > > +++++++++++++++++++++++++++++++---- > > > > >  drivers/gpu/drm/i915/intel_sprite.c  |   2 + > > > > >  6 files changed, 255 insertions(+), 23 deletions(-) > > > > > > > > > > --  > > > > > 2.7.4 > > > > > > > > > > _______________________________________________ > > > > > Intel-gfx mailing list > > > > > Intel-gfx@lists.freedesktop.org > > > > > https://lists.freedesktop.org/mailman/listinfo/intel-gfx > > > > > > > > --  > > > > Matt Roper > > > > Graphics Software Engineer > > > > IoTG Platform Enabling & Development > > > > Intel Corporation > > > > (916) 356-2795 > > > > > -- > > Cheers, > > Lyude > > -- > Ville Syrjälä > Intel OTC -- Matt Roper Graphics Software Engineer IoTG Platform Enabling & Development Intel Corporation (916) 356-2795