src/mesa/drivers/dri/intel/intel_buffer_objects.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2003 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 #include "main/imports.h"
  30 #include "main/mtypes.h"
  31 #include "main/macros.h"
  32 #include "main/bufferobj.h"
  33
  34 #include "intel_context.h"
  35 #include "intel_blit.h"
  36 #include "intel_buffer_objects.h"
  37 #include "intel_batchbuffer.h"
  38 #include "intel_regions.h"
  39
  40 static GLboolean
  41 intel_bufferobj_unmap(GLcontext * ctx,
  42                       GLenum target, struct gl_buffer_object *obj);
  43
  44 /** Allocates a new dri_bo to store the data for the buffer object. */
  45 static void
  46 intel_bufferobj_alloc_buffer(struct intel_context *intel,
  47                              struct intel_buffer_object *intel_obj)
  48 {
  49    intel_obj->buffer = dri_bo_alloc(intel->bufmgr, "bufferobj",
  50                                     intel_obj->Base.Size, 64);
  51 }
  52
  53 /**
  54  * There is some duplication between mesa's bufferobjects and our
  55  * bufmgr buffers.  Both have an integer handle and a hashtable to
  56  * lookup an opaque structure.  It would be nice if the handles and
  57  * internal structure where somehow shared.
  58  */
  59 static struct gl_buffer_object *
  60 intel_bufferobj_alloc(GLcontext * ctx, GLuint name, GLenum target)
  61 {
  62    struct intel_buffer_object *obj = CALLOC_STRUCT(intel_buffer_object);
  63
  64    _mesa_initialize_buffer_object(&obj->Base, name, target);
  65
  66    obj->buffer = NULL;
  67
  68    return &obj->Base;
  69 }
  70
  71 /* Break the COW tie to the region.  The region gets to keep the data.
  72  */
  73 void
  74 intel_bufferobj_release_region(struct intel_context *intel,
  75                                struct intel_buffer_object *intel_obj)
  76 {
  77    assert(intel_obj->region->buffer == intel_obj->buffer);
  78    intel_obj->region->pbo = NULL;
  79    intel_obj->region = NULL;
  80
  81    dri_bo_unreference(intel_obj->buffer);
  82    intel_obj->buffer = NULL;
  83 }
  84
  85 /* Break the COW tie to the region.  Both the pbo and the region end
  86  * up with a copy of the data.
  87  */
  88 void
  89 intel_bufferobj_cow(struct intel_context *intel,
  90                     struct intel_buffer_object *intel_obj)
  91 {
  92    assert(intel_obj->region);
  93    intel_region_cow(intel, intel_obj->region);
  94 }
  95
  96
  97 /**
  98  * Deallocate/free a vertex/pixel buffer object.
  99  * Called via glDeleteBuffersARB().
 100  */
 101 static void
 102 intel_bufferobj_free(GLcontext * ctx, struct gl_buffer_object *obj)
 103 {
 104    struct intel_context *intel = intel_context(ctx);
 105    struct intel_buffer_object *intel_obj = intel_buffer_object(obj);
 106
 107    assert(intel_obj);
 108
 109    /* Buffer objects are automatically unmapped when deleting according
 110     * to the spec, but Mesa doesn't do UnmapBuffer for us at context destroy
 111     * (though it does if you call glDeleteBuffers)
 112     */
 113    if (obj->Pointer)
 114       intel_bufferobj_unmap(ctx, 0, obj);
 115
 116    _mesa_free(intel_obj->sys_buffer);
 117    if (intel_obj->region) {
 118       intel_bufferobj_release_region(intel, intel_obj);
 119    }
 120    else if (intel_obj->buffer) {
 121       dri_bo_unreference(intel_obj->buffer);
 122    }
 123
 124    _mesa_free(intel_obj);
 125 }
 126
 127
 128
 129 /**
 130  * Allocate space for and store data in a buffer object.  Any data that was
 131  * previously stored in the buffer object is lost.  If data is NULL,
 132  * memory will be allocated, but no copy will occur.
 133  * Called via ctx->Driver.BufferData().
 134  * \return GL_TRUE for success, GL_FALSE if out of memory
 135  */
 136 static GLboolean
 137 intel_bufferobj_data(GLcontext * ctx,
 138                      GLenum target,
 139                      GLsizeiptrARB size,
 140                      const GLvoid * data,
 141                      GLenum usage, struct gl_buffer_object *obj)
 142 {
 143    struct intel_context *intel = intel_context(ctx);
 144    struct intel_buffer_object *intel_obj = intel_buffer_object(obj);
 145
 146    intel_obj->Base.Size = size;
 147    intel_obj->Base.Usage = usage;
 148
 149    assert(!obj->Pointer); /* Mesa should have unmapped it */
 150
 151    if (intel_obj->region)
 152       intel_bufferobj_release_region(intel, intel_obj);
 153
 154    if (intel_obj->buffer != NULL) {
 155       dri_bo_unreference(intel_obj->buffer);
 156       intel_obj->buffer = NULL;
 157    }
 158    _mesa_free(intel_obj->sys_buffer);
 159    intel_obj->sys_buffer = NULL;
 160
 161    if (size != 0) {
 162 #ifdef I915
 163       /* On pre-965, stick VBOs in system memory, as we're always doing swtnl
 164        * with their contents anyway.
 165        */
 166       if (target == GL_ARRAY_BUFFER || target == GL_ELEMENT_ARRAY_BUFFER) {
 167          intel_obj->sys_buffer = _mesa_malloc(size);
 168          if (intel_obj->sys_buffer != NULL) {
 169             if (data != NULL)
 170                memcpy(intel_obj->sys_buffer, data, size);
 171             return GL_TRUE;
 172          }
 173       }
 174 #endif
 175       intel_bufferobj_alloc_buffer(intel, intel_obj);
 176       if (!intel_obj->buffer)
 177          return GL_FALSE;
 178
 179       if (data != NULL)
 180          dri_bo_subdata(intel_obj->buffer, 0, size, data);
 181    }
 182
 183    return GL_TRUE;
 184 }
 185
 186
 187 /**
 188  * Replace data in a subrange of buffer object.  If the data range
 189  * specified by size + offset extends beyond the end of the buffer or
 190  * if data is NULL, no copy is performed.
 191  * Called via glBufferSubDataARB().
 192  */
 193 static void
 194 intel_bufferobj_subdata(GLcontext * ctx,
 195                         GLenum target,
 196                         GLintptrARB offset,
 197                         GLsizeiptrARB size,
 198                         const GLvoid * data, struct gl_buffer_object *obj)
 199 {
 200    struct intel_context *intel = intel_context(ctx);
 201    struct intel_buffer_object *intel_obj = intel_buffer_object(obj);
 202
 203    assert(intel_obj);
 204
 205    if (intel_obj->region)
 206       intel_bufferobj_cow(intel, intel_obj);
 207
 208    if (intel_obj->sys_buffer)
 209       memcpy((char *)intel_obj->sys_buffer + offset, data, size);
 210    else {
 211       /* Flush any existing batchbuffer that might reference this data. */
 212       if (drm_intel_bo_busy(intel_obj->buffer) ||
 213           drm_intel_bo_references(intel->batch->buf, intel_obj->buffer)) {
 214          drm_intel_bo *temp_bo;
 215
 216          temp_bo = drm_intel_bo_alloc(intel->bufmgr, "subdata temp", size, 64);
 217
 218          drm_intel_bo_subdata(temp_bo, 0, size, data);
 219
 220          intel_emit_linear_blit(intel,
 221                                 intel_obj->buffer, offset,
 222                                 temp_bo, 0,
 223                                 size);
 224
 225          drm_intel_bo_unreference(temp_bo);
 226       } else {
 227          dri_bo_subdata(intel_obj->buffer, offset, size, data);
 228       }
 229    }
 230 }
 231
 232
 233 /**
 234  * Called via glGetBufferSubDataARB().
 235  */
 236 static void
 237 intel_bufferobj_get_subdata(GLcontext * ctx,
 238                             GLenum target,
 239                             GLintptrARB offset,
 240                             GLsizeiptrARB size,
 241                             GLvoid * data, struct gl_buffer_object *obj)
 242 {
 243    struct intel_buffer_object *intel_obj = intel_buffer_object(obj);
 244
 245    assert(intel_obj);
 246    if (intel_obj->sys_buffer)
 247       memcpy(data, (char *)intel_obj->sys_buffer + offset, size);
 248    else
 249       dri_bo_get_subdata(intel_obj->buffer, offset, size, data);
 250 }
 251
 252
 253
 254 /**
 255  * Called via glMapBufferARB().
 256  */
 257 static void *
 258 intel_bufferobj_map(GLcontext * ctx,
 259                     GLenum target,
 260                     GLenum access, struct gl_buffer_object *obj)
 261 {
 262    struct intel_context *intel = intel_context(ctx);
 263    struct intel_buffer_object *intel_obj = intel_buffer_object(obj);
 264    GLboolean read_only = (access == GL_READ_ONLY_ARB);
 265    GLboolean write_only = (access == GL_WRITE_ONLY_ARB);
 266
 267    assert(intel_obj);
 268
 269    if (intel_obj->sys_buffer) {
 270       obj->Pointer = intel_obj->sys_buffer;
 271       obj->Length = obj->Size;
 272       obj->Offset = 0;
 273       return obj->Pointer;
 274    }
 275
 276    /* Flush any existing batchbuffer that might reference this data. */
 277    if (drm_intel_bo_references(intel->batch->buf, intel_obj->buffer))
 278       intelFlush(ctx);
 279
 280    if (intel_obj->region)
 281       intel_bufferobj_cow(intel, intel_obj);
 282
 283    if (intel_obj->buffer == NULL) {
 284       obj->Pointer = NULL;
 285       return NULL;
 286    }
 287
 288    if (write_only && intel->intelScreen->kernel_exec_fencing) {
 289       drm_intel_gem_bo_map_gtt(intel_obj->buffer);
 290       intel_obj->mapped_gtt = GL_TRUE;
 291    } else {
 292       drm_intel_bo_map(intel_obj->buffer, !read_only);
 293       intel_obj->mapped_gtt = GL_FALSE;
 294    }
 295
 296    obj->Pointer = intel_obj->buffer->virtual;
 297    obj->Length = obj->Size;
 298    obj->Offset = 0;
 299
 300    return obj->Pointer;
 301 }
 302
 303 /**
 304  * Called via glMapBufferRange().
 305  *
 306  * The goal of this extension is to allow apps to accumulate their rendering
 307  * at the same time as they accumulate their buffer object.  Without it,
 308  * you'd end up blocking on execution of rendering every time you mapped
 309  * the buffer to put new data in.
 310  *
 311  * We support it in 3 ways: If unsynchronized, then don't bother
 312  * flushing the batchbuffer before mapping the buffer, which can save blocking
 313  * in many cases.  If we would still block, and they allow the whole buffer
 314  * to be invalidated, then just allocate a new buffer to replace the old one.
 315  * If not, and we'd block, and they allow the subrange of the buffer to be
 316  * invalidated, then we can make a new little BO, let them write into that,
 317  * and blit it into the real BO at unmap time.
 318  */
 319 static void *
 320 intel_bufferobj_map_range(GLcontext * ctx,
 321                           GLenum target, GLintptr offset, GLsizeiptr length,
 322                           GLbitfield access, struct gl_buffer_object *obj)
 323 {
 324    struct intel_context *intel = intel_context(ctx);
 325    struct intel_buffer_object *intel_obj = intel_buffer_object(obj);
 326
 327    assert(intel_obj);
 328
 329    /* _mesa_MapBufferRange (GL entrypoint) sets these, but the vbo module also
 330     * internally uses our functions directly.
 331     */
 332    obj->Offset = offset;
 333    obj->Length = length;
 334    obj->AccessFlags = access;
 335
 336    if (intel_obj->sys_buffer) {
 337       obj->Pointer = intel_obj->sys_buffer + offset;
 338       return obj->Pointer;
 339    }
 340
 341    if (intel_obj->region)
 342       intel_bufferobj_cow(intel, intel_obj);
 343
 344    /* If the mapping is synchronized with other GL operations, flush
 345     * the batchbuffer so that GEM knows about the buffer access for later
 346     * syncing.
 347     */
 348    if (!(access & GL_MAP_UNSYNCHRONIZED_BIT) &&
 349        drm_intel_bo_references(intel->batch->buf, intel_obj->buffer))
 350       intelFlush(ctx);
 351
 352    if (intel_obj->buffer == NULL) {
 353       obj->Pointer = NULL;
 354       return NULL;
 355    }
 356
 357    /* If the user doesn't care about existing buffer contents and mapping
 358     * would cause us to block, then throw out the old buffer.
 359     */
 360    if (!(access & GL_MAP_UNSYNCHRONIZED_BIT) &&
 361        (access & GL_MAP_INVALIDATE_BUFFER_BIT) &&
 362        drm_intel_bo_busy(intel_obj->buffer)) {
 363       drm_intel_bo_unreference(intel_obj->buffer);
 364       intel_obj->buffer = dri_bo_alloc(intel->bufmgr, "bufferobj",
 365                                        intel_obj->Base.Size, 64);
 366    }
 367
 368    /* If the user is mapping a range of an active buffer object but
 369     * doesn't require the current contents of that range, make a new
 370     * BO, and we'll copy what they put in there out at unmap or
 371     * FlushRange time.
 372     */
 373    if ((access & GL_MAP_INVALIDATE_RANGE_BIT) &&
 374        drm_intel_bo_busy(intel_obj->buffer)) {
 375       if (access & GL_MAP_FLUSH_EXPLICIT_BIT) {
 376          intel_obj->range_map_buffer = _mesa_malloc(length);
 377          obj->Pointer = intel_obj->range_map_buffer;
 378       } else {
 379          intel_obj->range_map_bo = drm_intel_bo_alloc(intel->bufmgr,
 380                                                       "range map",
 381                                                       length, 64);
 382          if (!(access & GL_MAP_READ_BIT) &&
 383              intel->intelScreen->kernel_exec_fencing) {
 384             drm_intel_gem_bo_map_gtt(intel_obj->range_map_bo);
 385             intel_obj->mapped_gtt = GL_TRUE;
 386          } else {
 387             drm_intel_bo_map(intel_obj->range_map_bo,
 388                              (access & GL_MAP_WRITE_BIT) != 0);
 389             intel_obj->mapped_gtt = GL_FALSE;
 390          }
 391          obj->Pointer = intel_obj->range_map_bo->virtual;
 392       }
 393       return obj->Pointer;
 394    }
 395
 396    if (!(access & GL_MAP_READ_BIT) &&
 397        intel->intelScreen->kernel_exec_fencing) {
 398       drm_intel_gem_bo_map_gtt(intel_obj->buffer);
 399       intel_obj->mapped_gtt = GL_TRUE;
 400    } else {
 401       drm_intel_bo_map(intel_obj->buffer, (access & GL_MAP_WRITE_BIT) != 0);
 402       intel_obj->mapped_gtt = GL_FALSE;
 403    }
 404
 405    obj->Pointer = intel_obj->buffer->virtual + offset;
 406    return obj->Pointer;
 407 }
 408
 409 /* Ideally we'd use a BO to avoid taking up cache space for the temporary
 410  * data, but FlushMappedBufferRange may be followed by further writes to
 411  * the pointer, so we would have to re-map after emitting our blit, which
 412  * would defeat the point.
 413  */
 414 static void
 415 intel_bufferobj_flush_mapped_range(GLcontext *ctx, GLenum target,
 416                                    GLintptr offset, GLsizeiptr length,
 417                                    struct gl_buffer_object *obj)
 418 {
 419    struct intel_context *intel = intel_context(ctx);
 420    struct intel_buffer_object *intel_obj = intel_buffer_object(obj);
 421    drm_intel_bo *temp_bo;
 422
 423    /* Unless we're in the range map using a temporary system buffer,
 424     * there's no work to do.
 425     */
 426    if (intel_obj->range_map_buffer == NULL)
 427       return;
 428
 429    temp_bo = drm_intel_bo_alloc(intel->bufmgr, "range map flush", length, 64);
 430
 431    drm_intel_bo_subdata(temp_bo, 0, length, intel_obj->range_map_buffer);
 432
 433    intel_emit_linear_blit(intel,
 434                           intel_obj->buffer, obj->Offset + offset,
 435                           temp_bo, 0,
 436                           length);
 437
 438    drm_intel_bo_unreference(temp_bo);
 439 }
 440
 441
 442 /**
 443  * Called via glUnmapBuffer().
 444  */
 445 static GLboolean
 446 intel_bufferobj_unmap(GLcontext * ctx,
 447                       GLenum target, struct gl_buffer_object *obj)
 448 {
 449    struct intel_context *intel = intel_context(ctx);
 450    struct intel_buffer_object *intel_obj = intel_buffer_object(obj);
 451
 452    assert(intel_obj);
 453    assert(obj->Pointer);
 454    if (intel_obj->sys_buffer != NULL) {
 455       /* always keep the mapping around. */
 456    } else if (intel_obj->range_map_buffer != NULL) {
 457       /* Since we've emitted some blits to buffers that will (likely) be used
 458        * in rendering operations in other cache domains in this batch, emit a
 459        * flush.  Once again, we wish for a domain tracker in libdrm to cover
 460        * usage inside of a batchbuffer.
 461        */
 462       intel_batchbuffer_emit_mi_flush(intel->batch);
 463       free(intel_obj->range_map_buffer);
 464       intel_obj->range_map_buffer = NULL;
 465    } else if (intel_obj->range_map_bo != NULL) {
 466       if (intel_obj->mapped_gtt) {
 467          drm_intel_gem_bo_unmap_gtt(intel_obj->range_map_bo);
 468       } else {
 469          drm_intel_bo_unmap(intel_obj->range_map_bo);
 470       }
 471
 472       intel_emit_linear_blit(intel,
 473                              intel_obj->buffer, obj->Offset,
 474                              intel_obj->range_map_bo, 0,
 475                              obj->Length);
 476
 477       /* Since we've emitted some blits to buffers that will (likely) be used
 478        * in rendering operations in other cache domains in this batch, emit a
 479        * flush.  Once again, we wish for a domain tracker in libdrm to cover
 480        * usage inside of a batchbuffer.
 481        */
 482       intel_batchbuffer_emit_mi_flush(intel->batch);
 483
 484       drm_intel_bo_unreference(intel_obj->range_map_bo);
 485       intel_obj->range_map_bo = NULL;
 486    } else if (intel_obj->buffer != NULL) {
 487       if (intel_obj->mapped_gtt) {
 488          drm_intel_gem_bo_unmap_gtt(intel_obj->buffer);
 489       } else {
 490          drm_intel_bo_unmap(intel_obj->buffer);
 491       }
 492    }
 493    obj->Pointer = NULL;
 494    obj->Offset = 0;
 495    obj->Length = 0;
 496
 497    return GL_TRUE;
 498 }
 499
 500 dri_bo *
 501 intel_bufferobj_buffer(struct intel_context *intel,
 502                        struct intel_buffer_object *intel_obj, GLuint flag)
 503 {
 504    if (intel_obj->region) {
 505       if (flag == INTEL_WRITE_PART)
 506          intel_bufferobj_cow(intel, intel_obj);
 507       else if (flag == INTEL_WRITE_FULL) {
 508          intel_bufferobj_release_region(intel, intel_obj);
 509          intel_bufferobj_alloc_buffer(intel, intel_obj);
 510       }
 511    }
 512
 513    if (intel_obj->buffer == NULL) {
 514       void *sys_buffer = intel_obj->sys_buffer;
 515
 516       /* only one of buffer and sys_buffer could be non-NULL */
 517       intel_bufferobj_alloc_buffer(intel, intel_obj);
 518       intel_obj->sys_buffer = NULL;
 519
 520       intel_bufferobj_subdata(&intel->ctx,
 521                               GL_ARRAY_BUFFER_ARB,
 522                               0,
 523                               intel_obj->Base.Size,
 524                               sys_buffer,
 525                               &intel_obj->Base);
 526       _mesa_free(sys_buffer);
 527       intel_obj->sys_buffer = NULL;
 528    }
 529
 530    return intel_obj->buffer;
 531 }
 532
 533 static void
 534 intel_bufferobj_copy_subdata(GLcontext *ctx,
 535                              struct gl_buffer_object *src,
 536                              struct gl_buffer_object *dst,
 537                              GLintptr read_offset, GLintptr write_offset,
 538                              GLsizeiptr size)
 539 {
 540    struct intel_context *intel = intel_context(ctx);
 541    struct intel_buffer_object *intel_src = intel_buffer_object(src);
 542    struct intel_buffer_object *intel_dst = intel_buffer_object(dst);
 543    drm_intel_bo *src_bo, *dst_bo;
 544
 545    if (size == 0)
 546       return;
 547
 548    /* If we're in system memory, just map and memcpy. */
 549    if (intel_src->sys_buffer || intel_dst->sys_buffer) {
 550       /* The same buffer may be used, but note that regions copied may
 551        * not overlap.
 552        */
 553       if (src == dst) {
 554          char *ptr = intel_bufferobj_map(ctx, GL_COPY_WRITE_BUFFER,
 555                                          GL_READ_WRITE, dst);
 556          memcpy(ptr + write_offset, ptr + read_offset, size);
 557          intel_bufferobj_unmap(ctx, GL_COPY_WRITE_BUFFER, dst);
 558       } else {
 559          const char *src_ptr;
 560          char *dst_ptr;
 561
 562          src_ptr =  intel_bufferobj_map(ctx, GL_COPY_READ_BUFFER,
 563                                         GL_READ_ONLY, src);
 564          dst_ptr =  intel_bufferobj_map(ctx, GL_COPY_WRITE_BUFFER,
 565                                         GL_WRITE_ONLY, dst);
 566
 567          memcpy(dst_ptr + write_offset, src_ptr + read_offset, size);
 568
 569          intel_bufferobj_unmap(ctx, GL_COPY_READ_BUFFER, src);
 570          intel_bufferobj_unmap(ctx, GL_COPY_WRITE_BUFFER, dst);
 571       }
 572    }
 573
 574    /* Otherwise, we have real BOs, so blit them. */
 575
 576    dst_bo = intel_bufferobj_buffer(intel, intel_dst, INTEL_WRITE_PART);
 577    src_bo = intel_bufferobj_buffer(intel, intel_src, INTEL_READ);
 578
 579    intel_emit_linear_blit(intel,
 580                           dst_bo, write_offset,
 581                           src_bo, read_offset, size);
 582
 583    /* Since we've emitted some blits to buffers that will (likely) be used
 584     * in rendering operations in other cache domains in this batch, emit a
 585     * flush.  Once again, we wish for a domain tracker in libdrm to cover
 586     * usage inside of a batchbuffer.
 587     */
 588    intel_batchbuffer_emit_mi_flush(intel->batch);
 589 }
 590
 591 void
 592 intelInitBufferObjectFuncs(struct dd_function_table *functions)
 593 {
 594    functions->NewBufferObject = intel_bufferobj_alloc;
 595    functions->DeleteBuffer = intel_bufferobj_free;
 596    functions->BufferData = intel_bufferobj_data;
 597    functions->BufferSubData = intel_bufferobj_subdata;
 598    functions->GetBufferSubData = intel_bufferobj_get_subdata;
 599    functions->MapBuffer = intel_bufferobj_map;
 600    functions->MapBufferRange = intel_bufferobj_map_range;
 601    functions->FlushMappedBufferRange = intel_bufferobj_flush_mapped_range;
 602    functions->UnmapBuffer = intel_bufferobj_unmap;
 603    functions->CopyBufferSubData = intel_bufferobj_copy_subdata;
 604 }