src/gallium/auxiliary/pipebuffer/pb_bufmgr_ondemand.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2008 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  * A variation of malloc buffers which get transferred to real graphics memory
  31  * when there is an attempt to validate them.
  32  *
  33  * @author Jose Fonseca <jrfonseca@tungstengraphics.com>
  34  */
  35
  36
  37 #include "util/u_debug.h"
  38 #include "util/u_memory.h"
  39 #include "pb_buffer.h"
  40 #include "pb_bufmgr.h"
  41
  42
  43 struct pb_ondemand_manager;
  44
  45
  46 struct pb_ondemand_buffer
  47 {
  48    struct pb_buffer base;
  49
  50    struct pb_ondemand_manager *mgr;
  51
  52    /** Regular malloc'ed memory */
  53    void *data;
  54    unsigned mapcount;
  55
  56    /** Real buffer */
  57    struct pb_buffer *buffer;
  58    size_t size;
  59    struct pb_desc desc;
  60 };
  61
  62
  63 struct pb_ondemand_manager
  64 {
  65    struct pb_manager base;
  66
  67    struct pb_manager *provider;
  68 };
  69
  70
  71 extern const struct pb_vtbl pb_ondemand_buffer_vtbl;
  72
  73 static INLINE struct pb_ondemand_buffer *
  74 pb_ondemand_buffer(struct pb_buffer *buf)
  75 {
  76    assert(buf);
  77    assert(buf->vtbl == &pb_ondemand_buffer_vtbl);
  78    return (struct pb_ondemand_buffer *)buf;
  79 }
  80
  81 static INLINE struct pb_ondemand_manager *
  82 pb_ondemand_manager(struct pb_manager *mgr)
  83 {
  84    assert(mgr);
  85    return (struct pb_ondemand_manager *)mgr;
  86 }
  87
  88
  89 static void
  90 pb_ondemand_buffer_destroy(struct pb_buffer *_buf)
  91 {
  92    struct pb_ondemand_buffer *buf = pb_ondemand_buffer(_buf);
  93
  94    pb_reference(&buf->buffer, NULL);
  95
  96    align_free(buf->data);
  97
  98    FREE(buf);
  99 }
 100
 101
 102 static void *
 103 pb_ondemand_buffer_map(struct pb_buffer *_buf,
 104                        unsigned flags)
 105 {
 106    struct pb_ondemand_buffer *buf = pb_ondemand_buffer(_buf);
 107
 108    if(buf->buffer) {
 109       assert(!buf->data);
 110       return pb_map(buf->buffer, flags);
 111    }
 112    else {
 113       assert(buf->data);
 114       ++buf->mapcount;
 115       return buf->data;
 116    }
 117 }
 118
 119
 120 static void
 121 pb_ondemand_buffer_unmap(struct pb_buffer *_buf)
 122 {
 123    struct pb_ondemand_buffer *buf = pb_ondemand_buffer(_buf);
 124
 125    if(buf->buffer) {
 126       assert(!buf->data);
 127       pb_unmap(buf->buffer);
 128    }
 129    else {
 130       assert(buf->data);
 131       assert(buf->mapcount);
 132       if(buf->mapcount)
 133          --buf->mapcount;
 134    }
 135 }
 136
 137
 138 static enum pipe_error
 139 pb_ondemand_buffer_instantiate(struct pb_ondemand_buffer *buf)
 140 {
 141    if(!buf->buffer) {
 142       struct pb_manager *provider = buf->mgr->provider;
 143       uint8_t *map;
 144
 145       assert(!buf->mapcount);
 146
 147       buf->buffer = provider->create_buffer(provider, buf->size, &buf->desc);
 148       if(!buf->buffer)
 149          return PIPE_ERROR_OUT_OF_MEMORY;
 150
 151       map = pb_map(buf->buffer, PIPE_BUFFER_USAGE_CPU_READ);
 152       if(!map) {
 153          pb_reference(&buf->buffer, NULL);
 154          return PIPE_ERROR;
 155       }
 156
 157       memcpy(map, buf->data, buf->size);
 158
 159       pb_unmap(buf->buffer);
 160
 161       if(!buf->mapcount) {
 162          FREE(buf->data);
 163          buf->data = NULL;
 164       }
 165    }
 166
 167    return PIPE_OK;
 168 }
 169
 170 static enum pipe_error
 171 pb_ondemand_buffer_validate(struct pb_buffer *_buf,
 172                             struct pb_validate *vl,
 173                             unsigned flags)
 174 {
 175    struct pb_ondemand_buffer *buf = pb_ondemand_buffer(_buf);
 176    enum pipe_error ret;
 177
 178    assert(!buf->mapcount);
 179    if(buf->mapcount)
 180       return PIPE_ERROR;
 181
 182    ret = pb_ondemand_buffer_instantiate(buf);
 183    if(ret != PIPE_OK)
 184       return ret;
 185
 186    return pb_validate(buf->buffer, vl, flags);
 187 }
 188
 189
 190 static void
 191 pb_ondemand_buffer_fence(struct pb_buffer *_buf,
 192                          struct pipe_fence_handle *fence)
 193 {
 194    struct pb_ondemand_buffer *buf = pb_ondemand_buffer(_buf);
 195
 196    assert(buf->buffer);
 197    if(!buf->buffer)
 198       return;
 199
 200    pb_fence(buf->buffer, fence);
 201 }
 202
 203
 204 static void
 205 pb_ondemand_buffer_get_base_buffer(struct pb_buffer *_buf,
 206                                    struct pb_buffer **base_buf,
 207                                    unsigned *offset)
 208 {
 209    struct pb_ondemand_buffer *buf = pb_ondemand_buffer(_buf);
 210
 211    if(pb_ondemand_buffer_instantiate(buf) != PIPE_OK) {
 212       assert(0);
 213       *base_buf = &buf->base;
 214       *offset = 0;
 215       return;
 216    }
 217
 218    pb_get_base_buffer(buf->buffer, base_buf, offset);
 219 }
 220
 221
 222 const struct pb_vtbl
 223 pb_ondemand_buffer_vtbl = {
 224       pb_ondemand_buffer_destroy,
 225       pb_ondemand_buffer_map,
 226       pb_ondemand_buffer_unmap,
 227       pb_ondemand_buffer_validate,
 228       pb_ondemand_buffer_fence,
 229       pb_ondemand_buffer_get_base_buffer
 230 };
 231
 232
 233 static struct pb_buffer *
 234 pb_ondemand_manager_create_buffer(struct pb_manager *_mgr,
 235                                   size_t size,
 236                                   const struct pb_desc *desc)
 237 {
 238    struct pb_ondemand_manager *mgr = pb_ondemand_manager(_mgr);
 239    struct pb_ondemand_buffer *buf;
 240
 241    buf = CALLOC_STRUCT(pb_ondemand_buffer);
 242    if(!buf)
 243       return NULL;
 244
 245    buf->base.base.refcount = 1;
 246    buf->base.base.alignment = desc->alignment;
 247    buf->base.base.usage = desc->usage;
 248    buf->base.base.size = size;
 249    buf->base.vtbl = &pb_ondemand_buffer_vtbl;
 250
 251    buf->mgr = mgr;
 252
 253    buf->data = align_malloc(size, desc->alignment < sizeof(void*) ? sizeof(void*) : desc->alignment);
 254    if(!buf->data) {
 255       FREE(buf);
 256       return NULL;
 257    }
 258
 259    buf->size = size;
 260    buf->desc = *desc;
 261
 262    return &buf->base;
 263 }
 264
 265
 266 static void
 267 pb_ondemand_manager_flush(struct pb_manager *_mgr)
 268 {
 269    struct pb_ondemand_manager *mgr = pb_ondemand_manager(_mgr);
 270
 271    mgr->provider->flush(mgr->provider);
 272 }
 273
 274
 275 static void
 276 pb_ondemand_manager_destroy(struct pb_manager *_mgr)
 277 {
 278    struct pb_ondemand_manager *mgr = pb_ondemand_manager(_mgr);
 279
 280    FREE(mgr);
 281 }
 282
 283
 284 struct pb_manager *
 285 pb_ondemand_manager_create(struct pb_manager *provider)
 286 {
 287    struct pb_ondemand_manager *mgr;
 288
 289    if(!provider)
 290       return NULL;
 291
 292    mgr = CALLOC_STRUCT(pb_ondemand_manager);
 293    if(!mgr)
 294       return NULL;
 295
 296    mgr->base.destroy = pb_ondemand_manager_destroy;
 297    mgr->base.create_buffer = pb_ondemand_manager_create_buffer;
 298    mgr->base.flush = pb_ondemand_manager_flush;
 299
 300    mgr->provider = provider;
 301
 302    return &mgr->base;
 303 }