From: Felix Kuehling <Felix.Kuehling@amd.com> To: amd-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Cc: alex.sierra@amd.com, Philip Yang <Philip.Yang@amd.com> Subject: [PATCH 14/35] drm/amdkfd: svm range eviction and restore Date: Wed, 6 Jan 2021 22:01:06 -0500 [thread overview] Message-ID: <20210107030127.20393-15-Felix.Kuehling@amd.com> (raw) In-Reply-To: <20210107030127.20393-1-Felix.Kuehling@amd.com> From: Philip Yang <Philip.Yang@amd.com> HMM interval notifier callback notify CPU page table will be updated, stop process queues if the updated address belongs to svm range registered in process svms objects tree. Scheduled restore work to update GPU page table using new pages address in the updated svm range. svm restore work to use srcu to scan svms list to avoid deadlock between below two cases: case1: svm restore work takes svm lock to scan svms list, then call hmm_page_fault which takes mm->mmap_sem. case2: unmap event callback and set_attr ioctl takes mm->mmap_sem, than takes svm lock to add/remove ranges. Calling synchronize_srcu in unmap event callback will deadlock with restore work because restore work may wait for unmap event done to take mm->mmap_sem, so schedule srcu_free_work to wait for srcu read critical section done in svm restore work then free svm ranges. Signed-off-by: Philip Yang <Philip.Yang@amd.com> Signed-off-by: Felix Kuehling <Felix.Kuehling@amd.com> --- drivers/gpu/drm/amd/amdkfd/kfd_priv.h | 2 + drivers/gpu/drm/amd/amdkfd/kfd_process.c | 1 + drivers/gpu/drm/amd/amdkfd/kfd_svm.c | 169 ++++++++++++++++++++++- drivers/gpu/drm/amd/amdkfd/kfd_svm.h | 2 + 4 files changed, 169 insertions(+), 5 deletions(-) diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_priv.h b/drivers/gpu/drm/amd/amdkfd/kfd_priv.h index 97cf267b6f51..f1e95773e19b 100644 --- a/drivers/gpu/drm/amd/amdkfd/kfd_priv.h +++ b/drivers/gpu/drm/amd/amdkfd/kfd_priv.h @@ -736,6 +736,8 @@ struct svm_range_list { struct list_head free_list; struct mutex free_list_lock; struct mmu_interval_notifier notifier; + atomic_t evicted_ranges; + struct delayed_work restore_work; }; /* Process data */ diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_process.c b/drivers/gpu/drm/amd/amdkfd/kfd_process.c index 791f17308b1b..0f31538b2a91 100644 --- a/drivers/gpu/drm/amd/amdkfd/kfd_process.c +++ b/drivers/gpu/drm/amd/amdkfd/kfd_process.c @@ -1048,6 +1048,7 @@ static void kfd_process_notifier_release(struct mmu_notifier *mn, cancel_delayed_work_sync(&p->eviction_work); cancel_delayed_work_sync(&p->restore_work); + cancel_delayed_work_sync(&p->svms.restore_work); mutex_lock(&p->mutex); diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_svm.c b/drivers/gpu/drm/amd/amdkfd/kfd_svm.c index 3c4a036609c4..e3ba6e7262a7 100644 --- a/drivers/gpu/drm/amd/amdkfd/kfd_svm.c +++ b/drivers/gpu/drm/amd/amdkfd/kfd_svm.c @@ -21,6 +21,7 @@ */ #include <linux/types.h> +#include <linux/sched/task.h> #include "amdgpu_sync.h" #include "amdgpu_object.h" #include "amdgpu_vm.h" @@ -28,6 +29,8 @@ #include "kfd_priv.h" #include "kfd_svm.h" +#define AMDGPU_SVM_RANGE_RESTORE_DELAY_MS 1 + /** * svm_range_unlink - unlink svm_range from lists and interval tree * @prange: svm range structure to be removed @@ -99,6 +102,7 @@ svm_range *svm_range_new(struct svm_range_list *svms, uint64_t start, INIT_LIST_HEAD(&prange->list); INIT_LIST_HEAD(&prange->update_list); INIT_LIST_HEAD(&prange->remove_list); + atomic_set(&prange->invalid, 0); svm_range_set_default_attributes(&prange->preferred_loc, &prange->prefetch_loc, &prange->granularity, &prange->flags); @@ -191,6 +195,10 @@ svm_range_validate(struct mm_struct *mm, struct svm_range *prange) r = svm_range_validate_ram(mm, prange); + pr_debug("svms 0x%p [0x%lx 0x%lx] ret %d invalid %d\n", prange->svms, + prange->it_node.start, prange->it_node.last, + r, atomic_read(&prange->invalid)); + return r; } @@ -757,6 +765,151 @@ static int svm_range_map_to_gpus(struct svm_range *prange, bool reserve_vm) return r; } +static void svm_range_restore_work(struct work_struct *work) +{ + struct delayed_work *dwork = to_delayed_work(work); + struct amdkfd_process_info *process_info; + struct svm_range_list *svms; + struct svm_range *prange; + struct kfd_process *p; + struct mm_struct *mm; + int evicted_ranges; + int srcu_idx; + int invalid; + int r; + + svms = container_of(dwork, struct svm_range_list, restore_work); + evicted_ranges = atomic_read(&svms->evicted_ranges); + if (!evicted_ranges) + return; + + pr_debug("restore svm ranges\n"); + + /* kfd_process_notifier_release destroys this worker thread. So during + * the lifetime of this thread, kfd_process and mm will be valid. + */ + p = container_of(svms, struct kfd_process, svms); + process_info = p->kgd_process_info; + mm = p->mm; + if (!mm) + return; + + mutex_lock(&process_info->lock); + mmap_read_lock(mm); + srcu_idx = srcu_read_lock(&svms->srcu); + + list_for_each_entry_rcu(prange, &svms->list, list) { + invalid = atomic_read(&prange->invalid); + if (!invalid) + continue; + + pr_debug("restoring svms 0x%p [0x%lx %lx] invalid %d\n", + prange->svms, prange->it_node.start, + prange->it_node.last, invalid); + + r = svm_range_validate(mm, prange); + if (r) { + pr_debug("failed %d to validate [0x%lx 0x%lx]\n", r, + prange->it_node.start, prange->it_node.last); + + goto unlock_out; + } + + r = svm_range_map_to_gpus(prange, true); + if (r) { + pr_debug("failed %d to map 0x%lx to gpu\n", r, + prange->it_node.start); + goto unlock_out; + } + + if (atomic_cmpxchg(&prange->invalid, invalid, 0) != invalid) + goto unlock_out; + } + + if (atomic_cmpxchg(&svms->evicted_ranges, evicted_ranges, 0) != + evicted_ranges) + goto unlock_out; + + evicted_ranges = 0; + + r = kgd2kfd_resume_mm(mm); + if (r) { + /* No recovery from this failure. Probably the CP is + * hanging. No point trying again. + */ + pr_debug("failed %d to resume KFD\n", r); + } + + pr_debug("restore svm ranges successfully\n"); + +unlock_out: + srcu_read_unlock(&svms->srcu, srcu_idx); + mmap_read_unlock(mm); + mutex_unlock(&process_info->lock); + + /* If validation failed, reschedule another attempt */ + if (evicted_ranges) { + pr_debug("reschedule to restore svm range\n"); + schedule_delayed_work(&svms->restore_work, + msecs_to_jiffies(AMDGPU_SVM_RANGE_RESTORE_DELAY_MS)); + } +} + +/** + * svm_range_evict - evict svm range + * + * Stop all queues of the process to ensure GPU doesn't access the memory, then + * return to let CPU evict the buffer and proceed CPU pagetable update. + * + * Don't need use lock to sync cpu pagetable invalidation with GPU execution. + * If invalidation happens while restore work is running, restore work will + * restart to ensure to get the latest CPU pages mapping to GPU, then start + * the queues. + */ +static int +svm_range_evict(struct svm_range_list *svms, struct mm_struct *mm, + unsigned long start, unsigned long last) +{ + int invalid, evicted_ranges; + int r = 0; + struct interval_tree_node *node; + struct svm_range *prange; + + svms_lock(svms); + + pr_debug("invalidate svms 0x%p [0x%lx 0x%lx]\n", svms, start, last); + + node = interval_tree_iter_first(&svms->objects, start, last); + while (node) { + struct interval_tree_node *next; + + prange = container_of(node, struct svm_range, it_node); + next = interval_tree_iter_next(node, start, last); + + invalid = atomic_inc_return(&prange->invalid); + evicted_ranges = atomic_inc_return(&svms->evicted_ranges); + if (evicted_ranges == 1) { + pr_debug("evicting svms 0x%p range [0x%lx 0x%lx]\n", + prange->svms, prange->it_node.start, + prange->it_node.last); + + /* First eviction, stop the queues */ + r = kgd2kfd_quiesce_mm(mm); + if (r) + pr_debug("failed to quiesce KFD\n"); + + pr_debug("schedule to restore svm %p ranges\n", svms); + schedule_delayed_work(&svms->restore_work, + msecs_to_jiffies(AMDGPU_SVM_RANGE_RESTORE_DELAY_MS)); + } + node = next; + } + + svms_unlock(svms); + + return r; +} + struct svm_range *svm_range_clone(struct svm_range *old) { struct svm_range *new; @@ -994,6 +1147,11 @@ svm_range_unmap_from_cpu(struct mm_struct *mm, unsigned long start, * svm_range_cpu_invalidate_pagetables - interval notifier callback * * MMU range unmap notifier to remove svm ranges + * + * If GPU vm fault retry is not enabled, evict the svm range, then restore + * work will update GPU mapping. + * If GPU vm fault retry is enabled, unmap the svm range from GPU, vm fault + * will update GPU mapping. */ static bool svm_range_cpu_invalidate_pagetables(struct mmu_interval_notifier *mni, @@ -1009,15 +1167,14 @@ svm_range_cpu_invalidate_pagetables(struct mmu_interval_notifier *mni, if (range->event == MMU_NOTIFY_RELEASE) { pr_debug("cpu release range [0x%lx 0x%lx]\n", range->start, range->end - 1); - return true; - } - if (range->event == MMU_NOTIFY_UNMAP) { + } else if (range->event == MMU_NOTIFY_UNMAP) { pr_debug("mm 0x%p unmap range [0x%lx 0x%lx]\n", range->mm, start, last); svm_range_unmap_from_cpu(mni->mm, start, last); - return true; + } else { + mmu_interval_set_seq(mni, cur_seq); + svm_range_evict(svms, mni->mm, start, last); } - return true; } @@ -1045,6 +1202,8 @@ int svm_range_list_init(struct kfd_process *p) svms->objects = RB_ROOT_CACHED; mutex_init(&svms->lock); INIT_LIST_HEAD(&svms->list); + atomic_set(&svms->evicted_ranges, 0); + INIT_DELAYED_WORK(&svms->restore_work, svm_range_restore_work); r = init_srcu_struct(&svms->srcu); if (r) { pr_debug("failed %d to init srcu\n", r); diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_svm.h b/drivers/gpu/drm/amd/amdkfd/kfd_svm.h index fb68b5ee54f8..4c7daf8e0b6f 100644 --- a/drivers/gpu/drm/amd/amdkfd/kfd_svm.h +++ b/drivers/gpu/drm/amd/amdkfd/kfd_svm.h @@ -50,6 +50,7 @@ * @perfetch_loc: last prefetch location, 0 for CPU, or GPU id * @actual_loc: the actual location, 0 for CPU, or GPU id * @granularity:migration granularity, log2 num pages + * @invalid: not 0 means cpu page table is invalidated * @bitmap_access: index bitmap of GPUs which can access the range * @bitmap_aip: index bitmap of GPUs which can access the range in place * @@ -72,6 +73,7 @@ struct svm_range { uint32_t prefetch_loc; uint32_t actual_loc; uint8_t granularity; + atomic_t invalid; DECLARE_BITMAP(bitmap_access, MAX_GPU_INSTANCE); DECLARE_BITMAP(bitmap_aip, MAX_GPU_INSTANCE); }; -- 2.29.2 _______________________________________________ dri-devel mailing list dri-devel@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/dri-devel
WARNING: multiple messages have this Message-ID (diff)
From: Felix Kuehling <Felix.Kuehling@amd.com> To: amd-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Cc: alex.sierra@amd.com, Philip Yang <Philip.Yang@amd.com> Subject: [PATCH 14/35] drm/amdkfd: svm range eviction and restore Date: Wed, 6 Jan 2021 22:01:06 -0500 [thread overview] Message-ID: <20210107030127.20393-15-Felix.Kuehling@amd.com> (raw) In-Reply-To: <20210107030127.20393-1-Felix.Kuehling@amd.com> From: Philip Yang <Philip.Yang@amd.com> HMM interval notifier callback notify CPU page table will be updated, stop process queues if the updated address belongs to svm range registered in process svms objects tree. Scheduled restore work to update GPU page table using new pages address in the updated svm range. svm restore work to use srcu to scan svms list to avoid deadlock between below two cases: case1: svm restore work takes svm lock to scan svms list, then call hmm_page_fault which takes mm->mmap_sem. case2: unmap event callback and set_attr ioctl takes mm->mmap_sem, than takes svm lock to add/remove ranges. Calling synchronize_srcu in unmap event callback will deadlock with restore work because restore work may wait for unmap event done to take mm->mmap_sem, so schedule srcu_free_work to wait for srcu read critical section done in svm restore work then free svm ranges. Signed-off-by: Philip Yang <Philip.Yang@amd.com> Signed-off-by: Felix Kuehling <Felix.Kuehling@amd.com> --- drivers/gpu/drm/amd/amdkfd/kfd_priv.h | 2 + drivers/gpu/drm/amd/amdkfd/kfd_process.c | 1 + drivers/gpu/drm/amd/amdkfd/kfd_svm.c | 169 ++++++++++++++++++++++- drivers/gpu/drm/amd/amdkfd/kfd_svm.h | 2 + 4 files changed, 169 insertions(+), 5 deletions(-) diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_priv.h b/drivers/gpu/drm/amd/amdkfd/kfd_priv.h index 97cf267b6f51..f1e95773e19b 100644 --- a/drivers/gpu/drm/amd/amdkfd/kfd_priv.h +++ b/drivers/gpu/drm/amd/amdkfd/kfd_priv.h @@ -736,6 +736,8 @@ struct svm_range_list { struct list_head free_list; struct mutex free_list_lock; struct mmu_interval_notifier notifier; + atomic_t evicted_ranges; + struct delayed_work restore_work; }; /* Process data */ diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_process.c b/drivers/gpu/drm/amd/amdkfd/kfd_process.c index 791f17308b1b..0f31538b2a91 100644 --- a/drivers/gpu/drm/amd/amdkfd/kfd_process.c +++ b/drivers/gpu/drm/amd/amdkfd/kfd_process.c @@ -1048,6 +1048,7 @@ static void kfd_process_notifier_release(struct mmu_notifier *mn, cancel_delayed_work_sync(&p->eviction_work); cancel_delayed_work_sync(&p->restore_work); + cancel_delayed_work_sync(&p->svms.restore_work); mutex_lock(&p->mutex); diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_svm.c b/drivers/gpu/drm/amd/amdkfd/kfd_svm.c index 3c4a036609c4..e3ba6e7262a7 100644 --- a/drivers/gpu/drm/amd/amdkfd/kfd_svm.c +++ b/drivers/gpu/drm/amd/amdkfd/kfd_svm.c @@ -21,6 +21,7 @@ */ #include <linux/types.h> +#include <linux/sched/task.h> #include "amdgpu_sync.h" #include "amdgpu_object.h" #include "amdgpu_vm.h" @@ -28,6 +29,8 @@ #include "kfd_priv.h" #include "kfd_svm.h" +#define AMDGPU_SVM_RANGE_RESTORE_DELAY_MS 1 + /** * svm_range_unlink - unlink svm_range from lists and interval tree * @prange: svm range structure to be removed @@ -99,6 +102,7 @@ svm_range *svm_range_new(struct svm_range_list *svms, uint64_t start, INIT_LIST_HEAD(&prange->list); INIT_LIST_HEAD(&prange->update_list); INIT_LIST_HEAD(&prange->remove_list); + atomic_set(&prange->invalid, 0); svm_range_set_default_attributes(&prange->preferred_loc, &prange->prefetch_loc, &prange->granularity, &prange->flags); @@ -191,6 +195,10 @@ svm_range_validate(struct mm_struct *mm, struct svm_range *prange) r = svm_range_validate_ram(mm, prange); + pr_debug("svms 0x%p [0x%lx 0x%lx] ret %d invalid %d\n", prange->svms, + prange->it_node.start, prange->it_node.last, + r, atomic_read(&prange->invalid)); + return r; } @@ -757,6 +765,151 @@ static int svm_range_map_to_gpus(struct svm_range *prange, bool reserve_vm) return r; } +static void svm_range_restore_work(struct work_struct *work) +{ + struct delayed_work *dwork = to_delayed_work(work); + struct amdkfd_process_info *process_info; + struct svm_range_list *svms; + struct svm_range *prange; + struct kfd_process *p; + struct mm_struct *mm; + int evicted_ranges; + int srcu_idx; + int invalid; + int r; + + svms = container_of(dwork, struct svm_range_list, restore_work); + evicted_ranges = atomic_read(&svms->evicted_ranges); + if (!evicted_ranges) + return; + + pr_debug("restore svm ranges\n"); + + /* kfd_process_notifier_release destroys this worker thread. So during + * the lifetime of this thread, kfd_process and mm will be valid. + */ + p = container_of(svms, struct kfd_process, svms); + process_info = p->kgd_process_info; + mm = p->mm; + if (!mm) + return; + + mutex_lock(&process_info->lock); + mmap_read_lock(mm); + srcu_idx = srcu_read_lock(&svms->srcu); + + list_for_each_entry_rcu(prange, &svms->list, list) { + invalid = atomic_read(&prange->invalid); + if (!invalid) + continue; + + pr_debug("restoring svms 0x%p [0x%lx %lx] invalid %d\n", + prange->svms, prange->it_node.start, + prange->it_node.last, invalid); + + r = svm_range_validate(mm, prange); + if (r) { + pr_debug("failed %d to validate [0x%lx 0x%lx]\n", r, + prange->it_node.start, prange->it_node.last); + + goto unlock_out; + } + + r = svm_range_map_to_gpus(prange, true); + if (r) { + pr_debug("failed %d to map 0x%lx to gpu\n", r, + prange->it_node.start); + goto unlock_out; + } + + if (atomic_cmpxchg(&prange->invalid, invalid, 0) != invalid) + goto unlock_out; + } + + if (atomic_cmpxchg(&svms->evicted_ranges, evicted_ranges, 0) != + evicted_ranges) + goto unlock_out; + + evicted_ranges = 0; + + r = kgd2kfd_resume_mm(mm); + if (r) { + /* No recovery from this failure. Probably the CP is + * hanging. No point trying again. + */ + pr_debug("failed %d to resume KFD\n", r); + } + + pr_debug("restore svm ranges successfully\n"); + +unlock_out: + srcu_read_unlock(&svms->srcu, srcu_idx); + mmap_read_unlock(mm); + mutex_unlock(&process_info->lock); + + /* If validation failed, reschedule another attempt */ + if (evicted_ranges) { + pr_debug("reschedule to restore svm range\n"); + schedule_delayed_work(&svms->restore_work, + msecs_to_jiffies(AMDGPU_SVM_RANGE_RESTORE_DELAY_MS)); + } +} + +/** + * svm_range_evict - evict svm range + * + * Stop all queues of the process to ensure GPU doesn't access the memory, then + * return to let CPU evict the buffer and proceed CPU pagetable update. + * + * Don't need use lock to sync cpu pagetable invalidation with GPU execution. + * If invalidation happens while restore work is running, restore work will + * restart to ensure to get the latest CPU pages mapping to GPU, then start + * the queues. + */ +static int +svm_range_evict(struct svm_range_list *svms, struct mm_struct *mm, + unsigned long start, unsigned long last) +{ + int invalid, evicted_ranges; + int r = 0; + struct interval_tree_node *node; + struct svm_range *prange; + + svms_lock(svms); + + pr_debug("invalidate svms 0x%p [0x%lx 0x%lx]\n", svms, start, last); + + node = interval_tree_iter_first(&svms->objects, start, last); + while (node) { + struct interval_tree_node *next; + + prange = container_of(node, struct svm_range, it_node); + next = interval_tree_iter_next(node, start, last); + + invalid = atomic_inc_return(&prange->invalid); + evicted_ranges = atomic_inc_return(&svms->evicted_ranges); + if (evicted_ranges == 1) { + pr_debug("evicting svms 0x%p range [0x%lx 0x%lx]\n", + prange->svms, prange->it_node.start, + prange->it_node.last); + + /* First eviction, stop the queues */ + r = kgd2kfd_quiesce_mm(mm); + if (r) + pr_debug("failed to quiesce KFD\n"); + + pr_debug("schedule to restore svm %p ranges\n", svms); + schedule_delayed_work(&svms->restore_work, + msecs_to_jiffies(AMDGPU_SVM_RANGE_RESTORE_DELAY_MS)); + } + node = next; + } + + svms_unlock(svms); + + return r; +} + struct svm_range *svm_range_clone(struct svm_range *old) { struct svm_range *new; @@ -994,6 +1147,11 @@ svm_range_unmap_from_cpu(struct mm_struct *mm, unsigned long start, * svm_range_cpu_invalidate_pagetables - interval notifier callback * * MMU range unmap notifier to remove svm ranges + * + * If GPU vm fault retry is not enabled, evict the svm range, then restore + * work will update GPU mapping. + * If GPU vm fault retry is enabled, unmap the svm range from GPU, vm fault + * will update GPU mapping. */ static bool svm_range_cpu_invalidate_pagetables(struct mmu_interval_notifier *mni, @@ -1009,15 +1167,14 @@ svm_range_cpu_invalidate_pagetables(struct mmu_interval_notifier *mni, if (range->event == MMU_NOTIFY_RELEASE) { pr_debug("cpu release range [0x%lx 0x%lx]\n", range->start, range->end - 1); - return true; - } - if (range->event == MMU_NOTIFY_UNMAP) { + } else if (range->event == MMU_NOTIFY_UNMAP) { pr_debug("mm 0x%p unmap range [0x%lx 0x%lx]\n", range->mm, start, last); svm_range_unmap_from_cpu(mni->mm, start, last); - return true; + } else { + mmu_interval_set_seq(mni, cur_seq); + svm_range_evict(svms, mni->mm, start, last); } - return true; } @@ -1045,6 +1202,8 @@ int svm_range_list_init(struct kfd_process *p) svms->objects = RB_ROOT_CACHED; mutex_init(&svms->lock); INIT_LIST_HEAD(&svms->list); + atomic_set(&svms->evicted_ranges, 0); + INIT_DELAYED_WORK(&svms->restore_work, svm_range_restore_work); r = init_srcu_struct(&svms->srcu); if (r) { pr_debug("failed %d to init srcu\n", r); diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_svm.h b/drivers/gpu/drm/amd/amdkfd/kfd_svm.h index fb68b5ee54f8..4c7daf8e0b6f 100644 --- a/drivers/gpu/drm/amd/amdkfd/kfd_svm.h +++ b/drivers/gpu/drm/amd/amdkfd/kfd_svm.h @@ -50,6 +50,7 @@ * @perfetch_loc: last prefetch location, 0 for CPU, or GPU id * @actual_loc: the actual location, 0 for CPU, or GPU id * @granularity:migration granularity, log2 num pages + * @invalid: not 0 means cpu page table is invalidated * @bitmap_access: index bitmap of GPUs which can access the range * @bitmap_aip: index bitmap of GPUs which can access the range in place * @@ -72,6 +73,7 @@ struct svm_range { uint32_t prefetch_loc; uint32_t actual_loc; uint8_t granularity; + atomic_t invalid; DECLARE_BITMAP(bitmap_access, MAX_GPU_INSTANCE); DECLARE_BITMAP(bitmap_aip, MAX_GPU_INSTANCE); }; -- 2.29.2 _______________________________________________ amd-gfx mailing list amd-gfx@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/amd-gfx
next prev parent reply other threads:[~2021-01-07 3:03 UTC|newest] Thread overview: 168+ messages / expand[flat|nested] mbox.gz Atom feed top 2021-01-07 3:00 [PATCH 00/35] Add HMM-based SVM memory manager to KFD Felix Kuehling 2021-01-07 3:00 ` Felix Kuehling 2021-01-07 3:00 ` [PATCH 01/35] drm/amdkfd: select kernel DEVICE_PRIVATE option Felix Kuehling 2021-01-07 3:00 ` Felix Kuehling 2021-01-07 3:00 ` [PATCH 02/35] drm/amdgpu: replace per_device_list by array Felix Kuehling 2021-01-07 3:00 ` Felix Kuehling 2021-01-07 3:00 ` [PATCH 03/35] drm/amdkfd: helper to convert gpu id and idx Felix Kuehling 2021-01-07 3:00 ` Felix Kuehling 2021-01-07 3:00 ` [PATCH 04/35] drm/amdkfd: add svm ioctl API Felix Kuehling 2021-01-07 3:00 ` Felix Kuehling 2021-01-07 3:00 ` [PATCH 05/35] drm/amdkfd: Add SVM API support capability bits Felix Kuehling 2021-01-07 3:00 ` Felix Kuehling 2021-01-07 3:00 ` [PATCH 06/35] drm/amdkfd: register svm range Felix Kuehling 2021-01-07 3:00 ` Felix Kuehling 2021-01-07 3:00 ` [PATCH 07/35] drm/amdkfd: add svm ioctl GET_ATTR op Felix Kuehling 2021-01-07 3:00 ` Felix Kuehling 2021-01-07 3:01 ` [PATCH 08/35] drm/amdgpu: add common HMM get pages function Felix Kuehling 2021-01-07 3:01 ` Felix Kuehling 2021-01-07 10:53 ` Christian König 2021-01-07 10:53 ` Christian König 2021-01-07 3:01 ` [PATCH 09/35] drm/amdkfd: validate svm range system memory Felix Kuehling 2021-01-07 3:01 ` Felix Kuehling 2021-01-07 3:01 ` [PATCH 10/35] drm/amdkfd: register overlap system memory range Felix Kuehling 2021-01-07 3:01 ` Felix Kuehling 2021-01-07 3:01 ` [PATCH 11/35] drm/amdkfd: deregister svm range Felix Kuehling 2021-01-07 3:01 ` Felix Kuehling 2021-01-07 3:01 ` [PATCH 12/35] drm/amdgpu: export vm update mapping interface Felix Kuehling 2021-01-07 3:01 ` Felix Kuehling 2021-01-07 10:54 ` Christian König 2021-01-07 10:54 ` Christian König 2021-01-07 3:01 ` [PATCH 13/35] drm/amdkfd: map svm range to GPUs Felix Kuehling 2021-01-07 3:01 ` Felix Kuehling 2021-01-07 3:01 ` Felix Kuehling [this message] 2021-01-07 3:01 ` [PATCH 14/35] drm/amdkfd: svm range eviction and restore Felix Kuehling 2021-01-07 3:01 ` [PATCH 15/35] drm/amdkfd: add xnack enabled flag to kfd_process Felix Kuehling 2021-01-07 3:01 ` Felix Kuehling 2021-01-07 3:01 ` [PATCH 16/35] drm/amdkfd: add ioctl to configure and query xnack retries Felix Kuehling 2021-01-07 3:01 ` Felix Kuehling 2021-01-07 3:01 ` [PATCH 17/35] drm/amdkfd: register HMM device private zone Felix Kuehling 2021-01-07 3:01 ` Felix Kuehling 2021-03-01 8:32 ` Daniel Vetter 2021-03-01 8:32 ` Daniel Vetter 2021-03-01 8:46 ` Thomas Hellström (Intel) 2021-03-01 8:46 ` Thomas Hellström (Intel) 2021-03-01 8:58 ` Daniel Vetter 2021-03-01 8:58 ` Daniel Vetter 2021-03-01 9:30 ` Thomas Hellström (Intel) 2021-03-01 9:30 ` Thomas Hellström (Intel) 2021-03-04 17:58 ` Felix Kuehling 2021-03-04 17:58 ` Felix Kuehling 2021-03-11 12:24 ` Thomas Hellström (Intel) 2021-03-11 12:24 ` Thomas Hellström (Intel) 2021-01-07 3:01 ` [PATCH 18/35] drm/amdkfd: validate vram svm range from TTM Felix Kuehling 2021-01-07 3:01 ` Felix Kuehling 2021-01-07 3:01 ` [PATCH 19/35] drm/amdkfd: support xgmi same hive mapping Felix Kuehling 2021-01-07 3:01 ` Felix Kuehling 2021-01-07 3:01 ` [PATCH 20/35] drm/amdkfd: copy memory through gart table Felix Kuehling 2021-01-07 3:01 ` Felix Kuehling 2021-01-07 3:01 ` [PATCH 21/35] drm/amdkfd: HMM migrate ram to vram Felix Kuehling 2021-01-07 3:01 ` Felix Kuehling 2021-01-07 3:01 ` [PATCH 22/35] drm/amdkfd: HMM migrate vram to ram Felix Kuehling 2021-01-07 3:01 ` Felix Kuehling 2021-01-07 3:01 ` [PATCH 23/35] drm/amdkfd: invalidate tables on page retry fault Felix Kuehling 2021-01-07 3:01 ` Felix Kuehling 2021-01-07 3:01 ` [PATCH 24/35] drm/amdkfd: page table restore through svm API Felix Kuehling 2021-01-07 3:01 ` Felix Kuehling 2021-01-07 3:01 ` [PATCH 25/35] drm/amdkfd: SVM API call to restore page tables Felix Kuehling 2021-01-07 3:01 ` Felix Kuehling 2021-01-07 3:01 ` [PATCH 26/35] drm/amdkfd: add svm_bo reference for eviction fence Felix Kuehling 2021-01-07 3:01 ` Felix Kuehling 2021-01-07 3:01 ` [PATCH 27/35] drm/amdgpu: add param bit flag to create SVM BOs Felix Kuehling 2021-01-07 3:01 ` Felix Kuehling 2021-01-07 3:01 ` [PATCH 28/35] drm/amdkfd: add svm_bo eviction mechanism support Felix Kuehling 2021-01-07 3:01 ` Felix Kuehling 2021-01-07 3:01 ` [PATCH 29/35] drm/amdgpu: svm bo enable_signal call condition Felix Kuehling 2021-01-07 3:01 ` Felix Kuehling 2021-01-07 10:56 ` Christian König 2021-01-07 10:56 ` Christian König 2021-01-07 16:16 ` Felix Kuehling 2021-01-07 16:16 ` Felix Kuehling 2021-01-07 16:28 ` Christian König 2021-01-07 16:28 ` Christian König 2021-01-07 16:53 ` Felix Kuehling 2021-01-07 16:53 ` Felix Kuehling 2021-01-07 3:01 ` [PATCH 30/35] drm/amdgpu: add svm_bo eviction to enable_signal cb Felix Kuehling 2021-01-07 3:01 ` Felix Kuehling 2021-01-07 3:01 ` [PATCH 31/35] drm/amdgpu: reserve fence slot to update page table Felix Kuehling 2021-01-07 3:01 ` Felix Kuehling 2021-01-07 10:57 ` Christian König 2021-01-07 10:57 ` Christian König 2021-01-07 3:01 ` [PATCH 32/35] drm/amdgpu: enable retry fault wptr overflow Felix Kuehling 2021-01-07 3:01 ` Felix Kuehling 2021-01-07 11:01 ` Christian König 2021-01-07 11:01 ` Christian König 2021-01-07 3:01 ` [PATCH 33/35] drm/amdkfd: refine migration policy with xnack on Felix Kuehling 2021-01-07 3:01 ` Felix Kuehling 2021-01-07 3:01 ` [PATCH 34/35] drm/amdkfd: add svm range validate timestamp Felix Kuehling 2021-01-07 3:01 ` Felix Kuehling 2021-01-07 3:01 ` [PATCH 35/35] drm/amdkfd: multiple gpu migrate vram to vram Felix Kuehling 2021-01-07 3:01 ` Felix Kuehling 2021-01-07 9:23 ` [PATCH 00/35] Add HMM-based SVM memory manager to KFD Daniel Vetter 2021-01-07 9:23 ` Daniel Vetter 2021-01-07 16:25 ` Felix Kuehling 2021-01-07 16:25 ` Felix Kuehling 2021-01-08 14:40 ` Daniel Vetter 2021-01-08 14:40 ` Daniel Vetter 2021-01-08 14:45 ` Christian König 2021-01-08 14:45 ` Christian König 2021-01-08 15:58 ` Felix Kuehling 2021-01-08 15:58 ` Felix Kuehling 2021-01-08 16:06 ` Daniel Vetter 2021-01-08 16:06 ` Daniel Vetter 2021-01-08 16:36 ` Felix Kuehling 2021-01-08 16:36 ` Felix Kuehling 2021-01-08 16:53 ` Daniel Vetter 2021-01-08 16:53 ` Daniel Vetter 2021-01-08 17:56 ` Felix Kuehling 2021-01-08 17:56 ` Felix Kuehling 2021-01-11 16:29 ` Daniel Vetter 2021-01-11 16:29 ` Daniel Vetter 2021-01-14 5:34 ` Felix Kuehling 2021-01-14 5:34 ` Felix Kuehling 2021-01-14 12:19 ` Christian König 2021-01-14 12:19 ` Christian König 2021-01-13 16:56 ` Jerome Glisse 2021-01-13 16:56 ` Jerome Glisse 2021-01-13 20:31 ` Daniel Vetter 2021-01-13 20:31 ` Daniel Vetter 2021-01-14 3:27 ` Jerome Glisse 2021-01-14 3:27 ` Jerome Glisse 2021-01-14 9:26 ` Daniel Vetter 2021-01-14 9:26 ` Daniel Vetter 2021-01-14 10:39 ` Daniel Vetter 2021-01-14 10:39 ` Daniel Vetter 2021-01-14 10:49 ` Christian König 2021-01-14 10:49 ` Christian König 2021-01-14 11:52 ` Daniel Vetter 2021-01-14 11:52 ` Daniel Vetter 2021-01-14 13:37 ` HMM fence (was Re: [PATCH 00/35] Add HMM-based SVM memory manager to KFD) Christian König 2021-01-14 13:37 ` Christian König 2021-01-14 13:57 ` Daniel Vetter 2021-01-14 13:57 ` Daniel Vetter 2021-01-14 14:13 ` Christian König 2021-01-14 14:13 ` Christian König 2021-01-14 14:23 ` Daniel Vetter 2021-01-14 14:23 ` Daniel Vetter 2021-01-14 15:08 ` Christian König 2021-01-14 15:08 ` Christian König 2021-01-14 15:40 ` Daniel Vetter 2021-01-14 15:40 ` Daniel Vetter 2021-01-14 16:01 ` Christian König 2021-01-14 16:01 ` Christian König 2021-01-14 16:36 ` Daniel Vetter 2021-01-14 16:36 ` Daniel Vetter 2021-01-14 19:08 ` Christian König 2021-01-14 19:08 ` Christian König 2021-01-14 20:09 ` Daniel Vetter 2021-01-14 20:09 ` Daniel Vetter 2021-01-14 16:51 ` Jerome Glisse 2021-01-14 16:51 ` Jerome Glisse 2021-01-14 21:13 ` Felix Kuehling 2021-01-14 21:13 ` Felix Kuehling 2021-01-15 7:47 ` Christian König 2021-01-15 7:47 ` Christian König 2021-01-13 16:47 ` [PATCH 00/35] Add HMM-based SVM memory manager to KFD Jerome Glisse 2021-01-13 16:47 ` Jerome Glisse 2021-01-14 0:06 ` Felix Kuehling 2021-01-14 0:06 ` Felix Kuehling
Reply instructions: You may reply publicly to this message via plain-text email using any one of the following methods: * Save the following mbox file, import it into your mail client, and reply-to-all from there: mbox Avoid top-posting and favor interleaved quoting: https://en.wikipedia.org/wiki/Posting_style#Interleaved_style * Reply using the --to, --cc, and --in-reply-to switches of git-send-email(1): git send-email \ --in-reply-to=20210107030127.20393-15-Felix.Kuehling@amd.com \ --to=felix.kuehling@amd.com \ --cc=Philip.Yang@amd.com \ --cc=alex.sierra@amd.com \ --cc=amd-gfx@lists.freedesktop.org \ --cc=dri-devel@lists.freedesktop.org \ /path/to/YOUR_REPLY https://kernel.org/pub/software/scm/git/docs/git-send-email.html * If your mail client supports setting the In-Reply-To header via mailto: links, try the mailto: linkBe sure your reply has a Subject: header at the top and a blank line before the message body.
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.