From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-wm0-f45.google.com (mail-wm0-f45.google.com [74.125.82.45]) by kanga.kvack.org (Postfix) with ESMTP id 953DD6B025B for ; Fri, 4 Dec 2015 10:59:10 -0500 (EST) Received: by wmec201 with SMTP id c201so70899450wme.1 for ; Fri, 04 Dec 2015 07:59:10 -0800 (PST) Received: from fireflyinternet.com (mail.fireflyinternet.com. [87.106.93.118]) by mx.google.com with ESMTP id up7si19358527wjc.121.2015.12.04.07.59.09 for ; Fri, 04 Dec 2015 07:59:09 -0800 (PST) From: Chris Wilson Subject: [PATCH v2 2/2] drm/i915: Disable shrinker for non-swapped backed objects Date: Fri, 4 Dec 2015 15:58:54 +0000 Message-Id: <1449244734-25733-2-git-send-email-chris@chris-wilson.co.uk> In-Reply-To: <1449244734-25733-1-git-send-email-chris@chris-wilson.co.uk> References: <1449244734-25733-1-git-send-email-chris@chris-wilson.co.uk> Sender: owner-linux-mm@kvack.org List-ID: To: intel-gfx@lists.freedesktop.org Cc: Chris Wilson , linux-mm@kvack.org, Akash Goel , sourab.gupta@intel.com If the system has no available swap pages, we cannot make forward progress in the shrinker by releasing active pages, only by releasing purgeable pages which are immediately reaped. Take total_swap_pages into account when counting up available objects to be shrunk and subsequently shrinking them. By doing so, we avoid unbinding objects that cannot be shrunk and so wasting CPU cycles flushing those objects from the GPU to the system and then immediately back again (as they will more than likely be reused shortly after). Based on a patch by Akash Goel. v2: frontswap registers extra swap pages available for the system, so it is already include in the count of available swap pages. v3: Use get_nr_swap_pages() to query the currently available amount of swap space. This should also stop us from shrinking the GPU buffers if we ever run out of swap space. Though at that point, we would expect the oom-notifier to be running and failing miserably... Reported-by: Akash Goel Signed-off-by: Chris Wilson Cc: linux-mm@kvack.org Cc: Akash Goel Cc: sourab.gupta@intel.com --- drivers/gpu/drm/i915/i915_gem_shrinker.c | 60 +++++++++++++++++++++++--------- 1 file changed, 44 insertions(+), 16 deletions(-) diff --git a/drivers/gpu/drm/i915/i915_gem_shrinker.c b/drivers/gpu/drm/i915/i915_gem_shrinker.c index f7df54a8ee2b..16da9c1422cc 100644 --- a/drivers/gpu/drm/i915/i915_gem_shrinker.c +++ b/drivers/gpu/drm/i915/i915_gem_shrinker.c @@ -47,6 +47,46 @@ static bool mutex_is_locked_by(struct mutex *mutex, struct task_struct *task) #endif } +static int num_vma_bound(struct drm_i915_gem_object *obj) +{ + struct i915_vma *vma; + int count = 0; + + list_for_each_entry(vma, &obj->vma_list, vma_link) { + if (drm_mm_node_allocated(&vma->node)) + count++; + if (vma->pin_count) + count++; + } + + return count; +} + +static bool swap_available(void) +{ + return get_nr_swap_pages() > 0; +} + +static bool can_release_pages(struct drm_i915_gem_object *obj) +{ + /* Only report true if by unbinding the object and putting its pages + * we can actually make forward progress towards freeing physical + * pages. + * + * If the pages are pinned for any other reason than being bound + * to the GPU, simply unbinding from the GPU is not going to succeed + * in releasing our pin count on the pages themselves. + */ + if (obj->pages_pin_count != num_vma_bound(obj)) + return false; + + /* We can only return physical pages to the system if we can either + * discard the contents (because the user has marked them as being + * purgeable) or if we can move their contents out to swap. + */ + return swap_available() || obj->madv == I915_MADV_DONTNEED; +} + /** * i915_gem_shrink - Shrink buffer object caches * @dev_priv: i915 device @@ -129,6 +169,9 @@ i915_gem_shrink(struct drm_i915_private *dev_priv, if ((flags & I915_SHRINK_ACTIVE) == 0 && obj->active) continue; + if (!can_release_pages(obj)) + continue; + drm_gem_object_reference(&obj->base); /* For the unbound phase, this should be a no-op! */ @@ -188,21 +231,6 @@ static bool i915_gem_shrinker_lock(struct drm_device *dev, bool *unlock) return true; } -static int num_vma_bound(struct drm_i915_gem_object *obj) -{ - struct i915_vma *vma; - int count = 0; - - list_for_each_entry(vma, &obj->vma_list, vma_link) { - if (drm_mm_node_allocated(&vma->node)) - count++; - if (vma->pin_count) - count++; - } - - return count; -} - static unsigned long i915_gem_shrinker_count(struct shrinker *shrinker, struct shrink_control *sc) { @@ -222,7 +250,7 @@ i915_gem_shrinker_count(struct shrinker *shrinker, struct shrink_control *sc) count += obj->base.size >> PAGE_SHIFT; list_for_each_entry(obj, &dev_priv->mm.bound_list, global_list) { - if (!obj->active && obj->pages_pin_count == num_vma_bound(obj)) + if (!obj->active && can_release_pages(obj)) count += obj->base.size >> PAGE_SHIFT; } -- 2.6.2 -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to majordomo@kvack.org. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: email@kvack.org From mboxrd@z Thu Jan 1 00:00:00 1970 From: Chris Wilson Subject: [PATCH v2 2/2] drm/i915: Disable shrinker for non-swapped backed objects Date: Fri, 4 Dec 2015 15:58:54 +0000 Message-ID: <1449244734-25733-2-git-send-email-chris@chris-wilson.co.uk> References: <1449244734-25733-1-git-send-email-chris@chris-wilson.co.uk> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from fireflyinternet.com (mail.fireflyinternet.com [87.106.93.118]) by gabe.freedesktop.org (Postfix) with ESMTP id 19A086E055 for ; Fri, 4 Dec 2015 07:59:11 -0800 (PST) In-Reply-To: <1449244734-25733-1-git-send-email-chris@chris-wilson.co.uk> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: intel-gfx@lists.freedesktop.org Cc: linux-mm@kvack.org, Akash Goel , sourab.gupta@intel.com List-Id: intel-gfx@lists.freedesktop.org SWYgdGhlIHN5c3RlbSBoYXMgbm8gYXZhaWxhYmxlIHN3YXAgcGFnZXMsIHdlIGNhbm5vdCBtYWtl IGZvcndhcmQKcHJvZ3Jlc3MgaW4gdGhlIHNocmlua2VyIGJ5IHJlbGVhc2luZyBhY3RpdmUgcGFn ZXMsIG9ubHkgYnkgcmVsZWFzaW5nCnB1cmdlYWJsZSBwYWdlcyB3aGljaCBhcmUgaW1tZWRpYXRl bHkgcmVhcGVkLiBUYWtlIHRvdGFsX3N3YXBfcGFnZXMgaW50bwphY2NvdW50IHdoZW4gY291bnRp bmcgdXAgYXZhaWxhYmxlIG9iamVjdHMgdG8gYmUgc2hydW5rIGFuZCBzdWJzZXF1ZW50bHkKc2hy aW5raW5nIHRoZW0uIEJ5IGRvaW5nIHNvLCB3ZSBhdm9pZCB1bmJpbmRpbmcgb2JqZWN0cyB0aGF0 IGNhbm5vdCBiZQpzaHJ1bmsgYW5kIHNvIHdhc3RpbmcgQ1BVIGN5Y2xlcyBmbHVzaGluZyB0aG9z ZSBvYmplY3RzIGZyb20gdGhlIEdQVSB0bwp0aGUgc3lzdGVtIGFuZCB0aGVuIGltbWVkaWF0ZWx5 IGJhY2sgYWdhaW4gKGFzIHRoZXkgd2lsbCBtb3JlIHRoYW4KbGlrZWx5IGJlIHJldXNlZCBzaG9y dGx5IGFmdGVyKS4KCkJhc2VkIG9uIGEgcGF0Y2ggYnkgQWthc2ggR29lbC4KCnYyOiBmcm9udHN3 YXAgcmVnaXN0ZXJzIGV4dHJhIHN3YXAgcGFnZXMgYXZhaWxhYmxlIGZvciB0aGUgc3lzdGVtLCBz byBpdAppcyBhbHJlYWR5IGluY2x1ZGUgaW4gdGhlIGNvdW50IG9mIGF2YWlsYWJsZSBzd2FwIHBh Z2VzLgoKdjM6IFVzZSBnZXRfbnJfc3dhcF9wYWdlcygpIHRvIHF1ZXJ5IHRoZSBjdXJyZW50bHkg YXZhaWxhYmxlIGFtb3VudCBvZgpzd2FwIHNwYWNlLiBUaGlzIHNob3VsZCBhbHNvIHN0b3AgdXMg ZnJvbSBzaHJpbmtpbmcgdGhlIEdQVSBidWZmZXJzIGlmCndlIGV2ZXIgcnVuIG91dCBvZiBzd2Fw IHNwYWNlLiBUaG91Z2ggYXQgdGhhdCBwb2ludCwgd2Ugd291bGQgZXhwZWN0IHRoZQpvb20tbm90 aWZpZXIgdG8gYmUgcnVubmluZyBhbmQgZmFpbGluZyBtaXNlcmFibHkuLi4KClJlcG9ydGVkLWJ5 OiBBa2FzaCBHb2VsIDxha2FzaC5nb2VsQGludGVsLmNvbT4KU2lnbmVkLW9mZi1ieTogQ2hyaXMg V2lsc29uIDxjaHJpc0BjaHJpcy13aWxzb24uY28udWs+CkNjOiBsaW51eC1tbUBrdmFjay5vcmcK Q2M6IEFrYXNoIEdvZWwgPGFrYXNoLmdvZWxAaW50ZWwuY29tPgpDYzogc291cmFiLmd1cHRhQGlu dGVsLmNvbQotLS0KIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2VtX3Nocmlua2VyLmMgfCA2 MCArKysrKysrKysrKysrKysrKysrKysrKy0tLS0tLS0tLQogMSBmaWxlIGNoYW5nZWQsIDQ0IGlu c2VydGlvbnMoKyksIDE2IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2k5MTVfZ2VtX3Nocmlua2VyLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2dl bV9zaHJpbmtlci5jCmluZGV4IGY3ZGY1NGE4ZWUyYi4uMTZkYTljMTQyMmNjIDEwMDY0NAotLS0g YS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2dlbV9zaHJpbmtlci5jCisrKyBiL2RyaXZlcnMv Z3B1L2RybS9pOTE1L2k5MTVfZ2VtX3Nocmlua2VyLmMKQEAgLTQ3LDYgKzQ3LDQ2IEBAIHN0YXRp YyBib29sIG11dGV4X2lzX2xvY2tlZF9ieShzdHJ1Y3QgbXV0ZXggKm11dGV4LCBzdHJ1Y3QgdGFz a19zdHJ1Y3QgKnRhc2spCiAjZW5kaWYKIH0KIAorc3RhdGljIGludCBudW1fdm1hX2JvdW5kKHN0 cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmopCit7CisJc3RydWN0IGk5MTVfdm1hICp2bWE7 CisJaW50IGNvdW50ID0gMDsKKworCWxpc3RfZm9yX2VhY2hfZW50cnkodm1hLCAmb2JqLT52bWFf bGlzdCwgdm1hX2xpbmspIHsKKwkJaWYgKGRybV9tbV9ub2RlX2FsbG9jYXRlZCgmdm1hLT5ub2Rl KSkKKwkJCWNvdW50Kys7CisJCWlmICh2bWEtPnBpbl9jb3VudCkKKwkJCWNvdW50Kys7CisJfQor CisJcmV0dXJuIGNvdW50OworfQorCitzdGF0aWMgYm9vbCBzd2FwX2F2YWlsYWJsZSh2b2lkKQor eworCXJldHVybiBnZXRfbnJfc3dhcF9wYWdlcygpID4gMDsKK30KKworc3RhdGljIGJvb2wgY2Fu X3JlbGVhc2VfcGFnZXMoc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaikKK3sKKwkvKiBP bmx5IHJlcG9ydCB0cnVlIGlmIGJ5IHVuYmluZGluZyB0aGUgb2JqZWN0IGFuZCBwdXR0aW5nIGl0 cyBwYWdlcworCSAqIHdlIGNhbiBhY3R1YWxseSBtYWtlIGZvcndhcmQgcHJvZ3Jlc3MgdG93YXJk cyBmcmVlaW5nIHBoeXNpY2FsCisJICogcGFnZXMuCisJICoKKwkgKiBJZiB0aGUgcGFnZXMgYXJl IHBpbm5lZCBmb3IgYW55IG90aGVyIHJlYXNvbiB0aGFuIGJlaW5nIGJvdW5kCisJICogdG8gdGhl IEdQVSwgc2ltcGx5IHVuYmluZGluZyBmcm9tIHRoZSBHUFUgaXMgbm90IGdvaW5nIHRvIHN1Y2Nl ZWQKKwkgKiBpbiByZWxlYXNpbmcgb3VyIHBpbiBjb3VudCBvbiB0aGUgcGFnZXMgdGhlbXNlbHZl cy4KKwkgKi8KKwlpZiAob2JqLT5wYWdlc19waW5fY291bnQgIT0gbnVtX3ZtYV9ib3VuZChvYmop KQorCQlyZXR1cm4gZmFsc2U7CisKKwkvKiBXZSBjYW4gb25seSByZXR1cm4gcGh5c2ljYWwgcGFn ZXMgdG8gdGhlIHN5c3RlbSBpZiB3ZSBjYW4gZWl0aGVyCisJICogZGlzY2FyZCB0aGUgY29udGVu dHMgKGJlY2F1c2UgdGhlIHVzZXIgaGFzIG1hcmtlZCB0aGVtIGFzIGJlaW5nCisJICogcHVyZ2Vh YmxlKSBvciBpZiB3ZSBjYW4gbW92ZSB0aGVpciBjb250ZW50cyBvdXQgdG8gc3dhcC4KKwkgKi8K KwlyZXR1cm4gc3dhcF9hdmFpbGFibGUoKSB8fCBvYmotPm1hZHYgPT0gSTkxNV9NQURWX0RPTlRO RUVEOworfQorCiAvKioKICAqIGk5MTVfZ2VtX3NocmluayAtIFNocmluayBidWZmZXIgb2JqZWN0 IGNhY2hlcwogICogQGRldl9wcml2OiBpOTE1IGRldmljZQpAQCAtMTI5LDYgKzE2OSw5IEBAIGk5 MTVfZ2VtX3NocmluayhzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYsCiAJCQlpZiAo KGZsYWdzICYgSTkxNV9TSFJJTktfQUNUSVZFKSA9PSAwICYmIG9iai0+YWN0aXZlKQogCQkJCWNv bnRpbnVlOwogCisJCQlpZiAoIWNhbl9yZWxlYXNlX3BhZ2VzKG9iaikpCisJCQkJY29udGludWU7 CisKIAkJCWRybV9nZW1fb2JqZWN0X3JlZmVyZW5jZSgmb2JqLT5iYXNlKTsKIAogCQkJLyogRm9y IHRoZSB1bmJvdW5kIHBoYXNlLCB0aGlzIHNob3VsZCBiZSBhIG5vLW9wISAqLwpAQCAtMTg4LDIx ICsyMzEsNiBAQCBzdGF0aWMgYm9vbCBpOTE1X2dlbV9zaHJpbmtlcl9sb2NrKHN0cnVjdCBkcm1f ZGV2aWNlICpkZXYsIGJvb2wgKnVubG9jaykKIAlyZXR1cm4gdHJ1ZTsKIH0KIAotc3RhdGljIGlu dCBudW1fdm1hX2JvdW5kKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmopCi17Ci0Jc3Ry dWN0IGk5MTVfdm1hICp2bWE7Ci0JaW50IGNvdW50ID0gMDsKLQotCWxpc3RfZm9yX2VhY2hfZW50 cnkodm1hLCAmb2JqLT52bWFfbGlzdCwgdm1hX2xpbmspIHsKLQkJaWYgKGRybV9tbV9ub2RlX2Fs bG9jYXRlZCgmdm1hLT5ub2RlKSkKLQkJCWNvdW50Kys7Ci0JCWlmICh2bWEtPnBpbl9jb3VudCkK LQkJCWNvdW50Kys7Ci0JfQotCi0JcmV0dXJuIGNvdW50OwotfQotCiBzdGF0aWMgdW5zaWduZWQg bG9uZwogaTkxNV9nZW1fc2hyaW5rZXJfY291bnQoc3RydWN0IHNocmlua2VyICpzaHJpbmtlciwg c3RydWN0IHNocmlua19jb250cm9sICpzYykKIHsKQEAgLTIyMiw3ICsyNTAsNyBAQCBpOTE1X2dl bV9zaHJpbmtlcl9jb3VudChzdHJ1Y3Qgc2hyaW5rZXIgKnNocmlua2VyLCBzdHJ1Y3Qgc2hyaW5r X2NvbnRyb2wgKnNjKQogCQkJY291bnQgKz0gb2JqLT5iYXNlLnNpemUgPj4gUEFHRV9TSElGVDsK IAogCWxpc3RfZm9yX2VhY2hfZW50cnkob2JqLCAmZGV2X3ByaXYtPm1tLmJvdW5kX2xpc3QsIGds b2JhbF9saXN0KSB7Ci0JCWlmICghb2JqLT5hY3RpdmUgJiYgb2JqLT5wYWdlc19waW5fY291bnQg PT0gbnVtX3ZtYV9ib3VuZChvYmopKQorCQlpZiAoIW9iai0+YWN0aXZlICYmIGNhbl9yZWxlYXNl X3BhZ2VzKG9iaikpCiAJCQljb3VudCArPSBvYmotPmJhc2Uuc2l6ZSA+PiBQQUdFX1NISUZUOwog CX0KIAotLSAKMi42LjIKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fCkludGVsLWdmeCBtYWlsaW5nIGxpc3QKSW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9w Lm9yZwpodHRwOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vaW50ZWwt Z2Z4Cg==