Batch Buffer: igt-gpu-tools Reference Manual

## Batch Buffer Batch Buffer — Batchbuffer and blitter support |

## Functions

void | igt_blitter_src_copy ()
void | igt_blitter_fast_copy__raw ()
void | (*igt_render_copyfunc_t) ()
igt_render_copyfunc_t | igt_get_render_copyfunc ()
void | (*igt_vebox_copyfunc_t) ()
igt_vebox_copyfunc_t | igt_get_vebox_copyfunc ()
void | (*igt_render_clearfunc_t) ()
igt_render_clearfunc_t | igt_get_render_clearfunc ()
void | (*igt_fillfunc_t) ()
igt_fillfunc_t | igt_get_gpgpu_fillfunc ()
igt_fillfunc_t | igt_get_media_fillfunc ()
void | (*igt_vme_func_t) ()
igt_vme_func_t | igt_get_media_vme_func ()
void | (*igt_media_spinfunc_t) ()
igt_media_spinfunc_t | igt_get_media_spinfunc ()
struct intel_bb * | intel_bb_create_full ()
struct intel_bb * | intel_bb_create_with_allocator ()
struct intel_bb * | intel_bb_create ()
struct intel_bb * | intel_bb_create_with_context ()
struct intel_bb * | intel_bb_create_with_relocs ()
struct intel_bb * | intel_bb_create_with_relocs_and_context ()
struct intel_bb * | intel_bb_create_no_relocs ()
void | intel_bb_destroy ()
void | intel_bb_reinit_allocator ()
void | intel_bb_track ()
void | intel_bb_ref ()
void | intel_bb_unref ()
void | intel_bb_reset ()
int | intel_bb_sync ()
void | intel_bb_print ()
void | intel_bb_dump ()
void | intel_bb_set_debug ()
void | intel_bb_set_dump_base64 ()
uint32_t | intel_bb_offset ()
void | intel_bb_ptr_set ()
void | intel_bb_ptr_add ()
uint32_t | intel_bb_ptr_add_return_prev_offset ()
void * | intel_bb_ptr_align ()
void * | intel_bb_ptr ()
void | intel_bb_out ()
void | intel_bb_set_pxp ()
bool | intel_bb_pxp_enabled ()
uint32_t | intel_bb_pxp_apptype ()
uint32_t | intel_bb_pxp_appid ()
struct drm_i915_gem_exec_object2 * | intel_bb_add_object ()
bool | intel_bb_remove_object ()
struct drm_i915_gem_exec_object2 * | intel_bb_add_intel_buf ()
struct drm_i915_gem_exec_object2 * | intel_bb_add_intel_buf_with_alignment ()
bool | intel_bb_remove_intel_buf ()
void | intel_bb_print_intel_bufs ()
struct drm_i915_gem_exec_object2 * | intel_bb_find_object ()
bool | intel_bb_object_set_flag ()
bool | intel_bb_object_clear_flag ()
uint64_t | intel_bb_emit_reloc ()
uint64_t | intel_bb_emit_reloc_fenced ()
uint64_t | intel_bb_offset_reloc ()
uint64_t | intel_bb_offset_reloc_with_delta ()
uint64_t | intel_bb_offset_reloc_to_object ()
void | intel_bb_dump_cache ()
void | intel_bb_exec ()
uint64_t | intel_bb_get_object_offset ()
bool | intel_bb_object_offset_to_buf ()
uint32_t | intel_bb_emit_bbe ()
uint32_t | intel_bb_emit_flush_common ()
void | intel_bb_flush ()
void | intel_bb_flush_render ()
void | intel_bb_flush_blit ()
uint32_t | intel_bb_copy_data ()
void | intel_bb_blit_start ()
void | intel_bb_emit_blt_copy ()
void | intel_bb_blt_copy ()
void | intel_bb_copy_intel_buf ()
void | (*igt_huc_copyfunc_t) ()
igt_huc_copyfunc_t | igt_get_huc_copyfunc ()

## Types and Values

#define | BATCH_SZ
#define | I915_TILING_4
#define | I915_TILING_Yf
#define | I915_TILING_Ys
enum | i915_compression
struct | igt_pxp
struct | intel_bb
struct | intel_buf

## Includes

    #include <igt.h>

## Description

Note that this library's header pulls in the i-g-t core library as a dependency.

## Functions

### igt_blitter_src_copy ()

    void
    igt_blitter_src_copy (int fd,
                          uint64_t ahnd,
                          uint32_t ctx,
                          const intel_ctx_cfg_t *cfg,
                          uint32_t src_handle,
                          uint32_t src_delta,
                          uint32_t src_stride,
                          uint32_t src_tiling,
                          uint32_t src_x,
                          uint32_t src_y,
                          uint64_t src_size,
                          uint32_t width,
                          uint32_t height,
                          uint32_t bpp,
                          uint32_t dst_handle,
                          uint32_t dst_delta,
                          uint32_t dst_stride,
                          uint32_t dst_tiling,
                          uint32_t dst_x,
                          uint32_t dst_y,
                          uint64_t dst_size);

Copy `src` into `dst` using the XY_SRC blit command.

#### Parameters

fd | file descriptor of the i915 driver |
ahnd | handle to an allocator |
ctx | context within which execute copy blit |
cfg | intel_ctx configuration, NULL for default context or legacy mode |
src_handle | GEM handle of the source buffer |
src_delta | offset into the source GEM bo, in bytes |
src_stride | Stride (in bytes) of the source buffer |
src_tiling | Tiling mode of the source buffer |
src_x | X coordinate of the source region to copy |
src_y | Y coordinate of the source region to copy |
src_size | size of the src bo required for allocator and softpin |
width | Width of the region to copy |
height | Height of the region to copy |
bpp | source and destination bits per pixel |
dst_handle | GEM handle of the destination buffer |
dst_delta | offset into the destination GEM bo, in bytes |
dst_stride | Stride (in bytes) of the destination buffer |
dst_tiling | Tiling mode of the destination buffer |
dst_x | X coordinate of destination |
dst_y | Y coordinate of destination |
dst_size | size of the dst bo required for allocator and softpin |

### igt_blitter_fast_copy__raw ()

    void
    igt_blitter_fast_copy__raw (int fd,
                                uint64_t ahnd,
                                uint32_t ctx,
                                const intel_ctx_cfg_t *cfg,
                                uint32_t src_handle,
                                unsigned int src_delta,
                                unsigned int src_stride,
                                unsigned int src_tiling,
                                unsigned int src_x,
                                unsigned  src_y,
                                uint64_t src_size,
                                unsigned int width,
                                unsigned int height,
                                int bpp,
                                uint32_t dst_handle,
                                unsigned int dst_delta,
                                unsigned int dst_stride,
                                unsigned int dst_tiling,
                                unsigned int dst_x,
                                unsigned  dst_y,
                                uint64_t dst_size);

Like `igt_blitter_fast_copy()`, but talking to the kernel directly.

#### Parameters

fd | file descriptor of the i915 driver |
ahnd | handle to an allocator |
ctx | context within which execute copy blit |
cfg | intel_ctx configuration, NULL for default context or legacy mode |
src_handle | GEM handle of the source buffer |
src_delta | offset into the source GEM bo, in bytes |
src_stride | Stride (in bytes) of the source buffer |
src_tiling | Tiling mode of the source buffer |
src_x | X coordinate of the source region to copy |
src_y | Y coordinate of the source region to copy |
src_size | size of the src bo required for allocator and softpin |
width | Width of the region to copy |
height | Height of the region to copy |
bpp | source and destination bits per pixel |
dst_handle | GEM handle of the destination buffer |
dst_delta | offset into the destination GEM bo, in bytes |
dst_stride | Stride (in bytes) of the destination buffer |
dst_tiling | Tiling mode of the destination buffer |
dst_x | X coordinate of destination |
dst_y | Y coordinate of destination |
dst_size | size of the dst bo required for allocator and softpin |

### igt_render_copyfunc_t ()

    void
    (*igt_render_copyfunc_t) (struct intel_bb *ibb,
                              struct intel_buf *src,
                              uint32_t src_x,
                              uint32_t src_y,
                              uint32_t width,
                              uint32_t height,
                              struct intel_buf *dst,
                              uint32_t dst_x,
                              uint32_t dst_y);

This is the type of the per-platform render copy functions. The platform-specific implementation can be obtained by calling `igt_get_render_copyfunc()`.

A render copy function will emit a batchbuffer to the kernel which executes the specified blit copy operation using the render engine. `ctx` is optional and can be 0.

#### Parameters

ibb | batchbuffer |
ctx | context to use |
src | intel_buf source object |
src_x | source pixel x-coordination |
src_y | source pixel y-coordination |
width | width of the copied rectangle |
height | height of the copied rectangle |
dst | intel_buf destination object |
dst_x | destination pixel x-coordination |
dst_y | destination pixel y-coordination |

### igt_get_render_copyfunc ()

    igt_render_copyfunc_t
    igt_get_render_copyfunc (int devid);

#### Parameters

devid | pci device id |

#### Returns

The platform-specific render copy function pointer for the device specified with `devid` . Will return NULL when no render copy function is implemented.

### igt_vebox_copyfunc_t ()

    void
    (*igt_vebox_copyfunc_t) (struct intel_bb *ibb,
                             struct intel_buf *src,
                             unsigned int width,
                             unsigned int height,
                             struct intel_buf *dst);

This is the type of the per-platform vebox copy functions. The platform-specific implementation can be obtained by calling `igt_get_vebox_copyfunc()`.

A vebox copy function will emit a batchbuffer to the kernel which executes the specified blit copy operation using the vebox engine.

#### Parameters

ibb | batchbuffer |
src | intel_buf source object |
width | width of the copied rectangle |
height | height of the copied rectangle |
dst | intel_buf destination object |

### igt_get_vebox_copyfunc ()

    igt_vebox_copyfunc_t
    igt_get_vebox_copyfunc (int devid);

### igt_render_clearfunc_t ()

    void
    (*igt_render_clearfunc_t) (struct intel_bb *ibb,
                               struct intel_buf *dst,
                               unsigned int dst_x,
                               unsigned int dst_y,
                               unsigned int width,
                               unsigned int height,
                               const float cc_color[4]);

### igt_get_render_clearfunc ()

    igt_render_clearfunc_t
    igt_get_render_clearfunc (int devid);

### igt_fillfunc_t ()

    void
    (*igt_fillfunc_t) (int i915,
                       struct intel_buf *buf,
                       unsigned  x,
                       unsigned  y,
                       unsigned  width,
                       unsigned  height,
                       uint8_t color);

This is the type of the per-platform fill functions using media or gpgpu pipeline. The platform-specific implementation can be obtained by calling `igt_get_media_fillfunc()` or `igt_get_gpgpu_fillfunc()`.

A fill function will emit a batchbuffer to the kernel which executes the specified blit fill operation using the media/gpgpu engine.

#### Parameters

i915 | drm fd |
buf | destination intel_buf object |
x | destination pixel x-coordination |
y | destination pixel y-coordination |
width | width of the filled rectangle |
height | height of the filled rectangle |
color | fill color to use |

### igt_get_gpgpu_fillfunc ()

    igt_fillfunc_t
    igt_get_gpgpu_fillfunc (int devid);

#### Parameters

devid | pci device id |

#### Returns

The platform-specific gpgpu fill function pointer for the device specified with `devid` . Will return NULL when no gpgpu fill function is implemented.

### igt_get_media_fillfunc ()

    igt_fillfunc_t
    igt_get_media_fillfunc (int devid);

#### Parameters

devid | pci device id |

#### Returns

The platform-specific media fill function pointer for the device specified with `devid` . Will return NULL when no media fill function is implemented.

### igt_vme_func_t ()

    void
    (*igt_vme_func_t) (int i915,
                       uint32_t ctx,
                       struct intel_buf *src,
                       unsigned int width,
                       unsigned int height,
                       struct intel_buf *dst);

### igt_get_media_vme_func ()

    igt_vme_func_t
    igt_get_media_vme_func (int devid);

### igt_media_spinfunc_t ()

    void
    (*igt_media_spinfunc_t) (int i915,
                             struct intel_buf *buf,
                             uint32_t spins);

This is the type of the per-platform media spin functions. The platform-specific implementation can be obtained by calling `igt_get_media_spinfunc()`.

The media spin function emits a batchbuffer for the render engine with the media pipeline selected. The workload consists of a single thread which spins in a tight loop the requested number of times. Each spin increments a counter whose final 32-bit value is written to the destination buffer on completion. This utility provides a simple way to keep the render engine busy for a set time for various tests.

#### Parameters

i915 | drm fd |
buf | destination buffer object |
spins | number of loops to execute |

### igt_get_media_spinfunc ()

    igt_media_spinfunc_t
    igt_get_media_spinfunc (int devid);

#### Parameters

devid | pci device id |

#### Returns

The platform-specific media spin function pointer for the device specified with `devid` . Will return NULL when no media spin function is implemented.

### intel_bb_create_full ()

    struct intel_bb *
    intel_bb_create_full (int i915,
                          uint32_t ctx,
                          const intel_ctx_cfg_t *cfg,
                          uint32_t size,
                          uint64_t start,
                          uint64_t end,
                          uint8_t allocator_type,
                          enum allocator_strategy strategy);

Creates bb with context passed in `ctx` , size in `size` and allocator type in `allocator_type` . Relocations are set to false because IGT allocator is used in that case. VM range is passed to allocator (`start` and `end` ) and allocation `strategy` (suggestion to allocator about address allocation preferences).

#### Parameters

i915 | drm fd |
ctx | context |
cfg | intel_ctx configuration, NULL for default context or legacy mode |
size | size of the batchbuffer |
start | allocator vm start address |
end | allocator vm start address |
allocator_type | allocator type, SIMPLE, RANDOM, ... |
strategy | allocation strategy |

#### Returns

Pointer the intel_bb, asserts on failure.

### intel_bb_create_with_allocator ()

    struct intel_bb *
    intel_bb_create_with_allocator (int i915,
                                    uint32_t ctx,
                                    const intel_ctx_cfg_t *cfg,
                                    uint32_t size,
                                    uint8_t allocator_type);

Creates bb with context passed in `ctx` , size in `size` and allocator type in `allocator_type` . Relocations are set to false because IGT allocator is used in that case.

#### Parameters

i915 | drm fd |
ctx | context |
cfg | intel_ctx configuration, NULL for default context or legacy mode |
size | size of the batchbuffer |
allocator_type | allocator type, SIMPLE, RANDOM, ... |

#### Returns

Pointer the intel_bb, asserts on failure.

### intel_bb_create ()

    struct intel_bb *
    intel_bb_create (int i915,
                     uint32_t size);

Creates bb with default context.

#### Parameters

i915 | drm fd |
size | size of the batchbuffer |

#### Returns

Pointer the intel_bb, asserts on failure.

Notes:

intel_bb must not be created in igt_fixture. The reason is intel_bb "opens" connection to the allocator and when test completes it can leave the allocator in unknown state (mostly for failed tests). As igt_core was armed to reset the allocator infrastructure connection to it inside intel_bb is not valid anymore. Trying to use it leads to catastrofic errors.

### intel_bb_create_with_context ()

    struct intel_bb *
    intel_bb_create_with_context (int i915,
                                  uint32_t ctx,
                                  const intel_ctx_cfg_t *cfg,
                                  uint32_t size);

Creates bb with context passed in `ctx` and `cfg` configuration (when working with custom engines layout).

#### Parameters

i915 | drm fd |
ctx | context id |
cfg | intel_ctx configuration, NULL for default context or legacy mode |
size | size of the batchbuffer |

#### Returns

Pointer the intel_bb, asserts on failure.

### intel_bb_create_with_relocs ()

    struct intel_bb *
    intel_bb_create_with_relocs (int i915,
                                 uint32_t size);

Creates bb which will disable passing addresses. This will lead to relocations when objects are not previously pinned.

#### Parameters

i915 | drm fd |
size | size of the batchbuffer |

#### Returns

Pointer the intel_bb, asserts on failure.

### intel_bb_create_with_relocs_and_context ()

    struct intel_bb *
    intel_bb_create_with_relocs_and_context
                                   (int i915,
                                    uint32_t ctx,
                                    const intel_ctx_cfg_t *cfg,
                                    uint32_t size);

Creates bb with default context which will disable passing addresses. This will lead to relocations when objects are not previously pinned.

#### Parameters

i915 | drm fd |
ctx | context |
cfg | intel_ctx configuration, NULL for default context or legacy mode |
size | size of the batchbuffer |

#### Returns

Pointer the intel_bb, asserts on failure.

### intel_bb_create_no_relocs ()

    struct intel_bb *
    intel_bb_create_no_relocs (int i915,
                               uint32_t size);

Creates bb with disabled relocations. This enables passing addresses and requires pinning objects.

#### Parameters

i915 | drm fd |
size | size of the batchbuffer |

#### Returns

Pointer the intel_bb, asserts on failure.

### intel_bb_destroy ()

    void
    intel_bb_destroy (struct intel_bb *ibb);

Frees all relocations / objects allocated during filling the batch.

#### Parameters

ibb | pointer to intel_bb |

### intel_bb_reinit_allocator ()

    void
    intel_bb_reinit_allocator (void);

Reinit allocator and get offsets in tracked intel_batchbuffers.

### intel_bb_track ()

    void
    intel_bb_track (bool do_tracking);

Turn on (true) or off (false) tracking for intel_batchbuffers.

#### Parameters

do_tracking | bool |

### intel_bb_ref ()

    void
    intel_bb_ref (struct intel_bb *ibb);

### intel_bb_unref ()

    void
    intel_bb_unref (struct intel_bb *ibb);

### intel_bb_reset ()

    void
    intel_bb_reset (struct intel_bb *ibb,
                    bool purge_objects_cache);

### intel_bb_sync ()

    int
    intel_bb_sync (struct intel_bb *ibb);

### intel_bb_print ()

    void
    intel_bb_print (struct intel_bb *ibb);

### intel_bb_dump ()

    void
    intel_bb_dump (struct intel_bb *ibb,
                   const char *filename);

### intel_bb_set_debug ()

    void
    intel_bb_set_debug (struct intel_bb *ibb,
                        bool debug);

Sets debug to true / false. Execbuf is then called synchronously and object/reloc arrays are printed after execution.

#### Parameters

ibb | pointer to intel_bb |
debug | true / false |

### intel_bb_set_dump_base64 ()

    void
    intel_bb_set_dump_base64 (struct intel_bb *ibb,
                              bool dump);

Do bb dump as base64 string before execbuf call.

#### Parameters

ibb | pointer to intel_bb |
dump | true / false |

### intel_bb_offset ()

    uint32_t
    intel_bb_offset (struct intel_bb *ibb);

### intel_bb_ptr_set ()

    void
    intel_bb_ptr_set (struct intel_bb *ibb,
                      uint32_t offset);

### intel_bb_ptr_add ()

    void
    intel_bb_ptr_add (struct intel_bb *ibb,
                      uint32_t offset);

### intel_bb_ptr_add_return_prev_offset ()

    uint32_t
    intel_bb_ptr_add_return_prev_offset (struct intel_bb *ibb,
                                         uint32_t offset);

### intel_bb_ptr_align ()

    void *
    intel_bb_ptr_align (struct intel_bb *ibb,
                        uint32_t alignment);

### intel_bb_ptr ()

    void *
    intel_bb_ptr (struct intel_bb *ibb);

### intel_bb_out ()

    void
    intel_bb_out (struct intel_bb *ibb,
                  uint32_t dword);

### intel_bb_set_pxp ()

    void
    intel_bb_set_pxp (struct intel_bb *ibb,
                      bool new_state,
                      uint32_t apptype,
                      uint32_t appid);

### intel_bb_pxp_enabled ()

    bool
    intel_bb_pxp_enabled (struct intel_bb *ibb);

### intel_bb_pxp_apptype ()

    uint32_t
    intel_bb_pxp_apptype (struct intel_bb *ibb);

### intel_bb_pxp_appid ()

    uint32_t
    intel_bb_pxp_appid (struct intel_bb *ibb);

### intel_bb_add_object ()

    struct drm_i915_gem_exec_object2 *
    intel_bb_add_object (struct intel_bb *ibb,
                         uint32_t handle,
                         uint64_t size,
                         uint64_t offset,
                         uint64_t alignment,
                         bool write);

Function adds or updates execobj slot in bb objects array and in the object tree. When object is a render target it has to be marked with EXEC_OBJECT_WRITE flag.

#### Parameters

ibb | pointer to intel_bb |
handle | which handle to add to objects array |
size | object size |
offset | presumed offset of the object when no relocation is enforced |
alignment | alignment of the object, if 0 it will be set to page size |
write | does a handle is a render target |

### intel_bb_remove_object ()

    bool
    intel_bb_remove_object (struct intel_bb *ibb,
                            uint32_t handle,
                            uint64_t offset,
                            uint64_t size);

### intel_bb_add_intel_buf ()

    struct drm_i915_gem_exec_object2 *
    intel_bb_add_intel_buf (struct intel_bb *ibb,
                            struct intel_buf *buf,
                            bool write);

### intel_bb_add_intel_buf_with_alignment ()

    struct drm_i915_gem_exec_object2 *
    intel_bb_add_intel_buf_with_alignment (struct intel_bb *ibb,
                                           struct intel_buf *buf,
                                           uint64_t alignment,
                                           bool write);

### intel_bb_remove_intel_buf ()

    bool
    intel_bb_remove_intel_buf (struct intel_bb *ibb,
                               struct intel_buf *buf);

### intel_bb_print_intel_bufs ()

    void
    intel_bb_print_intel_bufs (struct intel_bb *ibb);

### intel_bb_find_object ()

    struct drm_i915_gem_exec_object2 *
    intel_bb_find_object (struct intel_bb *ibb,
                          uint32_t handle);

### intel_bb_object_set_flag ()

    bool
    intel_bb_object_set_flag (struct intel_bb *ibb,
                              uint32_t handle,
                              uint64_t flag);

### intel_bb_object_clear_flag ()

    bool
    intel_bb_object_clear_flag (struct intel_bb *ibb,
                                uint32_t handle,
                                uint64_t flag);

### intel_bb_emit_reloc ()

    uint64_t
    intel_bb_emit_reloc (struct intel_bb *ibb,
                         uint32_t handle,
                         uint32_t read_domains,
                         uint32_t write_domain,
                         uint64_t delta,
                         uint64_t presumed_offset);

Function prepares relocation (execobj if required + reloc) and emits offset in bb. For I915_EXEC_NO_RELOC presumed_offset is a hint we already have object in valid place and relocation step can be skipped in this case.

Note: delta is value added to address, mostly used when some instructions require modify-bit set to apply change. Which delta is valid depends on instruction (see instruction specification).

#### Parameters

ibb | pointer to intel_bb |
handle | object handle which address will be taken to patch the bb |
read_domains | gem domain bits for the relocation |
write_domain | gem domain bit for the relocation |
delta | delta value to add to `buffer` 's gpu address |
presumed_offset | address of the object in address space. If -1 is passed then final offset of the object will be randomized (for no-reloc bb) or 0 (for reloc bb, in that case reloc.presumed_offset will be -1). In case address is known it should passed in `presumed_offset` (for no-reloc). |
write | does a handle is a render target |

### intel_bb_emit_reloc_fenced ()

    uint64_t
    intel_bb_emit_reloc_fenced (struct intel_bb *ibb,
                                uint32_t handle,
                                uint32_t read_domains,
                                uint32_t write_domain,
                                uint64_t delta,
                                uint64_t presumed_offset);

### intel_bb_offset_reloc ()

    uint64_t
    intel_bb_offset_reloc (struct intel_bb *ibb,
                           uint32_t handle,
                           uint32_t read_domains,
                           uint32_t write_domain,
                           uint32_t offset,
                           uint64_t presumed_offset);

Function prepares relocation (execobj if required + reloc). It it used for editing batchbuffer via modifying structures. It means when we're preparing batchbuffer it is more descriptive to edit the structure than emitting dwords. But it require for some fields to point the relocation. For that case `offset` is passed by the user and it points to the offset in bb where the relocation will be applied.

#### Parameters

ibb | pointer to intel_bb |
handle | object handle which address will be taken to patch the bb |
read_domains | gem domain bits for the relocation |
write_domain | gem domain bit for the relocation |
offset | offset within bb to be patched |
presumed_offset | address of the object in address space. If -1 is passed then final offset of the object will be randomized (for no-reloc bb) or 0 (for reloc bb, in that case reloc.presumed_offset will be -1). In case address is known it should passed in `presumed_offset` (for no-reloc). |

### intel_bb_offset_reloc_with_delta ()

    uint64_t
    intel_bb_offset_reloc_with_delta (struct intel_bb *ibb,
                                      uint32_t handle,
                                      uint32_t read_domains,
                                      uint32_t write_domain,
                                      uint32_t delta,
                                      uint32_t offset,
                                      uint64_t presumed_offset);

### intel_bb_offset_reloc_to_object ()

    uint64_t
    intel_bb_offset_reloc_to_object (struct intel_bb *ibb,
                                     uint32_t handle,
                                     uint32_t to_handle,
                                     uint32_t read_domains,
                                     uint32_t write_domain,
                                     uint32_t delta,
                                     uint32_t offset,
                                     uint64_t presumed_offset);

### intel_bb_dump_cache ()

    void
    intel_bb_dump_cache (struct intel_bb *ibb);

### intel_bb_exec ()

    void
    intel_bb_exec (struct intel_bb *ibb,
                   uint32_t end_offset,
                   uint64_t flags,
                   bool sync);

Do execbuf on context selected during bb creation. Asserts on failure.

#### Parameters

ibb | pointer to intel_bb |
end_offset | offset of the last instruction in the bb |
flags | flags passed directly to execbuf |
sync | if true wait for execbuf completion, otherwise caller is responsible to wait for completion |

### intel_bb_get_object_offset ()

    uint64_t
    intel_bb_get_object_offset (struct intel_bb *ibb,
                                uint32_t handle);

### intel_bb_object_offset_to_buf ()

    bool
    intel_bb_object_offset_to_buf (struct intel_bb *ibb,
                                   struct intel_buf *buf);

### intel_bb_emit_bbe ()

    uint32_t
    intel_bb_emit_bbe (struct intel_bb *ibb);

### intel_bb_emit_flush_common ()

    uint32_t
    intel_bb_emit_flush_common (struct intel_bb *ibb);

### intel_bb_flush ()

    void
    intel_bb_flush (struct intel_bb *ibb,
                    uint32_t ring);

### intel_bb_flush_render ()

    void
    intel_bb_flush_render (struct intel_bb *ibb);

### intel_bb_flush_blit ()

    void
    intel_bb_flush_blit (struct intel_bb *ibb);

### intel_bb_copy_data ()

    uint32_t
    intel_bb_copy_data (struct intel_bb *ibb,
                        const void *data,
                        unsigned int bytes,
                        uint32_t align);

### intel_bb_blit_start ()

    void
    intel_bb_blit_start (struct intel_bb *ibb,
                         uint32_t flags);

### intel_bb_emit_blt_copy ()

    void
    intel_bb_emit_blt_copy (struct intel_bb *ibb,
                            struct intel_buf *src,
                            int src_x1,
                            int src_y1,
                            int src_pitch,
                            struct intel_buf *dst,
                            int dst_x1,
                            int dst_y1,
                            int dst_pitch,
                            int width,
                            int height,
                            int bpp);

### intel_bb_blt_copy ()

    void
    intel_bb_blt_copy (struct intel_bb *ibb,
                       struct intel_buf *src,
                       int src_x1,
                       int src_y1,
                       int src_pitch,
                       struct intel_buf *dst,
                       int dst_x1,
                       int dst_y1,
                       int dst_pitch,
                       int width,
                       int height,
                       int bpp);

### intel_bb_copy_intel_buf ()

    void
    intel_bb_copy_intel_buf (struct intel_bb *ibb,
                             struct intel_buf *dst,
                             struct intel_buf *src,
                             long int size);

Emits a copy operation using blitter commands into the supplied batch. A total of `size` bytes from the start of `src` is copied over to `dst` . Note that `size` must be page-aligned.

#### Parameters

batch | batchbuffer object |
src | source buffer (intel_buf) |
dst | destination libdrm buffer object |
size | size of the copy range in bytes |

### igt_huc_copyfunc_t ()

    void
    (*igt_huc_copyfunc_t) (int fd,
                           uint64_t ahnd,
                           struct drm_i915_gem_exec_object2 *obj,
                           uint64_t *objsize);

This is the type of the per-platform huc copy functions.

The huc copy function emits a batchbuffer to the VDBOX engine to invoke the HuC Copy kernel to copy 4K bytes from the source buffer to the destination buffer.

#### Parameters

fd | drm fd |
ahnd | allocator handle, if it is equal to 0 we use relocations |
obj | drm_i915_gem_exec_object2 buffer array obj[0] is source buffer obj[1] is destination buffer obj[2] is execution buffer |
objsize | corresponding buffer sizes to `obj` |

### igt_get_huc_copyfunc ()

    igt_huc_copyfunc_t
    igt_get_huc_copyfunc (int devid);

#### Parameters

devid | pci device id |

#### Returns

The platform-specific huc copy function pointer for the device specified with `devid` . Will return NULL when no media spin function is implemented.

## Types and Values

### BATCH_SZ

    #define BATCH_SZ 4096

### I915_TILING_4

    #define I915_TILING_4 (I915_TILING_LAST + 1)

### I915_TILING_Yf

    #define I915_TILING_Yf (I915_TILING_LAST + 2)

### I915_TILING_Ys

    #define I915_TILING_Ys (I915_TILING_LAST + 3)

### enum i915_compression

#### Members

I915_COMPRESSION_NONE |  |
I915_COMPRESSION_RENDER |  |
I915_COMPRESSION_MEDIA |  |

### struct igt_pxp

    struct igt_pxp {
    	bool     enabled;
    	uint32_t apptype;
    	uint32_t appid;
    };

### struct intel_bb

    struct intel_bb {
    	struct igt_list_head link;

    	uint64_t allocator_handle;
    	uint64_t allocator_start, allocator_end;
    	uint8_t allocator_type;
    	enum allocator_strategy allocator_strategy;

    	int i915;
    	unsigned int gen;
    	bool debug;
    	bool dump_base64;
    	bool enforce_relocs;
    	uint32_t devid;
    	uint32_t handle;
    	uint32_t size;
    	uint32_t *batch;
    	uint32_t *ptr;
    	uint64_t alignment;
    	int fence;

    	uint64_t gtt_size;
    	bool supports_48b_address;
    	bool uses_full_ppgtt;
    	bool allows_obj_alignment;

    	struct igt_pxp pxp;
    	uint32_t ctx;
    	uint32_t vm_id;

    	/* Context configuration */
    	intel_ctx_cfg_t *cfg;

    	/* Cache */
    	void *root;

    	/* Current objects for execbuf */
    	void *current;

    	/* Objects for current execbuf */
    	struct drm_i915_gem_exec_object2 **objects;
    	uint32_t num_objects;
    	uint32_t allocated_objects;
    	uint64_t batch_offset;

    	struct drm_i915_gem_relocation_entry *relocs;
    	uint32_t num_relocs;
    	uint32_t allocated_relocs;

    	/* Tracked intel_bufs */
    	struct igt_list_head intel_bufs;

    	/*
    	 * BO recreate in reset path only when refcount == 0
    	 * Currently we don't need to use atomics because intel_bb
    	 * is not thread-safe.
    	 */
    	int32_t refcount;
    };

### struct intel_buf

    struct intel_buf {
    	struct buf_ops *bops;

    	bool is_owner;
    	uint32_t handle;
    	uint64_t size;
    	uint32_t tiling;
    	uint32_t bpp;
    	uint32_t compression;
    	uint32_t swizzle_mode;
    	uint32_t yuv_semiplanar_bpp;
    	bool format_is_yuv;
    	bool format_is_yuv_semiplanar;
    	struct {
    		uint32_t offset;
    		uint32_t stride;
    		uint64_t size;
    	} surface[2];
    	struct {
    		uint32_t offset;
    		uint32_t stride;
    	} ccs[2];
    	struct {
    		uint32_t offset;
    	} cc;
    	struct {
    		uint64_t offset;
    		uint32_t ctx;
    	} addr;

    	uint64_t bo_size;

    	/* Tracking */
    	struct intel_bb *ibb;
    	struct igt_list_head link;

    	/* CPU mapping */
    	uint32_t *ptr;
    	bool cpu_write;

    	/* Content Protection*/
    	bool is_protected;

    	/* For debugging purposes */
    	char name[INTEL_BUF_NAME_MAXSIZE + 1];
    };