src/gallium/auxiliary/pipebuffer/pb_bufmgr_mm.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2006 Tungsten Graphics, Inc., Cedar Park, Texas.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28 /**
  29  * \file
  30  * Buffer manager using the old texture memory manager.
  31  *
  32  * \author Jose Fonseca <jrfonseca@tungstengraphics.com>
  33  */
  34
  35
  36 #include "pipe/p_defines.h"
  37 #include "util/u_debug.h"
  38 #include "os/os_thread.h"
  39 #include "util/u_memory.h"
  40 #include "util/u_double_list.h"
  41 #include "util/u_mm.h"
  42 #include "pb_buffer.h"
  43 #include "pb_bufmgr.h"
  44
  45
  46 /**
  47  * Convenience macro (type safe).
  48  */
  49 #define SUPER(__derived) (&(__derived)->base)
  50
  51
  52 struct mm_pb_manager
  53 {
  54    struct pb_manager base;
  55
  56    pipe_mutex mutex;
  57
  58    pb_size size;
  59    struct mem_block *heap;
  60
  61    pb_size align2;
  62
  63    struct pb_buffer *buffer;
  64    void *map;
  65 };
  66
  67
  68 static INLINE struct mm_pb_manager *
  69 mm_pb_manager(struct pb_manager *mgr)
  70 {
  71    assert(mgr);
  72    return (struct mm_pb_manager *)mgr;
  73 }
  74
  75
  76 struct mm_buffer
  77 {
  78    struct pb_buffer base;
  79
  80    struct mm_pb_manager *mgr;
  81
  82    struct mem_block *block;
  83 };
  84
  85
  86 static INLINE struct mm_buffer *
  87 mm_buffer(struct pb_buffer *buf)
  88 {
  89    assert(buf);
  90    return (struct mm_buffer *)buf;
  91 }
  92
  93
  94 static void
  95 mm_buffer_destroy(struct pb_buffer *buf)
  96 {
  97    struct mm_buffer *mm_buf = mm_buffer(buf);
  98    struct mm_pb_manager *mm = mm_buf->mgr;
  99
 100    assert(!pipe_is_referenced(&mm_buf->base.base.reference));
 101
 102    pipe_mutex_lock(mm->mutex);
 103    u_mmFreeMem(mm_buf->block);
 104    FREE(mm_buf);
 105    pipe_mutex_unlock(mm->mutex);
 106 }
 107
 108
 109 static void *
 110 mm_buffer_map(struct pb_buffer *buf,
 111               unsigned flags)
 112 {
 113    struct mm_buffer *mm_buf = mm_buffer(buf);
 114    struct mm_pb_manager *mm = mm_buf->mgr;
 115
 116    return (unsigned char *) mm->map + mm_buf->block->ofs;
 117 }
 118
 119
 120 static void
 121 mm_buffer_unmap(struct pb_buffer *buf)
 122 {
 123    /* No-op */
 124 }
 125
 126
 127 static enum pipe_error
 128 mm_buffer_validate(struct pb_buffer *buf,
 129                    struct pb_validate *vl,
 130                    unsigned flags)
 131 {
 132    struct mm_buffer *mm_buf = mm_buffer(buf);
 133    struct mm_pb_manager *mm = mm_buf->mgr;
 134    return pb_validate(mm->buffer, vl, flags);
 135 }
 136
 137
 138 static void
 139 mm_buffer_fence(struct pb_buffer *buf,
 140                 struct pipe_fence_handle *fence)
 141 {
 142    struct mm_buffer *mm_buf = mm_buffer(buf);
 143    struct mm_pb_manager *mm = mm_buf->mgr;
 144    pb_fence(mm->buffer, fence);
 145 }
 146
 147
 148 static void
 149 mm_buffer_get_base_buffer(struct pb_buffer *buf,
 150                           struct pb_buffer **base_buf,
 151                           pb_size *offset)
 152 {
 153    struct mm_buffer *mm_buf = mm_buffer(buf);
 154    struct mm_pb_manager *mm = mm_buf->mgr;
 155    pb_get_base_buffer(mm->buffer, base_buf, offset);
 156    *offset += mm_buf->block->ofs;
 157 }
 158
 159
 160 static const struct pb_vtbl
 161 mm_buffer_vtbl = {
 162       mm_buffer_destroy,
 163       mm_buffer_map,
 164       mm_buffer_unmap,
 165       mm_buffer_validate,
 166       mm_buffer_fence,
 167       mm_buffer_get_base_buffer
 168 };
 169
 170
 171 static struct pb_buffer *
 172 mm_bufmgr_create_buffer(struct pb_manager *mgr,
 173                         pb_size size,
 174                         const struct pb_desc *desc)
 175 {
 176    struct mm_pb_manager *mm = mm_pb_manager(mgr);
 177    struct mm_buffer *mm_buf;
 178
 179    /* We don't handle alignments larger then the one initially setup */
 180    assert(pb_check_alignment(desc->alignment, (pb_size)1 << mm->align2));
 181    if(!pb_check_alignment(desc->alignment, (pb_size)1 << mm->align2))
 182       return NULL;
 183
 184    pipe_mutex_lock(mm->mutex);
 185
 186    mm_buf = CALLOC_STRUCT(mm_buffer);
 187    if (!mm_buf) {
 188       pipe_mutex_unlock(mm->mutex);
 189       return NULL;
 190    }
 191
 192    pipe_reference_init(&mm_buf->base.base.reference, 1);
 193    mm_buf->base.base.alignment = desc->alignment;
 194    mm_buf->base.base.usage = desc->usage;
 195    mm_buf->base.base.size = size;
 196
 197    mm_buf->base.vtbl = &mm_buffer_vtbl;
 198
 199    mm_buf->mgr = mm;
 200
 201    mm_buf->block = u_mmAllocMem(mm->heap, (int)size, (int)mm->align2, 0);
 202    if(!mm_buf->block) {
 203 #if 0
 204       debug_printf("warning: heap full\n");
 205       mmDumpMemInfo(mm->heap);
 206 #endif
 207       FREE(mm_buf);
 208       pipe_mutex_unlock(mm->mutex);
 209       return NULL;
 210    }
 211
 212    /* Some sanity checks */
 213    assert(0 <= (pb_size)mm_buf->block->ofs && (pb_size)mm_buf->block->ofs < mm->size);
 214    assert(size <= (pb_size)mm_buf->block->size && (pb_size)mm_buf->block->ofs + (pb_size)mm_buf->block->size <= mm->size);
 215
 216    pipe_mutex_unlock(mm->mutex);
 217    return SUPER(mm_buf);
 218 }
 219
 220
 221 static void
 222 mm_bufmgr_flush(struct pb_manager *mgr)
 223 {
 224    /* No-op */
 225 }
 226
 227
 228 static void
 229 mm_bufmgr_destroy(struct pb_manager *mgr)
 230 {
 231    struct mm_pb_manager *mm = mm_pb_manager(mgr);
 232
 233    pipe_mutex_lock(mm->mutex);
 234
 235    u_mmDestroy(mm->heap);
 236
 237    pb_unmap(mm->buffer);
 238    pb_reference(&mm->buffer, NULL);
 239
 240    pipe_mutex_unlock(mm->mutex);
 241
 242    FREE(mgr);
 243 }
 244
 245
 246 struct pb_manager *
 247 mm_bufmgr_create_from_buffer(struct pb_buffer *buffer,
 248                              pb_size size, pb_size align2)
 249 {
 250    struct mm_pb_manager *mm;
 251
 252    if(!buffer)
 253       return NULL;
 254
 255    mm = CALLOC_STRUCT(mm_pb_manager);
 256    if (!mm)
 257       return NULL;
 258
 259    mm->base.destroy = mm_bufmgr_destroy;
 260    mm->base.create_buffer = mm_bufmgr_create_buffer;
 261    mm->base.flush = mm_bufmgr_flush;
 262
 263    mm->size = size;
 264    mm->align2 = align2; /* 64-byte alignment */
 265
 266    pipe_mutex_init(mm->mutex);
 267
 268    mm->buffer = buffer;
 269
 270    mm->map = pb_map(mm->buffer,
 271                     PB_USAGE_CPU_READ |
 272                     PB_USAGE_CPU_WRITE);
 273    if(!mm->map)
 274       goto failure;
 275
 276    mm->heap = u_mmInit(0, (int)size);
 277    if (!mm->heap)
 278       goto failure;
 279
 280    return SUPER(mm);
 281
 282 failure:
 283 if(mm->heap)
 284    u_mmDestroy(mm->heap);
 285    if(mm->map)
 286       pb_unmap(mm->buffer);
 287    if(mm)
 288       FREE(mm);
 289    return NULL;
 290 }
 291
 292
 293 struct pb_manager *
 294 mm_bufmgr_create(struct pb_manager *provider,
 295                  pb_size size, pb_size align2)
 296 {
 297    struct pb_buffer *buffer;
 298    struct pb_manager *mgr;
 299    struct pb_desc desc;
 300
 301    if(!provider)
 302       return NULL;
 303
 304    memset(&desc, 0, sizeof(desc));
 305    desc.alignment = 1 << align2;
 306
 307    buffer = provider->create_buffer(provider, size, &desc);
 308    if (!buffer)
 309       return NULL;
 310
 311    mgr = mm_bufmgr_create_from_buffer(buffer, size, align2);
 312    if (!mgr) {
 313       pb_reference(&buffer, NULL);
 314       return NULL;
 315    }
 316
 317   return mgr;
 318 }