From mboxrd@z Thu Jan 1 00:00:00 1970 From: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= Subject: Re: [PATCH v4 0/6] Finally fix watermarks Date: Fri, 29 Jul 2016 22:26:20 +0300 Message-ID: <20160729192620.GK4329@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> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Content-Disposition: inline In-Reply-To: <1469818089.23735.32.camel@redhat.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: Lyude Cc: Daniel Vetter , intel-gfx@lists.freedesktop.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org List-Id: dri-devel@lists.freedesktop.org T24gRnJpLCBKdWwgMjksIDIwMTYgYXQgMDI6NDg6MDlQTSAtMDQwMCwgTHl1ZGUgd3JvdGU6Cj4g U28gSSd2ZSBiZWVuIHdvcmtpbmcgb24gdHJ5aW5nIHRvIGZpeCB0aGlzIGVudGlyZWx5IGFnYWlu IChlLmcuIHdyaXRpbmcKPiB0aGUgZGRiIHByb3Blcmx5KSwgc2luY2UgZnJvbSBidWcgcmVwb3J0 cyBpdCBzdGlsbCBkb2Vzbid0IHNvdW5kIGxpa2UKPiB3ZSd2ZSBnb3QgZW5vdWdoIHdvcmthcm91 bmRzIHRvIG1ha2UgdGhpcyB0b2xlcmFibGUuIEkndmUgc2hvd24gdGhpcyB0bwo+IG1hdHQgcm9w ZXIsIGJ1dCBJIHNob3VsZCBwcm9iYWJseSBwb3N0IHdoYXQgSSd2ZSBiZWVuIHRyeWluZyB0byBk byBmb3IKPiB5b3UgYXMgd2VsbC4KPiAKPiBTbyB0aGUgYXBwcm9hY2ggSSBjYW1lIHVwIHdpdGgg aXMgaGVyZQo+IAo+IGh0dHBzOi8vZ2l0aHViLmNvbS9seXVkZS9saW51eC90cmVlL3dpcC9za2wt Zml4LXdtcy12NXIyCj4gCj4gTXkgYXBwcm9hY2ggZGlmZmVycyBhIGxpdHRsZSBiaXQgZnJvbSB3 aGF0IHRoZSBic3BlYyByZWNvbW1lbmRzLCBidXQgSQo+IHRoaW5rIGl0J3MgZ29pbmcgdG8gYmUg YSBiaXQgZWFzaWVyIHRvIGltcGxlbWVudC4gQXQgdGhlIGVuZCBvZiBhbGwgdGhlCj4gY2hhbmdl cyBJJ20gYXR0ZW1wdGluZyBpdCBzaG91bGQgbG9vayBsaWtlIHRoaXM6Cj4gCj4gICogV2Ugbm8g bG9uZ2VyIGhhdmUgYSBnbG9iYWwgd2F0ZXJtYXJrIHVwZGF0ZSBmb3Igc2tsCj4gICogQSBuZXcg aG9vayBjYWxsZWQgInVwZGF0ZV9kZGJzIiBpcyBhZGRlZCB0byBpOTE1X2Rpc3BsYXlfZnVuY3Mu IFRoaXMKPiAgICBnZXRzIGNhbGxlZCBpbiBpbnRlbF9hdG9taWNfY29tbWl0X3RhaWwoKSBhZnRl ciB3ZSd2ZSBkaXNhYmxlZCBhbnkKPiAgICBDUlRDcyB0aGF0IG5lZWRlZCBkaXNhYmxpbmcsIGFu ZCBiZWZvcmUgd2UgYmVnaW4gZW5hYmxpbmcvdXBkYXRpbmcKPiAgICBDUlRDcwo+ICAqIEJlY2F1 c2UgcGlwZSBkZGIgYWxsb2NhdGlvbnMgKG5vdCB0aGUgaW5uZXItcGlwZSBkZGIgYWxsb2NhdGlv bnMKPiAgICB0aGF0IGFwcGx5IHRvIGVhY2ggcGlwZSdzIHBsYW5lcykgb25seSBjaGFuZ2Ugd2hp bGUKPiAgICBlbmFibGluZy9kaXNhYmxpbmcgY3J0Y3M6Cj4gICAgICogUGFzcyAxOiBGaW5kIHdo aWNoIHBpcGUncyBuZXcgZGRiIGFsbG9jYXRpb24gd29uJ3Qgb3ZlcmxhcCB3aXRoCj4gICAgICAg YW5vdGhlciBwaXBlJ3MgcHJldmlvdXMgYWxsb2NhdGlvbiwgYW5kIHVwZGF0ZSB0aGF0IHBpcGUg Zmlyc3QKPiAgICAgKiBQYXNzIDI6IFVwZGF0ZSB0aGUgYWxsb2NhdGlvbiBvZiB0aGUgcmVtYWlu aW5nIHBpcGUKPiAKPiBIZXJlJ3MgYW4gaWxsdXN0cmF0aW9uIG9mIHdoYXQgdGhpcyBsb29rcyBs aWtlLiBQYXJ0cyBvZiB0aGUgZGRiIG5vdAo+IGJlaW5nIHVzZWQgYnkgYW55IENSVENzIGFyZSBt YXJrZWQgb3V0IHdpdGggJ3gnczoKPiAKPiBXaXRoIHBpcGUgQSBlbmFibGVkLCB3ZSBlbmFibGUg cGlwZSBCOgo+IEluaXRpYWwgRERCOiDCoCDCoHwgwqAgwqAgwqAgwqAgwqAgQSDCoCDCoCDCoCDC oCDCoCB8Cj4gdXBkYXRlX2RkYnM6IMKgIMKgfCDCoCDCoCBBIMKgIMKgIHx4eHh4eHh4eHh4eHwg UGFzcyAxCj4gRW5hYmxlIHBpcGUgQjogwqB8IMKgIMKgIEEgwqAgwqAgfCDCoCDCoCBCIMKgIMKg IHwKPiAKPiBXaXRoIHBpcGVzIEIgYW5kIEEgYWN0aXZlLCB3ZSBlbmFibGUgcGlwZSBDOgo+IAo+ IEluaXRpYWwgRERCOiDCoCDCoHwgwqAgwqAgQiDCoCDCoCB8IMKgIMKgIEEgwqAgwqAgfAo+IHVw ZGF0ZV9kZGJzOiDCoCDCoHwgwqAgQiDCoCB8eHh4fCDCoCDCoCBBIMKgIMKgIHwgUGFzcyAxCj4g dXBkYXRlX2RkYnM6IMKgIMKgfCDCoCBCIMKgIHwgwqAgQSDCoCB8eHh4eHh4eHwgUGFzcyAyCj4g RW5hYmxlIHBpcGUgQzogwqB8IMKgIEIgwqAgfCDCoCBBIMKgIHwgwqAgQyDCoCB8Cj4gCj4gV2l0 aCBwaXBlcyBBLCBCLCBhbmQgQyBhY3RpdmUsIHdlIGRpc2FibGUgQjoKPiBJbml0aWFsIEREQjog wqAgwqB8IMKgIEEgwqAgfCDCoCBCIMKgIHwgwqAgQyDCoCB8Cj4gRGlzYWJsZSBwaXBlIEI6IHwg wqAgQSDCoCB8eHh4eHh4eHwgwqAgQyDCoCB8Cj4gdXBkYXRlX2RkYnM6IMKgIMKgfCDCoCDCoCBB IMKgIMKgIHwgwqAgwqAgQyDCoCDCoCB8IFBhc3MgMQo+IFNpbmNlIG5laXRoZXIgcGlwZSdzIG5l dyBhbGxvY2F0aW9uIG92ZXJsYXBwZWQsIHdlIHNraXAgcGFzcyAyCj4gCj4gQW5vdGhlciBhbGxv Y2F0aW9uIHdpdGggQSwgQiwgYW5kIEMgYWN0aXZlLCBkaXNhYmxpbmcgQToKPiBJbml0aWFsIERE QjogwqAgwqB8IMKgIEEgwqAgfCDCoCBCIMKgIHwgwqAgQyDCoCB8Cj4gRGlzYWJsZSBwaXBlIEE6 IHx4eHh4eHh4fCDCoCBCIMKgIHwgwqAgQyDCoCB8Cj4gdXBkYXRlX2RkYnM6IMKgIMKgfCDCoCDC oCBCIMKgIMKgIHx4eHh8IMKgIEMgwqAgfCBQYXNzIDEKPiB1cGRhdGVfZGRiczogwqAgwqB8IMKg IMKgIEIgwqAgwqAgfCDCoCDCoCBDIMKgIMKgIHwgUGFzcyAyCj4gCj4gVGhpcyBzaG91bGQgZW5z dXJlIHdlIGNhbiBhbHdheXMgbW92ZSBhcm91bmQgdGhlIGFsbG9jYXRpb25zIG9mIHBpcGVzCj4g d2l0aG91dCB0aGVtIGV2ZXIgb3ZlcmxhcHBpbmcgYW5kIGV4cGxvZGluZy4KClRoYXQncyB3aGF0 IHRoZSBjdXJyZW50IGZsdXNoIHRoaW5nIGRvZXMsIG9yIGF0IGxlYXN0IHRoYXQgd2hhdCBpdCB1 c2VkCnRvIGRvIGF0IGxlYXN0LiBOb3Qgc3VyZSBpdCdzIHJlYWxseSBkb2luZyBpdCBhbnltb3Jl LCBidXQgSSdtIHByZXR0eQpzdXJlIHRoZSBvcmRlciBpbiB3aGljaCBpdCBkaWQgdGhpbmdzIHdh cyBzb3VuZCBhdCBzb21lIHBvaW50LgoKPiAKPiBUaGlzIGJyYW5jaCBkb2Vzbid0IGVudGlyZWx5 IGZpeCB1bmRlcnJ1biBpc3N1ZXMsIGJ1dCBJJ20gbW9zdGx5IHN1cmUKPiB0aGF0J3MgdGhlIGZh dWx0IG9mIHN0aWxsIG5vdCBoYXZpbmcgcmVtb3ZlZCB0aGUgZ2xvYmFsIHdtIHVwZGF0ZSBob29r Cj4geWV0ICh3aGljaCBpcyBsZWFkaW5nIHRvIGFkZGl0aW9uYWwgcGlwZSBmbHVzaGVzIGluIHBs YWNlcyB0aGV5Cj4gc2hvdWxkbid0IGJlKToKCldlbGwgaXQgc2hvdWxkIGJhc2ljYWxseSBib2ls IGRvd24gdG8gcy91cGRhdGVfd20vdXBkYXRlX2RkYi8KT25seSBEREIgcmVhbGxvY2F0aW9uIHJl YWxseSB3YXJyYW50cyBhIGdsb2JhbCBob29rLiBFdmVyeXRoaW5nIGVsc2UKc2hvdWxkIGJlIGhh bmRsZWQgdmlhIHBlci1jcnRjIGhvb2tzLCBvbiBhbGwgcGxhdGZvcm1zLgoKPiAKPiBodHRwczov L2dpdGh1Yi5jb20vbHl1ZGUvbGludXgvdHJlZS93aXAvc2tsLWZpeC13bXMtdjVyMgo+IAo+IEFz IGZvciB1cGRhdGluZyBpbm5lci1waXBlIGRkYiBhbGxvY2F0aW9ucyBmb3IgZWFjaCBwbGFuZSBv biBhIHBpcGUsIHdlCj4gc2hvdWxkIGJlIGFibGUgdG8ganVzdCBkbyB0aGF0IGF0IHRoZSBzYW1l IHRpbWUgd2UgdXBkYXRlIGVhY2ggcGlwZSdzCj4gd2F0ZXJtYXJrcwoKWWVzLgoKTm9uZSBvZiB0 aGF0IGNoYW5nZXMgd2hhdCBJIHNhaWQgYmVmb3JlIHRob3VnaC4gRWl0aGVyIHlvdSBuZWVkIHRv CmxvY2sgZG93biBldmVyeXRoaW5nIHdoZW4gdGhlIEREQiBuZWVkcyB0byBiZSByZXBhcnRpdGlv bmVkLCBvciB5b3UKZG8gd2hhdCBJIG91dGxpbmVkIGluIHRoZSBwcmV2aW91cyBtYWlsLiBPdGhl cndpc2UgYSBwbGFuZSB1cGRhdGUKZXRjLiBoYXBwZW5pbmcgaW4gcGFyYWxsZWwgd2lsbCBzdGls bCBibG93IHVwIG9uIGFjY291bnQgb2YgdGhlIEREQgpzdGF0ZSBjaGFuZ2luZyB1bmRlcm5lYXRo IHRoZSBwbGFuZSB1cGRhdGUgc29tZXdoZXJlIGJldHdlZW4gY29tcHV0ZQphbmQgY29tbWl0LiBJ IGNhbid0IHJlYWxseSB0aGluayBvZiB0aGlyZCBvcHRpb24gdGhhdCB3b3VsZCB3b3JrLgoKPiAK PiBMZXQgbWUga25vdyB3aGF0IHlvdSB0aGluawo+IAlMeXVkZQo+IAo+IE9uIEZyaSwgMjAxNi0w Ny0yOSBhdCAxMjozOSArMDMwMCwgVmlsbGUgU3lyasOkbMOkIHdyb3RlOgo+ID4gT24gVGh1LCBK dWwgMjgsIDIwMTYgYXQgMDU6MDM6NTJQTSAtMDcwMCwgTWF0dCBSb3BlciB3cm90ZToKPiA+ID4g Cj4gPiA+IFRoaXMgaXMgY29tcGxldGVseSB1bnRlc3RlZCAoYW5kIHByb2JhYmx5IGhvcnJpYmx5 IGJyb2tlbi9idWdneSksCj4gPiA+IGJ1dAo+ID4gPiBoZXJlJ3MgYSBxdWljayBtb2NrdXAgb2Yg dGhlIGdlbmVyYWwgYXBwcm9hY2ggSSB3YXMgdGhpbmtpbmcgZm9yCj4gPiA+IGVuc3VyaW5nIERE QiAmIFdNJ3MgY2FuIGJlIHVwZGF0ZWQgdG9nZXRoZXIgd2hpbGUgZW5zdXJpbmcgdGhlCj4gPiA+ IHRocmVlLXN0ZXAgcGlwZSBmbHVzaGluZyBwcm9jZXNzIGlzIGhvbm9yZWQ6Cj4gPiA+IAo+ID4g PiDCoMKgwqDCoMKgwqDCoMKgaHR0cHM6Ly9naXRodWIuY29tL21hdHRyb3BlL2tlcm5lbC9jb21t aXRzL2V4cGVyaW1lbnRhbC9seXUKPiA+ID4gZGVfZGRiCj4gPiA+IAo+ID4gPiBCYXNpY2FsbHkg dGhlIGlkZWEgaXMgdG8gdGFrZSBub3RlIG9mIHdoYXQncyBoYXBwZW5pbmcgdG8gdGhlCj4gPiA+ IHBpcGUncyBEREIKPiA+ID4gYWxsb2NhdGlvbiAoc2hyaW5raW5nLCBncm93aW5nLCB1bmNoYW5n ZWQsIGV0Yy4pIGR1cmluZyB0aGUgYXRvbWljCj4gPiA+IGNoZWNrCj4gPiA+IHBoYXNlOwo+ID4g Cj4gPiBEaWRuJ3QgbG9vayB0b28gY2xvc2VseSwgYnV0IEkgdGhpbmsgeW91IGNhbid0IGFjdHVh bGx5IGRvIHRoYXQKPiA+IHVubGVzcwo+ID4geW91IGxvY2sgYWxsIHRoZSBjcnRjcyB3aGVuZXZl ciB0aGUgbnVtYmVyIG9mIGFjdGl2ZSBwaXBlcyBpcyBnb2luZAo+ID4gdG8KPiA+IGNoYW5nZS4g TWVhbmluZyB3ZSdkIGVzc2VudGlhbGx5IGJlIGJhY2sgdG8gdGhlIG9uZS1iaWctbW9kZXNldC1s b2NrCj4gPiBhcHBvcmFjaCwgd2hpY2ggd2lsbCBjYXVzZSBtaXNzZWQgZmxpcHMgYW5kIHdoYW5v dCBvbiB0aGUgb3RoZXIKPiA+IHBpcGVzLgo+ID4gCj4gPiBUaGUgYWx0ZXJuYXRpdmUgSSB0aGlu ayB3b3VsZCBjb25zaXN0IG9mOgo+ID4gLSBtYWtlIHN1cmUgbGV2ZWwgMCB3YXRlcm1hcmsgbmV2 ZXIgZXhjZWVkcyB0b3RhbF9kZGJfc2l6ZS9tYXhfcGlwZXMsCj4gPiDCoCBzbyB0aGF0IGEgbW9k ZXNldCBkb2Vzbid0IGhhdmUgdG8gY2FyZSBhYm91dCB0aGUgd21zIGZvciB0aGUgb3RoZXIKPiA+ IMKgIHBpcGVzIG5vdCBmaXR0aW5nIGluCj4gPiAtIGxldmVsIDErIHdhdGVybWFya3Mgd291bGQg YmUgY2hlY2tlZCBhZ2FpbnN0IHRvdGFsX2RkYl9zaXplCj4gPiAtIHByb3RlY3QgdGhlIHBsYW5l L3BpcGUgY29tbWl0IHdpdGggdGhlIHdtIG11dGV4IHdoZW5ldmVyIHRoZSB3bXMKPiA+IMKgIG5l ZWQgdG8gYmUgcmVwcm9ncmFtbWVkCj4gPiAtIGtlZXAgdGhlIGZsdXNoX3dtIHRoaW5nIGFyb3Vu ZCBmb3IgdGhlIGNhc2Ugd2hlbiBkZGIgc2l6ZSBkb2VzIGdldAo+ID4gwqAgY2hhbmdlZCwgcHJv dGVjdCBpdCB3aXRoIHRoZSB3bSBsb2NrCj4gPiAtIHdoZW4gcHJvZ3JhbW1pbmcgd21zLCB3ZSB3 aWxsIGZpcnN0IGZpbHRlciBvdXQgYW55IGxldmVsIHRoYXQKPiA+IMKgIGRvZXNuJ3QgZml0IGlu IHdpdGggdGhlIGN1cnJlbnQgZGRiIHNpemUsIGFuZCB0aGVuIHByb2dyYW0gdGhlCj4gPiDCoCBy ZXN0IGluCj4gPiAtIHBvdGVudGlhbGx5IGludHJvZHVjZSBwZXItcGlwZSB3bSBsb2NrcyBpZiB0 aGUgb25lIGJpZyBsb2NrIGxvb2tzCj4gPiDCoCBsaWtlIGFuIGlzc3VlLCB3aGljaCBpdCBtaWdo dCBpZiB0aGUgZmx1c2hfd20gaG9sZHMgaXQgYWxsIHRoZSB3YXkKPiA+IMKgIHRocm91Z2gKPiA+ IAo+ID4gPiAKPiA+ID4gdGhlbiBkdXJpbmcgdGhlIGNvbW1pdCBwaGFzZSwgd2UgbG9vcCBvdmVy IHRoZSBDUlRDJ3MgdGhyZWUgdGltZXMKPiA+ID4gaW5zdGVhZCBvZiBqdXN0IG9uY2UsIGJ1dCBv bmx5IG9wZXJhdGUgb24gYSBzdWJzZXQgb2YgdGhlIENSVEMncyBpbgo+ID4gPiBlYWNoCj4gPiA+ IGxvb3AuwqDCoFdoaWxlIG9wZXJhdGluZyBvbiBlYWNoIENSVEMsIHRoZSBwbGFuZSwgV00sIGFu ZCBEREIgYWxsIGdldAo+ID4gPiBwcm9ncmFtbWVkIHRvZ2V0aGVyIGFuZCBoYXZlIGEgc2luZ2xl IGZsdXNoIGZvciBhbGwgdGhyZWUuCj4gPiA+IAo+ID4gPiAKPiA+ID4gCj4gPiA+IAo+ID4gPiBN YXR0Cj4gPiA+IAo+ID4gPiBPbiBUdWUsIEp1bCAyNiwgMjAxNiBhdCAwMTozNDozNlBNIC0wNDAw LCBMeXVkZSB3cm90ZToKPiA+ID4gPiAKPiA+ID4gPiBMYXRlc3QgdmVyc2lvbiBvZiBodHRwczov L2xrbWwub3JnL2xrbWwvMjAxNi83LzI2LzI5MCAuIFJlc2VuZGluZwo+ID4gPiA+IHRoZSB3aG9s ZQo+ID4gPiA+IHRoaW5nIHRvIGtlZXAgaXQgaW4gb25lIHBsYWNlLgo+ID4gPiA+IAo+ID4gPiA+ IEx5dWRlICg1KToKPiA+ID4gPiDCoCBkcm0vaTkxNS9za2w6IEFkZCBzdXBwb3J0IGZvciB0aGUg U0FHViwgZml4IHVuZGVycnVuIGhhbmdzCj4gPiA+ID4gwqAgZHJtL2k5MTUvc2tsOiBPbmx5IGZs dXNoIHBpcGVzIHdoZW4gd2UgY2hhbmdlIHRoZSBkZGIKPiA+ID4gPiBhbGxvY2F0aW9uCj4gPiA+ ID4gwqAgZHJtL2k5MTUvc2tsOiBGaXggZXh0cmEgd2hpdGVzcGFjZSBpbiBza2xfZmx1c2hfd21f dmFsdWVzKCkKPiA+ID4gPiDCoCBkcm0vaTkxNS9za2w6IFVwZGF0ZSBwbGFuZSB3YXRlcm1hcmtz IGF0b21pY2FsbHkgZHVyaW5nIHBsYW5lCj4gPiA+ID4gdXBkYXRlcwo+ID4gPiA+IMKgIGRybS9p OTE1L3NrbDogQWx3YXlzIHdhaXQgZm9yIHBpcGVzIHRvIHVwZGF0ZSBhZnRlciBhIGZsdXNoCj4g PiA+ID4gCj4gPiA+ID4gTWF0dCBSb3BlciAoMSk6Cj4gPiA+ID4gwqAgZHJtL2k5MTUvZ2VuOTog T25seSBjb3B5IFdNIHJlc3VsdHMgZm9yIGNoYW5nZWQgcGlwZXMgdG8gc2tsX2h3Cj4gPiA+ID4g Cj4gPiA+ID4gwqBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5owqDCoMKgwqDCoMKgfMKg wqDCoDMgKwo+ID4gPiA+IMKgZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9yZWcuaMKgwqDCoMKg wqDCoHzCoMKgwqA1ICsKPiA+ID4gPiDCoGRyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rpc3Bs YXkuYyB8wqDCoDI0ICsrKysKPiA+ID4gPiDCoGRyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Ry di5owqDCoMKgwqDCoHzCoMKgwqA0ICsKPiA+ID4gPiDCoGRyaXZlcnMvZ3B1L2RybS9pOTE1L2lu dGVsX3BtLmPCoMKgwqDCoMKgwqB8IDI0MAo+ID4gPiA+ICsrKysrKysrKysrKysrKysrKysrKysr KysrKysrKystLS0tCj4gPiA+ID4gwqBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9zcHJpdGUu Y8KgwqB8wqDCoMKgMiArCj4gPiA+ID4gwqA2IGZpbGVzIGNoYW5nZWQsIDI1NSBpbnNlcnRpb25z KCspLCAyMyBkZWxldGlvbnMoLSkKPiA+ID4gPiAKPiA+ID4gPiAtLcKgCj4gPiA+ID4gMi43LjQK PiA+ID4gPiAKPiA+ID4gPiBfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fXwo+ID4gPiA+IEludGVsLWdmeCBtYWlsaW5nIGxpc3QKPiA+ID4gPiBJbnRlbC1nZnhA bGlzdHMuZnJlZWRlc2t0b3Aub3JnCj4gPiA+ID4gaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5v cmcvbWFpbG1hbi9saXN0aW5mby9pbnRlbC1nZngKPiA+ID4gCj4gPiA+IC0twqAKPiA+ID4gTWF0 dCBSb3Blcgo+ID4gPiBHcmFwaGljcyBTb2Z0d2FyZSBFbmdpbmVlcgo+ID4gPiBJb1RHIFBsYXRm b3JtIEVuYWJsaW5nICYgRGV2ZWxvcG1lbnQKPiA+ID4gSW50ZWwgQ29ycG9yYXRpb24KPiA+ID4g KDkxNikgMzU2LTI3OTUKPiA+IAo+IC0tIAo+IENoZWVycywKPiAJTHl1ZGUKCi0tIApWaWxsZSBT eXJqw6Rsw6QKSW50ZWwgT1RDCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fCkludGVsLWdmeCBtYWlsaW5nIGxpc3QKSW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNr dG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2lu dGVsLWdmeAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752512AbcG2T0j (ORCPT ); Fri, 29 Jul 2016 15:26:39 -0400 Received: from mga14.intel.com ([192.55.52.115]:43089 "EHLO mga14.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750923AbcG2T03 (ORCPT ); Fri, 29 Jul 2016 15:26:29 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.28,441,1464678000"; d="scan'208";a="1031683655" Date: Fri, 29 Jul 2016 22:26:20 +0300 From: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= To: Lyude Cc: Matt Roper , 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: <20160729192620.GK4329@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> MIME-Version: 1.0 Content-Type: text/plain; charset=iso-8859-1 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <1469818089.23735.32.camel@redhat.com> User-Agent: Mutt/1.5.24 (2015-08-30) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org 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. > > 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. > > 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