Subversion Repositories Kolibri OS

#include "util/u_memory.h"

#include "util/list.h"

#include "nouveau_screen.h"

#include "nouveau_mm.h"

 * add an extra cache for such buffer objects.

 *

 * HACK: Max order == 21 to accommodate TF2's 1.5 MiB, frequently reallocated

 * vertex buffer (VM flush (?) decreases performance dramatically).

 */

#define MM_MAX_ORDER 21

#define MM_MAX_SIZE (1 << MM_MAX_ORDER)

   struct list_head free;

   struct list_head used;

   struct list_head full;

   int num_free;

};

   struct nouveau_device *dev;

   struct mm_bucket bucket[MM_NUM_BUCKETS];

   uint32_t domain;

   union nouveau_bo_config config;

   uint64_t allocated;

};

   struct list_head head;

   struct nouveau_bo *bo;

   struct nouveau_mman *cache;

   int order;

   int count;

   int free;

   uint32_t bits[0];

};

mm_slab_alloc(struct mm_slab *slab)

{

   int i, n, b;

      return -1;

      b = ffs(slab->bits[i]) - 1;

      if (b >= 0) {

         n = i * 32 + b;

         assert(n < slab->count);

         slab->free--;

         slab->bits[i] &= ~(1 << b);

         return n;

      }

   }

   return -1;

}

mm_slab_free(struct mm_slab *slab, int i)

{

   assert(i < slab->count);

   slab->bits[i / 32] |= 1 << (i % 32);

   slab->free++;

   assert(slab->free <= slab->count);

}

mm_get_order(uint32_t size)

{

   int s = __builtin_clz(size) ^ 31;

      s += 1;

   return s;

}

mm_bucket_by_order(struct nouveau_mman *cache, int order)

{

   if (order > MM_MAX_ORDER)

      return NULL;

   return &cache->bucket[MAX2(order, MM_MIN_ORDER) - MM_MIN_ORDER];

}

mm_bucket_by_size(struct nouveau_mman *cache, unsigned size)

{

   return mm_bucket_by_order(cache, mm_get_order(size));

}

static INLINE uint32_t

mm_default_slab_size(unsigned chunk_order)

{

   static const int8_t slab_order[MM_MAX_ORDER - MM_MIN_ORDER + 1] =

   {

      12, 12, 13, 14, 14, 17, 17, 17, 17, 19, 19, 20, 21, 22, 22

   };

}

mm_slab_new(struct nouveau_mman *cache, int chunk_order)

{

   struct mm_slab *slab;

   int words, ret;

   const uint32_t size = mm_default_slab_size(chunk_order);

   assert(words);

   if (!slab)

      return PIPE_ERROR_OUT_OF_MEMORY;

                        &slab->bo);

   if (ret) {

      FREE(slab);

      return PIPE_ERROR_OUT_OF_MEMORY;

   }

   slab->order = chunk_order;

   slab->count = slab->free = size >> chunk_order;

      debug_printf("MM: new slab, total memory = %"PRIu64" KiB\n",

                   cache->allocated / 1024);

}

struct nouveau_mm_allocation *

nouveau_mm_allocate(struct nouveau_mman *cache,

                    uint32_t size, struct nouveau_bo **bo, uint32_t *offset)

{

   struct mm_bucket *bucket;

   struct mm_slab *slab;

   struct nouveau_mm_allocation *alloc;

   int ret;

   if (!bucket) {

      ret = nouveau_bo_new(cache->dev, cache->domain, 0, size, &cache->config,

                           bo);

      if (ret)

         debug_printf("bo_new(%x, %x): %i\n",

                      size, cache->config.nv50.memtype, ret);

      return NULL;

   }

      slab = LIST_ENTRY(struct mm_slab, bucket->used.next, head);

   } else {

      if (LIST_IS_EMPTY(&bucket->free)) {

         mm_slab_new(cache, MAX2(mm_get_order(size), MM_MIN_ORDER));

      }

      slab = LIST_ENTRY(struct mm_slab, bucket->free.next, head);

      LIST_ADD(&slab->head, &bucket->used);

   }

   if (!alloc)

      return NULL;

      LIST_DEL(&slab->head);

      LIST_ADD(&slab->head, &bucket->full);

   }

   alloc->offset = *offset;

   alloc->priv = (void *)slab;

}

nouveau_mm_free(struct nouveau_mm_allocation *alloc)

{

   struct mm_slab *slab = (struct mm_slab *)alloc->priv;

   struct mm_bucket *bucket = mm_bucket_by_order(slab->cache, slab->order);

      LIST_DEL(&slab->head);

      LIST_ADDTAIL(&slab->head, &bucket->free);

   } else

   if (slab->free == 1) {

      LIST_DEL(&slab->head);

      LIST_ADDTAIL(&slab->head, &bucket->used);

   }

}

nouveau_mm_free_work(void *data)

{

   nouveau_mm_free(data);

}

nouveau_mm_create(struct nouveau_device *dev, uint32_t domain,

                  union nouveau_bo_config *config)

{

   struct nouveau_mman *cache = MALLOC_STRUCT(nouveau_mman);

   int i;

      return NULL;

   cache->domain = domain;

   cache->config = *config;

   cache->allocated = 0;

      LIST_INITHEAD(&cache->bucket[i].free);

      LIST_INITHEAD(&cache->bucket[i].used);

      LIST_INITHEAD(&cache->bucket[i].full);

   }

}

nouveau_mm_free_slabs(struct list_head *head)

{

   struct mm_slab *slab, *next;

      LIST_DEL(&slab->head);

      nouveau_bo_ref(NULL, &slab->bo);

      FREE(slab);

   }

}

nouveau_mm_destroy(struct nouveau_mman *cache)

{

   int i;

      return;

      if (!LIST_IS_EMPTY(&cache->bucket[i].used) ||

          !LIST_IS_EMPTY(&cache->bucket[i].full))

         debug_printf("WARNING: destroying GPU memory cache "

                      "with some buffers still in use\n");

      nouveau_mm_free_slabs(&cache->bucket[i].used);

      nouveau_mm_free_slabs(&cache->bucket[i].full);

   }

}