gpu: nvgpu: New allocator for VA space

Implement a new buddy allocation scheme for the GPU's VA space.
The bitmap allocator was using too much memory and is not a scaleable
solution as the GPU's address space keeps getting bigger. The buddy
allocation scheme is much more memory efficient when the majority
of the address space is not allocated.

The buddy allocator is not constrained by the notion of a split
address space. The bitmap allocator could only manage either small
pages or large pages but not both at the same time. Thus the bottom
of the address space was for small pages, the top for large pages.
Although, that split is not removed quite yet, the new allocator
enables that to happen.

The buddy allocator is also very scalable. It manages the relatively
small comptag space to the enormous GPU VA space and everything in
between. This is important since the GPU has lots of different sized
spaces that need managing.

Currently there are certain limitations. For one the allocator does
not handle the fixed allocations from CUDA very well. It can do so
but with certain caveats. The PTE page size is always set to small.
This means the BA may place other small page allocations in the
buddies around the fixed allocation. It does this to avoid having
large and small page allocations in the same PDE.

Change-Id: I501cd15af03611536490137331d43761c402c7f9
Signed-off-by: Alex Waterman <alexw@nvidia.com>
Reviewed-on: http://git-master/r/740694
Reviewed-by: Automatic_Commit_Validation_User
GVS: Gerrit_Virtual_Submit
Reviewed-by: Terje Bergstrom <tbergstrom@nvidia.com>
Tested-by: Terje Bergstrom <tbergstrom@nvidia.com>

2 files changed, 16 insertions, 25 deletions

diff --git a/drivers/gpu/nvgpu/vgpu/ltc_vgpu.c b/drivers/gpu/nvgpu/vgpu/ltc_vgpu.c
index 1beac216..211e34b5 100644
--- a/drivers/gpu/nvgpu/vgpu/ltc_vgpu.c
+++ b/drivers/gpu/nvgpu/vgpu/ltc_vgpu.c
@@ -41,9 +41,8 @@ static int vgpu_ltc_init_comptags(struct gk20a *g, struct gr_gk20a *gr)
         if (max_comptag_lines < 2)
                 return -ENXIO;
 
-        gk20a_allocator_init(&gr->comp_tags, "comptag",
-                              1, /* start */
-                              max_comptag_lines - 1); /* length*/
+        __gk20a_allocator_init(&gr->comp_tags, NULL, "comptag",
+                               1, max_comptag_lines - 1, 1, 10, 0); /* length*/
         return 0;
 }
 
diff --git a/drivers/gpu/nvgpu/vgpu/mm_vgpu.c b/drivers/gpu/nvgpu/vgpu/mm_vgpu.c
index 94e4602f..855aac0d 100644
--- a/drivers/gpu/nvgpu/vgpu/mm_vgpu.c
+++ b/drivers/gpu/nvgpu/vgpu/mm_vgpu.c
@@ -243,11 +243,9 @@ static int vgpu_vm_alloc_share(struct gk20a_as_share *as_share,
         struct tegra_vgpu_as_share_params *p = &msg.params.as_share;
         struct mm_gk20a *mm = &g->mm;
         struct vm_gk20a *vm;
-        u32 num_small_pages, num_large_pages, low_hole_pages;
         u64 small_vma_size, large_vma_size;
         char name[32];
         int err, i;
-        u32 start;
 
         /* note: keep the page sizes sorted lowest to highest here */
         u32 gmmu_page_sizes[gmmu_nr_page_sizes] = {
@@ -294,33 +292,27 @@ static int vgpu_vm_alloc_share(struct gk20a_as_share *as_share,
         small_vma_size = (u64)16 << 30;
         large_vma_size = vm->va_limit - small_vma_size;
 
-        num_small_pages = (u32)(small_vma_size >>
-                    ilog2(vm->gmmu_page_sizes[gmmu_page_size_small]));
-
-        /* num_pages above is without regard to the low-side hole. */
-        low_hole_pages = (vm->va_start >>
-                          ilog2(vm->gmmu_page_sizes[gmmu_page_size_small]));
-
         snprintf(name, sizeof(name), "gk20a_as_%d-%dKB", as_share->id,
                  gmmu_page_sizes[gmmu_page_size_small]>>10);
-        err = gk20a_allocator_init(&vm->vma[gmmu_page_size_small],
-                             name,
-                             low_hole_pages,             /*start*/
-                             num_small_pages - low_hole_pages);/* length*/
+        err = __gk20a_allocator_init(&vm->vma[gmmu_page_size_small],
+                                     vm, name,
+                                     vm->va_start,
+                                     small_vma_size - vm->va_start,
+                                     SZ_4K,
+                                     GPU_BALLOC_MAX_ORDER,
+                                     GPU_BALLOC_GVA_SPACE);
         if (err)
                 goto clean_up_share;
 
-        start = (u32)(small_vma_size >>
-                    ilog2(vm->gmmu_page_sizes[gmmu_page_size_big]));
-        num_large_pages = (u32)(large_vma_size >>
-                            ilog2(vm->gmmu_page_sizes[gmmu_page_size_big]));
-
         snprintf(name, sizeof(name), "gk20a_as_%d-%dKB", as_share->id,
                 gmmu_page_sizes[gmmu_page_size_big]>>10);
-        err = gk20a_allocator_init(&vm->vma[gmmu_page_size_big],
-                              name,
-                              start,                    /* start */
-                              num_large_pages);         /* length */
+        err = __gk20a_allocator_init(&vm->vma[gmmu_page_size_big],
+                                     vm, name,
+                                     small_vma_size,
+                                     large_vma_size,
+                                     big_page_size,
+                                     GPU_BALLOC_MAX_ORDER,
+                                     GPU_BALLOC_GVA_SPACE);
         if (err)
                 goto clean_up_small_allocator;