src/gallium/drivers/ilo/core/ilo_builder.c

   1 /*
   2  * Mesa 3-D graphics library
   3  *
   4  * Copyright (C) 2014 LunarG, Inc.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included
  14  * in all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  21  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  22  * DEALINGS IN THE SOFTWARE.
  23  *
  24  * Authors:
  25  *    Chia-I Wu <olv@lunarg.com>
  26  */
  27
  28 #include "util/u_memory.h"
  29
  30 #include "ilo_builder.h"
  31 #include "ilo_builder_render.h" /* for ilo_builder_batch_patch_sba() */
  32
  33 enum ilo_builder_writer_flags {
  34    /*
  35     * When this bit is set, ilo_builder_begin() will not realllocate.  New
  36     * data will be appended instead.
  37     */
  38    WRITER_FLAG_APPEND    = 1 << 0,
  39
  40    /*
  41     * When this bit is set, the writer grows when full.  When not, callers
  42     * must make sure the writer never needs to grow.
  43     */
  44    WRITER_FLAG_GROW      = 1 << 1,
  45
  46    /*
  47     * The writer will be mapped directly.
  48     */
  49    WRITER_FLAG_MAP       = 1 << 2,
  50 };
  51
  52 /**
  53  * Set the initial size and flags of a writer.
  54  */
  55 static void
  56 ilo_builder_writer_init(struct ilo_builder *builder,
  57                         enum ilo_builder_writer_type which)
  58 {
  59    struct ilo_builder_writer *writer = &builder->writers[which];
  60
  61    switch (which) {
  62    case ILO_BUILDER_WRITER_BATCH:
  63       writer->size = sizeof(uint32_t) * 8192;
  64       break;
  65    case ILO_BUILDER_WRITER_INSTRUCTION:
  66       /*
  67        * The EUs pretch some instructions.  But since the kernel invalidates
  68        * the instruction cache between batch buffers, we can set
  69        * WRITER_FLAG_APPEND without worrying the EUs would see invalid
  70        * instructions prefetched.
  71        */
  72       writer->flags = WRITER_FLAG_APPEND | WRITER_FLAG_GROW;
  73       writer->size = 8192;
  74       break;
  75    default:
  76       assert(!"unknown builder writer");
  77       return;
  78       break;
  79    }
  80
  81    if (builder->dev->has_llc)
  82       writer->flags |= WRITER_FLAG_MAP;
  83 }
  84
  85 /**
  86  * Free all resources used by a writer.  Note that the initial size is not
  87  * reset.
  88  */
  89 static void
  90 ilo_builder_writer_reset(struct ilo_builder *builder,
  91                          enum ilo_builder_writer_type which)
  92 {
  93    struct ilo_builder_writer *writer = &builder->writers[which];
  94
  95    if (writer->ptr) {
  96       if (writer->flags & WRITER_FLAG_MAP)
  97          intel_bo_unmap(writer->bo);
  98       else
  99          FREE(writer->ptr);
 100
 101       writer->ptr = NULL;
 102    }
 103
 104    intel_bo_unref(writer->bo);
 105    writer->bo = NULL;
 106
 107    writer->used = 0;
 108    writer->stolen = 0;
 109
 110    if (writer->items) {
 111       FREE(writer->items);
 112       writer->item_alloc = 0;
 113       writer->item_used = 0;
 114    }
 115 }
 116
 117 /**
 118  * Discard everything written so far.
 119  */
 120 void
 121 ilo_builder_writer_discard(struct ilo_builder *builder,
 122                            enum ilo_builder_writer_type which)
 123 {
 124    struct ilo_builder_writer *writer = &builder->writers[which];
 125
 126    intel_bo_truncate_relocs(writer->bo, 0);
 127    writer->used = 0;
 128    writer->stolen = 0;
 129    writer->item_used = 0;
 130 }
 131
 132 static struct intel_bo *
 133 alloc_writer_bo(struct intel_winsys *winsys,
 134                 enum ilo_builder_writer_type which,
 135                 unsigned size)
 136 {
 137    static const char *writer_names[ILO_BUILDER_WRITER_COUNT] = {
 138       [ILO_BUILDER_WRITER_BATCH] = "batch",
 139       [ILO_BUILDER_WRITER_INSTRUCTION] = "instruction",
 140    };
 141
 142    return intel_winsys_alloc_bo(winsys, writer_names[which], size, true);
 143 }
 144
 145 static void *
 146 map_writer_bo(struct intel_bo *bo, unsigned flags)
 147 {
 148    assert(flags & WRITER_FLAG_MAP);
 149
 150    if (flags & WRITER_FLAG_APPEND)
 151       return intel_bo_map_gtt_async(bo);
 152    else
 153       return intel_bo_map(bo, true);
 154 }
 155
 156 /**
 157  * Allocate and map the buffer for writing.
 158  */
 159 static bool
 160 ilo_builder_writer_alloc_and_map(struct ilo_builder *builder,
 161                                  enum ilo_builder_writer_type which)
 162 {
 163    struct ilo_builder_writer *writer = &builder->writers[which];
 164
 165    /* allocate a new bo when not appending */
 166    if (!(writer->flags & WRITER_FLAG_APPEND) || !writer->bo) {
 167       struct intel_bo *bo;
 168
 169       bo = alloc_writer_bo(builder->winsys, which, writer->size);
 170       if (bo) {
 171          intel_bo_unref(writer->bo);
 172          writer->bo = bo;
 173       } else if (writer->bo) {
 174          /* reuse the old bo */
 175          ilo_builder_writer_discard(builder, which);
 176       } else {
 177          return false;
 178       }
 179
 180       writer->used = 0;
 181       writer->stolen = 0;
 182       writer->item_used = 0;
 183    }
 184
 185    /* map the bo or allocate the staging system memory */
 186    if (writer->flags & WRITER_FLAG_MAP)
 187       writer->ptr = map_writer_bo(writer->bo, writer->flags);
 188    else if (!writer->ptr)
 189       writer->ptr = MALLOC(writer->size);
 190
 191    return (writer->ptr != NULL);
 192 }
 193
 194 /**
 195  * Unmap the buffer for submission.
 196  */
 197 static bool
 198 ilo_builder_writer_unmap(struct ilo_builder *builder,
 199                          enum ilo_builder_writer_type which)
 200 {
 201    struct ilo_builder_writer *writer = &builder->writers[which];
 202    unsigned offset;
 203    int err = 0;
 204
 205    if (writer->flags & WRITER_FLAG_MAP) {
 206       intel_bo_unmap(writer->bo);
 207       writer->ptr = NULL;
 208       return true;
 209    }
 210
 211    offset = builder->begin_used[which];
 212    if (writer->used > offset) {
 213       err = intel_bo_pwrite(writer->bo, offset, writer->used - offset,
 214             (char *) writer->ptr + offset);
 215    }
 216
 217    if (writer->stolen && !err) {
 218       const unsigned offset = writer->size - writer->stolen;
 219       err = intel_bo_pwrite(writer->bo, offset, writer->stolen,
 220             (const char *) writer->ptr + offset);
 221    }
 222
 223    /* keep writer->ptr */
 224
 225    return !err;
 226 }
 227
 228 /**
 229  * Grow a mapped writer to at least \p new_size.
 230  */
 231 bool
 232 ilo_builder_writer_grow(struct ilo_builder *builder,
 233                         enum ilo_builder_writer_type which,
 234                         unsigned new_size, bool preserve)
 235 {
 236    struct ilo_builder_writer *writer = &builder->writers[which];
 237    struct intel_bo *new_bo;
 238    void *new_ptr;
 239
 240    if (!(writer->flags & WRITER_FLAG_GROW))
 241       return false;
 242
 243    /* stolen data may already be referenced and cannot be moved */
 244    if (writer->stolen)
 245       return false;
 246
 247    if (new_size < writer->size << 1)
 248       new_size = writer->size << 1;
 249    /* STATE_BASE_ADDRESS requires page-aligned buffers */
 250    new_size = align(new_size, 4096);
 251
 252    new_bo = alloc_writer_bo(builder->winsys, which, new_size);
 253    if (!new_bo)
 254       return false;
 255
 256    /* map and copy the data over */
 257    if (writer->flags & WRITER_FLAG_MAP) {
 258       new_ptr = map_writer_bo(new_bo, writer->flags);
 259
 260       /*
 261        * When WRITER_FLAG_APPEND and WRITER_FLAG_GROW are both set, we may end
 262        * up copying between two GTT-mapped BOs.  That is slow.  The issue
 263        * could be solved by adding intel_bo_map_async(), or callers may choose
 264        * to manually grow the writer without preserving the data.
 265        */
 266       if (new_ptr && preserve)
 267          memcpy(new_ptr, writer->ptr, writer->used);
 268    } else if (preserve) {
 269       new_ptr = REALLOC(writer->ptr, writer->size, new_size);
 270    } else {
 271       new_ptr = MALLOC(new_size);
 272    }
 273
 274    if (!new_ptr) {
 275       intel_bo_unref(new_bo);
 276       return false;
 277    }
 278
 279    if (writer->flags & WRITER_FLAG_MAP)
 280       intel_bo_unmap(writer->bo);
 281    else if (!preserve)
 282       FREE(writer->ptr);
 283
 284    intel_bo_unref(writer->bo);
 285
 286    writer->size = new_size;
 287    writer->bo = new_bo;
 288    writer->ptr = new_ptr;
 289
 290    return true;
 291 }
 292
 293 /**
 294  * Record an item for later decoding.
 295  */
 296 bool
 297 ilo_builder_writer_record(struct ilo_builder *builder,
 298                           enum ilo_builder_writer_type which,
 299                           enum ilo_builder_item_type type,
 300                           unsigned offset, unsigned size)
 301 {
 302    struct ilo_builder_writer *writer = &builder->writers[which];
 303    struct ilo_builder_item *item;
 304
 305    if (writer->item_used == writer->item_alloc) {
 306       const unsigned new_alloc = (writer->item_alloc) ?
 307          writer->item_alloc << 1 : 256;
 308       struct ilo_builder_item *items;
 309
 310       items = REALLOC(writer->items,
 311             sizeof(writer->items[0]) * writer->item_alloc,
 312             sizeof(writer->items[0]) * new_alloc);
 313       if (!items)
 314          return false;
 315
 316       writer->items = items;
 317       writer->item_alloc = new_alloc;
 318    }
 319
 320    item = &writer->items[writer->item_used++];
 321    item->type = type;
 322    item->offset = offset;
 323    item->size = size;
 324
 325    return true;
 326 }
 327
 328 /**
 329  * Initialize the builder.
 330  */
 331 void
 332 ilo_builder_init(struct ilo_builder *builder,
 333                  const struct ilo_dev *dev,
 334                  struct intel_winsys *winsys)
 335 {
 336    unsigned i;
 337
 338    assert(ilo_is_zeroed(builder, sizeof(*builder)));
 339
 340    builder->dev = dev;
 341    builder->winsys = winsys;
 342
 343    /* gen6_SURFACE_STATE() may override this */
 344    switch (ilo_dev_gen(dev)) {
 345    case ILO_GEN(8):
 346       builder->mocs = GEN8_MOCS_MT_WB | GEN8_MOCS_CT_L3;
 347       break;
 348    case ILO_GEN(7.5):
 349    case ILO_GEN(7):
 350       builder->mocs = GEN7_MOCS_L3_WB;
 351       break;
 352    default:
 353       builder->mocs = 0;
 354       break;
 355    }
 356
 357    for (i = 0; i < ILO_BUILDER_WRITER_COUNT; i++)
 358       ilo_builder_writer_init(builder, i);
 359 }
 360
 361 /**
 362  * Reset the builder and free all resources used.  After resetting, the
 363  * builder behaves as if it is newly initialized, except for potentially
 364  * larger initial bo sizes.
 365  */
 366 void
 367 ilo_builder_reset(struct ilo_builder *builder)
 368 {
 369    unsigned i;
 370
 371    for (i = 0; i < ILO_BUILDER_WRITER_COUNT; i++)
 372       ilo_builder_writer_reset(builder, i);
 373 }
 374
 375 /**
 376  * Allocate and map the BOs.  It may re-allocate or reuse existing BOs if
 377  * there is any.
 378  *
 379  * Most builder functions can only be called after ilo_builder_begin() and
 380  * before ilo_builder_end().
 381  */
 382 bool
 383 ilo_builder_begin(struct ilo_builder *builder)
 384 {
 385    unsigned i;
 386
 387    for (i = 0; i < ILO_BUILDER_WRITER_COUNT; i++) {
 388       if (!ilo_builder_writer_alloc_and_map(builder, i)) {
 389          ilo_builder_reset(builder);
 390          return false;
 391       }
 392
 393       builder->begin_used[i] = builder->writers[i].used;
 394    }
 395
 396    builder->unrecoverable_error = false;
 397    builder->sba_instruction_pos = 0;
 398
 399    return true;
 400 }
 401
 402 /**
 403  * Unmap BOs and make sure the written data landed the BOs.  The batch buffer
 404  * ready for submission is returned.
 405  */
 406 struct intel_bo *
 407 ilo_builder_end(struct ilo_builder *builder, unsigned *used)
 408 {
 409    struct ilo_builder_writer *bat;
 410    unsigned i;
 411
 412    ilo_builder_batch_patch_sba(builder);
 413
 414    assert(ilo_builder_validate(builder, 0, NULL));
 415
 416    for (i = 0; i < ILO_BUILDER_WRITER_COUNT; i++) {
 417       if (!ilo_builder_writer_unmap(builder, i))
 418          builder->unrecoverable_error = true;
 419    }
 420
 421    if (builder->unrecoverable_error)
 422       return NULL;
 423
 424    bat = &builder->writers[ILO_BUILDER_WRITER_BATCH];
 425
 426    *used = bat->used;
 427
 428    return bat->bo;
 429 }
 430
 431 /**
 432  * Return true if the builder is in a valid state, after accounting for the
 433  * additional BOs specified.  The additional BOs can be listed to avoid
 434  * snapshotting and restoring when they are known ahead of time.
 435  *
 436  * The number of additional BOs should not be more than a few.  Like two, for
 437  * copying between two BOs.
 438  *
 439  * Callers must make sure the builder is in a valid state when
 440  * ilo_builder_end() is called.
 441  */
 442 bool
 443 ilo_builder_validate(struct ilo_builder *builder,
 444                      unsigned bo_count, struct intel_bo **bos)
 445 {
 446    const unsigned max_bo_count = 2;
 447    struct intel_bo *bos_to_submit[ILO_BUILDER_WRITER_COUNT + max_bo_count];
 448    int i;
 449
 450    for (i = 0; i < ILO_BUILDER_WRITER_COUNT; i++)
 451       bos_to_submit[i] = builder->writers[i].bo;
 452
 453    if (bo_count) {
 454       assert(bo_count <= max_bo_count);
 455       if (bo_count > max_bo_count)
 456          return false;
 457
 458       memcpy(&bos_to_submit[ILO_BUILDER_WRITER_COUNT],
 459             bos, sizeof(*bos) * bo_count);
 460       i += bo_count;
 461    }
 462
 463    return intel_winsys_can_submit_bo(builder->winsys, bos_to_submit, i);
 464 }
 465
 466 /**
 467  * Take a snapshot of the writer state.
 468  */
 469 void
 470 ilo_builder_batch_snapshot(const struct ilo_builder *builder,
 471                            struct ilo_builder_snapshot *snapshot)
 472 {
 473    const enum ilo_builder_writer_type which = ILO_BUILDER_WRITER_BATCH;
 474    const struct ilo_builder_writer *writer = &builder->writers[which];
 475
 476    snapshot->reloc_count = intel_bo_get_reloc_count(writer->bo);
 477    snapshot->used = writer->used;
 478    snapshot->stolen = writer->stolen;
 479    snapshot->item_used = writer->item_used;
 480 }
 481
 482 /**
 483  * Restore the writer state to when the snapshot was taken, except that it
 484  * does not (unnecessarily) shrink BOs or the item array.
 485  */
 486 void
 487 ilo_builder_batch_restore(struct ilo_builder *builder,
 488                           const struct ilo_builder_snapshot *snapshot)
 489 {
 490    const enum ilo_builder_writer_type which = ILO_BUILDER_WRITER_BATCH;
 491    struct ilo_builder_writer *writer = &builder->writers[which];
 492
 493    intel_bo_truncate_relocs(writer->bo, snapshot->reloc_count);
 494    writer->used = snapshot->used;
 495    writer->stolen = snapshot->stolen;
 496    writer->item_used = snapshot->item_used;
 497 }