From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1758316AbcFANLc (ORCPT ); Wed, 1 Jun 2016 09:11:32 -0400 Received: from pegasos-out.vodafone.de ([80.84.1.38]:34161 "EHLO pegasos-out.vodafone.de" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1758149AbcFANK0 (ORCPT ); Wed, 1 Jun 2016 09:10:26 -0400 X-Spam-Flag: NO X-Spam-Score: -0.045 Authentication-Results: rohrpostix2.prod.vfnet.de (amavisd-new); dkim=pass header.i=@vodafone.de X-DKIM: OpenDKIM Filter v2.6.8 pegasos-out.vodafone.de 1C67B5E0123 From: =?UTF-8?q?Christian=20K=C3=B6nig?= To: dri-devel@lists.freedesktop.org Cc: linux-kernel@vger.kernel.org, daniel@ffwll.ch, chris@chris-wilson.co.uk, gustavo@padovan.org Subject: [PATCH 09/11] drm/amdgpu: reuse VMIDs assigned to a VM only if there is also a free one Date: Wed, 1 Jun 2016 15:10:10 +0200 Message-Id: <1464786612-5010-10-git-send-email-deathsimple@vodafone.de> X-Mailer: git-send-email 2.5.0 In-Reply-To: <1464786612-5010-1-git-send-email-deathsimple@vodafone.de> References: <1464786612-5010-1-git-send-email-deathsimple@vodafone.de> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: Christian König This fixes a fairness problem with the GPU scheduler. VM having lot of jobs could previously starve VM with less jobs. Signed-off-by: Christian König --- drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c | 113 +++++++++++++++++---------------- 1 file changed, 59 insertions(+), 54 deletions(-) diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c index b6484a2..f206820 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c @@ -179,75 +179,80 @@ int amdgpu_vm_grab_id(struct amdgpu_vm *vm, struct amdgpu_ring *ring, uint64_t pd_addr = amdgpu_bo_gpu_offset(vm->page_directory); struct amdgpu_device *adev = ring->adev; struct fence *updates = sync->last_vm_update; - struct amdgpu_vm_id *id; + struct amdgpu_vm_id *id, *idle; unsigned i = ring->idx; int r; mutex_lock(&adev->vm_manager.lock); - /* Check if we can use a VMID already assigned to this VM */ - do { - struct fence *flushed; - - id = vm->ids[i++]; - if (i == AMDGPU_MAX_RINGS) - i = 0; - - /* Check all the prerequisites to using this VMID */ - if (!id) - continue; - - if (atomic64_read(&id->owner) != vm->client_id) - continue; - - if (pd_addr != id->pd_gpu_addr) - continue; + /* Check if we have an idle VMID */ + list_for_each_entry(idle, &adev->vm_manager.ids_lru, list) { + if (amdgpu_sync_is_idle(&idle->active, ring)) + break; - if (id->last_user != ring && - (!id->last_flush || !fence_is_signaled(id->last_flush))) - continue; + } - flushed = id->flushed_updates; - if (updates && (!flushed || fence_is_later(updates, flushed))) - continue; + /* If we can't find a idle VMID to use, just wait for the oldest */ + if (&idle->list == &adev->vm_manager.ids_lru) { + id = list_first_entry(&adev->vm_manager.ids_lru, + struct amdgpu_vm_id, + list); + } else { + /* Check if we can use a VMID already assigned to this VM */ + do { + struct fence *flushed; + + id = vm->ids[i++]; + if (i == AMDGPU_MAX_RINGS) + i = 0; + + /* Check all the prerequisites to using this VMID */ + if (!id) + continue; + + if (atomic64_read(&id->owner) != vm->client_id) + continue; + + if (pd_addr != id->pd_gpu_addr) + continue; + + if (id->last_user != ring && (!id->last_flush || + !fence_is_signaled(id->last_flush))) + continue; + + flushed = id->flushed_updates; + if (updates && (!flushed || + fence_is_later(updates, flushed))) + continue; + + /* Good we can use this VMID */ + if (id->last_user == ring) { + r = amdgpu_sync_fence(ring->adev, sync, + id->first); + if (r) + goto error; + } - /* Good we can use this VMID */ - if (id->last_user == ring) { - r = amdgpu_sync_fence(ring->adev, sync, - id->first); + /* And remember this submission as user of the VMID */ + r = amdgpu_sync_fence(ring->adev, &id->active, fence); if (r) goto error; - } - - /* And remember this submission as user of the VMID */ - r = amdgpu_sync_fence(ring->adev, &id->active, fence); - if (r) - goto error; - list_move_tail(&id->list, &adev->vm_manager.ids_lru); - vm->ids[ring->idx] = id; + list_move_tail(&id->list, &adev->vm_manager.ids_lru); + vm->ids[ring->idx] = id; - *vm_id = id - adev->vm_manager.ids; - *vm_pd_addr = AMDGPU_VM_NO_FLUSH; - trace_amdgpu_vm_grab_id(vm, ring->idx, *vm_id, *vm_pd_addr); + *vm_id = id - adev->vm_manager.ids; + *vm_pd_addr = AMDGPU_VM_NO_FLUSH; + trace_amdgpu_vm_grab_id(vm, ring->idx, *vm_id, + *vm_pd_addr); - mutex_unlock(&adev->vm_manager.lock); - return 0; + mutex_unlock(&adev->vm_manager.lock); + return 0; - } while (i != ring->idx); + } while (i != ring->idx); - /* Check if we have an idle VMID */ - list_for_each_entry(id, &adev->vm_manager.ids_lru, list) { - if (amdgpu_sync_is_idle(&id->active, ring)) - break; - - } - - /* If we can't find a idle VMID to use, just wait for the oldest */ - if (&id->list == &adev->vm_manager.ids_lru) { - id = list_first_entry(&adev->vm_manager.ids_lru, - struct amdgpu_vm_id, - list); + /* Still no ID to use? Then use the idle one found earlier */ + id = idle; } r = amdgpu_sync_cycle_fences(sync, &id->active, fence); -- 2.5.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: =?UTF-8?q?Christian=20K=C3=B6nig?= Subject: [PATCH 09/11] drm/amdgpu: reuse VMIDs assigned to a VM only if there is also a free one Date: Wed, 1 Jun 2016 15:10:10 +0200 Message-ID: <1464786612-5010-10-git-send-email-deathsimple@vodafone.de> References: <1464786612-5010-1-git-send-email-deathsimple@vodafone.de> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from pegasos-out.vodafone.de (pegasos-out.vodafone.de [80.84.1.38]) by gabe.freedesktop.org (Postfix) with ESMTP id B25966E9A7 for ; Wed, 1 Jun 2016 13:10:27 +0000 (UTC) In-Reply-To: <1464786612-5010-1-git-send-email-deathsimple@vodafone.de> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: dri-devel@lists.freedesktop.org Cc: linux-kernel@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org RnJvbTogQ2hyaXN0aWFuIEvDtm5pZyA8Y2hyaXN0aWFuLmtvZW5pZ0BhbWQuY29tPgoKVGhpcyBm aXhlcyBhIGZhaXJuZXNzIHByb2JsZW0gd2l0aCB0aGUgR1BVIHNjaGVkdWxlci4gVk0gaGF2aW5n IGxvdCBvZgpqb2JzIGNvdWxkIHByZXZpb3VzbHkgc3RhcnZlIFZNIHdpdGggbGVzcyBqb2JzLgoK U2lnbmVkLW9mZi1ieTogQ2hyaXN0aWFuIEvDtm5pZyA8Y2hyaXN0aWFuLmtvZW5pZ0BhbWQuY29t PgotLS0KIGRyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV92bS5jIHwgMTEzICsrKysr KysrKysrKysrKysrLS0tLS0tLS0tLS0tLS0tLQogMSBmaWxlIGNoYW5nZWQsIDU5IGluc2VydGlv bnMoKyksIDU0IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9hbWQv YW1kZ3B1L2FtZGdwdV92bS5jIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X3Zt LmMKaW5kZXggYjY0ODRhMi4uZjIwNjgyMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2Ft ZC9hbWRncHUvYW1kZ3B1X3ZtLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1k Z3B1X3ZtLmMKQEAgLTE3OSw3NSArMTc5LDgwIEBAIGludCBhbWRncHVfdm1fZ3JhYl9pZChzdHJ1 Y3QgYW1kZ3B1X3ZtICp2bSwgc3RydWN0IGFtZGdwdV9yaW5nICpyaW5nLAogCXVpbnQ2NF90IHBk X2FkZHIgPSBhbWRncHVfYm9fZ3B1X29mZnNldCh2bS0+cGFnZV9kaXJlY3RvcnkpOwogCXN0cnVj dCBhbWRncHVfZGV2aWNlICphZGV2ID0gcmluZy0+YWRldjsKIAlzdHJ1Y3QgZmVuY2UgKnVwZGF0 ZXMgPSBzeW5jLT5sYXN0X3ZtX3VwZGF0ZTsKLQlzdHJ1Y3QgYW1kZ3B1X3ZtX2lkICppZDsKKwlz dHJ1Y3QgYW1kZ3B1X3ZtX2lkICppZCwgKmlkbGU7CiAJdW5zaWduZWQgaSA9IHJpbmctPmlkeDsK IAlpbnQgcjsKIAogCW11dGV4X2xvY2soJmFkZXYtPnZtX21hbmFnZXIubG9jayk7CiAKLQkvKiBD aGVjayBpZiB3ZSBjYW4gdXNlIGEgVk1JRCBhbHJlYWR5IGFzc2lnbmVkIHRvIHRoaXMgVk0gKi8K LQlkbyB7Ci0JCXN0cnVjdCBmZW5jZSAqZmx1c2hlZDsKLQotCQlpZCA9IHZtLT5pZHNbaSsrXTsK LQkJaWYgKGkgPT0gQU1ER1BVX01BWF9SSU5HUykKLQkJCWkgPSAwOwotCi0JCS8qIENoZWNrIGFs bCB0aGUgcHJlcmVxdWlzaXRlcyB0byB1c2luZyB0aGlzIFZNSUQgKi8KLQkJaWYgKCFpZCkKLQkJ CWNvbnRpbnVlOwotCi0JCWlmIChhdG9taWM2NF9yZWFkKCZpZC0+b3duZXIpICE9IHZtLT5jbGll bnRfaWQpCi0JCQljb250aW51ZTsKLQotCQlpZiAocGRfYWRkciAhPSBpZC0+cGRfZ3B1X2FkZHIp Ci0JCQljb250aW51ZTsKKwkvKiBDaGVjayBpZiB3ZSBoYXZlIGFuIGlkbGUgVk1JRCAqLworCWxp c3RfZm9yX2VhY2hfZW50cnkoaWRsZSwgJmFkZXYtPnZtX21hbmFnZXIuaWRzX2xydSwgbGlzdCkg eworCQlpZiAoYW1kZ3B1X3N5bmNfaXNfaWRsZSgmaWRsZS0+YWN0aXZlLCByaW5nKSkKKwkJCWJy ZWFrOwogCi0JCWlmIChpZC0+bGFzdF91c2VyICE9IHJpbmcgJiYKLQkJICAgICghaWQtPmxhc3Rf Zmx1c2ggfHwgIWZlbmNlX2lzX3NpZ25hbGVkKGlkLT5sYXN0X2ZsdXNoKSkpCi0JCQljb250aW51 ZTsKKwl9CiAKLQkJZmx1c2hlZCAgPSBpZC0+Zmx1c2hlZF91cGRhdGVzOwotCQlpZiAodXBkYXRl cyAmJiAoIWZsdXNoZWQgfHwgZmVuY2VfaXNfbGF0ZXIodXBkYXRlcywgZmx1c2hlZCkpKQotCQkJ Y29udGludWU7CisJLyogSWYgd2UgY2FuJ3QgZmluZCBhIGlkbGUgVk1JRCB0byB1c2UsIGp1c3Qg d2FpdCBmb3IgdGhlIG9sZGVzdCAqLworCWlmICgmaWRsZS0+bGlzdCA9PSAmYWRldi0+dm1fbWFu YWdlci5pZHNfbHJ1KSB7CisJCWlkID0gbGlzdF9maXJzdF9lbnRyeSgmYWRldi0+dm1fbWFuYWdl ci5pZHNfbHJ1LAorCQkJCSAgICAgIHN0cnVjdCBhbWRncHVfdm1faWQsCisJCQkJICAgICAgbGlz dCk7CisJfSBlbHNlIHsKKwkJLyogQ2hlY2sgaWYgd2UgY2FuIHVzZSBhIFZNSUQgYWxyZWFkeSBh c3NpZ25lZCB0byB0aGlzIFZNICovCisJCWRvIHsKKwkJCXN0cnVjdCBmZW5jZSAqZmx1c2hlZDsK KworCQkJaWQgPSB2bS0+aWRzW2krK107CisJCQlpZiAoaSA9PSBBTURHUFVfTUFYX1JJTkdTKQor CQkJCWkgPSAwOworCisJCQkvKiBDaGVjayBhbGwgdGhlIHByZXJlcXVpc2l0ZXMgdG8gdXNpbmcg dGhpcyBWTUlEICovCisJCQlpZiAoIWlkKQorCQkJCWNvbnRpbnVlOworCisJCQlpZiAoYXRvbWlj NjRfcmVhZCgmaWQtPm93bmVyKSAhPSB2bS0+Y2xpZW50X2lkKQorCQkJCWNvbnRpbnVlOworCisJ CQlpZiAocGRfYWRkciAhPSBpZC0+cGRfZ3B1X2FkZHIpCisJCQkJY29udGludWU7CisKKwkJCWlm IChpZC0+bGFzdF91c2VyICE9IHJpbmcgJiYgKCFpZC0+bGFzdF9mbHVzaCB8fAorCQkJICAgICFm ZW5jZV9pc19zaWduYWxlZChpZC0+bGFzdF9mbHVzaCkpKQorCQkJCWNvbnRpbnVlOworCisJCQlm bHVzaGVkICA9IGlkLT5mbHVzaGVkX3VwZGF0ZXM7CisJCQlpZiAodXBkYXRlcyAmJiAoIWZsdXNo ZWQgfHwKKwkJCSAgICBmZW5jZV9pc19sYXRlcih1cGRhdGVzLCBmbHVzaGVkKSkpCisJCQkJY29u dGludWU7CisKKwkJCS8qIEdvb2Qgd2UgY2FuIHVzZSB0aGlzIFZNSUQgKi8KKwkJCWlmIChpZC0+ bGFzdF91c2VyID09IHJpbmcpIHsKKwkJCQlyID0gYW1kZ3B1X3N5bmNfZmVuY2UocmluZy0+YWRl diwgc3luYywKKwkJCQkJCSAgICAgIGlkLT5maXJzdCk7CisJCQkJaWYgKHIpCisJCQkJCWdvdG8g ZXJyb3I7CisJCQl9CiAKLQkJLyogR29vZCB3ZSBjYW4gdXNlIHRoaXMgVk1JRCAqLwotCQlpZiAo aWQtPmxhc3RfdXNlciA9PSByaW5nKSB7Ci0JCQlyID0gYW1kZ3B1X3N5bmNfZmVuY2UocmluZy0+ YWRldiwgc3luYywKLQkJCQkJICAgICAgaWQtPmZpcnN0KTsKKwkJCS8qIEFuZCByZW1lbWJlciB0 aGlzIHN1Ym1pc3Npb24gYXMgdXNlciBvZiB0aGUgVk1JRCAqLworCQkJciA9IGFtZGdwdV9zeW5j X2ZlbmNlKHJpbmctPmFkZXYsICZpZC0+YWN0aXZlLCBmZW5jZSk7CiAJCQlpZiAocikKIAkJCQln b3RvIGVycm9yOwotCQl9Ci0KLQkJLyogQW5kIHJlbWVtYmVyIHRoaXMgc3VibWlzc2lvbiBhcyB1 c2VyIG9mIHRoZSBWTUlEICovCi0JCXIgPSBhbWRncHVfc3luY19mZW5jZShyaW5nLT5hZGV2LCAm aWQtPmFjdGl2ZSwgZmVuY2UpOwotCQlpZiAocikKLQkJCWdvdG8gZXJyb3I7CiAKLQkJbGlzdF9t b3ZlX3RhaWwoJmlkLT5saXN0LCAmYWRldi0+dm1fbWFuYWdlci5pZHNfbHJ1KTsKLQkJdm0tPmlk c1tyaW5nLT5pZHhdID0gaWQ7CisJCQlsaXN0X21vdmVfdGFpbCgmaWQtPmxpc3QsICZhZGV2LT52 bV9tYW5hZ2VyLmlkc19scnUpOworCQkJdm0tPmlkc1tyaW5nLT5pZHhdID0gaWQ7CiAKLQkJKnZt X2lkID0gaWQgLSBhZGV2LT52bV9tYW5hZ2VyLmlkczsKLQkJKnZtX3BkX2FkZHIgPSBBTURHUFVf Vk1fTk9fRkxVU0g7Ci0JCXRyYWNlX2FtZGdwdV92bV9ncmFiX2lkKHZtLCByaW5nLT5pZHgsICp2 bV9pZCwgKnZtX3BkX2FkZHIpOworCQkJKnZtX2lkID0gaWQgLSBhZGV2LT52bV9tYW5hZ2VyLmlk czsKKwkJCSp2bV9wZF9hZGRyID0gQU1ER1BVX1ZNX05PX0ZMVVNIOworCQkJdHJhY2VfYW1kZ3B1 X3ZtX2dyYWJfaWQodm0sIHJpbmctPmlkeCwgKnZtX2lkLAorCQkJCQkJKnZtX3BkX2FkZHIpOwog Ci0JCW11dGV4X3VubG9jaygmYWRldi0+dm1fbWFuYWdlci5sb2NrKTsKLQkJcmV0dXJuIDA7CisJ CQltdXRleF91bmxvY2soJmFkZXYtPnZtX21hbmFnZXIubG9jayk7CisJCQlyZXR1cm4gMDsKIAot CX0gd2hpbGUgKGkgIT0gcmluZy0+aWR4KTsKKwkJfSB3aGlsZSAoaSAhPSByaW5nLT5pZHgpOwog Ci0JLyogQ2hlY2sgaWYgd2UgaGF2ZSBhbiBpZGxlIFZNSUQgKi8KLQlsaXN0X2Zvcl9lYWNoX2Vu dHJ5KGlkLCAmYWRldi0+dm1fbWFuYWdlci5pZHNfbHJ1LCBsaXN0KSB7Ci0JCWlmIChhbWRncHVf c3luY19pc19pZGxlKCZpZC0+YWN0aXZlLCByaW5nKSkKLQkJCWJyZWFrOwotCi0JfQotCi0JLyog SWYgd2UgY2FuJ3QgZmluZCBhIGlkbGUgVk1JRCB0byB1c2UsIGp1c3Qgd2FpdCBmb3IgdGhlIG9s ZGVzdCAqLwotCWlmICgmaWQtPmxpc3QgPT0gJmFkZXYtPnZtX21hbmFnZXIuaWRzX2xydSkgewot CQlpZCA9IGxpc3RfZmlyc3RfZW50cnkoJmFkZXYtPnZtX21hbmFnZXIuaWRzX2xydSwKLQkJCQkg ICAgICBzdHJ1Y3QgYW1kZ3B1X3ZtX2lkLAotCQkJCSAgICAgIGxpc3QpOworCQkvKiBTdGlsbCBu byBJRCB0byB1c2U/IFRoZW4gdXNlIHRoZSBpZGxlIG9uZSBmb3VuZCBlYXJsaWVyICovCisJCWlk ID0gaWRsZTsKIAl9CiAKIAlyID0gYW1kZ3B1X3N5bmNfY3ljbGVfZmVuY2VzKHN5bmMsICZpZC0+ YWN0aXZlLCBmZW5jZSk7Ci0tIAoyLjUuMAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMu ZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlz dGluZm8vZHJpLWRldmVsCg==