Remove libdrm in rendercopy
Subsystems (2)
v2 cover Remove libdrm in rendercopy
Try to check how much will be broken when we migrate to no-libdrm rendercopy.
I still have some doubts in gem_stress, gem_concurrent_blit so depending on the result we'll decide to spread the change to smaller series (with introducing _v2 suffix) or will we be able to do that in single step.
v2: fix invalid offset in bind (gen4)
fix bufops selftest is not executed from default
Dominik Grzegorzek (2):
lib/igt_fb: Removal of libdrm dependency tests/gem|kms: remove libdrm dependency (batch 1)
Zbigniew Kempczyński (10):
lib/intel_bufops: add mapping on cpu / device lib/intel_batchbuffer: add new functions to support rendercopy tests/gem_caching: adopt to batch flush function cleanup lib/rendercopy: remove libdrm dependency tests/api_intel_bb: add render tests
lib/igt_draw: remove libdrm dependency tests/gem|kms: remove libdrm dependency (batch 2) tools/intel_residency: adopt intel_residency to use bufops tests/perf: remove libdrm dependency for rendercopy
HAX: run rendercopy tests
lib/Makefile.sources | 2 - lib/igt_draw.c | 158 ++-- lib/igt_draw.h | 8 +- lib/igt_fb.c | 96 ++- lib/intel_aux_pgtable.c | 325 ++++--- lib/intel_aux_pgtable.h | 29 +- lib/intel_batchbuffer.c | 303 ++++++- lib/intel_batchbuffer.h | 83 +- lib/intel_bufops.c | 106 ++- lib/intel_bufops.h | 15 +- lib/meson.build | 1 - lib/rendercopy.h | 102 +-- lib/rendercopy_bufmgr.c | 171 ---- lib/rendercopy_bufmgr.h | 28 - lib/rendercopy_gen4.c | 568 ++++++------ lib/rendercopy_gen6.c | 590 +++++++------ lib/rendercopy_gen7.c | 612 ++++++------- lib/rendercopy_gen8.c | 1030 ++++++++++------------ lib/rendercopy_gen9.c | 1145 +++++++++++-------------- lib/rendercopy_i830.c | 278 +++--- lib/rendercopy_i915.c | 281 +++--- lib/veboxcopy.h | 8 +- lib/veboxcopy_gen12.c | 117 ++- tests/i915/api_intel_bb.c | 168 ++++ tests/i915/gem_caching.c | 5 - tests/i915/gem_concurrent_all.c | 431 +++++----- tests/i915/gem_ppgtt.c | 183 ++-- tests/i915/gem_read_read_speed.c | 160 ++-- tests/i915/gem_render_copy.c | 313 +++---- tests/i915/gem_render_copy_redux.c | 66 +- tests/i915/gem_render_linear_blits.c | 90 +- tests/i915/gem_render_tiled_blits.c | 85 +- tests/i915/gem_stress.c | 244 +++--- tests/i915/perf.c | 663 ++++++-------- tests/intel-ci/fast-feedback.testlist | 42 +- tests/kms_big_fb.c | 54 +- tests/kms_cursor_crc.c | 63 +- tests/kms_draw_crc.c | 20 +- tests/kms_frontbuffer_tracking.c | 20 +- tests/kms_psr.c | 134 +-- tools/intel_residency.c | 10 +- 41 files changed, 4329 insertions(+), 4478 deletions(-) delete mode 100644 lib/rendercopy_bufmgr.c delete mode 100644 lib/rendercopy_bufmgr.h
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v2 1/12 lib/intel_bufops: add mapping on cpu / device
Simplify mapping intel_buf. To be extended with ref counting. Add intel_buf dump function for easy dump buffer to the file. Fixing returned type of bo size function.
Idempotency selftest is now skipped for default buf_ops creation to avoid time consuming comparison of HW and SW tiled buffers (this can be the problem for forked tests). Additional function buf_ops_create_with_selftest() was added to allow perform verification step where it is required.
--- lib/intel_bufops.c | 106 +++++++++++++++++++++++++++++++++++++++------ lib/intel_bufops.h | 15 ++++++- 2 files changed, 107 insertions(+), 14 deletions(-)
lib/intel_bufops.c +93 -13
@@ -870,6 +870,48 @@ void intel_buf_destroy(struct intel_buf *buf)free (buf); } +void *intel_buf_cpu_map (struct intel_buf *buf,bool write) +{ +int i915 =buf_ops_get_fd (buf->bops); + +igt_assert (buf->ptr ==NULL );/* already mapped */ + + buf->cpu_write = write; + buf->ptr =gem_mmap__cpu_coherent (i915, buf->handle,0 , + buf->surface[0 ].size, + write ?PROT_WRITE :PROT_READ ); + +gem_set_domain (i915, buf->handle, +I915_GEM_DOMAIN_CPU , + write ?I915_GEM_DOMAIN_CPU :0 ); + +return buf->ptr; +} + +void *intel_buf_device_map (struct intel_buf *buf,bool write) +{ +int i915 =buf_ops_get_fd (buf->bops); + +igt_assert (buf->ptr ==NULL );/* already mapped */ + + buf->ptr =gem_mmap__device_coherent (i915, buf->handle,0 , + buf->surface[0 ].size, + write ?PROT_WRITE :PROT_READ ); + +return buf->ptr; +} + +void intel_buf_unmap (struct intel_buf *buf) +{ +igt_assert (buf->ptr); + +if (buf->cpu_write) +gem_sw_finish (buf_ops_get_fd (buf->bops), buf->handle); + +munmap (buf->ptr, buf->surface[0 ].size); + buf->ptr =NULL ; +} +void intel_buf_print (const struct intel_buf *buf) {igt_info ("[name: %s]\n" , buf->name);
@@ -888,6 +930,21 @@ void intel_buf_print(const struct intel_buf *buf) from_user_pointer(buf->addr.offset), buf->addr.ctx); } +void intel_buf_dump (const struct intel_buf *buf,const char *filename) +{ +int i915 =buf_ops_get_fd (buf->bops); +uint64_t size =intel_buf_bo_size (buf); +FILE *out; +void *ptr; + + ptr =gem_mmap__device_coherent (i915, buf->handle,0 , size,PROT_READ ); + out =fopen (filename,"wb" ); +igt_assert (out); +fwrite (ptr, size,1 , out); +fclose (out); +munmap (ptr, size); +} +const char *intel_buf_set_name (struct intel_buf *buf,const char *name) {return strncpy (buf->name, name,INTEL_BUF_NAME_MAXSIZE );
@@ -1066,7 +1123,7 @@ static void idempotency_selftest(struct buf_ops *bops, uint32_t tiling)buf_ops_set_software_tiling (bops, tiling, false); } -int intel_buf_bo_size (const struct intel_buf *buf) +uint32_t intel_buf_bo_size (const struct intel_buf *buf) {int offset =CCS_OFFSET (buf) ?: buf->surface[0 ].size; int ccs_size =
@@ -1075,16 +1132,7 @@ int intel_buf_bo_size(const struct intel_buf *buf)return offset + ccs_size; } -/** -* buf_ops_create -* @fd: device filedescriptor -* -* Create buf_ops structure depending on fd-device capabilities. -* -* Returns: opaque pointer to buf_ops. -* -*/ -struct buf_ops *buf_ops_create (int fd) +static struct buf_ops *__buf_ops_create (int fd,bool check_idempotency) {struct buf_ops *bops =calloc (1 ,sizeof (*bops));uint32_t devid;
@@ -1161,12 +1209,44 @@ struct buf_ops *buf_ops_create(int fd) bops->ys_to_linear =NULL ; } -idempotency_selftest (bops,I915_TILING_X ); -idempotency_selftest (bops,I915_TILING_Y ); +if (check_idempotency) { +idempotency_selftest (bops,I915_TILING_X ); +idempotency_selftest (bops,I915_TILING_Y ); + }return bops; } +/** +* buf_ops_create +* @fd: device filedescriptor +* +* Create buf_ops structure depending on fd-device capabilities. +* +* Returns: opaque pointer to buf_ops. +* +*/ +struct buf_ops *buf_ops_create (int fd) +{ +return __buf_ops_create (fd, false); +} + +/** +* buf_ops_create_with_selftest +* @fd: device filedescriptor +* +* Create buf_ops structure depending on fd-device capabilities. +* Runs with idempotency selftest to verify software tiling gives same +* result like hardware tiling (gens with mappable gtt). +* +* Returns: opaque pointer to buf_ops. +* +*/ +struct buf_ops *buf_ops_create_with_selftest (int fd) +{ +return __buf_ops_create (fd, true); +} +/** * buf_ops_destroy * @bops: pointer to buf_ops
lib/intel_bufops.h +14 -1
@@ -16,6 +16,9 @@ struct intel_buf {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;
@@ -33,6 +36,10 @@ struct intel_buf {uint32_t ctx; } addr; +/* CPU mapping */ +uint32_t *ptr; +bool cpu_write; +/* For debugging purposes */ char name[INTEL_BUF_NAME_MAXSIZE +1 ]; };
@@ -80,9 +87,10 @@ intel_buf_ccs_height(int gen, const struct intel_buf *buf)return DIV_ROUND_UP (intel_buf_height (buf),512 ) *32 ; } -int intel_buf_bo_size (const struct intel_buf *buf); +uint32_t intel_buf_bo_size (const struct intel_buf *buf);struct buf_ops *buf_ops_create (int fd); +struct buf_ops *buf_ops_create_with_selftest (int fd);void buf_ops_destroy (struct buf_ops *bops);int buf_ops_get_fd (struct buf_ops *bops);
@@ -116,7 +124,12 @@ struct intel_buf *intel_buf_create(struct buf_ops *bops, uint32_t req_tiling, uint32_t compression);void intel_buf_destroy (struct intel_buf *buf); +void *intel_buf_cpu_map (struct intel_buf *buf,bool write); +void *intel_buf_device_map (struct intel_buf *buf,bool write); +void intel_buf_unmap (struct intel_buf *buf); +void intel_buf_print (const struct intel_buf *buf); +void intel_buf_dump (const struct intel_buf *buf,const char *filename);const char *intel_buf_set_name (struct intel_buf *buf,const char *name);void intel_buf_write_to_png (struct intel_buf *buf,const char *filename);
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v2 2/12 lib/intel_batchbuffer: add new functions to support rendercopy
In reply to Zbigniew KempczyńskiTo cover rendercopy in dependent tests we need to add the following:
1. relocation in any handle
Previously batchbuffer was the main target of relocations. As AUX table require relocations too add support for that in intel_bb.
2. set/get default alignment
Add default alignment for objects added to intel_bb (AUX tables use different alignment for different objects).
3. add intel_buf to intel_bb
Save proposed address to intel_buf
4. add set flag function
5. unification of intel_bb_flush.*() functions.
6. fixing indentation
--- lib/intel_batchbuffer.c | 303 ++++++++++++++++++++++++++++++++++------ lib/intel_batchbuffer.h | 41 +++++- 2 files changed, 297 insertions(+), 47 deletions(-)
lib/intel_batchbuffer.c +258 -45
@@ -37,6 +37,7 @@#include "drmtest.h" #include "intel_batchbuffer.h" #include "intel_bufmgr.h" +#include "intel_bufops.h" #include "intel_chipset.h" #include "intel_reg.h" #include "veboxcopy.h"
@@ -1214,6 +1215,7 @@ static inline uint64_t __intel_bb_propose_offset(struct intel_bb *ibb) offset =hars_petruska_f54_1_random64 (&ibb->prng); offset +=256 <<10 ;/* Keep the low 256k clear, for negative deltas */ offset &= ibb->gtt_size -1 ; + offset &= ~(ibb->alignment -1 );return offset; }
@@ -1232,7 +1234,6 @@ __intel_bb_create(int i915, uint32_t size, bool do_relocs) {struct intel_bb *ibb =calloc (1 ,sizeof (*ibb));uint64_t gtt_size; -uint64_t bb_address;igt_assert (ibb);
@@ -1242,6 +1243,7 @@ __intel_bb_create(int i915, uint32_t size, bool do_relocs) ibb->enforce_relocs = do_relocs; ibb->handle =gem_create (i915, size); ibb->size = size; + ibb->alignment =4096 ; ibb->batch =calloc (1 , size);igt_assert (ibb->batch); ibb->ptr = ibb->batch;
@@ -1253,11 +1255,12 @@ __intel_bb_create(int i915, uint32_t size, bool do_relocs) gtt_size /=2 ;if ((gtt_size -1 ) >>32 ) ibb->supports_48b_address = true; + ibb->gtt_size = gtt_size;__reallocate_objects (ibb); - bb_address =__intel_bb_propose_offset (ibb); -intel_bb_add_object (ibb, ibb->handle, bb_address, false); + ibb->batch_offset =__intel_bb_propose_offset (ibb); +intel_bb_add_object (ibb, ibb->handle, ibb->batch_offset, false); ibb->refcount =1 ;
@@ -1364,8 +1367,6 @@ void intel_bb_destroy(struct intel_bb *ibb)*/ void intel_bb_reset (struct intel_bb *ibb,bool purge_objects_cache) { -uint64_t bb_address; -if (purge_objects_cache && ibb->refcount >1 )igt_warn ("Cannot purge objects cache on bb, refcount > 1!" );
@@ -1383,8 +1384,8 @@ void intel_bb_reset(struct intel_bb *ibb, bool purge_objects_cache)gem_close (ibb->i915, ibb->handle); ibb->handle =gem_create (ibb->i915, ibb->size); - bb_address =__intel_bb_propose_offset (ibb); -intel_bb_add_object (ibb, ibb->handle, bb_address, false); + ibb->batch_offset =__intel_bb_propose_offset (ibb); +intel_bb_add_object (ibb, ibb->handle, ibb->batch_offset, false); ibb->ptr = ibb->batch;memset (ibb->batch,0 , ibb->size); }
@@ -1499,6 +1500,7 @@ intel_bb_add_object(struct intel_bb *ibb, uint32_t handle, object = &ibb->objects[i]; object->handle = handle; object->offset = offset; + object->alignment = ibb->alignment; found =tsearch ((void *) object, &ibb->root, __compare_objects);
@@ -1519,7 +1521,38 @@ intel_bb_add_object(struct intel_bb *ibb, uint32_t handle,return object; } -static bool intel_bb_object_set_fence (struct intel_bb *ibb,uint32_t handle) +struct drm_i915_gem_exec_object2 * +intel_bb_add_intel_buf (struct intel_bb *ibb,struct intel_buf *buf,bool write) +{ +struct drm_i915_gem_exec_object2 *obj; + + obj =intel_bb_add_object (ibb, buf->handle, buf->addr.offset, write); + +/* For compressed surfaces ensure address is aligned to 64KB */ +if (ibb->gen >=12 && buf->compression) { + obj->offset &= ~(0x10000 -1 ); + obj->alignment =0x10000 ; + } + +/* Update address in intel_buf buffer */ + buf->addr.offset = obj->offset; + +return obj; +} + +struct drm_i915_gem_exec_object2 * +intel_bb_find_object (struct intel_bb *ibb,uint32_t handle) +{ +struct drm_i915_gem_exec_object2 object = { .handle = handle }; +struct drm_i915_gem_exec_object2 **found; + + found =tfind ((void *) &object, &ibb->root, __compare_objects); + +return *found; +} + +bool +intel_bb_object_set_flag (struct intel_bb *ibb,uint32_t handle,uint64_t flag) {struct drm_i915_gem_exec_object2 object = { .handle = handle };struct drm_i915_gem_exec_object2 **found;
@@ -1531,7 +1564,7 @@ static bool intel_bb_object_set_fence(struct intel_bb *ibb, uint32_t handle)return false; } - (*found)->flags |=EXEC_OBJECT_NEEDS_FENCE ; + (*found)->flags |= flag;return true; }
@@ -1539,7 +1572,8 @@ static bool intel_bb_object_set_fence(struct intel_bb *ibb, uint32_t handle)/* * intel_bb_add_reloc: * @ibb: pointer to intel_bb -* @handle: object handle which address will be taken to patch the bb +* @to_handle: object handle in which do relocation +* @handle: object handle which address will be taken to patch the @to_handle * @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
@@ -1554,6 +1588,7 @@ static bool intel_bb_object_set_fence(struct intel_bb *ibb, uint32_t handle)* exists but doesn't mark it as a render target. */ static uint64_t intel_bb_add_reloc(struct intel_bb *ibb, + uint32_t to_handle, uint32_t handle, uint32_t read_domains, uint32_t write_domain,
@@ -1562,20 +1597,32 @@ static uint64_t intel_bb_add_reloc(struct intel_bb *ibb, uint64_t presumed_offset) {struct drm_i915_gem_relocation_entry *relocs; -struct drm_i915_gem_exec_object2 *object; +struct drm_i915_gem_exec_object2 *object, *to_object;uint32_t i; object =intel_bb_add_object (ibb, handle, presumed_offset, false); - relocs = ibb->relocs; -if (ibb->num_relocs == ibb->allocated_relocs) { - ibb->allocated_relocs +=4096 /sizeof (*relocs); - relocs =realloc (relocs,sizeof (*relocs) * ibb->allocated_relocs); +/* For ibb we have relocs allocated in chunks */ +if (to_handle == ibb->handle) { + relocs = ibb->relocs; +if (ibb->num_relocs == ibb->allocated_relocs) { + ibb->allocated_relocs +=4096 /sizeof (*relocs); + relocs =realloc (relocs,sizeof (*relocs) * ibb->allocated_relocs); +igt_assert (relocs); + ibb->relocs = relocs; + } + i = ibb->num_relocs++; + }else { + to_object =intel_bb_find_object (ibb, to_handle); +igt_assert_f (to_object,"object has to be added to ibb first!\n" ); + + i = to_object->relocation_count++; + relocs =from_user_pointer (to_object->relocs_ptr); + relocs =realloc (relocs,sizeof (*relocs) * to_object->relocation_count); + to_object->relocs_ptr =to_user_pointer (relocs);igt_assert (relocs); - ibb->relocs = relocs; } - i = ibb->num_relocs++;memset (&relocs[i],0 ,sizeof (*relocs)); relocs[i].target_handle = handle; relocs[i].read_domains = read_domains;
@@ -1587,17 +1634,42 @@ static uint64_t intel_bb_add_reloc(struct intel_bb *ibb,else relocs[i].presumed_offset = object->offset; -igt_debug ("add reloc: handle: %u, r/w: 0x%x/0x%x, " +igt_debug ("add reloc: to_handle: %u, handle: %u, r/w: 0x%x/0x%x, " "delta: 0x%" PRIx64", " "offset: 0x%" PRIx64", " "poffset: %p\n" , - handle, read_domains, write_domain, + to_handle, handle, read_domains, write_domain, delta, offset,from_user_pointer (relocs[i].presumed_offset));return object->offset; } +static uint64_t __intel_bb_emit_reloc (struct intel_bb *ibb, +uint32_t to_handle, +uint32_t to_offset, +uint32_t handle, +uint32_t read_domains, +uint32_t write_domain, +uint64_t delta, +uint64_t presumed_offset) +{ +uint64_t address; + +igt_assert (ibb); + + address =intel_bb_add_reloc (ibb, to_handle, handle, + read_domains, write_domain, + delta, to_offset, + presumed_offset); + +intel_bb_out (ibb, delta + address); +if (ibb->gen >=8 ) +intel_bb_out (ibb, address >>32 ); + +return address; +} +/** * intel_bb_emit_reloc: * @ibb: pointer to intel_bb
@@ -1626,19 +1698,11 @@ uint64_t intel_bb_emit_reloc(struct intel_bb *ibb,uint64_t delta, uint64_t presumed_offset) { - uint64_t address; -igt_assert (ibb ); - address =intel_bb_add_reloc (ibb, handle, read_domains, write_domain, - delta,intel_bb_offset (ibb), - presumed_offset); - -intel_bb_out (ibb, delta + address); -if (ibb->gen >=8 ) -intel_bb_out (ibb, address >>32 ); - -return address; +return __intel_bb_emit_reloc (ibb, ibb->handle,intel_bb_offset (ibb), + handle, read_domains, write_domain, + delta, presumed_offset); } uint64_t intel_bb_emit_reloc_fenced(struct intel_bb *ibb,
@@ -1653,7 +1717,7 @@ uint64_t intel_bb_emit_reloc_fenced(struct intel_bb *ibb, address =intel_bb_emit_reloc (ibb, handle, read_domains, write_domain, delta, presumed_offset); -intel_bb_object_set_fence (ibb, handle); +intel_bb_object_set_flag (ibb, handle,EXEC_OBJECT_NEEDS_FENCE );return address; }
@@ -1686,7 +1750,8 @@ uint64_t intel_bb_offset_reloc(struct intel_bb *ibb, {igt_assert (ibb); -return intel_bb_add_reloc (ibb, handle, read_domains, write_domain, +return intel_bb_add_reloc (ibb, ibb->handle, handle, + read_domains, write_domain,0 , offset, presumed_offset); }
@@ -1700,7 +1765,24 @@ uint64_t intel_bb_offset_reloc_with_delta(struct intel_bb *ibb, {igt_assert (ibb); -return intel_bb_add_reloc (ibb, handle, read_domains, write_domain, +return intel_bb_add_reloc (ibb, ibb->handle, handle, + read_domains, write_domain, + delta, offset, presumed_offset); +} + +uint64_t intel_bb_offset_reloc_to_object (struct intel_bb *ibb, +uint32_t to_handle, +uint32_t handle, +uint32_t read_domains, +uint32_t write_domain, +uint32_t delta, +uint32_t offset, +uint64_t presumed_offset) +{ +igt_assert (ibb); + +return intel_bb_add_reloc (ibb, to_handle, handle, + read_domains, write_domain, delta, offset, presumed_offset); }
@@ -1955,16 +2037,38 @@ uint32_t intel_bb_emit_bbe(struct intel_bb *ibb) }/* -* intel_bb_flush_with_context_ring: +* intel_bb_emit_flush_common: * @ibb: batchbuffer -* @ctx: context id -* @ring: ring * -* Submits the batch for execution on the @ring engine with the supplied -* hardware context @ctx. +* Emits instructions which completes batch buffer. +* +* Returns: offset in batch buffer where there's end of instructions. */ -static void intel_bb_flush_with_context_ring (struct intel_bb *ibb, -uint32_t ctx,uint32_t ring) +uint32_t intel_bb_emit_flush_common (struct intel_bb *ibb) +{ +if (intel_bb_offset (ibb) ==0 ) +return 0 ; + +if (ibb->gen ==5 ) { +/* +* emit gen5 w/a without batch space checks - we reserve that +* already. +*/ +intel_bb_out (ibb,CMD_POLY_STIPPLE_OFFSET <<16 ); +intel_bb_out (ibb,0 ); + } + +/* Round batchbuffer usage to 2 DWORDs. */ +if ((intel_bb_offset (ibb) &4 ) ==0 ) +intel_bb_out (ibb,0 ); + +intel_bb_emit_bbe (ibb); + +return intel_bb_offset (ibb); +} + +static void intel_bb_exec_with_context_ring (struct intel_bb *ibb, +uint32_t ctx,uint32_t ring) { intel_bb_exec_with_context(ibb, intel_bb_offset(ibb), ctx, ring | I915_EXEC_NO_RELOC,
@@ -1972,23 +2076,109 @@ static void intel_bb_flush_with_context_ring(struct intel_bb *ibb,intel_bb_reset (ibb, false); } -void intel_bb_flush_render (struct intel_bb *ibb) +/* +* intel_bb_flush: +* @ibb: batchbuffer +* @ctx: context +* @ring: ring +* +* If batch is not empty emit batch buffer end, execute on specified +* context, ring then reset the batch. +*/ +void intel_bb_flush (struct intel_bb *ibb,uint32_t ctx,uint32_t ring) +{ +if (intel_bb_emit_flush_common (ibb) ==0 ) +return ; + +intel_bb_exec_with_context_ring (ibb, ctx, ring); +} + +static void __intel_bb_flush_render_with_context (struct intel_bb *ibb, +uint32_t ctx) {uint32_t ring =I915_EXEC_RENDER ; -intel_bb_flush_with_context_ring (ibb, ibb->ctx, ring); +if (intel_bb_emit_flush_common (ibb) ==0 ) +return ; + +intel_bb_exec_with_context_ring (ibb, ctx, ring); } -void intel_bb_flush_blit (struct intel_bb *ibb) +/* +* intel_bb_flush_render: +* @ibb: batchbuffer +* +* If batch is not empty emit batch buffer end, execute on render ring +* and reset the batch. +* Context used to execute is previous batch context. +*/ +void intel_bb_flush_render (struct intel_bb *ibb) +{ +__intel_bb_flush_render_with_context (ibb, ibb->ctx); +} + +/* +* intel_bb_flush_render_with_context: +* @ibb: batchbuffer +* @ctx: context +* +* If batch is not empty emit batch buffer end, execute on render ring with @ctx +* and reset the batch. +*/ +void intel_bb_flush_render_with_context (struct intel_bb *ibb,uint32_t ctx) +{ +__intel_bb_flush_render_with_context (ibb, ctx); +} + +static void __intel_bb_flush_blit_with_context (struct intel_bb *ibb, +uint32_t ctx) {uint32_t ring =I915_EXEC_DEFAULT ; +if (intel_bb_emit_flush_common (ibb) ==0 ) +return ; +if (HAS_BLT_RING (ibb->devid)) ring =I915_EXEC_BLT ; -intel_bb_flush_with_context_ring (ibb, ibb->ctx, ring); +intel_bb_exec_with_context_ring (ibb, ctx, ring); +} + +/* +* intel_bb_flush_blit: +* @ibb: batchbuffer +* +* If batch is not empty emit batch buffer end, execute on default/blit ring +* (depends on gen) and reset the batch. +* Context used to execute is previous batch context. +*/ +void intel_bb_flush_blit (struct intel_bb *ibb) +{ +__intel_bb_flush_blit_with_context (ibb, ibb->ctx); +} + +/* +* intel_bb_flush_blit_with_context: +* @ibb: batchbuffer +* @ctx: context +* +* If batch is not empty emit batch buffer end, execute on default/blit ring +* (depends on gen) with @ctx and reset the batch. +*/ +void intel_bb_flush_blit_with_context (struct intel_bb *ibb,uint32_t ctx) +{ +__intel_bb_flush_blit_with_context (ibb, ctx); } +/* +* intel_bb_copy_data: +* @ibb: batchbuffer +* @data: pointer of data which should be copied into batch +* @bytes: number of bytes to copy, must be dword multiplied +* @align: alignment in the batch +* +* Function copies @bytes of data pointed by @data into batch buffer. +*/ uint32_t intel_bb_copy_data (struct intel_bb *ibb,const void *data,unsigned int bytes,uint32_t align)
@@ -2008,6 +2198,14 @@ uint32_t intel_bb_copy_data(struct intel_bb *ibb,return offset; } +/* +* intel_bb_blit_start: +* @ibb: batchbuffer +* @flags: flags to blit command +* +* Function emits XY_SRC_COPY_BLT instruction with size appropriate size +* which depend on gen. +*/ void intel_bb_blit_start (struct intel_bb *ibb,uint32_t flags) { intel_bb_out(ibb, XY_SRC_COPY_BLT_CMD |
@@ -2017,6 +2215,22 @@ void intel_bb_blit_start(struct intel_bb *ibb, uint32_t flags) (6 + 2 * (ibb->gen >= 8))); } +/* +* intel_bb_emit_blt_copy: +* @ibb: batchbuffer +* @src: source buffer (intel_buf) +* @src_x1: source x1 position +* @src_y1: source y1 position +* @src_pitch: source pitch +* @dst: destination buffer (intel_buf) +* @dst_x1: destination x1 position +* @dst_y1: destination y1 position +* @dst_pitch: destination pitch +* @width: width of data to copy +* @height: height of data to copy +* +* Function emits complete blit command. +*/ void intel_bb_emit_blt_copy(struct intel_bb *ibb, struct intel_buf *src, int src_x1, int src_y1, int src_pitch,
@@ -2123,7 +2337,6 @@ void intel_bb_blt_copy(struct intel_bb *ibb,intel_bb_emit_blt_copy (ibb, src, src_x1, src_y1, src_pitch, dst, dst_x1, dst_y1, dst_pitch, width, height, bpp); -intel_bb_emit_bbe (ibb);intel_bb_flush_blit (ibb); }
lib/intel_batchbuffer.h +39 -2
79 lines not on this page · raw message
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v2 3/12 tests/gem_caching: adopt to batch flush function cleanup
In reply to Zbigniew Kempczyńskiintel_bb API has been cleaned so flush generates also BBE and executes the batch. Remove redundant code to use flush properly.
--- tests/i915/gem_caching.c | 5 ----- 1 file changed, 5 deletions(-)
tests/i915/gem_caching.c +0 -5
@@ -99,11 +99,6 @@ copy_bo(struct intel_bb *ibb, struct intel_buf *src, struct intel_buf *dst)intel_bb_emit_reloc_fenced (ibb, src->handle,I915_GEM_DOMAIN_RENDER ,0 ,0 ,0x0 ); - -/* Mark the end of the buffer. */ -intel_bb_out (ibb,MI_BATCH_BUFFER_END ); -intel_bb_ptr_align (ibb,8 ); -intel_bb_flush_blit (ibb);intel_bb_sync (ibb); }
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v2 4/12 lib/rendercopy: remove libdrm dependency
In reply to Zbigniew KempczyńskiUse intel_bb as main batch implementation to remove libdrm dependency. Rewrite all pipelines to use intel_bb and update render|vebox_copy function prototypes.
--- lib/intel_aux_pgtable.c | 325 +++++------ lib/intel_aux_pgtable.h | 29 +- lib/intel_batchbuffer.h | 42 +- lib/rendercopy.h | 102 ++-- lib/rendercopy_gen4.c | 568 ++++++++++--------- lib/rendercopy_gen6.c | 590 ++++++++++---------- lib/rendercopy_gen7.c | 612 ++++++++++----------- lib/rendercopy_gen8.c | 1030 +++++++++++++++-------------------- lib/rendercopy_gen9.c | 1145 +++++++++++++++++---------------------- lib/rendercopy_i830.c | 278 +++++----- lib/rendercopy_i915.c | 281 +++++----- lib/veboxcopy.h | 8 +- lib/veboxcopy_gen12.c | 117 ++-- 13 files changed, 2423 insertions(+), 2704 deletions(-)
lib/intel_aux_pgtable.c +144 -181
@@ -4,7 +4,7 @@#include "drmtest.h" #include "intel_aux_pgtable.h" #include "intel_batchbuffer.h" -#include "intel_bufmgr.h" +#include "intel_bufops.h" #include "ioctl_wrappers.h" #include "i915/gem_mman.h"
@@ -31,8 +31,6 @@#define GFX_ADDRESS_BITS 48 -#define max (a, b) ((a) > (b) ? (a) : (b)) -#define AUX_FORMAT_YCRCB 0x03#define AUX_FORMAT_P010 0x07#define AUX_FORMAT_P016 0x08
@@ -58,10 +56,12 @@ struct pgtable {struct pgtable_level_info *level_info;int size;int max_align; -drm_intel_bo *bo; +struct intel_bb *ibb; +struct intel_buf *buf; +void *ptr; }; -static uint64_t last_buf_surface_end (const struct igt_buf *buf) +static uint64_t last_buf_surface_end (struct intel_buf *buf) {uint64_t end_offset =0 ;int num_surfaces = buf->format_is_yuv_semiplanar ?2 :1 ;
@@ -79,7 +79,7 @@ static uint64_t last_buf_surface_end(const struct igt_buf *buf) }static int -pgt_table_count (int address_bits,const struct igt_buf **bufs,int buf_count) +pgt_table_count (int address_bits,struct intel_buf **bufs,int buf_count) {uint64_t end;int count;
@@ -88,19 +88,19 @@ pgt_table_count(int address_bits, const struct igt_buf **bufs, int buf_count) count =0 ; end =0 ;for (i =0 ; i < buf_count; i++) { -const struct igt_buf *buf = bufs[i]; +struct intel_buf *buf = bufs[i];uint64_t start;/* We require bufs to be sorted. */ igt_assert (i ==0 || - buf->bo->offset64 >= bufs[i -1 ]->bo->offset64 + - bufs[i -1 ]->bo->size); + buf->addr.offset >= bufs[i -1 ]->addr.offset + +intel_buf_bo_size (bufs[i -1 ])); - start =ALIGN_DOWN (buf->bo->offset64,1UL << address_bits); + start =ALIGN_DOWN (buf->addr.offset,1UL << address_bits);/* Avoid double counting for overlapping aligned bufs. */ start =max (start, end); - end =ALIGN (buf->bo->offset64 +last_buf_surface_end (buf), + end =ALIGN (buf->addr.offset +last_buf_surface_end (buf),1UL << address_bits);igt_assert (end >= start);
@@ -111,7 +111,7 @@ pgt_table_count(int address_bits, const struct igt_buf **bufs, int buf_count) }static void -pgt_calc_size (struct pgtable *pgt,const struct igt_buf **bufs,int buf_count) +pgt_calc_size (struct pgtable *pgt,struct intel_buf **bufs,int buf_count) {int level;
@@ -171,28 +171,33 @@ pgt_get_child_table(struct pgtable *pgt, uint64_t parent_table,uint64_t *child_entry_ptr;uint64_t child_table; - parent_table_ptr = pgt->bo->virtual + parent_table; + parent_table_ptr = pgt->ptr + parent_table; child_entry_idx =pgt_entry_index (pgt, level, address); child_entry_ptr = &parent_table_ptr[child_entry_idx];if (!*child_entry_ptr) {uint64_t pte; +uint32_t offset; child_table =pgt_alloc_table (pgt, level -1 ); -igt_assert (!((child_table + pgt->bo->offset64) & +igt_assert (!((child_table + pgt->buf->addr.offset) & ~ptr_mask (pgt, level))); pte = child_table | flags; - *child_entry_ptr = pgt->bo->offset64 + pte; + *child_entry_ptr = pgt->buf->addr.offset + pte;igt_assert (pte <=INT32_MAX ); -drm_intel_bo_emit_reloc (pgt->bo, - parent_table + - child_entry_idx *sizeof (uint64_t ), - pgt->bo, pte,0 ,0 ); + + offset = parent_table + child_entry_idx *sizeof (uint64_t ); +intel_bb_offset_reloc_to_object (pgt->ibb, + pgt->buf->handle, + pgt->buf->handle, +0 ,0 , + pte, offset, + pgt->buf->addr.offset); }else { child_table = (*child_entry_ptr &ptr_mask (pgt, level)) - - pgt->bo->offset64; + pgt->buf->addr.offset; }return child_table;
@@ -205,7 +210,7 @@ pgt_set_l1_entry(struct pgtable *pgt, uint64_t l1_table,uint64_t *l1_table_ptr;uint64_t *l1_entry_ptr; - l1_table_ptr = pgt->bo->virtual + l1_table; + l1_table_ptr = pgt->ptr + l1_table; l1_entry_ptr = &l1_table_ptr[pgt_entry_index (pgt,0 , address)];igt_assert (!(ptr & ~ptr_mask (pgt,0 )));
@@ -234,7 +239,7 @@ static int bpp_to_depth_val(int bpp) } } -static uint64_t pgt_get_l1_flags (const struct igt_buf *buf,int surface_idx) +static uint64_t pgt_get_l1_flags (const struct intel_buf *buf,int surface_idx) {/* * The offset of .tile_mode isn't specifed by bspec, it's what Mesa
@@ -337,15 +342,15 @@ static uint64_t pgt_get_lx_flags(void)static void pgt_populate_entries_for_buf (struct pgtable *pgt, -const struct igt_buf *buf, -uint64_t top_table, -int surface_idx) +struct intel_buf *buf, +uint64_t top_table, +int surface_idx) { -uint64_t surface_addr = buf->bo->offset64 + +uint64_t surface_addr = buf->addr.offset + buf->surface[surface_idx].offset;uint64_t surface_end = surface_addr + buf->surface[surface_idx].size; -uint64_t aux_addr = buf->bo->offset64 + buf->ccs[surface_idx].offset; +uint64_t aux_addr = buf->addr.offset + buf->ccs[surface_idx].offset;uint64_t l1_flags =pgt_get_l1_flags (buf, surface_idx);uint64_t lx_flags =pgt_get_lx_flags ();
@@ -367,19 +372,24 @@ pgt_populate_entries_for_buf(struct pgtable *pgt, } } +static void pgt_map (int i915,struct pgtable *pgt) +{ + pgt->ptr =gem_mmap__device_coherent (i915, pgt->buf->handle,0 , + pgt->size,PROT_READ |PROT_WRITE ); +} + +static void pgt_unmap (struct pgtable *pgt) +{ +munmap (pgt->ptr, pgt->size); +} +static void pgt_populate_entries (struct pgtable *pgt, -const struct igt_buf **bufs, -int buf_count, -drm_intel_bo *pgt_bo) +struct intel_buf **bufs, +int buf_count) {uint64_t top_table;int i; - pgt->bo = pgt_bo; - -igt_assert (pgt_bo->size >= pgt->size); -memset (pgt_bo->virtual,0 , pgt->size); - top_table =pgt_alloc_table (pgt, pgt->levels -1 );/* Top level table must be at offset 0. */ igt_assert (top_table ==0 );
@@ -395,7 +405,7 @@ static void pgt_populate_entries(struct pgtable *pgt,static struct pgtable *pgt_create (const struct pgtable_level_desc *level_descs,int levels, -const struct igt_buf **bufs,int buf_count) +struct intel_buf **bufs,int buf_count) {struct pgtable *pgt;int level;
@@ -427,10 +437,11 @@ static void pgt_destroy(struct pgtable *pgt)free (pgt); } -drm_intel_bo * -intel_aux_pgtable_create (drm_intel_bufmgr *bufmgr, -const struct igt_buf **bufs,int buf_count) +struct intel_buf * +intel_aux_pgtable_create (struct intel_bb *ibb, +struct intel_buf **bufs,int buf_count) { +struct drm_i915_gem_exec_object2 *obj;static const struct pgtable_level_desc level_desc[] = { { .idx_shift =16 ,
@@ -452,99 +463,43 @@ intel_aux_pgtable_create(drm_intel_bufmgr *bufmgr, }, };struct pgtable *pgt; -drm_intel_bo *pgt_bo; - - pgt =pgt_create (level_desc,ARRAY_SIZE (level_desc), bufs, buf_count); +struct buf_ops *bops; +struct intel_buf *buf; +uint64_t prev_alignment; - pgt_bo =drm_intel_bo_alloc_for_render (bufmgr,"aux pgt" , - pgt->size, pgt->max_align); -igt_assert (pgt_bo); - -igt_assert (drm_intel_bo_map (pgt_bo, true) ==0 ); -pgt_populate_entries (pgt, bufs, buf_count, pgt_bo); -igt_assert (drm_intel_bo_unmap (pgt_bo) ==0 ); +igt_assert (buf_count); + bops = bufs[0 ]->bops; + pgt =pgt_create (level_desc,ARRAY_SIZE (level_desc), bufs, buf_count); + pgt->ibb = ibb; + pgt->buf =intel_buf_create (bops, pgt->size,1 ,8 ,0 ,I915_TILING_NONE , +I915_COMPRESSION_NONE ); + +/* We need to use pgt->max_align for aux table */ + prev_alignment =intel_bb_set_default_object_alignment (ibb, + pgt->max_align); + obj =intel_bb_add_intel_buf (ibb, pgt->buf, false); +intel_bb_set_default_object_alignment (ibb, prev_alignment); + obj->alignment = pgt->max_align; + +pgt_map (ibb->i915, pgt); +pgt_populate_entries (pgt, bufs, buf_count); +pgt_unmap (pgt); + + buf = pgt->buf;pgt_destroy (pgt); -return pgt_bo; -} - -static void -aux_pgtable_find_max_free_range (const struct igt_buf **bufs,int buf_count, -uint64_t *range_start,uint64_t *range_size) -{ -/* -* Keep the first page reserved, so we can differentiate pinned -* objects based on a non-NULL offset. -*/ -uint64_t start =0x1000 ; -/* For now alloc only from the first 4GB address space. */ -const uint64_t end =1ULL <<32 ; -uint64_t max_range_start =0 ; -uint64_t max_range_size =0 ; -int i; - -for (i =0 ; i < buf_count; i++) { -if (bufs[i]->bo->offset64 >= end) -break ; - -if (bufs[i]->bo->offset64 - start > max_range_size) { - max_range_start = start; - max_range_size = bufs[i]->bo->offset64 - start; - } - start = bufs[i]->bo->offset64 + bufs[i]->bo->size; - } - -if (start < end && end - start > max_range_size) { - max_range_start = start; - max_range_size = end - start; - } - - *range_start = max_range_start; - *range_size = max_range_size; -} - -static uint64_t -aux_pgtable_find_free_range (const struct igt_buf **bufs,int buf_count, -uint32_t size) -{ -uint64_t range_start; -uint64_t range_size; -/* A compressed surface must be 64kB aligned. */ -const uint32_t align =0x10000 ; -int pad; - -aux_pgtable_find_max_free_range (bufs, buf_count, - &range_start, &range_size); - - pad =ALIGN (range_start, align) - range_start; - range_start += pad; - range_size -= pad; -igt_assert (range_size >= size); - -return range_start + -ALIGN_DOWN (rand () % ((range_size - size) +1 ), align); +return buf; }static void -aux_pgtable_reserve_range (const struct igt_buf **bufs,int buf_count, -const struct igt_buf *new_buf) +aux_pgtable_reserve_buf_slot (struct intel_buf **bufs,int buf_count, +struct intel_buf *new_buf) {int i; -if (igt_buf_compressed (new_buf)) { -uint64_t pin_offset = new_buf->bo->offset64; - -if (!pin_offset) - pin_offset =aux_pgtable_find_free_range (bufs, - buf_count, - new_buf->bo->size); -drm_intel_bo_set_softpin_offset (new_buf->bo, pin_offset); -igt_assert (new_buf->bo->offset64 == pin_offset); - } -for (i =0 ; i < buf_count; i++) -if (bufs[i]->bo->offset64 > new_buf->bo->offset64) +if (bufs[i]->addr.offset > new_buf->addr.offset)break ;memmove (&bufs[i +1 ], &bufs[i],sizeof (bufs[0 ]) * (buf_count - i));
@@ -554,107 +509,115 @@ aux_pgtable_reserve_range(const struct igt_buf **bufs, int buf_count,void gen12_aux_pgtable_init (struct aux_pgtable_info *info, -drm_intel_bufmgr *bufmgr, -const struct igt_buf *src_buf, -const struct igt_buf *dst_buf) +struct intel_bb *ibb, +struct intel_buf *src_buf, +struct intel_buf *dst_buf) { -const struct igt_buf *bufs[2 ]; -const struct igt_buf *reserved_bufs[2 ]; +struct intel_buf *bufs[2 ]; +struct intel_buf *reserved_bufs[2 ];int reserved_buf_count;int i; -if (!igt_buf_compressed (src_buf) && !igt_buf_compressed (dst_buf)) +igt_assert_f (ibb->enforce_relocs == false, +"We support aux pgtables for non-forced relocs yet!" ); + +if (!intel_buf_compressed (src_buf) && !intel_buf_compressed (dst_buf))return ; bufs[0 ] = src_buf; bufs[1 ] = dst_buf;/* -* Ideally we'd need an IGT-wide GFX address space allocator, which -* would consider all allocations and thus avoid evictions. For now use -* a simpler scheme here, which only considers the buffers involved in -* the blit, which should at least minimize the chance for evictions -* in the case of subsequent blits: -* 1. If they were already bound (bo->offset64 != 0), use this -* address. -* 2. Pick a range randomly from the 4GB address space, that is not -* already occupied by a bound object, or an object we pinned. +* Surface index in pgt table depend on its address so: +* 1. if handle was previously executed in batch use that address +* 2. add object to batch, this will generate random address +* +* Randomizing addresses can lead to overlapping, but we don't have +* global address space generator in IGT. Currently assumption is +* randomizing address is spread over 48-bit address space equally +* so risk with overlapping is minimal. Of course it is growing +* with number of objects (+its sizes) involved in blit. +* To avoid relocation EXEC_OBJECT_PINNED flag is set for compressed +* surfaces. */ + +intel_bb_add_intel_buf (ibb, src_buf, false); +if (intel_buf_compressed (src_buf)) +intel_bb_object_set_flag (ibb, src_buf->handle,EXEC_OBJECT_PINNED ); + +intel_bb_add_intel_buf (ibb, dst_buf, true); +if (intel_buf_compressed (dst_buf)) +intel_bb_object_set_flag (ibb, dst_buf->handle,EXEC_OBJECT_PINNED ); + reserved_buf_count =0 ;/* First reserve space for any bufs that are bound already. */ -for (i =0 ; i <ARRAY_SIZE (bufs); i++) -if (bufs[i]->bo->offset64) -aux_pgtable_reserve_range (reserved_bufs, - reserved_buf_count++, - bufs[i]); - -/* Next, reserve space for unbound bufs with an AUX surface. */ -for (i =0 ; i <ARRAY_SIZE (bufs); i++) -if (!bufs[i]->bo->offset64 &&igt_buf_compressed (bufs[i])) -aux_pgtable_reserve_range (reserved_bufs, - reserved_buf_count++, - bufs[i]); +for (i =0 ; i <ARRAY_SIZE (bufs); i++) { +igt_assert (bufs[i]->addr.offset !=INTEL_BUF_INVALID_ADDRESS ); +aux_pgtable_reserve_buf_slot (reserved_bufs, + reserved_buf_count++, + bufs[i]); + }/* Create AUX pgtable entries only for bufs with an AUX surface */ info->buf_count =0 ;for (i =0 ; i < reserved_buf_count; i++) { -if (!igt_buf_compressed (reserved_bufs[i])) +if (!intel_buf_compressed (reserved_bufs[i]))continue ; info->bufs[info->buf_count] = reserved_bufs[i]; info->buf_pin_offsets[info->buf_count] = - reserved_bufs[i]->bo->offset64; + reserved_bufs[i]->addr.offset; + info->buf_count++; } - info->pgtable_bo =intel_aux_pgtable_create (bufmgr, - info->bufs, - info->buf_count); -igt_assert (info->pgtable_bo); + info->pgtable_buf =intel_aux_pgtable_create (ibb, + info->bufs, + info->buf_count); + +igt_assert (info->pgtable_buf); }void -gen12_aux_pgtable_cleanup (struct aux_pgtable_info *info) +gen12_aux_pgtable_cleanup (struct intel_bb *ibb,struct aux_pgtable_info *info) {int i;/* Check that the pinned bufs kept their offset after the exec. */ -for (i =0 ; i < info->buf_count; i++) -igt_assert_eq_u64 (info->bufs[i]->bo->offset64, - info->buf_pin_offsets[i]); +for (i =0 ; i < info->buf_count; i++) { +uint64_t addr; + + addr =intel_bb_get_object_offset (ibb, info->bufs[i]->handle); +igt_assert_eq_u64 (addr, info->buf_pin_offsets[i]); + } -drm_intel_bo_unreference (info->pgtable_bo); +if (info->pgtable_buf) +intel_buf_destroy (info->pgtable_buf); }uint32_t -gen12_create_aux_pgtable_state (struct intel_batchbuffer *batch, -drm_intel_bo *aux_pgtable_bo) +gen12_create_aux_pgtable_state (struct intel_bb *ibb, +struct intel_buf *aux_pgtable_buf) {uint64_t *pgtable_ptr;uint32_t pgtable_ptr_offset; -int ret; -if (!aux_pgtable_bo) +if (!aux_pgtable_buf)return 0 ; - pgtable_ptr =intel_batchbuffer_subdata_alloc (batch, -sizeof (*pgtable_ptr), -sizeof (*pgtable_ptr)); - pgtable_ptr_offset =intel_batchbuffer_subdata_offset (batch, - pgtable_ptr); + pgtable_ptr =intel_bb_ptr (ibb); + pgtable_ptr_offset =intel_bb_offset (ibb); - *pgtable_ptr = aux_pgtable_bo->offset64; - ret =drm_intel_bo_emit_reloc (batch->bo, pgtable_ptr_offset, - aux_pgtable_bo,0 , -0 ,0 ); -assert (ret ==0 ); + *pgtable_ptr =intel_bb_offset_reloc (ibb, aux_pgtable_buf->handle, +0 ,0 , + pgtable_ptr_offset,-1 ); +intel_bb_ptr_add (ibb,sizeof (*pgtable_ptr));return pgtable_ptr_offset; }void -gen12_emit_aux_pgtable_state (struct intel_batchbuffer *batch,uint32_t state, -bool render) +gen12_emit_aux_pgtable_state (struct intel_bb *ibb,uint32_t state,bool render) {uint32_t table_base_reg = render ?GEN12_GFX_AUX_TABLE_BASE_ADDR :GEN12_VEBOX_AUX_TABLE_BASE_ADDR ;
@@ -662,11 +625,11 @@ gen12_emit_aux_pgtable_state(struct intel_batchbuffer *batch, uint32_t state,if (!state)return ; -OUT_BATCH (MI_LOAD_REGISTER_MEM_GEN8 |MI_MMIO_REMAP_ENABLE_GEN12 ); -OUT_BATCH (table_base_reg); -OUT_RELOC (batch->bo,0 ,0 , state); +intel_bb_out (ibb,MI_LOAD_REGISTER_MEM_GEN8 |MI_MMIO_REMAP_ENABLE_GEN12 ); +intel_bb_out (ibb, table_base_reg); +intel_bb_emit_reloc (ibb, ibb->handle,0 ,0 , state, ibb->batch_offset); -OUT_BATCH (MI_LOAD_REGISTER_MEM_GEN8 |MI_MMIO_REMAP_ENABLE_GEN12 ); -OUT_BATCH (table_base_reg +4 ); -OUT_RELOC (batch->bo,0 ,0 , state +4 ); +intel_bb_out (ibb,MI_LOAD_REGISTER_MEM_GEN8 |MI_MMIO_REMAP_ENABLE_GEN12 ); +intel_bb_out (ibb, table_base_reg +4 ); +intel_bb_emit_reloc (ibb, ibb->handle,0 ,0 , state +4 , ibb->batch_offset); }
lib/intel_aux_pgtable.h +13 -16
@@ -1,36 +1,33 @@#ifndef __INTEL_AUX_PGTABLE_H__#define __INTEL_AUX_PGTABLE_H__ -#include "intel_bufmgr.h" - -struct igt_buf ; -struct intel_batchbuffer ; +#include "intel_bufops.h" struct aux_pgtable_info {int buf_count; -const struct igt_buf *bufs[2 ]; +struct intel_buf *bufs[2 ];uint64_t buf_pin_offsets[2 ]; -drm_intel_bo *pgtable_bo; +struct intel_buf *pgtable_buf; }; -drm_intel_bo * -intel_aux_pgtable_create (drm_intel_bufmgr *bufmgr, -const struct igt_buf **bufs,int buf_count); +struct intel_buf * +intel_aux_pgtable_create (struct intel_bb *ibb, +struct intel_buf **bufs,int buf_count);void gen12_aux_pgtable_init (struct aux_pgtable_info *info, -drm_intel_bufmgr *bufmgr, -const struct igt_buf *src_buf, -const struct igt_buf *dst_buf); +struct intel_bb *ibb, +struct intel_buf *src_buf, +struct intel_buf *dst_buf);void -gen12_aux_pgtable_cleanup (struct aux_pgtable_info *info); +gen12_aux_pgtable_cleanup (struct intel_bb *ibb,struct aux_pgtable_info *info);uint32_t -gen12_create_aux_pgtable_state (struct intel_batchbuffer *batch, -drm_intel_bo *aux_pgtable_bo); +gen12_create_aux_pgtable_state (struct intel_bb *batch, +struct intel_buf *aux_pgtable_buf);void -gen12_emit_aux_pgtable_state (struct intel_batchbuffer *batch,uint32_t state, +gen12_emit_aux_pgtable_state (struct intel_bb *batch,uint32_t state,bool render);#endif
lib/intel_batchbuffer.h +23 -19
79 lines not on this page · raw message
lib/rendercopy.h +51 -51
121 lines not on this page · raw message
lib/rendercopy_gen4.c +277 -291
838 lines not on this page · raw message
lib/rendercopy_gen6.c +293 -297
796 lines not on this page · raw message
lib/rendercopy_gen7.c +309 -303
605 lines not on this page · raw message
lib/rendercopy_gen8.c +451 -579
1,030 lines not on this page · raw message
lib/rendercopy_gen9.c +512 -633
1,145 lines not on this page · raw message
lib/rendercopy_i830.c +143 -135
278 lines not on this page · raw message
lib/rendercopy_i915.c +145 -136
281 lines not on this page · raw message
lib/veboxcopy_gen12.c +58 -59
117 lines not on this page · raw message
The rest of this diff is not shown. View the raw message.
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
Part of the diff is not shown here. View the raw message.
PATCH v2 5/12 tests/api_intel_bb: add render tests
In reply to Zbigniew KempczyńskiCheck render / render-ccs tests works fine on all supported gens.
--- tests/i915/api_intel_bb.c | 168 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 168 insertions(+)
tests/i915/api_intel_bb.c +168 -0
@@ -632,6 +632,162 @@ static void full_batch(struct buf_ops *bops)intel_bb_destroy (ibb); } +static int render (struct buf_ops *bops,uint32_t tiling) +{ +struct intel_bb *ibb; +const int width =1024 ; +const int height =1024 ; +struct intel_buf src, dst, final; +int i915 =buf_ops_get_fd (bops); +uint32_t fails =0 ; +char name[128 ]; +uint32_t devid =intel_get_drm_devid (i915); +igt_render_copyfunc_t render_copy =NULL ; + + ibb =intel_bb_create (i915,PAGE_SIZE ); +if (debug_bb) +intel_bb_set_debug (ibb, true); + +scratch_buf_init (bops, &src, width, height,I915_TILING_NONE , +I915_COMPRESSION_NONE ); +scratch_buf_init (bops, &dst, width, height, tiling, +I915_COMPRESSION_NONE ); +scratch_buf_init (bops, &final, width, height,I915_TILING_NONE , +I915_COMPRESSION_NONE ); + +scratch_buf_draw_pattern (bops, &src, +0 ,0 , width, height, +0 ,0 , width, height,0 ); + + render_copy =igt_get_render_copyfunc (devid); +igt_assert (render_copy); + +render_copy (ibb,0 , + &src, +0 ,0 , width, height, + &dst, +0 ,0 ); + +render_copy (ibb,0 , + &dst, +0 ,0 , width, height, + &final, +0 ,0 ); + +intel_bb_sync (ibb); +intel_bb_destroy (ibb); + +if (write_png) { +snprintf (name,sizeof (name) -1 , +"render_dst_tiling_%d.png" , tiling); +intel_buf_write_to_png (&src,"render_src_tiling_none.png" ); +intel_buf_write_to_png (&dst, name); +intel_buf_write_to_png (&final,"render_final_tiling_none.png" ); + } + +/* We'll fail on src <-> final compare so just warn */ +if (tiling ==I915_TILING_NONE ) { +if (compare_bufs (&src, &dst, false) >0 ) +igt_warn ("%s: none->none failed!\n" , __func__); + }else { +if (compare_bufs (&src, &dst, false) ==0 ) +igt_warn ("%s: none->tiled failed!\n" , __func__); + } + + fails =compare_bufs (&src, &final, true); + +intel_buf_close (bops, &src); +intel_buf_close (bops, &dst); +intel_buf_close (bops, &final); + +igt_assert_f (fails ==0 ,"%s: (tiling: %d) fails: %d\n" , + __func__, tiling, fails); + +return fails; +} + +static uint32_t count_compressed (int gen,struct intel_buf *buf) +{ +int ccs_size =intel_buf_ccs_width (gen, buf) *intel_buf_ccs_height (gen, buf); +uint8_t *ptr =intel_buf_device_map (buf, false); +uint32_t compressed =0 ; +int i; + +for (i =0 ; i < ccs_size; i++) +if (ptr[buf->ccs[0 ].offset + i]) + compressed++; + +intel_buf_unmap (buf); + +return compressed; +} + +#define IMGSIZE (512 * 512 * 4) +#define CCSIMGSIZE (IMGSIZE + 4096) +static void render_ccs (struct buf_ops *bops) +{ +struct intel_bb *ibb; +const int width =1024 ; +const int height =1024 ; +struct intel_buf src, dst, final; +int i915 =buf_ops_get_fd (bops); +uint32_t fails =0 ; +uint32_t compressed =0 ; +uint32_t devid =intel_get_drm_devid (i915); +igt_render_copyfunc_t render_copy =NULL ; + + ibb =intel_bb_create (i915,PAGE_SIZE ); +if (debug_bb) +intel_bb_set_debug (ibb, true); + +scratch_buf_init (bops, &src, width, height,I915_TILING_NONE , +I915_COMPRESSION_NONE ); +scratch_buf_init (bops, &dst, width, height,I915_TILING_Y , +I915_COMPRESSION_RENDER ); +scratch_buf_init (bops, &final, width, height,I915_TILING_NONE , +I915_COMPRESSION_NONE ); + + render_copy =igt_get_render_copyfunc (devid); +igt_assert (render_copy); + +scratch_buf_draw_pattern (bops, &src, +0 ,0 , width, height, +0 ,0 , width, height,0 ); + +render_copy (ibb,0 , + &src, +0 ,0 , width, height, + &dst, +0 ,0 ); + +render_copy (ibb,0 , + &dst, +0 ,0 , width, height, + &final, +0 ,0 ); + +intel_bb_sync (ibb); +intel_bb_destroy (ibb); + + fails =compare_bufs (&src, &final, true); + compressed =count_compressed (ibb->gen, &dst); + +igt_debug ("fails: %u, compressed: %u\n" , fails, compressed); + +if (write_png) { +intel_buf_write_to_png (&src,"render-ccs-src.png" ); +intel_buf_write_to_png (&dst,"render-ccs-dst.png" ); +intel_buf_write_aux_to_png (&dst,"render-ccs-dst-aux.png" ); +intel_buf_write_to_png (&final,"render-ccs-final.png" ); + } + +intel_buf_close (bops, &src); +intel_buf_close (bops, &dst); +intel_buf_close (bops, &final); + +igt_assert_f (fails ==0 ,"render-ccs fails: %d\n" , fails); +} +static int opt_handler (int opt,int opt_index,void *data) {switch (opt) {
@@ -702,6 +858,18 @@ igt_main_args("dpi", NULL, help_str, opt_handler, NULL) igt_subtest("full-batch")full_batch (bops); + igt_subtest("render-none") +render (bops,I915_TILING_NONE ); + + igt_subtest("render-x") +render (bops,I915_TILING_X ); + + igt_subtest("render-y") +render (bops,I915_TILING_Y ); + + igt_subtest("render-ccs") +render_ccs (bops); + igt_fixture {buf_ops_destroy (bops);close (i915);
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v2 6/12 lib/igt_draw: remove libdrm dependency
In reply to Zbigniew KempczyńskiChange rendercopy to use intel_bb to remove libdrm dependency.
--- lib/igt_draw.c | 158 ++++++++++++++++++++++++------------------------- lib/igt_draw.h | 8 +-- 2 files changed, 80 insertions(+), 86 deletions(-)
lib/igt_draw.c +76 -82
@@ -27,6 +27,7 @@#include "igt_draw.h" #include "drmtest.h" +#include "intel_bufops.h" #include "intel_batchbuffer.h" #include "intel_chipset.h" #include "igt_core.h"
@@ -61,8 +62,8 @@/* Some internal data structures to avoid having to pass tons of parameters * around everything. */ struct cmd_data { -drm_intel_bufmgr *bufmgr; -drm_intel_context *context; +struct buf_ops *bops; +uint32_t ctx; };struct buf_data {
@@ -264,8 +265,7 @@ static void set_pixel(void *_ptr, int index, uint32_t color, int bpp) } } -static void switch_blt_tiling (struct intel_batchbuffer *batch,uint32_t tiling, -bool on) +static void switch_blt_tiling (struct intel_bb *ibb,uint32_t tiling,bool on) {uint32_t bcs_swctrl;
@@ -273,26 +273,22 @@ static void switch_blt_tiling(struct intel_batchbuffer *batch, uint32_t tiling,if (tiling !=I915_TILING_Y )return ; -igt_require (batch->gen >=6 ); +igt_require (ibb->gen >=6 ); bcs_swctrl = (0x3 <<16 ) | (on ?0x3 :0x0 );/* To change the tile register, insert an MI_FLUSH_DW followed by an * MI_LOAD_REGISTER_IMM */ -BEGIN_BATCH (4 ,0 ); -OUT_BATCH (MI_FLUSH_DW |2 ); -OUT_BATCH (0x0 ); -OUT_BATCH (0x0 ); -OUT_BATCH (0x0 ); -ADVANCE_BATCH (); - -BEGIN_BATCH (4 ,0 ); -OUT_BATCH (MI_LOAD_REGISTER_IMM ); -OUT_BATCH (0x22200 );/* BCS_SWCTRL */ -OUT_BATCH (bcs_swctrl); -OUT_BATCH (MI_NOOP ); -ADVANCE_BATCH (); +intel_bb_out (ibb,MI_FLUSH_DW |2 ); +intel_bb_out (ibb,0x0 ); +intel_bb_out (ibb,0x0 ); +intel_bb_out (ibb,0x0 ); + +intel_bb_out (ibb,MI_LOAD_REGISTER_IMM ); +intel_bb_out (ibb,0x22200 );/* BCS_SWCTRL */ +intel_bb_out (ibb, bcs_swctrl); +intel_bb_out (ibb,MI_NOOP ); } static void draw_rect_ptr_linear(void *ptr, uint32_t stride,
@@ -509,22 +505,39 @@ static void draw_rect_pwrite(int fd, struct buf_data *buf, } } +static struct intel_buf *create_buf (int fd,struct buf_ops *bops, +struct buf_data *from,uint32_t tiling) +{ +struct intel_buf *buf =calloc (sizeof (*buf),1 ); +uint32_t handle, name, width, height; + +igt_assert (buf); + + width = from->stride / (from->bpp /8 ); + height = from->size / from->stride; + + name =gem_flink (fd, from->handle); + handle =gem_open (fd, name); +intel_buf_init_using_handle (bops, handle, buf, + width, height, from->bpp,0 , + tiling,0 ); + +return buf; +} +static void draw_rect_blt (int fd,struct cmd_data *cmd_data,struct buf_data *buf,struct rect *rect,uint32_t tiling,uint32_t color) { -drm_intel_bo *dst; -struct intel_batchbuffer *batch; +struct intel_bb *ibb; +struct intel_buf *dst;int blt_cmd_len, blt_cmd_tiling, blt_cmd_depth;uint32_t devid =intel_get_drm_devid (fd);int gen =intel_gen (devid);int pitch; - dst =gem_handle_to_libdrm_bo (cmd_data->bufmgr, fd,"" , buf->handle); -igt_assert (dst); - - batch =intel_batchbuffer_alloc (cmd_data->bufmgr, devid); -igt_assert (batch); + dst =create_buf (fd, cmd_data->bops, buf, tiling); + ibb =intel_bb_create (fd,PAGE_SIZE );switch (buf->bpp) {case 8 :
@@ -544,81 +557,63 @@ static void draw_rect_blt(int fd, struct cmd_data *cmd_data, blt_cmd_tiling = (tiling) ?XY_COLOR_BLT_TILED :0 ; pitch = (gen >=4 && tiling) ? buf->stride /4 : buf->stride; -switch_blt_tiling (batch, tiling, true); +switch_blt_tiling (ibb, tiling, true); -BEGIN_BATCH (6 ,1 ); -OUT_BATCH (XY_COLOR_BLT_CMD_NOLEN |XY_COLOR_BLT_WRITE_ALPHA | -XY_COLOR_BLT_WRITE_RGB | blt_cmd_tiling | blt_cmd_len); -OUT_BATCH (blt_cmd_depth | (0xF0 <<16 ) | pitch); -OUT_BATCH ((rect->y <<16 ) | rect->x); -OUT_BATCH (((rect->y + rect->h) <<16 ) | (rect->x + rect->w)); -OUT_RELOC_FENCED (dst,0 ,I915_GEM_DOMAIN_RENDER ,0 ); -OUT_BATCH (color); -ADVANCE_BATCH (); +intel_bb_out (ibb,XY_COLOR_BLT_CMD_NOLEN |XY_COLOR_BLT_WRITE_ALPHA | +XY_COLOR_BLT_WRITE_RGB | blt_cmd_tiling | blt_cmd_len); +intel_bb_out (ibb, blt_cmd_depth | (0xF0 <<16 ) | pitch); +intel_bb_out (ibb, (rect->y <<16 ) | rect->x); +intel_bb_out (ibb, ((rect->y + rect->h) <<16 ) | (rect->x + rect->w)); +intel_bb_emit_reloc_fenced (ibb, dst->handle,0 ,I915_GEM_DOMAIN_RENDER , +0 , dst->addr.offset); +intel_bb_out (ibb, color); -switch_blt_tiling (batch, tiling, false); +switch_blt_tiling (ibb, tiling, false); -intel_batchbuffer_flush (batch); -intel_batchbuffer_free (batch); -drm_intel_bo_unreference (dst); +intel_bb_flush_blit (ibb); +intel_bb_destroy (ibb); +intel_buf_destroy (dst); }static void draw_rect_render (int fd,struct cmd_data *cmd_data,struct buf_data *buf,struct rect *rect,uint32_t tiling,uint32_t color) { -drm_intel_bo *src, *dst; +struct intel_buf *src, *dst;uint32_t devid =intel_get_drm_devid (fd);igt_render_copyfunc_t rendercopy =igt_get_render_copyfunc (devid); -struct igt_buf src_buf = {}, dst_buf = {}; -struct intel_batchbuffer *batch; +struct intel_bb *ibb;struct buf_data tmp;int pixel_size = buf->bpp /8 ;igt_skip_on (!rendercopy);/* We create a temporary buffer and copy from it using rendercopy. */ - tmp.size = rect->w * rect->h * pixel_size; + tmp.size =ALIGN (rect->w * rect->h * pixel_size,128 ); tmp.handle =gem_create (fd, tmp.size); - tmp.stride = rect->w * pixel_size; + tmp.stride =ALIGN (rect->w * pixel_size,32 ); tmp.bpp = buf->bpp;draw_rect_mmap_cpu (fd, &tmp, &(struct rect ){0 ,0 , rect->w, rect->h},I915_TILING_NONE ,I915_BIT_6_SWIZZLE_NONE , color); - src =gem_handle_to_libdrm_bo (cmd_data->bufmgr, fd,"" , tmp.handle); -igt_assert (src); - dst =gem_handle_to_libdrm_bo (cmd_data->bufmgr, fd,"" , buf->handle); -igt_assert (dst); - - src_buf.bo = src; - src_buf.surface[0 ].stride = tmp.stride; - src_buf.tiling =I915_TILING_NONE ; - src_buf.surface[0 ].size = tmp.size; - src_buf.bpp = tmp.bpp; - dst_buf.bo = dst; - dst_buf.surface[0 ].stride = buf->stride; - dst_buf.tiling = tiling; - dst_buf.surface[0 ].size = buf->size; - dst_buf.bpp = buf->bpp; - - batch =intel_batchbuffer_alloc (cmd_data->bufmgr, devid); -igt_assert (batch); - -rendercopy (batch, cmd_data->context, &src_buf,0 ,0 , rect->w, - rect->h, &dst_buf, rect->x, rect->y); - -intel_batchbuffer_free (batch); -drm_intel_bo_unreference (src); -drm_intel_bo_unreference (dst); + src =create_buf (fd, cmd_data->bops, &tmp,I915_TILING_NONE ); + dst =create_buf (fd, cmd_data->bops, buf, tiling); + ibb =intel_bb_create (fd,PAGE_SIZE ); + +rendercopy (ibb, cmd_data->ctx, src,0 ,0 , rect->w, + rect->h, dst, rect->x, rect->y); + +intel_bb_destroy (ibb); +intel_buf_destroy (src); +intel_buf_destroy (dst);gem_close (fd, tmp.handle); }/** * igt_draw_rect: * @fd: the DRM file descriptor -* @bufmgr: the libdrm bufmgr, only required for IGT_DRAW_BLT and -* IGT_DRAW_RENDER -* @context: the context, can be NULL if you don't want to think about it +* @bops: buf ops, only required for IGT_DRAW_BLT and IGT_DRAW_RENDER +* @ctx: the context, can be 0 if you don't want to think about it * @buf_handle: the handle of the buffer where you're going to draw to * @buf_size: the size of the buffer * @buf_stride: the stride of the buffer
@@ -634,7 +629,7 @@ static void draw_rect_render(int fd, struct cmd_data *cmd_data,* This function draws a colored rectangle on the destination buffer, allowing * you to specify the method used to draw the rectangle. */ -void igt_draw_rect(int fd, drm_intel_bufmgr *bufmgr, drm_intel_context *context, +void igt_draw_rect(int fd, struct buf_ops *bops, uint32_t ctx, uint32_t buf_handle, uint32_t buf_size, uint32_t buf_stride, uint32_t tiling, enum igt_draw_method method, int rect_x, int rect_y, int rect_w, int rect_h,
@@ -643,8 +638,8 @@ void igt_draw_rect(int fd, drm_intel_bufmgr *bufmgr, drm_intel_context *context,uint32_t buf_tiling, swizzle;struct cmd_data cmd_data = { - .bufmgr = bufmgr, - .context = context, + .bops = bops, + .ctx = ctx, };struct buf_data buf = { .handle = buf_handle,
@@ -693,9 +688,8 @@ void igt_draw_rect(int fd, drm_intel_bufmgr *bufmgr, drm_intel_context *context,/** * igt_draw_rect_fb: * @fd: the DRM file descriptor -* @bufmgr: the libdrm bufmgr, only required for IGT_DRAW_BLT and -* IGT_DRAW_RENDER -* @context: the context, can be NULL if you don't want to think about it +* @bops: buf ops, only required for IGT_DRAW_BLT and IGT_DRAW_RENDER +* @ctx: context, can be 0 if you don't want to think about it * @fb: framebuffer * @method: method you're going to use to write to the buffer * @rect_x: horizontal position on the buffer where your rectangle starts
@@ -707,12 +701,12 @@ void igt_draw_rect(int fd, drm_intel_bufmgr *bufmgr, drm_intel_context *context,* This is exactly the same as igt_draw_rect, but you can pass an igt_fb instead * of manually providing its details. See igt_draw_rect. */ -void igt_draw_rect_fb (int fd,drm_intel_bufmgr *bufmgr, -drm_intel_context *context,struct igt_fb *fb, +void igt_draw_rect_fb (int fd,struct buf_ops *bops, +uint32_t ctx,struct igt_fb *fb,enum igt_draw_method method,int rect_x,int rect_y,int rect_w,int rect_h,uint32_t color) { -igt_draw_rect (fd, bufmgr, context, fb->gem_handle, fb->size, fb->strides[0 ], +igt_draw_rect (fd, bops, ctx, fb->gem_handle, fb->size, fb->strides[0 ],igt_fb_mod_to_tiling (fb->modifier), method, rect_x, rect_y, rect_w, rect_h, color,igt_drm_format_to_bpp (fb->drm_format));
@@ -728,7 +722,7 @@ void igt_draw_rect_fb(int fd, drm_intel_bufmgr *bufmgr,*/ void igt_draw_fill_fb (int fd,struct igt_fb *fb,uint32_t color) { -igt_draw_rect_fb (fd,NULL ,NULL , fb, +igt_draw_rect_fb (fd,NULL ,0 , fb,gem_has_mappable_ggtt (fd) ?IGT_DRAW_MMAP_GTT :IGT_DRAW_MMAP_WC ,0 ,0 , fb->width, fb->height, color);
lib/igt_draw.h +4 -4
@@ -25,7 +25,7 @@#ifndef __IGT_DRAW_H__#define __IGT_DRAW_H__ -#include <intel_bufmgr.h> +#include <intel_bufops.h> #include "igt_fb.h" /**
@@ -50,14 +50,14 @@ enum igt_draw_method {const char *igt_draw_get_method_name (enum igt_draw_method method); -void igt_draw_rect (int fd,drm_intel_bufmgr *bufmgr,drm_intel_context *context, +void igt_draw_rect (int fd,struct buf_ops *bops,uint32_t ctx,uint32_t buf_handle,uint32_t buf_size,uint32_t buf_stride,uint32_t tiling,enum igt_draw_method method,int rect_x,int rect_y,int rect_w,int rect_h,uint32_t color,int bpp); -void igt_draw_rect_fb (int fd,drm_intel_bufmgr *bufmgr, -drm_intel_context *context,struct igt_fb *fb, +void igt_draw_rect_fb (int fd,struct buf_ops *bops, +uint32_t ctx,struct igt_fb *fb,enum igt_draw_method method,int rect_x,int rect_y,int rect_w,int rect_h,uint32_t color);
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v2 7/12 lib/igt_fb: Removal of libdrm dependency
In reply to Zbigniew KempczyńskiFrom: Dominik Grzegorzek <[email protected]>
Adopt to intel_bb/intel_buf for libdrm removal.
--- lib/igt_fb.c | 96 +++++++++++++++++++++++++++++----------------------- 1 file changed, 54 insertions(+), 42 deletions(-)
lib/igt_fb.c +54 -42
@@ -45,6 +45,7 @@#include "intel_batchbuffer.h" #include "intel_chipset.h" #include "i915/gem_mman.h" +#include "intel_bufops.h" /** * SECTION:igt_fb
@@ -1973,8 +1974,8 @@ struct fb_blit_upload {int fd;struct igt_fb *fb;struct fb_blit_linear linear; -drm_intel_bufmgr *bufmgr; -struct intel_batchbuffer *batch; +struct buf_ops *bops; +struct intel_bb *ibb; };static bool fast_blit_ok (const struct igt_fb *fb)
@@ -2044,14 +2045,14 @@ static bool use_blitter(const struct igt_fb *fb) !gem_has_mappable_ggtt (fb->fd); } -static void init_buf_ccs (struct igt_buf *buf,int ccs_idx, +static void init_buf_ccs (struct intel_buf *buf,int ccs_idx,uint32_t offset,uint32_t stride) { buf->ccs[ccs_idx].offset = offset; buf->ccs[ccs_idx].stride = stride; } -static void init_buf_surface (struct igt_buf *buf,int surface_idx, +static void init_buf_surface (struct intel_buf *buf,int surface_idx,uint32_t offset,uint32_t stride,uint32_t size) { buf->surface[surface_idx].offset = offset;
@@ -2075,26 +2076,17 @@ static int yuv_semiplanar_bpp(uint32_t drm_format) } } -static void init_buf (struct fb_blit_upload *blit, -struct igt_buf *buf, -const struct igt_fb *fb, -const char *name) +static struct intel_buf *create_buf (struct fb_blit_upload *blit, +const struct igt_fb *fb, +const char *name) { +struct intel_buf *buf; +uint32_t bo_name, handle, compression;int num_surfaces;int i;igt_assert_eq (fb->offsets[0 ],0 ); - buf->bo =gem_handle_to_libdrm_bo (blit->bufmgr, blit->fd, - name, fb->gem_handle); - buf->tiling =igt_fb_mod_to_tiling (fb->modifier); - buf->bpp = fb->plane_bpp[0 ]; - buf->format_is_yuv =igt_format_is_yuv (fb->drm_format); - buf->format_is_yuv_semiplanar = -igt_format_is_yuv_semiplanar (fb->drm_format); -if (buf->format_is_yuv_semiplanar) - buf->yuv_semiplanar_bpp =yuv_semiplanar_bpp (fb->drm_format); -if (is_ccs_modifier (fb->modifier)) {igt_assert_eq (fb->strides[0 ] &127 ,0 );
@@ -2104,17 +2096,36 @@ static void init_buf(struct fb_blit_upload *blit,igt_assert_eq (fb->strides[1 ] &127 ,0 );if (is_gen12_mc_ccs_modifier (fb->modifier)) - buf->compression =I915_COMPRESSION_MEDIA ; + compression =I915_COMPRESSION_MEDIA ;else - buf->compression =I915_COMPRESSION_RENDER ; + compression =I915_COMPRESSION_RENDER ; + }else { + num_surfaces = fb->num_planes; + compression =I915_COMPRESSION_NONE ; + } + bo_name =gem_flink (blit->fd, fb->gem_handle); + handle =gem_open (blit->fd, bo_name); + buf =calloc (1 ,sizeof (*buf)); +igt_assert (buf); +intel_buf_init_using_handle (blit->bops, handle, buf, fb->width, + fb->height, fb->plane_bpp[0 ],0 , +igt_fb_mod_to_tiling (fb->modifier), + compression); +intel_buf_set_name (buf, name); + + buf->format_is_yuv =igt_format_is_yuv (fb->drm_format); + buf->format_is_yuv_semiplanar = +igt_format_is_yuv_semiplanar (fb->drm_format); +if (buf->format_is_yuv_semiplanar) + buf->yuv_semiplanar_bpp =yuv_semiplanar_bpp (fb->drm_format); + +if (is_ccs_modifier (fb->modifier)) { num_surfaces = fb->num_planes /2 ;for (i =0 ; i < num_surfaces; i++)init_buf_ccs (buf, i, fb->offsets[num_surfaces + i], fb->strides[num_surfaces + i]); - }else { - num_surfaces = fb->num_planes; }igt_assert (fb->offsets[0 ] ==0 );
@@ -2130,11 +2141,13 @@ static void init_buf(struct fb_blit_upload *blit,if (fb->modifier ==I915_FORMAT_MOD_Y_TILED_GEN12_RC_CCS_CC ) buf->cc.offset = fb->offsets[2 ]; + +return buf; } -static void fini_buf (struct igt_buf *buf) +static void fini_buf (struct intel_buf *buf) { -drm_intel_bo_unreference (buf->bo); +intel_buf_destroy (buf); } static bool use_vebox_copy(const struct igt_fb *src_fb,
@@ -2164,7 +2177,7 @@ static void copy_with_engine(struct fb_blit_upload *blit,const struct igt_fb *dst_fb, const struct igt_fb *src_fb) { - struct igt_buf src = {}, dst = {}; + struct intel_buf *src, *dst;igt_render_copyfunc_t render_copy =NULL ;igt_vebox_copyfunc_t vebox_copy =NULL ;
@@ -2178,23 +2191,23 @@ static void copy_with_engine(struct fb_blit_upload *blit,igt_assert_eq (dst_fb->offsets[0 ],0 );igt_assert_eq (src_fb->offsets[0 ],0 ); -init_buf (blit, &src, src_fb,"cairo enginecopy src" ); -init_buf (blit, &dst, dst_fb,"cairo enginecopy dst" ); + src =create_buf (blit, src_fb,"cairo enginecopy src" ); + dst =create_buf (blit, dst_fb,"cairo enginecopy dst" );if (vebox_copy) -vebox_copy (blit->batch, &src, +vebox_copy (blit->ibb, src, dst_fb->plane_width[0 ], dst_fb->plane_height[0 ], - &dst); + dst);else -render_copy (blit->batch,NULL , - &src, +render_copy (blit->ibb,0 , + src,0 ,0 , dst_fb->plane_width[0 ], dst_fb->plane_height[0 ], - &dst, + dst,0 ,0 ); -fini_buf (&dst); -fini_buf (&src); +fini_buf (dst); +fini_buf (src); } static void blitcopy(const struct igt_fb *dst_fb,
@@ -2268,7 +2281,7 @@ static void free_linear_mapping(struct fb_blit_upload *blit)gem_set_domain (fd, linear->fb.gem_handle,I915_GEM_DOMAIN_GTT ,0 ); -if (blit->batch) +if (blit->ibb)copy_with_engine (blit, fb, &linear->fb);else blitcopy (fb, &linear->fb);
@@ -2277,9 +2290,9 @@ static void free_linear_mapping(struct fb_blit_upload *blit)gem_close (fd, linear->fb.gem_handle); } -if (blit->batch) { -intel_batchbuffer_free (blit->batch); -drm_intel_bufmgr_destroy (blit->bufmgr); +if (blit->ibb) { +intel_bb_destroy (blit->ibb); +buf_ops_destroy (blit->bops); } }
@@ -2301,9 +2314,8 @@ static void setup_linear_mapping(struct fb_blit_upload *blit)struct fb_blit_linear *linear = &blit->linear;if (!igt_vc4_is_tiled (fb->modifier) &&use_enginecopy (fb)) { - blit->bufmgr =drm_intel_bufmgr_gem_init (fd,4096 ); - blit->batch =intel_batchbuffer_alloc (blit->bufmgr, -intel_get_drm_devid (fd)); + blit->bops =buf_ops_create (fd); + blit->ibb =intel_bb_create (fd,4096 ); }/*
@@ -2335,7 +2347,7 @@ static void setup_linear_mapping(struct fb_blit_upload *blit)gem_set_domain (fd, linear->fb.gem_handle,I915_GEM_DOMAIN_GTT ,0 ); -if (blit->batch) +if (blit->ibb)copy_with_engine (blit, &linear->fb, fb);else blitcopy (&linear->fb, fb);
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v2 8/12 tests/gem|kms: remove libdrm dependency (batch 1)
In reply to Zbigniew KempczyńskiFrom: Dominik Grzegorzek <[email protected]>
Use intel_bb / intel_buf to remove libdrm dependency.
Tests changed:
- gem_concurrent_all
- gem_ppgtt
- kms_draw_crc
- kms_frontbuffer_tracking
- kms_psr
--- tests/i915/gem_concurrent_all.c | 431 ++++++++++++++++--------------- tests/i915/gem_ppgtt.c | 183 ++++++------- tests/kms_draw_crc.c | 20 +- tests/kms_frontbuffer_tracking.c | 20 +- tests/kms_psr.c | 134 +++++----- 5 files changed, 391 insertions(+), 397 deletions(-)
tests/i915/gem_concurrent_all.c +217 -214
@@ -64,7 +64,9 @@ int pass;struct create {const char *name;void (*require)(const struct create *,unsigned ); -drm_intel_bo *(*create)(drm_intel_bufmgr *,uint64_t size); +struct intel_buf *(*create)(struct buf_ops *bops,uint32_t width, +uint32_t height,uint32_t tiling, +uint64_t size); };struct size {
@@ -77,10 +79,10 @@ struct buffers {const struct create *create;const struct access_mode *mode;const struct size *size; -drm_intel_bufmgr *bufmgr; -struct intel_batchbuffer *batch; -drm_intel_bo **src, **dst; -drm_intel_bo *snoop, *spare; +struct buf_ops *bops; +struct intel_bb *ibb; +struct intel_buf **src, **dst; +struct intel_buf *snoop, *spare;uint32_t *tmp;int width, height, npixels, page_size;int count, num_buffers;
@@ -88,29 +90,32 @@ struct buffers {#define MIN_BUFFERS 3 -static void blt_copy_bo (struct buffers *b,drm_intel_bo *dst,drm_intel_bo *src); +static void blt_copy_bo (struct buffers *b,struct intel_buf *dst, +struct intel_buf *src);static void -nop_release_bo (drm_intel_bo *bo) +nop_release_bo (struct intel_buf *buf) { -drm_intel_bo_unreference (bo); +if (buf->ptr) +intel_buf_unmap (buf); +intel_buf_destroy (buf); }static void -prw_set_bo (struct buffers *b,drm_intel_bo *bo,uint32_t val) +prw_set_bo (struct buffers *b,struct intel_buf *buf,uint32_t val) {for (int i =0 ; i < b->npixels; i++) b->tmp[i] = val; -drm_intel_bo_subdata (bo,0 ,4 *b->npixels, b->tmp); +gem_write (fd, buf->handle,0 , b->tmp,4 *b->npixels); }static void -prw_cmp_bo (struct buffers *b,drm_intel_bo *bo,uint32_t val) +prw_cmp_bo (struct buffers *b,struct intel_buf *buf,uint32_t val) {uint32_t *vaddr; vaddr = b->tmp; -do_or_die (drm_intel_bo_get_subdata (bo,0 ,4 *b->npixels, vaddr)); +gem_read (fd, buf->handle,0 , vaddr,4 *b->npixels);for (int i =0 ; i < b->npixels; i++)igt_assert_eq_u32 (vaddr[i], val); }
@@ -118,31 +123,33 @@ prw_cmp_bo(struct buffers *b, drm_intel_bo *bo, uint32_t val)#define pixel (y, width) ((y)*(width) + (((y) + pass)%(width)))static void -partial_set_bo (struct buffers *b,drm_intel_bo *bo,uint32_t val) +partial_set_bo (struct buffers *b,struct intel_buf *buf,uint32_t val) {for (int y =0 ; y < b->height; y++) -do_or_die (drm_intel_bo_subdata (bo,4 *pixel (y, b->width),4 , &val)); +gem_write (fd, buf->handle,4 *pixel (y, b->width), &val,4 ); }static void -partial_cmp_bo (struct buffers *b,drm_intel_bo *bo,uint32_t val) +partial_cmp_bo (struct buffers *b,struct intel_buf *buf,uint32_t val) {for (int y =0 ; y < b->height; y++) { -uint32_t buf; -do_or_die (drm_intel_bo_get_subdata (bo,4 *pixel (y, b->width),4 , &buf)); -igt_assert_eq_u32 (buf, val); +uint32_t tmp; + +gem_read (fd, buf->handle,4 *pixel (y, b->width), &tmp,4 ); +igt_assert_eq_u32 (tmp, val); } } -static drm_intel_bo * -create_normal_bo (drm_intel_bufmgr *bufmgr,uint64_t size) +static struct intel_buf * +create_normal_bo (struct buf_ops *bops,uint32_t width, +uint32_t height,uint32_t tiling,uint64_t size) { -drm_intel_bo *bo; +struct intel_buf *buf; +int bpp = size/height/width *8 ; - bo =drm_intel_bo_alloc (bufmgr,"bo" , size,0 ); -igt_assert (bo); + buf =intel_buf_create (bops, width, height, bpp,0 , tiling,0 ); -return bo; +return buf; }static void can_create_normal (const struct create *create,unsigned count)
@@ -150,19 +157,26 @@ static void can_create_normal(const struct create *create, unsigned count) }#if HAVE_CREATE_PRIVATE -static drm_intel_bo * -create_private_bo (drm_intel_bufmgr *bufmgr,uint64_t size) +static struct intel_buf * +create_private_bo (buf_ops *bops,uint32_t width,uint32_t height, +uint32_t tiling,uint64_t size) { -drm_intel_bo *bo; -uint32_t handle; +struct intel_buf *buf; +uint32_t handle, buf_handle, name; +int bpp = size/height/width *8 ;/* XXX gem_create_with_flags(fd, size, I915_CREATE_PRIVATE); */ handle =gem_create (fd, size); - bo =gem_handle_to_libdrm_bo (bufmgr, fd,"stolen" , handle); + name =gem_flink (fd, handle); + buf_handle =gem_open (fd, name); + + buf =calloc (1 ,sizeof (*buf)); +intel_buf_init_using_handle (bops, buf_handle, buf, width, height, + bpp,0 , tiling,0 );gem_close (fd, handle); -return bo; +return buf; }static void can_create_private (const struct create *create,unsigned count)
@@ -172,19 +186,26 @@ static void can_create_private(const struct create *create, unsigned count)#endif #if HAVE_CREATE_STOLEN -static drm_intel_bo * -create_stolen_bo (drm_intel_bufmgr *bufmgr,uint64_t size) +static struct intel_buf * +create_stolen_bo (buf_ops *bops,uint32_t width,uint32_t height, +uint32_t tiling,uint64_t size) { -drm_intel_bo *bo; -uint32_t handle; +struct intel_buf *buf; +uint32_t handle, buf_handle, name; +int bpp = size/height/width *8 ; -/* XXX gem_create_with_flags(fd, size, I915_CREATE_STOLEN); */ +/* XXX gem_create_with_flags(fd, size, I915_CREATE_PRIVATE); */ handle =gem_create (fd, size); - bo =gem_handle_to_libdrm_bo (bufmgr, fd,"stolen" , handle); + name =gem_flink (fd, handle); + buf_handle =gem_open (fd, name); + + buf =calloc (1 ,sizeof (*buf)); +intel_buf_init_using_handle (bops, buf_handle, buf, width, height, + bpp,0 , tiling,0 );gem_close (fd, handle); -return bo; +return buf; }static void can_create_stolen (const struct create *create,unsigned count)
@@ -201,10 +222,17 @@ static void create_cpu_require(const struct create *create, unsigned count)#endif } -static drm_intel_bo * +static struct intel_buf * +create_bo (const struct buffers *b,uint32_t tiling) +{ +return b->create->create (b->bops, b->width, b->height, + tiling,4 *b->npixels); +} + +static struct intel_buf *unmapped_create_bo (const struct buffers *b) { -return b->create->create (b->bufmgr,4 *b->npixels); +return create_bo (b,I915_TILING_NONE ); }static void create_snoop_require (const struct create *create,unsigned count)
@@ -213,16 +241,15 @@ static void create_snoop_require(const struct create *create, unsigned count)igt_require (!gem_has_llc (fd)); } -static drm_intel_bo * +static struct intel_buf *snoop_create_bo (const struct buffers *b) { -drm_intel_bo *bo; +struct intel_buf *buf; - bo =unmapped_create_bo (b); -gem_set_caching (fd, bo->handle,I915_CACHING_CACHED ); -drm_intel_bo_disable_reuse (bo); + buf =unmapped_create_bo (b); +gem_set_caching (fd, buf->handle,I915_CACHING_CACHED ); -return bo; +return buf; }static void create_userptr_require (const struct create *create,unsigned count)
@@ -251,11 +278,11 @@ static void create_userptr_require(const struct create *create, unsigned count)igt_require (has_userptr); } -static drm_intel_bo * +static struct intel_buf *userptr_create_bo (const struct buffers *b) {struct drm_i915_gem_userptr userptr; -drm_intel_bo *bo; +struct intel_buf *buf;void *ptr;memset (&userptr,0 ,sizeof (userptr));
@@ -266,54 +293,48 @@ userptr_create_bo(const struct buffers *b)igt_assert (ptr != (void *)-1 ); userptr.user_ptr =to_user_pointer (ptr); -#if 0 do_or_die (drmIoctl (fd,DRM_IOCTL_I915_GEM_USERPTR , &userptr)); - bo =gem_handle_to_libdrm_bo (b->bufmgr, fd,"userptr" , userptr.handle); -gem_close (fd, userptr.handle); -#else - bo =drm_intel_bo_alloc_userptr (b->bufmgr,"name" , - ptr,I915_TILING_NONE ,0 , - userptr.user_size,0 ); -igt_assert (bo); -#endif - bo->virtual =from_user_pointer (userptr.user_ptr); + buf =calloc (1 ,sizeof (*buf)); +intel_buf_init_using_handle (b->bops, userptr.handle, buf, b->width, + b->height,32 ,0 ,I915_TILING_NONE ,0 ); + + buf->ptr = (void *)from_user_pointer (userptr.user_ptr); -return bo; +return buf; }static void -userptr_set_bo (struct buffers *b,drm_intel_bo *bo,uint32_t val) +userptr_set_bo (struct buffers *b,struct intel_buf *buf,uint32_t val) {int size = b->npixels; -uint32_t *vaddr = bo->virtual; +uint32_t *vaddr = buf->ptr; -gem_set_domain (fd, bo->handle, +gem_set_domain (fd, buf->handle,I915_GEM_DOMAIN_CPU ,I915_GEM_DOMAIN_CPU );while (size--) *vaddr++ = val; }static void -userptr_cmp_bo (struct buffers *b,drm_intel_bo *bo,uint32_t val) +userptr_cmp_bo (struct buffers *b,struct intel_buf *buf,uint32_t val) {int size = b->npixels; -uint32_t *vaddr = bo->virtual; +uint32_t *vaddr = buf->ptr; -gem_set_domain (fd, bo->handle, +gem_set_domain (fd, buf->handle,I915_GEM_DOMAIN_CPU ,0 );while (size--)igt_assert_eq_u32 (*vaddr++, val); }static void -userptr_release_bo (drm_intel_bo *bo) +userptr_release_bo (struct intel_buf *buf) { -igt_assert (bo->virtual); +igt_assert (buf->ptr); -munmap (bo->virtual, bo->size); - bo->virtual =NULL ; +munmap (buf->ptr, buf->surface[0 ].size); -drm_intel_bo_unreference (bo); +intel_buf_destroy (buf); }static void create_dmabuf_require (const struct create *create,unsigned count)
@@ -349,13 +370,14 @@ struct dmabuf {void *map; }; -static drm_intel_bo * +static struct intel_buf *dmabuf_create_bo (const struct buffers *b) {struct drm_prime_handle args; -drm_intel_bo *bo; +static struct intel_buf *buf;struct dmabuf *dmabuf;int size; +uint32_t handle; size = b->page_size;
@@ -366,9 +388,12 @@ dmabuf_create_bo(const struct buffers *b)do_ioctl (fd,DRM_IOCTL_PRIME_HANDLE_TO_FD , &args);gem_close (fd, args.handle); +igt_assert (args.fd !=-1 ); - bo =drm_intel_bo_gem_create_from_prime (b->bufmgr, args.fd, size); -igt_assert (bo); + handle =prime_fd_to_handle (buf_ops_get_fd (b->bops), args.fd); + buf =calloc (1 ,sizeof (*buf)); +intel_buf_init_using_handle (b->bops, handle, buf, b->width, + b->height,32 ,0 ,I915_TILING_NONE ,0 ); dmabuf =malloc (sizeof (*dmabuf));igt_assert (dmabuf);
@@ -379,15 +404,15 @@ dmabuf_create_bo(const struct buffers *b) dmabuf->fd, 0);igt_assert (dmabuf->map != (void *)-1 ); - bo->virtual = dmabuf; + buf->ptr = (void *) dmabuf; -return bo; +return buf; }static void -dmabuf_set_bo (struct buffers *b,drm_intel_bo *bo,uint32_t val) +dmabuf_set_bo (struct buffers *b,struct intel_buf *buf,uint32_t val) { -struct dmabuf *dmabuf = bo->virtual; +struct dmabuf *dmabuf = (void *) buf->ptr;uint32_t *v = dmabuf->map;int y;
@@ -398,9 +423,9 @@ dmabuf_set_bo(struct buffers *b, drm_intel_bo *bo, uint32_t val) }static void -dmabuf_cmp_bo (struct buffers *b,drm_intel_bo *bo,uint32_t val) +dmabuf_cmp_bo (struct buffers *b,struct intel_buf *buf,uint32_t val) { -struct dmabuf *dmabuf = bo->virtual; +struct dmabuf *dmabuf = (void *) buf->ptr;uint32_t *v = dmabuf->map;int y;
@@ -411,17 +436,16 @@ dmabuf_cmp_bo(struct buffers *b, drm_intel_bo *bo, uint32_t val) }static void -dmabuf_release_bo (drm_intel_bo *bo) +dmabuf_release_bo (struct intel_buf *buf) { -struct dmabuf *dmabuf = bo->virtual; +struct dmabuf *dmabuf = (void *) buf->ptr;igt_assert (dmabuf); -munmap (dmabuf->map, bo->size); +munmap (dmabuf->map, buf->surface[0 ].size);close (dmabuf->fd);free (dmabuf); - bo->virtual =NULL ; -drm_intel_bo_unreference (bo); +intel_buf_destroy (buf); }static bool has_prime_export (int _fd)
@@ -446,13 +470,14 @@ static void create_gtt_require(const struct create *create, unsigned count)gem_require_mappable_ggtt (fd); } -static drm_intel_bo * +static struct intel_buf *vgem_create_bo (const struct buffers *b) {struct drm_prime_handle args; -drm_intel_bo *bo; +struct intel_buf *buf;struct vgem_bo vgem;struct dmabuf *dmabuf; +uint32_t handle;igt_assert (vgem_drv !=-1 );
@@ -470,8 +495,11 @@ vgem_create_bo(const struct buffers *b)gem_close (vgem_drv, args.handle);igt_assert (args.fd !=-1 ); - bo =drm_intel_bo_gem_create_from_prime (b->bufmgr, args.fd, vgem.size); -igt_assert (bo); + handle =prime_fd_to_handle (buf_ops_get_fd (b->bops), args.fd); + buf =calloc (1 ,sizeof (*buf)); +intel_buf_init_using_handle (b->bops, handle, buf, + vgem.width, vgem.height, vgem.bpp, +0 ,I915_TILING_NONE ,0 ); dmabuf =malloc (sizeof (*dmabuf));igt_assert (dmabuf);
@@ -482,64 +510,58 @@ vgem_create_bo(const struct buffers *b) dmabuf->fd, 0);igt_assert (dmabuf->map != (void *)-1 ); - bo->virtual = dmabuf; + buf->ptr = (void *) dmabuf; -return bo; +return buf; }static void -gtt_set_bo (struct buffers *b,drm_intel_bo *bo,uint32_t val) +gtt_set_bo (struct buffers *b,struct intel_buf *buf,uint32_t val) { -uint32_t *vaddr = bo->virtual; +uint32_t *vaddr = buf->ptr; + +gem_set_domain (fd, buf->handle, +I915_GEM_DOMAIN_GTT ,I915_GEM_DOMAIN_GTT ); -drm_intel_gem_bo_start_gtt_access (bo, true);for (int y =0 ; y < b->height; y++) vaddr[pixel (y, b->width)] = val; }static void -gtt_cmp_bo (struct buffers *b,drm_intel_bo *bo,uint32_t val) +gtt_cmp_bo (struct buffers *b,struct intel_buf *buf,uint32_t val) { -uint32_t *vaddr = bo->virtual; +uint32_t *vaddr = buf->ptr;/* GTT access is slow. So we just compare a few points */ -drm_intel_gem_bo_start_gtt_access (bo, false); +gem_set_domain (fd, buf->handle, +I915_GEM_DOMAIN_GTT ,0 ); +for (int y =0 ; y < b->height; y++)igt_assert_eq_u32 (vaddr[pixel (y, b->width)], val); } -static drm_intel_bo * -map_bo (drm_intel_bo *bo) +static struct intel_buf * +map_bo (struct intel_buf *buf) {/* gtt map doesn't have a write parameter, so just keep the mapping * around (to avoid the set_domain with the gtt write domain set) and * manually tell the kernel when we start access the gtt. */ -do_or_die (drm_intel_gem_bo_map_gtt (bo)); - -return bo; -} - -static drm_intel_bo * -tile_bo (drm_intel_bo *bo,int width) -{ -uint32_t tiling =I915_TILING_X ; -uint32_t stride = width *4 ; - -do_or_die (drm_intel_bo_set_tiling (bo, &tiling, stride)); + buf->ptr =gem_mmap__gtt (buf_ops_get_fd (buf->bops), buf->handle, + buf->surface[0 ].size,PROT_READ |PROT_WRITE ); -return bo; +return buf; } -static drm_intel_bo * +static struct intel_buf *gtt_create_bo (const struct buffers *b) {return map_bo (unmapped_create_bo (b)); } -static drm_intel_bo * +static struct intel_buf *gttX_create_bo (const struct buffers *b) { -return tile_bo (gtt_create_bo (b), b->width); +return map_bo (create_bo (b,I915_TILING_X )); }static void bit17_require (void )
@@ -574,85 +596,83 @@ wc_create_require(const struct create *create, unsigned count)wc_require (); } -static drm_intel_bo * +static struct intel_buf *wc_create_bo (const struct buffers *b) { -drm_intel_bo *bo; +static struct intel_buf *buf; - bo =unmapped_create_bo (b); - bo->virtual =gem_mmap__wc (fd, bo->handle,0 , bo->size,PROT_READ |PROT_WRITE ); -return bo; + buf =unmapped_create_bo (b); + buf->ptr =gem_mmap__wc (fd, buf->handle,0 , buf->surface[0 ].size, +PROT_READ |PROT_WRITE ); +return buf; }static void -wc_release_bo (drm_intel_bo *bo) +wc_release_bo (struct intel_buf *buf) { -igt_assert (bo->virtual); +igt_assert (buf->ptr); -munmap (bo->virtual, bo->size); - bo->virtual =NULL ; +munmap (buf->ptr, buf->surface[0 ].size); + buf->ptr =0 ; -nop_release_bo (bo); +nop_release_bo (buf); } -static drm_intel_bo * +static struct intel_buf *gpu_create_bo (const struct buffers *b) {return unmapped_create_bo (b); } -static drm_intel_bo * +static struct intel_buf *gpuX_create_bo (const struct buffers *b) { -return tile_bo (gpu_create_bo (b), b->width); +return create_bo (b,I915_TILING_X ); }static void -cpu_set_bo (struct buffers *b,drm_intel_bo *bo,uint32_t val) +cpu_set_bo (struct buffers *b,struct intel_buf *buf,uint32_t val) {int size = b->npixels;uint32_t *vaddr; -do_or_die (drm_intel_bo_map (bo, true)); - vaddr = bo->virtual; +intel_buf_cpu_map (buf, true); + vaddr = buf->ptr;while (size--) *vaddr++ = val; -drm_intel_bo_unmap (bo); +intel_buf_unmap (buf); }static void -cpu_cmp_bo (struct buffers *b,drm_intel_bo *bo,uint32_t val) +cpu_cmp_bo (struct buffers *b,struct intel_buf *buf,uint32_t val) {int size = b->npixels;uint32_t *vaddr; -do_or_die (drm_intel_bo_map (bo, false)); - vaddr = bo->virtual; +intel_buf_cpu_map (buf, false); + vaddr = buf->ptr;while (size--)igt_assert_eq_u32 (*vaddr++, val); -drm_intel_bo_unmap (bo); +intel_buf_unmap (buf); }static void -gpu_set_bo (struct buffers *buffers,drm_intel_bo *bo,uint32_t val) +gpu_set_bo (struct buffers *buffers,struct intel_buf *buf,uint32_t val) {struct drm_i915_gem_relocation_entry reloc[1 ];struct drm_i915_gem_exec_object2 gem_exec[2 ];struct drm_i915_gem_execbuffer2 execbuf; -uint32_t buf[10 ], *b; -uint32_t tiling, swizzle; - -drm_intel_bo_get_tiling (bo, &tiling, &swizzle); +uint32_t tmp[10 ], *b;memset (reloc,0 ,sizeof (reloc));memset (gem_exec,0 ,sizeof (gem_exec));memset (&execbuf,0 ,sizeof (execbuf)); - b = buf; + b = tmp; *b++ =XY_COLOR_BLT_CMD_NOLEN | ((gen >=8 ) ?5 :4 ) |COLOR_BLT_WRITE_ALPHA |XY_COLOR_BLT_WRITE_RGB ; -if (gen >=4 && tiling) { +if (gen >=4 && buf->tiling) { b[-1 ] |=XY_COLOR_BLT_TILED ; *b = buffers->width; }else
@@ -660,8 +680,8 @@ gpu_set_bo(struct buffers *buffers, drm_intel_bo *bo, uint32_t val) *b++ |=0xf0 <<16 |1 <<25 |1 <<24 ; *b++ =0 ; *b++ = buffers->height <<16 | buffers->width; - reloc[0 ].offset = (b - buf) *sizeof (uint32_t ); - reloc[0 ].target_handle = bo->handle; + reloc[0 ].offset = (b - tmp) *sizeof (uint32_t ); + reloc[0 ].target_handle = buf->handle; reloc[0 ].read_domains =I915_GEM_DOMAIN_RENDER ; reloc[0 ].write_domain =I915_GEM_DOMAIN_RENDER ; *b++ =0 ;
@@ -669,10 +689,10 @@ gpu_set_bo(struct buffers *buffers, drm_intel_bo *bo, uint32_t val) *b++ =0 ; *b++ = val; *b++ =MI_BATCH_BUFFER_END ; -if ((b - buf) &1 ) +if ((b - tmp) &1 ) *b++ =0 ; - gem_exec[0 ].handle = bo->handle; + gem_exec[0 ].handle = buf->handle; gem_exec[0 ].flags =EXEC_OBJECT_NEEDS_FENCE ; gem_exec[1 ].handle =gem_create (fd,4096 );
@@ -681,30 +701,30 @@ gpu_set_bo(struct buffers *buffers, drm_intel_bo *bo, uint32_t val) execbuf.buffers_ptr =to_user_pointer (gem_exec); execbuf.buffer_count =2 ; - execbuf.batch_len = (b - buf) *sizeof (buf[0 ]); + execbuf.batch_len = (b - tmp) *sizeof (tmp[0 ]);if (gen >=6 ) execbuf.flags =I915_EXEC_BLT ; -gem_write (fd, gem_exec[1 ].handle,0 , buf, execbuf.batch_len); +gem_write (fd, gem_exec[1 ].handle,0 , tmp, execbuf.batch_len);gem_execbuf (fd, &execbuf);gem_close (fd, gem_exec[1 ].handle); }static void -gpu_cmp_bo (struct buffers *b,drm_intel_bo *bo,uint32_t val) +gpu_cmp_bo (struct buffers *b,struct intel_buf *buf,uint32_t val) { -blt_copy_bo (b, b->snoop, bo); +blt_copy_bo (b, b->snoop, buf);cpu_cmp_bo (b, b->snoop, val); }struct access_mode {const char *name;void (*require)(const struct create *,unsigned ); -drm_intel_bo *(*create_bo)(const struct buffers *b); -void (*set_bo)(struct buffers *b,drm_intel_bo *bo,uint32_t val); -void (*cmp_bo)(struct buffers *b,drm_intel_bo *bo,uint32_t val); -void (*release_bo)(drm_intel_bo *bo); +struct intel_buf *(*create_bo)(const struct buffers *b); +void (*set_bo)(struct buffers *b,struct intel_buf *buf,uint32_t val); +void (*cmp_bo)(struct buffers *b,struct intel_buf *buf,uint32_t val); +void (*release_bo)(struct intel_buf *buf); };igt_render_copyfunc_t rendercopy;
@@ -745,7 +765,7 @@ static void buffers_init(struct buffers *b,const struct access_mode *mode, const struct size *size, int num_buffers, - int _fd, int enable_reuse) + int _fd) { memset(b, 0, sizeof(*b)); b->name = name;
@@ -763,17 +783,13 @@ static void buffers_init(struct buffers *b, b->tmp =malloc (b->page_size);igt_assert (b->tmp); - b->bufmgr =drm_intel_bufmgr_gem_init (_fd,4096 ); -igt_assert (b->bufmgr); + b->bops =buf_ops_create (_fd); - b->src =malloc (2 *sizeof (drm_intel_bo *)*num_buffers); + b->src =malloc (2 *sizeof (struct intel_buf *)*num_buffers);igt_assert (b->src); b->dst = b->src + num_buffers; -if (enable_reuse) -drm_intel_bufmgr_gem_enable_reuse (b->bufmgr); - b->batch =intel_batchbuffer_alloc (b->bufmgr, devid); -igt_assert (b->batch); + b->ibb =intel_bb_create (_fd,4096 ); }static void buffers_destroy (struct buffers *b)
@@ -809,7 +825,7 @@ static void buffers_destroy(struct buffers *b)static void buffers_create (struct buffers *b) {int count = b->num_buffers; -igt_assert (b->bufmgr); +igt_assert (b->bops);buffers_destroy (b);igt_assert (b->count ==0 );
@@ -823,20 +839,15 @@ static void buffers_create(struct buffers *b) b->snoop =snoop_create_bo (b); } -static void buffers_reset (struct buffers *b,bool enable_reuse) +static void buffers_reset (struct buffers *b) { - b->bufmgr =drm_intel_bufmgr_gem_init (fd,4096 ); -igt_assert (b->bufmgr); - -if (enable_reuse) -drm_intel_bufmgr_gem_enable_reuse (b->bufmgr); - b->batch =intel_batchbuffer_alloc (b->bufmgr, devid); -igt_assert (b->batch); + b->bops =buf_ops_create (fd); + b->ibb =intel_bb_create (fd,4096 ); }static void buffers_fini (struct buffers *b) { -if (b->bufmgr ==NULL ) +if (b->bops ==NULL )return ;buffers_destroy (b);
@@ -844,58 +855,47 @@ static void buffers_fini(struct buffers *b)free (b->tmp);free (b->src); -intel_batchbuffer_free (b->batch); -drm_intel_bufmgr_destroy (b->bufmgr); +intel_bb_destroy (b->ibb); +buf_ops_destroy (b->bops);memset (b,0 ,sizeof (*b)); } -typedef void (*do_copy )(struct buffers *b,drm_intel_bo *dst,drm_intel_bo *src); +typedef void (*do_copy )(struct buffers *b,struct intel_buf *dst, +struct intel_buf *src);typedef igt_hang_t (*do_hang )(void ); -static void render_copy_bo (struct buffers *b,drm_intel_bo *dst,drm_intel_bo *src) +static void render_copy_bo (struct buffers *b,struct intel_buf *dst, +struct intel_buf *src) { -struct igt_buf d = { - .bo = dst, - .num_tiles = b->npixels *4 , - .surface[0 ] = { - .size = b->npixels *4 , .stride = b->width *4 , - }, - .bpp =32 , - }, s = { - .bo = src, - .num_tiles = b->npixels *4 , - .surface[0 ] = { - .size = b->npixels *4 , .stride = b->width *4 , - }, - .bpp =32 , - }; -uint32_t swizzle; - -drm_intel_bo_get_tiling (dst, &d.tiling, &swizzle); -drm_intel_bo_get_tiling (src, &s.tiling, &swizzle); - -rendercopy (b->batch,NULL , - &s,0 ,0 , +rendercopy (b->ibb,0 , + src,0 ,0 , b->width, b->height, - &d,0 ,0 ); + dst,0 ,0 ); +intel_bb_sync (b->ibb); +intel_bb_reset (b->ibb, true); } -static void blt_copy_bo (struct buffers *b,drm_intel_bo *dst,drm_intel_bo *src) +static void blt_copy_bo (struct buffers *b,struct intel_buf *dst, +struct intel_buf *src) { -intel_blt_copy (b->batch, +intel_bb_blt_copy (b->ibb, src,0 ,0 ,4 *b->width, dst,0 ,0 ,4 *b->width, b->width, b->height,32 ); +intel_bb_sync (b->ibb); +intel_bb_reset (b->ibb, true); } -static void cpu_copy_bo (struct buffers *b,drm_intel_bo *dst,drm_intel_bo *src) +static void cpu_copy_bo (struct buffers *b,struct intel_buf *dst, +struct intel_buf *src) {const int size = b->page_size;void *d, *s;gem_set_domain (fd, src->handle,I915_GEM_DOMAIN_CPU ,0 ); -gem_set_domain (fd, dst->handle,I915_GEM_DOMAIN_CPU ,I915_GEM_DOMAIN_CPU ); +gem_set_domain (fd, dst->handle,I915_GEM_DOMAIN_CPU , +I915_GEM_DOMAIN_CPU ); s =gem_mmap__cpu (fd, src->handle,0 , size,PROT_READ ); d =gem_mmap__cpu (fd, dst->handle,0 , size,PROT_WRITE );
@@ -905,13 +905,15 @@ static void cpu_copy_bo(struct buffers *b, drm_intel_bo *dst, drm_intel_bo *src)munmap (s, size); } -static void gtt_copy_bo (struct buffers *b,drm_intel_bo *dst,drm_intel_bo *src) +static void gtt_copy_bo (struct buffers *b,struct intel_buf *dst, +struct intel_buf *src) {const int size = b->page_size;void *d, *s;gem_set_domain (fd, src->handle,I915_GEM_DOMAIN_GTT ,0 ); -gem_set_domain (fd, dst->handle,I915_GEM_DOMAIN_GTT ,I915_GEM_DOMAIN_GTT ); +gem_set_domain (fd, dst->handle,I915_GEM_DOMAIN_GTT , +I915_GEM_DOMAIN_GTT ); s =gem_mmap__gtt (fd, src->handle, size,PROT_READ ); d =gem_mmap__gtt (fd, dst->handle, size,PROT_WRITE );
@@ -922,13 +924,15 @@ static void gtt_copy_bo(struct buffers *b, drm_intel_bo *dst, drm_intel_bo *src)munmap (s, size); } -static void wc_copy_bo (struct buffers *b,drm_intel_bo *dst,drm_intel_bo *src) +static void wc_copy_bo (struct buffers *b,struct intel_buf *dst, +struct intel_buf *src) {const int size = b->page_size;void *d, *s;gem_set_domain (fd, src->handle,I915_GEM_DOMAIN_WC ,0 ); -gem_set_domain (fd, dst->handle,I915_GEM_DOMAIN_WC ,I915_GEM_DOMAIN_WC ); +gem_set_domain (fd, dst->handle,I915_GEM_DOMAIN_WC , +I915_GEM_DOMAIN_WC ); s =gem_mmap__wc (fd, src->handle,0 , size,PROT_READ ); d =gem_mmap__wc (fd, dst->handle,0 , size,PROT_WRITE );
@@ -1353,10 +1357,10 @@ static void __run_forked(struct buffers *buffers, do_hang do_hang_func) { -/* purge the libdrm caches before cloing the process */ +/* purge the caches before cloing the process */ buffers_destroy (buffers); -intel_batchbuffer_free (buffers->batch); -drm_intel_bufmgr_destroy (buffers->bufmgr); +intel_bb_destroy (buffers->ibb); +buf_ops_destroy (buffers->bops); igt_fork(child, num_children) {int num_buffers;
@@ -1369,7 +1373,7 @@ static void __run_forked(struct buffers *buffers,if (num_buffers < buffers->num_buffers) buffers->num_buffers = num_buffers; -buffers_reset (buffers, true); +buffers_reset (buffers);buffers_create (buffers);igt_while_interruptible (interrupt) {
@@ -1382,7 +1386,7 @@ static void __run_forked(struct buffers *buffers,igt_waitchildren ();igt_assert_eq (intel_detect_and_clear_missed_interrupts (fd),0 ); -buffers_reset (buffers, true); +buffers_reset (buffers); } static void run_forked(struct buffers *buffers,
@@ -1459,8 +1463,7 @@ run_mode(const char *prefix,igt_fixture buffers_init(&buffers, prefix, create, mode, - size, num_buffers, - fd, run_wrap_func != run_child); +size ,num_buffers ,fd );for (h = hangs; h->suffix; h++) {if (!all && *h->suffix)
tests/i915/gem_ppgtt.c +82 -101
295 lines not on this page · raw message
tests/kms_draw_crc.c +9 -11
@@ -38,7 +38,7 @@ struct modeset_params {int drm_fd;drmModeResPtr drm_res;drmModeConnectorPtr drm_connectors[MAX_CONNECTORS ]; -drm_intel_bufmgr *bufmgr; +struct buf_ops *bops;igt_pipe_crc_t *pipe_crc;#define N_FORMATS 3
@@ -126,23 +126,23 @@ static void get_method_crc(enum igt_draw_method method, uint32_t drm_format,igt_create_fb (drm_fd, ms.mode->hdisplay, ms.mode->vdisplay, drm_format, tiling, &fb); -igt_draw_rect_fb (drm_fd, bufmgr,NULL , &fb, method, +igt_draw_rect_fb (drm_fd, bops,0 , &fb, method,0 ,0 , fb.width, fb.height,get_color (drm_format,0 ,0 ,1 )); -igt_draw_rect_fb (drm_fd, bufmgr,NULL , &fb, method, +igt_draw_rect_fb (drm_fd, bops,0 , &fb, method, fb.width /4 , fb.height /4 , fb.width /2 , fb.height /2 ,get_color (drm_format,0 ,1 ,0 )); -igt_draw_rect_fb (drm_fd, bufmgr,NULL , &fb, method, +igt_draw_rect_fb (drm_fd, bops,0 , &fb, method, fb.width /8 , fb.height /8 , fb.width /4 , fb.height /4 ,get_color (drm_format,1 ,0 ,0 )); -igt_draw_rect_fb (drm_fd, bufmgr,NULL , &fb, method, +igt_draw_rect_fb (drm_fd, bops,0 , &fb, method, fb.width /2 , fb.height /2 , fb.width /3 , fb.height /3 ,get_color (drm_format,1 ,0 ,1 )); -igt_draw_rect_fb (drm_fd, bufmgr,NULL , &fb, method,1 ,1 ,15 ,15 , +igt_draw_rect_fb (drm_fd, bops,0 , &fb, method,1 ,1 ,15 ,15 ,get_color (drm_format,0 ,1 ,1 )); rc = drmModeSetCrtc(drm_fd, ms.crtc_id, fb.fb_id, 0, 0,
@@ -228,7 +228,7 @@ static void fill_fb_subtest(void)igt_create_fb (drm_fd, ms.mode->hdisplay, ms.mode->vdisplay,DRM_FORMAT_XRGB8888 ,LOCAL_DRM_FORMAT_MOD_NONE , &fb); -igt_draw_rect_fb (drm_fd, bufmgr,NULL , &fb, +igt_draw_rect_fb (drm_fd, bops,0 , &fb,gem_has_mappable_ggtt (drm_fd) ?IGT_DRAW_MMAP_GTT :IGT_DRAW_MMAP_WC ,0 ,0 , fb.width, fb.height,0xFF );
@@ -270,9 +270,7 @@ static void setup_environment(void)kmstest_set_vt_graphics_mode (); - bufmgr =drm_intel_bufmgr_gem_init (drm_fd,4096 ); -igt_assert (bufmgr); -drm_intel_bufmgr_gem_enable_reuse (bufmgr); + bops =buf_ops_create (drm_fd);find_modeset_params (); pipe_crc = igt_pipe_crc_new(drm_fd, kmstest_get_crtc_idx(drm_res, ms.crtc_id),
@@ -285,7 +283,7 @@ static void teardown_environment(void)igt_pipe_crc_free (pipe_crc); -drm_intel_bufmgr_destroy (bufmgr); +buf_ops_destroy (bops);for (i =0 ; i < drm_res->count_connectors; i++)drmModeFreeConnector (drm_connectors[i]);
tests/kms_frontbuffer_tracking.c +9 -11
@@ -166,7 +166,7 @@ struct {int debugfs;igt_display_t display; -drm_intel_bufmgr *bufmgr; +struct buf_ops *bops; } drm;struct {
@@ -1091,7 +1091,7 @@ static void draw_rect(struct draw_pattern_info *pattern, struct fb_region *fb, {struct rect rect = pattern->get_rect (fb, r); -igt_draw_rect_fb (drm.fd, drm.bufmgr,NULL , fb->fb, method, +igt_draw_rect_fb (drm.fd, drm.bops,0 , fb->fb, method, fb->x + rect.x, fb->y + rect.y, rect.w, rect.h, rect.color);
@@ -1117,7 +1117,7 @@ static void fill_fb_region(struct fb_region *region, enum color ecolor) {uint32_t color =pick_color (region->fb, ecolor); -igt_draw_rect_fb (drm.fd, drm.bufmgr,NULL , region->fb,IGT_DRAW_BLT , +igt_draw_rect_fb (drm.fd, drm.bops,0 , region->fb,IGT_DRAW_BLT , region->x, region->y, region->w, region->h, color); }
@@ -1141,7 +1141,7 @@ static bool disable_features(const struct test_mode *t)static void *busy_thread_func (void *data) {while (!busy_thread.stop) - igt_draw_rect(drm.fd, drm.bufmgr, NULL, busy_thread.handle, + igt_draw_rect(drm.fd, drm.bops, 0, busy_thread.handle, busy_thread.size, busy_thread.stride, busy_thread.tiling, IGT_DRAW_BLT, 0, 0, busy_thread.width, busy_thread.height,
@@ -1288,14 +1288,12 @@ static void setup_drm(void)kmstest_set_vt_graphics_mode ();igt_display_require (&drm.display, drm.fd); - drm.bufmgr =drm_intel_bufmgr_gem_init (drm.fd,4096 ); -igt_assert (drm.bufmgr); -drm_intel_bufmgr_gem_enable_reuse (drm.bufmgr); + drm.bops =buf_ops_create (drm.fd); }static void teardown_drm (void ) { -drm_intel_bufmgr_destroy (drm.bufmgr); +buf_ops_destroy (drm.bops);igt_display_fini (&drm.display);close (drm.fd); }
@@ -2622,14 +2620,14 @@ static void scaledprimary_subtest(const struct test_mode *t) t->tiling, t->plane, &new_fb);fill_fb (&new_fb,COLOR_BLUE ); -igt_draw_rect_fb (drm.fd, drm.bufmgr,NULL , &new_fb, t->method, +igt_draw_rect_fb (drm.fd, drm.bops,0 , &new_fb, t->method, reg->x, reg->y, reg->w /2 , reg->h /2 ,pick_color (&new_fb,COLOR_GREEN )); -igt_draw_rect_fb (drm.fd, drm.bufmgr,NULL , &new_fb, t->method, +igt_draw_rect_fb (drm.fd, drm.bops,0 , &new_fb, t->method, reg->x + reg->w /2 , reg->y + reg->h /2 , reg->w /2 , reg->h /2 ,pick_color (&new_fb,COLOR_RED )); -igt_draw_rect_fb (drm.fd, drm.bufmgr,NULL , &new_fb, t->method, +igt_draw_rect_fb (drm.fd, drm.bops,0 , &new_fb, t->method, reg->x + reg->w /2 , reg->y + reg->h /2 , reg->w /4 , reg->h /4 ,pick_color (&new_fb,COLOR_MAGENTA ));
tests/kms_psr.c +74 -60
197 lines not on this page · raw message
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v2 9/12 tests/gem|kms: remove libdrm dependency (batch 2)
In reply to Zbigniew KempczyńskiUse intel_bb / intel_buf to remove libdrm dependency.
Tests changed:
- gem_read_read_speed
- gem_render_copy
- gem_render_copy_redux
- gem_render_linear_blits
- gem_render_tiled_blits
- gem_stress
- kms_big_fb
- kms_cursor_crc
Remove transitional rendercopy_bufmgr, we don't need it anymore.
--- lib/Makefile.sources | 2 - lib/meson.build | 1 - lib/rendercopy_bufmgr.c | 171 --------------- lib/rendercopy_bufmgr.h | 28 --- tests/i915/gem_read_read_speed.c | 160 +++++++------- tests/i915/gem_render_copy.c | 313 +++++++++++---------------- tests/i915/gem_render_copy_redux.c | 66 +++--- tests/i915/gem_render_linear_blits.c | 90 +++----- tests/i915/gem_render_tiled_blits.c | 85 ++++---- tests/i915/gem_stress.c | 244 +++++++++++---------- tests/kms_big_fb.c | 54 +++-- tests/kms_cursor_crc.c | 63 +++--- 12 files changed, 498 insertions(+), 779 deletions(-) delete mode 100644 lib/rendercopy_bufmgr.c delete mode 100644 lib/rendercopy_bufmgr.h
lib/Makefile.sources +0 -2
@@ -107,8 +107,6 @@ lib_source_list = \ gen7_render.h \ gen8_render.h \ gen9_render.h \ - rendercopy_bufmgr.c \ - rendercopy_bufmgr.h \ rendercopy_gen4.c \ rendercopy_gen6.c \ rendercopy_gen7.c \
lib/meson.build +0 -1
@@ -45,7 +45,6 @@ lib_sources = [ 'gpu_cmds.c', 'rendercopy_i915.c', 'rendercopy_i830.c', - 'rendercopy_bufmgr.c', 'rendercopy_gen4.c', 'rendercopy_gen6.c', 'rendercopy_gen7.c',
lib/rendercopy_bufmgr.c deleted +0 -171
171 lines not on this page · raw message
lib/rendercopy_bufmgr.h deleted +0 -28
@@ -1,28 +0,0 @@ -#ifndef __RENDERCOPY_BUFMGR_H__ -#define __RENDERCOPY_BUFMGR_H__ - -#include <stdint.h> -#include "intel_bufops.h" -#include "intel_batchbuffer.h" - -struct rendercopy_bufmgr ; - -struct rendercopy_bufmgr *rendercopy_bufmgr_create (int fd, -drm_intel_bufmgr *bufmgr); -void rendercopy_bufmgr_destroy (struct rendercopy_bufmgr *bmgr); - -bool rendercopy_bufmgr_set_software_tiling (struct rendercopy_bufmgr *bmgr, -uint32_t tiling, -bool use_software_tiling); - -void igt_buf_to_linear (struct rendercopy_bufmgr *bmgr,struct igt_buf *buf, -uint32_t *linear); - -void linear_to_igt_buf (struct rendercopy_bufmgr *bmgr,struct igt_buf *buf, -uint32_t *linear); - -void igt_buf_init (struct rendercopy_bufmgr *bmgr,struct igt_buf *buf, -int width,int height,int bpp, -uint32_t tiling,uint32_t compression); - -#endif
tests/i915/gem_read_read_speed.c +82 -78
240 lines not on this page · raw message
tests/i915/gem_render_copy.c +123 -190
583 lines not on this page · raw message
tests/i915/gem_render_copy_redux.c +29 -37
147 lines not on this page · raw message
tests/i915/gem_render_linear_blits.c +32 -58
160 lines not on this page · raw message
tests/i915/gem_render_tiled_blits.c +39 -46
180 lines not on this page · raw message
tests/i915/gem_stress.c +129 -115
500 lines not on this page · raw message
tests/kms_big_fb.c +32 -22
103 lines not on this page · raw message
tests/kms_cursor_crc.c +32 -31
116 lines not on this page · raw message
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v2 10/12 tools/intel_residency: adopt intel_residency to use bufops
In reply to Zbigniew KempczyńskiIGT draw functions remove libdrm dependency so migrate to new API.
--- tools/intel_residency.c | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-)
tools/intel_residency.c +4 -6
@@ -82,7 +82,7 @@ struct {int fd;drmModeResPtr res;drmModeConnectorPtr connectors[MAX_CONNECTORS ]; -drm_intel_bufmgr *bufmgr; +struct buf_ops *bops; } drm;struct {
@@ -191,16 +191,14 @@ static void setup_drm(void) drm.connectors[i] =drmModeGetConnector (drm.fd, drm.res->connectors[i]); - drm.bufmgr =drm_intel_bufmgr_gem_init (drm.fd,4096 ); -igt_assert (drm.bufmgr); -drm_intel_bufmgr_gem_enable_reuse (drm.bufmgr); + drm.bops =buf_ops_create (drm.fd); }static void teardown_drm (void ) {int i; -drm_intel_bufmgr_destroy (drm.bufmgr); +buf_ops_destroy (drm.bops);for (i =0 ; i < drm.res->count_connectors; i++)drmModeFreeConnector (drm.connectors[i]);
@@ -238,7 +236,7 @@ static void draw_rect(struct igt_fb *fb, enum igt_draw_method method,igt_assert (false); } -igt_draw_rect_fb (drm.fd, drm.bufmgr,NULL , fb, method, clip.x1, clip.y1, +igt_draw_rect_fb (drm.fd, drm.bops,0 , fb, method, clip.x1, clip.y1, clip.x2 - clip.x1, clip.y2 - clip.y1, color);if (method ==IGT_DRAW_MMAP_WC ) {
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v2 11/12 tests/perf: remove libdrm dependency for rendercopy
In reply to Zbigniew KempczyńskiRendercopy now uses no-drm version so all users has to migrate to new interface.
--- tests/i915/perf.c | 663 ++++++++++++++++++++-------------------------- 1 file changed, 281 insertions(+), 382 deletions(-)
tests/i915/perf.c +281 -382
@@ -497,64 +497,42 @@ oa_report_get_ctx_id(uint32_t *report) }static void -scratch_buf_memset (drm_intel_bo *bo,int width,int height,uint32_t color) +scratch_buf_memset (struct intel_buf *buf,int width,int height,uint32_t color) { -int ret; - - ret =drm_intel_bo_map (bo, true/* writable */ ); -igt_assert_eq (ret,0 ); +intel_buf_cpu_map (buf, true);for (int i =0 ; i < width * height; i++) - ((uint32_t *)bo->virtual)[i] = color; + buf->ptr[i] = color; -drm_intel_bo_unmap (bo); +intel_buf_unmap (buf); }static void -scratch_buf_init (drm_intel_bufmgr *bufmgr, -struct igt_buf *buf, +scratch_buf_init (struct buf_ops *bops, +struct intel_buf *buf,int width,int height,uint32_t color) { -size_t stride = width *4 ; -size_t size = stride * height; -drm_intel_bo *bo =drm_intel_bo_alloc (bufmgr,"" , size,4096 ); - -scratch_buf_memset (bo, width, height, color); - -memset (buf,0 ,sizeof (*buf)); - - buf->bo = bo; - buf->surface[0 ].stride = stride; - buf->tiling =I915_TILING_NONE ; - buf->surface[0 ].size = size; - buf->bpp =32 ; +intel_buf_init (bops, buf, width, height,32 ,0 , +I915_TILING_NONE ,I915_COMPRESSION_NONE ); +scratch_buf_memset (buf, width, height, color); }static void -emit_report_perf_count (struct intel_batchbuffer *batch, -drm_intel_bo *dst_bo, +emit_report_perf_count (struct intel_bb *ibb, +struct intel_buf *dst,int dst_offset,uint32_t report_id) { -if (IS_HASWELL (devid)) { -BEGIN_BATCH (3 ,1 ); -OUT_BATCH (GEN6_MI_REPORT_PERF_COUNT ); -OUT_RELOC (dst_bo,I915_GEM_DOMAIN_INSTRUCTION ,I915_GEM_DOMAIN_INSTRUCTION , - dst_offset); -OUT_BATCH (report_id); -ADVANCE_BATCH (); - }else { -/* XXX: NB: n dwords arg is actually magic since it internally -* automatically accounts for larger addresses on gen >= 8... -*/ -BEGIN_BATCH (3 ,1 ); -OUT_BATCH (GEN8_MI_REPORT_PERF_COUNT ); -OUT_RELOC (dst_bo,I915_GEM_DOMAIN_INSTRUCTION ,I915_GEM_DOMAIN_INSTRUCTION , - dst_offset); -OUT_BATCH (report_id); -ADVANCE_BATCH (); - } +if (IS_HASWELL (devid)) +intel_bb_out (ibb,GEN6_MI_REPORT_PERF_COUNT ); +else +intel_bb_out (ibb,GEN8_MI_REPORT_PERF_COUNT ); + +intel_bb_emit_reloc (ibb, dst->handle, +I915_GEM_DOMAIN_INSTRUCTION ,I915_GEM_DOMAIN_INSTRUCTION , + dst_offset, dst->addr.offset); +intel_bb_out (ibb, report_id); } static void
@@ -1495,14 +1473,13 @@ enum load {static struct load_helper {int devid; -drm_intel_bufmgr *bufmgr; -drm_intel_context *context; +struct buf_ops *bops;uint32_t context_id; -struct intel_batchbuffer *batch; +struct intel_bb *ibb;enum load load;bool exit;struct igt_helper_process igt_proc; -struct igt_buf src, dst; +struct intel_buf src, dst; } lh = {0 , };static void load_helper_signal_handler (int sig)
@@ -1524,6 +1501,14 @@ static void load_helper_set_load(enum load load)kill (lh.igt_proc.pid,SIGUSR2 ); } +static void set_to_gtt_domain (struct intel_buf *buf,int writing) +{ +int i915 =buf_ops_get_fd (buf->bops); + +gem_set_domain (i915, buf->handle,I915_GEM_DOMAIN_GTT , + writing ?I915_GEM_DOMAIN_GTT :0 ); +} +static void load_helper_run (enum load load) {/*
@@ -1542,21 +1527,12 @@ static void load_helper_run(enum load load)signal (SIGUSR2 , load_helper_signal_handler);while (!lh.exit) { -int ret; - -render_copy (lh.batch, - lh.context, +render_copy (lh.ibb, + lh.context_id, &lh.src,0 ,0 ,1920 ,1080 , &lh.dst,0 ,0 ); -intel_batchbuffer_flush_with_context (lh.batch, - lh.context); - - ret =drm_intel_gem_context_get_id (lh.context, - &lh.context_id); -igt_assert_eq (ret,0 ); - -drm_intel_bo_wait_rendering (lh.dst.bo); +set_to_gtt_domain (&lh.dst, true);/* Lower the load by pausing after every submitted * write. */
@@ -1574,52 +1550,36 @@ static void load_helper_stop(void)static void load_helper_init (void ) { -int ret; - lh.devid =intel_get_drm_devid (drm_fd);/* MI_STORE_DATA can only use GTT address on gen4+/g33 and needs * snoopable mem on pre-gen6. Hence load-helper only works on gen6+, but * that's also all we care about for the rps testcase*/ igt_assert (intel_gen (lh.devid) >=6 ); - lh.bufmgr =drm_intel_bufmgr_gem_init (drm_fd,4096 ); -igt_assert (lh.bufmgr); - -drm_intel_bufmgr_gem_enable_reuse (lh.bufmgr); - lh.context =drm_intel_gem_context_create (lh.bufmgr); -igt_assert (lh.context); + lh.bops =buf_ops_create (drm_fd); - lh.context_id =0xffffffff ; - ret =drm_intel_gem_context_get_id (lh.context, &lh.context_id); -igt_assert_eq (ret,0 ); + lh.context_id =gem_context_create (drm_fd);igt_assert_neq (lh.context_id,0xffffffff ); - lh.batch =intel_batchbuffer_alloc (lh.bufmgr, lh.devid); -igt_assert (lh.batch); + lh.ibb =intel_bb_create (drm_fd,BATCH_SZ ); -scratch_buf_init (lh.bufmgr, &lh.dst,1920 ,1080 ,0 ); -scratch_buf_init (lh.bufmgr, &lh.src,1920 ,1080 ,0 ); +scratch_buf_init (lh.bops, &lh.dst,1920 ,1080 ,0 ); +scratch_buf_init (lh.bops, &lh.src,1920 ,1080 ,0 ); }static void load_helper_fini (void ) { +int i915 =buf_ops_get_fd (lh.bops); +if (lh.igt_proc.running)load_helper_stop (); -if (lh.src.bo) -drm_intel_bo_unreference (lh.src.bo); -if (lh.dst.bo) -drm_intel_bo_unreference (lh.dst.bo); - -if (lh.batch) -intel_batchbuffer_free (lh.batch); - -if (lh.context) -drm_intel_gem_context_destroy (lh.context); - -if (lh.bufmgr) -drm_intel_bufmgr_destroy (lh.bufmgr); +intel_buf_close (lh.bops, &lh.src); +intel_buf_close (lh.bops, &lh.dst); +intel_bb_destroy (lh.ibb); +gem_context_destroy (i915, lh.context_id); +buf_ops_destroy (lh.bops); }static bool expected_report_timing_delta (uint32_t delta,uint32_t expected_delta)
@@ -1888,20 +1848,11 @@ test_per_context_mode_unprivileged(void)write_u64_file ("/proc/sys/dev/i915/perf_stream_paranoid" ,1 ); igt_fork(child, 1) { -drm_intel_context *context; -drm_intel_bufmgr *bufmgr;uint32_t ctx_id =0xffffffff ;/* invalid id */ -int ret;igt_drop_root (); - bufmgr =drm_intel_bufmgr_gem_init (drm_fd,4096 ); - context =drm_intel_gem_context_create (bufmgr); - -igt_assert (context); - - ret =drm_intel_gem_context_get_id (context, &ctx_id); -igt_assert_eq (ret,0 ); + ctx_id =gem_context_create (drm_fd);igt_assert_neq (ctx_id,0xffffffff ); properties[1 ] = ctx_id;
@@ -1909,8 +1860,7 @@ test_per_context_mode_unprivileged(void) stream_fd =__perf_open (drm_fd, ¶m, false);__perf_close (stream_fd); -drm_intel_gem_context_destroy (context); -drm_intel_bufmgr_destroy (bufmgr); +gem_context_destroy (drm_fd, ctx_id); }igt_waitchildren ();
@@ -2936,55 +2886,44 @@ gen12_test_mi_rpc(void) .num_properties = ARRAY_SIZE(properties) / 2, .properties_ptr = to_user_pointer(properties), }; -drm_intel_bo *bo; -drm_intel_bufmgr *bufmgr; -drm_intel_context *context; -struct intel_batchbuffer *batch; +struct buf_ops *bops; +struct intel_bb *ibb; +struct intel_buf *buf;#define INVALID_CTX_ID 0xffffffffuint32_t ctx_id =INVALID_CTX_ID ;uint32_t *report32; -int ret;size_t format_size_32;struct oa_format format =get_oa_format (test_set->perf_oa_format);/* Ensure perf_stream_paranoid is set to 1 by default */ write_u64_file ("/proc/sys/dev/i915/perf_stream_paranoid" ,1 ); - bufmgr =drm_intel_bufmgr_gem_init (drm_fd,4096 ); -igt_assert (bufmgr); - -drm_intel_bufmgr_gem_enable_reuse (bufmgr); - - context =drm_intel_gem_context_create (bufmgr); -igt_assert (context); - - ret =drm_intel_gem_context_get_id (context, &ctx_id); -igt_assert_eq (ret,0 ); + bops =buf_ops_create (drm_fd); + ctx_id =gem_context_create (drm_fd);igt_assert_neq (ctx_id,INVALID_CTX_ID ); properties[1 ] = ctx_id; - batch =intel_batchbuffer_alloc (bufmgr, devid); - bo =drm_intel_bo_alloc (bufmgr,"mi_rpc dest bo" ,4096 ,64 ); + ibb =intel_bb_create (drm_fd,BATCH_SZ ); + buf =intel_buf_create (bops,4096 ,1 ,8 ,64 , +I915_TILING_NONE ,I915_COMPRESSION_NONE ); - ret =drm_intel_bo_map (bo, true); -igt_assert_eq (ret,0 ); -memset (bo->virtual,0x80 ,4096 ); -drm_intel_bo_unmap (bo); +intel_buf_cpu_map (buf, true); +memset (buf->ptr,0x80 ,4096 ); +intel_buf_unmap (buf); stream_fd =__perf_open (drm_fd, ¶m, false);#define REPORT_ID 0xdeadbeef#define REPORT_OFFSET 0 -emit_report_perf_count (batch, - bo, +emit_report_perf_count (ibb, + buf,REPORT_OFFSET ,REPORT_ID ); -intel_batchbuffer_flush_with_context (batch, context); +intel_bb_flush_render_with_context (ibb, ctx_id); +intel_bb_sync (ibb); - ret =drm_intel_bo_map (bo, false); -igt_assert_eq (ret,0 ); - - report32 = bo->virtual; +intel_buf_cpu_map (buf, false); + report32 = buf->ptr; format_size_32 = format.size >>2 ;dump_report (report32, format_size_32,"mi-rpc" );
@@ -3006,11 +2945,11 @@ gen12_test_mi_rpc(void)igt_assert_neq (report32[format.b_off >>2 ],0x80808080 );igt_assert_eq (report32[format_size_32],0x80808080 ); -drm_intel_bo_unmap (bo); -drm_intel_bo_unreference (bo); -intel_batchbuffer_free (batch); -drm_intel_gem_context_destroy (context); -drm_intel_bufmgr_destroy (bufmgr); +intel_buf_unmap (buf); +intel_buf_destroy (buf); +intel_bb_destroy (ibb); +gem_context_destroy (drm_fd, ctx_id); +buf_ops_destroy (bops);__perf_close (stream_fd); }
@@ -3034,41 +2973,33 @@ test_mi_rpc(void) .num_properties = sizeof(properties) / 16, .properties_ptr = to_user_pointer(properties), }; -drm_intel_bufmgr *bufmgr =drm_intel_bufmgr_gem_init (drm_fd,4096 ); -drm_intel_context *context; -struct intel_batchbuffer *batch; -drm_intel_bo *bo; -uint32_t *report32; -int ret; +struct buf_ops *bops =buf_ops_create (drm_fd); +struct intel_bb *ibb; +struct intel_buf *buf; +uint32_t *report32, ctx_id; stream_fd =__perf_open (drm_fd, ¶m, false); -drm_intel_bufmgr_gem_enable_reuse (bufmgr); - - context =drm_intel_gem_context_create (bufmgr); -igt_assert (context); + ctx_id =gem_context_create (drm_fd); - batch =intel_batchbuffer_alloc (bufmgr, devid); + ibb =intel_bb_create (drm_fd,BATCH_SZ ); + buf =intel_buf_create (bops,4096 ,1 ,8 ,64 , +I915_TILING_NONE ,I915_COMPRESSION_NONE ); - bo =drm_intel_bo_alloc (bufmgr,"mi_rpc dest bo" ,4096 ,64 ); +intel_buf_cpu_map (buf, true); +memset (buf->ptr,0x80 ,4096 ); +intel_buf_unmap (buf); - ret =drm_intel_bo_map (bo, true); -igt_assert_eq (ret,0 ); - -memset (bo->virtual,0x80 ,4096 ); -drm_intel_bo_unmap (bo); - -emit_report_perf_count (batch, - bo,/* dst */ +emit_report_perf_count (ibb, + buf,/* dst */ 0 ,/* dst offset in bytes */ 0xdeadbeef );/* report ID */ -intel_batchbuffer_flush_with_context (batch, context); - - ret =drm_intel_bo_map (bo, false/* write enable */ ); -igt_assert_eq (ret,0 ); +intel_bb_flush_render_with_context (ibb, ctx_id); +intel_bb_sync (ibb); - report32 = bo->virtual; +intel_buf_cpu_map (buf, false); + report32 = buf->ptr;dump_report (report32,64 ,"mi-rpc" );igt_assert_eq (report32[0 ],0xdeadbeef );/* report ID */ igt_assert_neq (report32[1 ],0 );/* timestamp */
@@ -3076,17 +3007,17 @@ test_mi_rpc(void)igt_assert_neq (report32[63 ],0x80808080 );/* end of report */ igt_assert_eq (report32[64 ],0x80808080 );/* after 256 byte report */ -drm_intel_bo_unmap (bo); -drm_intel_bo_unreference (bo); -intel_batchbuffer_free (batch); -drm_intel_gem_context_destroy (context); -drm_intel_bufmgr_destroy (bufmgr); +intel_buf_unmap (buf); +intel_buf_destroy (buf); +intel_bb_destroy (ibb); +gem_context_destroy (drm_fd, ctx_id); +buf_ops_destroy (bops);__perf_close (stream_fd); }static void -emit_stall_timestamp_and_rpc (struct intel_batchbuffer *batch, -drm_intel_bo *dst, +emit_stall_timestamp_and_rpc (struct intel_bb *ibb, +struct intel_buf *dst,int timestamp_offset,int report_dst_offset,uint32_t report_id)
@@ -3095,27 +3026,19 @@ emit_stall_timestamp_and_rpc(struct intel_batchbuffer *batch,PIPE_CONTROL_RENDER_TARGET_FLUSH | PIPE_CONTROL_WRITE_TIMESTAMP); -if (intel_gen (devid) >=8 ) { -BEGIN_BATCH (5 ,1 ); -OUT_BATCH (GFX_OP_PIPE_CONTROL | (6 -2 )); -OUT_BATCH (pipe_ctl_flags); -OUT_RELOC (dst,I915_GEM_DOMAIN_INSTRUCTION ,I915_GEM_DOMAIN_INSTRUCTION , - timestamp_offset); -OUT_BATCH (0 );/* imm lower */ -OUT_BATCH (0 );/* imm upper */ -ADVANCE_BATCH (); - }else { -BEGIN_BATCH (5 ,1 ); -OUT_BATCH (GFX_OP_PIPE_CONTROL | (5 -2 )); -OUT_BATCH (pipe_ctl_flags); -OUT_RELOC (dst,I915_GEM_DOMAIN_INSTRUCTION ,I915_GEM_DOMAIN_INSTRUCTION , - timestamp_offset); -OUT_BATCH (0 );/* imm lower */ -OUT_BATCH (0 );/* imm upper */ -ADVANCE_BATCH (); - } +if (intel_gen (devid) >=8 ) +intel_bb_out (ibb,GFX_OP_PIPE_CONTROL | (6 -2 )); +else +intel_bb_out (ibb,GFX_OP_PIPE_CONTROL | (5 -2 )); + +intel_bb_out (ibb, pipe_ctl_flags); +intel_bb_emit_reloc (ibb, dst->handle, +I915_GEM_DOMAIN_INSTRUCTION ,I915_GEM_DOMAIN_INSTRUCTION , + timestamp_offset, dst->addr.offset); +intel_bb_out (ibb,0 );/* imm lower */ +intel_bb_out (ibb,0 );/* imm upper */ -emit_report_perf_count (batch, dst, report_dst_offset, report_id); +emit_report_perf_count (ibb, dst, report_dst_offset, report_id); }/* Tests the INTEL_performance_query use case where an unprivileged process
@@ -3156,11 +3079,10 @@ hsw_test_single_ctx_counters(void)write_u64_file ("/proc/sys/dev/i915/perf_stream_paranoid" ,1 ); igt_fork(child, 1) { -drm_intel_bufmgr *bufmgr; -drm_intel_context *context0, *context1; -struct intel_batchbuffer *batch; -struct igt_buf src[3 ], dst[3 ]; -drm_intel_bo *bo; +struct buf_ops *bops; +struct intel_buf src[3 ], dst[3 ], *dst_buf; +struct intel_bb *ibb0, *ibb1; +uint32_t context0_id, context1_id;uint32_t *report0_32, *report1_32;uint64_t timestamp0_64, timestamp1_64;uint32_t delta_ts64, delta_oa32;
@@ -3169,26 +3091,24 @@ hsw_test_single_ctx_counters(void)int n_samples_written;int width =800 ;int height =600 ; -uint32_t ctx_id =0xffffffff ;/* invalid id */ -int ret;igt_drop_root (); - bufmgr =drm_intel_bufmgr_gem_init (drm_fd,4096 ); -drm_intel_bufmgr_gem_enable_reuse (bufmgr); + bops =buf_ops_create (drm_fd);for (int i =0 ; i <ARRAY_SIZE (src); i++) { -scratch_buf_init (bufmgr, &src[i], width, height,0xff0000ff ); -scratch_buf_init (bufmgr, &dst[i], width, height,0x00ff00ff ); +scratch_buf_init (bops, &src[i], width, height,0xff0000ff ); +scratch_buf_init (bops, &dst[i], width, height,0x00ff00ff ); } - batch =intel_batchbuffer_alloc (bufmgr, devid); - - context0 =drm_intel_gem_context_create (bufmgr); -igt_assert (context0); - - context1 =drm_intel_gem_context_create (bufmgr); -igt_assert (context1); +/* +* We currently cache addresses for buffers within +* intel_bb, so use separate batches for different contexts +*/ + ibb0 =intel_bb_create (drm_fd,BATCH_SZ ); + ibb1 =intel_bb_create (drm_fd,BATCH_SZ ); + context0_id =gem_context_create (drm_fd); + context1_id =gem_context_create (drm_fd);igt_debug ("submitting warm up render_copy\n" );
@@ -3212,34 +3132,32 @@ hsw_test_single_ctx_counters(void)* up pinning the context since there won't ever be a pinning * hook callback. */ -render_copy (batch, - context0, +render_copy (ibb0, + context0_id, &src[0 ],0 ,0 , width, height, &dst[0 ],0 ,0 ); - ret =drm_intel_gem_context_get_id (context0, &ctx_id); -igt_assert_eq (ret,0 ); -igt_assert_neq (ctx_id,0xffffffff ); - properties[1 ] = ctx_id; + properties[1 ] = context0_id; -intel_batchbuffer_flush_with_context (batch, context0); +intel_bb_flush_render_with_context (ibb0, context0_id); +intel_bb_sync (ibb0); -scratch_buf_memset (src[0 ].bo, width, height,0xff0000ff ); -scratch_buf_memset (dst[0 ].bo, width, height,0x00ff00ff ); +scratch_buf_memset (&src[0 ], width, height,0xff0000ff ); +scratch_buf_memset (&dst[0 ], width, height,0x00ff00ff );igt_debug ("opening i915-perf stream\n" ); stream_fd =__perf_open (drm_fd, ¶m, false); - bo =drm_intel_bo_alloc (bufmgr,"mi_rpc dest bo" ,4096 ,64 ); - - ret =drm_intel_bo_map (bo, true/* write enable */ ); -igt_assert_eq (ret,0 ); + dst_buf =intel_buf_create (bops,4096 ,1 ,8 ,64 , +I915_TILING_NONE , +I915_COMPRESSION_NONE ); -memset (bo->virtual,0x80 ,4096 ); -drm_intel_bo_unmap (bo); +intel_buf_cpu_map (dst_buf, true/* write enable */ ); +memset (dst_buf->ptr,0x80 ,4096 ); +intel_buf_unmap (dst_buf); -emit_stall_timestamp_and_rpc (batch, - bo, +emit_stall_timestamp_and_rpc (ibb0, + dst_buf,512 /* timestamp offset */ ,0 ,/* report dst offset */ 0xdeadbeef );/* report id */
@@ -3249,45 +3167,45 @@ hsw_test_single_ctx_counters(void)* that the PIPE_CONTROL + MI_RPC commands will be in a * separate batch from the copy. */ -intel_batchbuffer_flush_with_context (batch, context0); +intel_bb_flush_render_with_context (ibb0, context0_id); -render_copy (batch, - context0, +render_copy (ibb0, + context0_id, &src[0 ],0 ,0 , width, height, &dst[0 ],0 ,0 );/* Another redundant flush to clarify batch bo is free to reuse */ -intel_batchbuffer_flush_with_context (batch, context0); +intel_bb_flush_render_with_context (ibb0, context0_id);/* submit two copies on the other context to avoid a false * positive in case the driver somehow ended up filtering for * context1 */ -render_copy (batch, - context1, +render_copy (ibb1, + context1_id, &src[1 ],0 ,0 , width, height, &dst[1 ],0 ,0 ); -render_copy (batch, - context1, +render_copy (ibb1, + context1_id, &src[2 ],0 ,0 , width, height, &dst[2 ],0 ,0 );/* And another */ -intel_batchbuffer_flush_with_context (batch, context1); +intel_bb_flush_render_with_context (ibb1, context1_id); -emit_stall_timestamp_and_rpc (batch, - bo, +emit_stall_timestamp_and_rpc (ibb0, + dst_buf,520 /* timestamp offset */ ,256 ,/* report dst offset */ 0xbeefbeef );/* report id */ -intel_batchbuffer_flush_with_context (batch, context0); +intel_bb_flush_render_with_context (ibb0, context0_id); +intel_bb_sync (ibb0); - ret =drm_intel_bo_map (bo, false/* write enable */ ); -igt_assert_eq (ret,0 ); +intel_buf_cpu_map (dst_buf, false/* write enable */ ); - report0_32 = bo->virtual; + report0_32 = dst_buf->ptr;igt_assert_eq (report0_32[0 ],0xdeadbeef );/* report ID */ igt_assert_neq (report0_32[1 ],0 );/* timestamp */
@@ -3307,8 +3225,8 @@ hsw_test_single_ctx_counters(void)igt_debug ("timestamp32 0 = %u\n" , report0_32[1 ]);igt_debug ("timestamp32 1 = %u\n" , report1_32[1 ]); - timestamp0_64 = *(uint64_t *)(((uint8_t *)bo->virtual) +512 ); - timestamp1_64 = *(uint64_t *)(((uint8_t *)bo->virtual) +520 ); + timestamp0_64 = *(uint64_t *)(((uint8_t *)dst_buf->ptr) +512 ); + timestamp1_64 = *(uint64_t *)(((uint8_t *)dst_buf->ptr) +520 );igt_debug ("timestamp64 0 = %" PRIu64"\n" , timestamp0_64);igt_debug ("timestamp64 1 = %" PRIu64"\n" , timestamp1_64);
@@ -3336,16 +3254,17 @@ hsw_test_single_ctx_counters(void)igt_assert (delta_delta <=320 );for (int i =0 ; i <ARRAY_SIZE (src); i++) { -drm_intel_bo_unreference (src[i].bo); -drm_intel_bo_unreference (dst[i].bo); +intel_buf_close (bops, &src[i]); +intel_buf_close (bops, &dst[i]); } -drm_intel_bo_unmap (bo); -drm_intel_bo_unreference (bo); -intel_batchbuffer_free (batch); -drm_intel_gem_context_destroy (context0); -drm_intel_gem_context_destroy (context1); -drm_intel_bufmgr_destroy (bufmgr); +intel_buf_unmap (dst_buf); +intel_buf_destroy (dst_buf); +intel_bb_destroy (ibb0); +intel_bb_destroy (ibb1); +gem_context_destroy (drm_fd, context0_id); +gem_context_destroy (drm_fd, context1_id); +buf_ops_destroy (bops);__perf_close (stream_fd); }
@@ -3406,11 +3325,10 @@ gen8_test_single_ctx_render_target_writes_a_counter(void) igt_fork_helper(&child) {struct drm_i915_perf_record_header *header; -drm_intel_bufmgr *bufmgr; -drm_intel_context *context0, *context1; -struct intel_batchbuffer *batch; -struct igt_buf src[3 ], dst[3 ]; -drm_intel_bo *bo; +struct buf_ops *bops; +struct intel_bb *ibb0, *ibb1; +struct intel_buf src[3 ], dst[3 ], *dst_buf; +uint32_t context0_id, context1_id;uint32_t *report0_32, *report1_32;uint32_t *prev, *lprev =NULL ;uint64_t timestamp0_64, timestamp1_64;
@@ -3428,21 +3346,17 @@ gen8_test_single_ctx_render_target_writes_a_counter(void) .format = test_set->perf_oa_format }; - bufmgr =drm_intel_bufmgr_gem_init (drm_fd,4096 ); -drm_intel_bufmgr_gem_enable_reuse (bufmgr); + bops =buf_ops_create (drm_fd);for (int i =0 ; i <ARRAY_SIZE (src); i++) { -scratch_buf_init (bufmgr, &src[i], width, height,0xff0000ff ); -scratch_buf_init (bufmgr, &dst[i], width, height,0x00ff00ff ); +scratch_buf_init (bops, &src[i], width, height,0xff0000ff ); +scratch_buf_init (bops, &dst[i], width, height,0x00ff00ff ); } - batch =intel_batchbuffer_alloc (bufmgr, devid); - - context0 =drm_intel_gem_context_create (bufmgr); -igt_assert (context0); - - context1 =drm_intel_gem_context_create (bufmgr); -igt_assert (context1); + ibb0 =intel_bb_create (drm_fd,BATCH_SZ ); + ibb1 =intel_bb_create (drm_fd,BATCH_SZ ); + context0_id =gem_context_create (drm_fd); + context1_id =gem_context_create (drm_fd);igt_debug ("submitting warm up render_copy\n" );
@@ -3466,32 +3380,30 @@ gen8_test_single_ctx_render_target_writes_a_counter(void)* up pinning the context since there won't ever be a pinning * hook callback. */ -render_copy (batch, - context0, +render_copy (ibb0, + context0_id, &src[0 ],0 ,0 , width, height, &dst[0 ],0 ,0 ); +intel_bb_sync (ibb0); - ret =drm_intel_gem_context_get_id (context0, &ctx_id); -igt_assert_eq (ret,0 ); -igt_assert_neq (ctx_id,0xffffffff ); - properties[1 ] = ctx_id; + properties[1 ] = context0_id; -scratch_buf_memset (src[0 ].bo, width, height,0xff0000ff ); -scratch_buf_memset (dst[0 ].bo, width, height,0x00ff00ff ); +scratch_buf_memset (&src[0 ], width, height,0xff0000ff ); +scratch_buf_memset (&dst[0 ], width, height,0x00ff00ff );igt_debug ("opening i915-perf stream\n" ); stream_fd =__perf_open (drm_fd, ¶m, false); - bo =drm_intel_bo_alloc (bufmgr,"mi_rpc dest bo" ,4096 ,64 ); - - ret =drm_intel_bo_map (bo, true/* write enable */ ); -igt_assert_eq (ret,0 ); + dst_buf =intel_buf_create (bops,4096 ,1 ,8 ,64 , +I915_TILING_NONE , +I915_COMPRESSION_NONE ); -memset (bo->virtual,0x80 ,4096 ); -drm_intel_bo_unmap (bo); +intel_buf_cpu_map (dst_buf, true/* write enable */ ); +memset (dst_buf->ptr,0x80 ,4096 ); +intel_buf_unmap (dst_buf); -emit_stall_timestamp_and_rpc (batch, - bo, +emit_stall_timestamp_and_rpc (ibb0, + dst_buf,512 /* timestamp offset */ ,0 ,/* report dst offset */ 0xdeadbeef );/* report id */
@@ -3501,49 +3413,46 @@ gen8_test_single_ctx_render_target_writes_a_counter(void)* that the PIPE_CONTROL + MI_RPC commands will be in a * separate batch from the copy. */ -intel_batchbuffer_flush_with_context (batch, context0); +intel_bb_flush_render_with_context (ibb0, context0_id); -render_copy (batch, - context0, +render_copy (ibb0, + context0_id, &src[0 ],0 ,0 , width, height, &dst[0 ],0 ,0 );/* Another redundant flush to clarify batch bo is free to reuse */ -intel_batchbuffer_flush_with_context (batch, context0); +intel_bb_flush_render_with_context (ibb0, context0_id);/* submit two copies on the other context to avoid a false * positive in case the driver somehow ended up filtering for * context1 */ -render_copy (batch, - context1, +render_copy (ibb1, + context1_id, &src[1 ],0 ,0 , width, height, &dst[1 ],0 ,0 ); - ret =drm_intel_gem_context_get_id (context1, &ctx1_id); -igt_assert_eq (ret,0 ); -igt_assert_neq (ctx1_id,0xffffffff ); - -render_copy (batch, - context1, +render_copy (ibb1, + context1_id, &src[2 ],0 ,0 , width, height, &dst[2 ],0 ,0 );/* And another */ -intel_batchbuffer_flush_with_context (batch, context1); +intel_bb_flush_render_with_context (ibb1, context1_id); -emit_stall_timestamp_and_rpc (batch, - bo, +emit_stall_timestamp_and_rpc (ibb1, + dst_buf,520 /* timestamp offset */ ,256 ,/* report dst offset */ 0xbeefbeef );/* report id */ -intel_batchbuffer_flush_with_context (batch, context1); +intel_bb_flush_render_with_context (ibb1, context1_id); +intel_bb_sync (ibb1); +intel_bb_sync (ibb0); - ret =drm_intel_bo_map (bo, false/* write enable */ ); -igt_assert_eq (ret,0 ); +intel_buf_cpu_map (dst_buf, false/* write enable */ ); - report0_32 = bo->virtual; + report0_32 = dst_buf->ptr;igt_assert_eq (report0_32[0 ],0xdeadbeef );/* report ID */ igt_assert_neq (report0_32[1 ],0 );/* timestamp */ prev = report0_32;
@@ -3555,6 +3464,7 @@ gen8_test_single_ctx_render_target_writes_a_counter(void)igt_assert_eq (report1_32[0 ],0xbeefbeef );/* report ID */ igt_assert_neq (report1_32[1 ],0 );/* timestamp */ ctx1_id = report1_32[2 ]; +igt_debug ("CTX1 ID: %u\n" , ctx1_id);dump_report (report1_32,64 ,"report1_32" );memset (accumulator.deltas,0 ,sizeof (accumulator.deltas));
@@ -3569,8 +3479,8 @@ gen8_test_single_ctx_render_target_writes_a_counter(void)igt_debug ("ctx_id 0 = %u\n" , report0_32[2 ]);igt_debug ("ctx_id 1 = %u\n" , report1_32[2 ]); - timestamp0_64 = *(uint64_t *)(((uint8_t *)bo->virtual) +512 ); - timestamp1_64 = *(uint64_t *)(((uint8_t *)bo->virtual) +520 ); + timestamp0_64 = *(uint64_t *)(((uint8_t *)dst_buf->ptr) +512 ); + timestamp1_64 = *(uint64_t *)(((uint8_t *)dst_buf->ptr) +520 );igt_debug ("ts_timestamp64 0 = %" PRIu64"\n" , timestamp0_64);igt_debug ("ts_timestamp64 1 = %" PRIu64"\n" , timestamp1_64);
@@ -3758,27 +3668,26 @@ gen8_test_single_ctx_render_target_writes_a_counter(void) width, height);accumulator_print (&accumulator,"filtered" ); - ret =drm_intel_bo_map (src[0 ].bo, false/* write enable */ ); -igt_assert_eq (ret,0 ); - ret =drm_intel_bo_map (dst[0 ].bo, false/* write enable */ ); -igt_assert_eq (ret,0 ); +intel_buf_cpu_map (&src[0 ], false/* write enable */ ); +intel_buf_cpu_map (&dst[0 ], false/* write enable */ ); - ret =memcmp (src[0 ].bo->virtual, dst[0 ].bo->virtual,4 * width * height); -drm_intel_bo_unmap (src[0 ].bo); -drm_intel_bo_unmap (dst[0 ].bo); + ret =memcmp (src[0 ].ptr, dst[0 ].ptr,4 * width * height); +intel_buf_unmap (&src[0 ]); +intel_buf_unmap (&dst[0 ]); again:for (int i =0 ; i <ARRAY_SIZE (src); i++) { -drm_intel_bo_unreference (src[i].bo); -drm_intel_bo_unreference (dst[i].bo); +intel_buf_close (bops, &src[i]); +intel_buf_close (bops, &dst[i]); } -drm_intel_bo_unmap (bo); -drm_intel_bo_unreference (bo); -intel_batchbuffer_free (batch); -drm_intel_gem_context_destroy (context0); -drm_intel_gem_context_destroy (context1); -drm_intel_bufmgr_destroy (bufmgr); +intel_buf_unmap (dst_buf); +intel_buf_destroy (dst_buf); +intel_bb_destroy (ibb0); +intel_bb_destroy (ibb1); +gem_context_destroy (drm_fd, context0_id); +gem_context_destroy (drm_fd, context1_id); +buf_ops_destroy (bops);__perf_close (stream_fd);gem_quiescent_gpu (drm_fd);
@@ -3825,11 +3734,10 @@ static void gen12_single_ctx_helper(void) .num_properties = ARRAY_SIZE(properties) / 2, .properties_ptr = to_user_pointer(properties), }; -drm_intel_bufmgr *bufmgr; -drm_intel_context *context0, *context1; -struct intel_batchbuffer *batch; -struct igt_buf src[3 ], dst[3 ]; -drm_intel_bo *bo; +struct buf_ops *bops; +struct intel_bb *ibb0, *ibb1; +struct intel_buf src[3 ], dst[3 ], *dst_buf; +uint32_t context0_id, context1_id;uint32_t *report0_32, *report1_32, *report2_32, *report3_32;uint64_t timestamp0_64, timestamp1_64;uint32_t delta_ts64, delta_oa32;
@@ -3845,21 +3753,17 @@ static void gen12_single_ctx_helper(void) .format = test_set->perf_oa_format }; - bufmgr =drm_intel_bufmgr_gem_init (drm_fd,4096 ); -drm_intel_bufmgr_gem_enable_reuse (bufmgr); + bops =buf_ops_create (drm_fd);for (int i =0 ; i <ARRAY_SIZE (src); i++) { -scratch_buf_init (bufmgr, &src[i], width, height,0xff0000ff ); -scratch_buf_init (bufmgr, &dst[i], width, height,0x00ff00ff ); +scratch_buf_init (bops, &src[i], width, height,0xff0000ff ); +scratch_buf_init (bops, &dst[i], width, height,0x00ff00ff ); } - batch =intel_batchbuffer_alloc (bufmgr, devid); - - context0 =drm_intel_gem_context_create (bufmgr); -igt_assert (context0); - - context1 =drm_intel_gem_context_create (bufmgr); -igt_assert (context1); + ibb0 =intel_bb_create (drm_fd,BATCH_SZ ); + ibb1 =intel_bb_create (drm_fd,BATCH_SZ ); + context0_id =gem_context_create (drm_fd); + context1_id =gem_context_create (drm_fd);igt_debug ("submitting warm up render_copy\n" );
@@ -3883,44 +3787,42 @@ static void gen12_single_ctx_helper(void)* up pinning the context since there won't ever be a pinning * hook callback. */ -render_copy (batch, context0, +render_copy (ibb0, context0_id, &src[0 ],0 ,0 , width, height, &dst[0 ],0 ,0 );/* Initialize the context parameter to the perf open ioctl here */ - ret =drm_intel_gem_context_get_id (context0, &ctx0_id); -igt_assert_eq (ret,0 ); -igt_assert_neq (ctx0_id,0xffffffff ); - properties[1 ] = ctx0_id; + properties[1 ] = context0_id;igt_debug ("opening i915-perf stream\n" ); stream_fd =__perf_open (drm_fd, ¶m, false); - bo =drm_intel_bo_alloc (bufmgr,"mi_rpc dest bo" ,4096 ,64 ); + dst_buf =intel_buf_create (bops,4096 ,1 ,8 ,64 , +I915_TILING_NONE , +I915_COMPRESSION_NONE );/* Set write domain to cpu briefly to fill the buffer with 80s */ - ret =drm_intel_bo_map (bo, true); -igt_assert_eq (ret,0 ); -memset (bo->virtual,0x80 ,2048 ); -memset (bo->virtual +2048 ,0 ,2048 ); -drm_intel_bo_unmap (bo); +intel_buf_cpu_map (dst_buf, true/* write enable */ ); +memset (dst_buf->ptr,0x80 ,2048 ); +memset ((uint8_t *) dst_buf->ptr +2048 ,0 ,2048 ); +intel_buf_unmap (dst_buf);/* Submit an mi-rpc to context0 before measurable work */ #define BO_TIMESTAMP_OFFSET0 1024#define BO_REPORT_OFFSET0 0#define BO_REPORT_ID0 0xdeadbeef -emit_stall_timestamp_and_rpc (batch, - bo, +emit_stall_timestamp_and_rpc (ibb0, + dst_buf,BO_TIMESTAMP_OFFSET0 ,BO_REPORT_OFFSET0 ,BO_REPORT_ID0 ); -intel_batchbuffer_flush_with_context (batch, context0); +intel_bb_flush_render_with_context (ibb0, context0_id);/* This is the work/context that is measured for counter increments */ -render_copy (batch, context0, +render_copy (ibb0, context0_id, &src[0 ],0 ,0 , width, height, &dst[0 ],0 ,0 ); -intel_batchbuffer_flush_with_context (batch, context0); +intel_bb_flush_render_with_context (ibb0, context0_id);/* Submit an mi-rpc to context1 before work *
@@ -3931,54 +3833,51 @@ static void gen12_single_ctx_helper(void)#define BO_TIMESTAMP_OFFSET2 1040#define BO_REPORT_OFFSET2 512#define BO_REPORT_ID2 0x00c0ffee -emit_stall_timestamp_and_rpc (batch, - bo, +emit_stall_timestamp_and_rpc (ibb1, + dst_buf,BO_TIMESTAMP_OFFSET2 ,BO_REPORT_OFFSET2 ,BO_REPORT_ID2 ); -intel_batchbuffer_flush_with_context (batch, context1); +intel_bb_flush_render_with_context (ibb1, context1_id);/* Submit two copies on the other context to avoid a false * positive in case the driver somehow ended up filtering for * context1 */ -render_copy (batch, context1, +render_copy (ibb1, context1_id, &src[1 ],0 ,0 , width, height, &dst[1 ],0 ,0 ); - ret =drm_intel_gem_context_get_id (context1, &ctx1_id); -igt_assert_eq (ret,0 ); -igt_assert_neq (ctx1_id,0xffffffff ); -render_copy (batch, context1, +render_copy (ibb1, context1_id, &src[2 ],0 ,0 , width, height, &dst[2 ],0 ,0 ); -intel_batchbuffer_flush_with_context (batch, context1); +intel_bb_flush_render_with_context (ibb1, context1_id);/* Submit an mi-rpc to context1 after all work */ #define BO_TIMESTAMP_OFFSET3 1048#define BO_REPORT_OFFSET3 768#define BO_REPORT_ID3 0x01c0ffee -emit_stall_timestamp_and_rpc (batch, - bo, +emit_stall_timestamp_and_rpc (ibb1, + dst_buf,BO_TIMESTAMP_OFFSET3 ,BO_REPORT_OFFSET3 ,BO_REPORT_ID3 ); -intel_batchbuffer_flush_with_context (batch, context1); +intel_bb_flush_render_with_context (ibb1, context1_id);/* Submit an mi-rpc to context0 after all measurable work */ #define BO_TIMESTAMP_OFFSET1 1032#define BO_REPORT_OFFSET1 256#define BO_REPORT_ID1 0xbeefbeef -emit_stall_timestamp_and_rpc (batch, - bo, +emit_stall_timestamp_and_rpc (ibb0, + dst_buf,BO_TIMESTAMP_OFFSET1 ,BO_REPORT_OFFSET1 ,BO_REPORT_ID1 ); -intel_batchbuffer_flush_with_context (batch, context0); +intel_bb_flush_render_with_context (ibb0, context0_id); +intel_bb_sync (ibb0); +intel_bb_sync (ibb1); -/* Set write domain to none */ - ret =drm_intel_bo_map (bo, false); -igt_assert_eq (ret,0 ); +intel_buf_cpu_map (dst_buf, false);/* Sanity check reports * reportX_32[0]: report id passed with mi-rpc
@@ -3990,7 +3889,7 @@ static void gen12_single_ctx_helper(void)* report2_32: start of other work * report3_32: end of other work */ - report0_32 = bo->virtual; + report0_32 = dst_buf->ptr;igt_assert_eq (report0_32[0 ],0xdeadbeef );igt_assert_neq (report0_32[1 ],0 ); ctx0_id = report0_32[2 ];
@@ -4001,6 +3900,7 @@ static void gen12_single_ctx_helper(void)igt_assert_eq (report1_32[0 ],0xbeefbeef );igt_assert_neq (report1_32[1 ],0 ); ctx1_id = report1_32[2 ]; +igt_debug ("CTX ID1: %u\n" , ctx1_id);dump_report (report1_32,64 ,"report1_32" );/* Verify that counters in context1 are all zeroes */
@@ -4009,7 +3909,7 @@ static void gen12_single_ctx_helper(void)igt_assert_neq (report2_32[1 ],0 );dump_report (report2_32,64 ,"report2_32" );igt_assert_eq (0 ,memcmp (&report2_32[4 ], - bo->virtual +2048 , + (uint8_t *) dst_buf->ptr +2048 ,240 )); report3_32 = report0_32 +192 ;
@@ -4017,7 +3917,7 @@ static void gen12_single_ctx_helper(void)igt_assert_neq (report3_32[1 ],0 );dump_report (report3_32,64 ,"report3_32" );igt_assert_eq (0 ,memcmp (&report3_32[4 ], - bo->virtual +2048 , + (uint8_t *) dst_buf->ptr +2048 ,240 ));/* Accumulate deltas for counters - A0, A21 and A26 */
@@ -4037,8 +3937,8 @@ static void gen12_single_ctx_helper(void)* the OA report timestamps should be almost identical but * allow a 500 nanoseconds margin. */ - timestamp0_64 = *(uint64_t *)(((uint8_t *)bo->virtual) +BO_TIMESTAMP_OFFSET0 ); - timestamp1_64 = *(uint64_t *)(((uint8_t *)bo->virtual) +BO_TIMESTAMP_OFFSET1 ); + timestamp0_64 = *(uint64_t *)(((uint8_t *)dst_buf->ptr) +BO_TIMESTAMP_OFFSET0 ); + timestamp1_64 = *(uint64_t *)(((uint8_t *)dst_buf->ptr) +BO_TIMESTAMP_OFFSET1 );igt_debug ("ts_timestamp64 0 = %" PRIu64"\n" , timestamp0_64);igt_debug ("ts_timestamp64 1 = %" PRIu64"\n" , timestamp1_64);
@@ -4073,20 +3973,18 @@ static void gen12_single_ctx_helper(void)/* Verify that the work actually happened by comparing the src * and dst buffers */ - ret =drm_intel_bo_map (src[0 ].bo, false); -igt_assert_eq (ret,0 ); - ret =drm_intel_bo_map (dst[0 ].bo, false); -igt_assert_eq (ret,0 ); +intel_buf_cpu_map (&src[0 ], false); +intel_buf_cpu_map (&dst[0 ], false); + + ret =memcmp (src[0 ].ptr, dst[0 ].ptr,4 * width * height); +intel_buf_unmap (&src[0 ]); +intel_buf_unmap (&dst[0 ]); - ret =memcmp (src[0 ].bo->virtual, dst[0 ].bo->virtual,4 * width * height);if (ret !=0 ) {accumulator_print (&accumulator,"total" );exit (EAGAIN ); } -drm_intel_bo_unmap (src[0 ].bo); -drm_intel_bo_unmap (dst[0 ].bo); -/* Check that this test passed. The test measures the number of 2x2 * samples written to the render target using the counter A26. For * OAR, this counter will only have increments relevant to this specific
@@ -4096,16 +3994,17 @@ static void gen12_single_ctx_helper(void)/* Clean up */ for (int i =0 ; i <ARRAY_SIZE (src); i++) { -drm_intel_bo_unreference (src[i].bo); -drm_intel_bo_unreference (dst[i].bo); +intel_buf_close (bops, &src[i]); +intel_buf_close (bops, &dst[i]); } -drm_intel_bo_unmap (bo); -drm_intel_bo_unreference (bo); -intel_batchbuffer_free (batch); -drm_intel_gem_context_destroy (context0); -drm_intel_gem_context_destroy (context1); -drm_intel_bufmgr_destroy (bufmgr); +intel_buf_unmap (dst_buf); +intel_buf_destroy (dst_buf); +intel_bb_destroy (ibb0); +intel_bb_destroy (ibb1); +gem_context_destroy (drm_fd, context0_id); +gem_context_destroy (drm_fd, context1_id); +buf_ops_destroy (bops);__perf_close (stream_fd); }
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v2 12/12 HAX: run rendercopy tests
In reply to Zbigniew Kempczyński--- tests/intel-ci/fast-feedback.testlist | 42 +++++++++++++++++---------- 1 file changed, 26 insertions(+), 16 deletions(-)
tests/intel-ci/fast-feedback.testlist +26 -16
@@ -1,5 +1,6 @@ # Keep alphabetically sorted by default +igt@api_intel_bb igt@core_auth@basic-auth igt@debugfs_test@read_all_entries igt@fbdev@mmap
@@ -7,6 +8,7 @@ igt@gem_basic@bad-close igt@gem_basic@create-close igt@gem_basic@create-fd-close igt@gem_busy@busy@all +igt@gem_caching igt@gem_close_race@basic-process igt@gem_close_race@basic-threads igt@gem_ctx_create@basic
@@ -14,9 +16,9 @@ igt@gem_ctx_create@basic-files igt@gem_ctx_exec@basic igt@gem_exec_basic@basic igt@gem_exec_create@basic +igt@gem_exec_fence@basic-await igt@gem_exec_fence@basic-busy igt@gem_exec_fence@basic-wait -igt@gem_exec_fence@basic-await igt@gem_exec_fence@nb-await igt@gem_exec_gttfill@basic igt@gem_exec_parallel@engines
@@ -32,6 +34,9 @@ igt@gem_huc_copy@huc-copy igt@gem_linear_blits@basic igt@gem_mmap@basic igt@gem_mmap_gtt@basic +igt@gem_ppgtt +igt@gem_read_read_speed +igt@gem_render_copy igt@gem_render_linear_blits@basic igt@gem_render_tiled_blits@basic igt@gem_ringfill@basic-all
@@ -45,6 +50,10 @@ igt@gem_wait@wait@all igt@i915_getparams_basic@basic-eu-total igt@i915_getparams_basic@basic-subslice-total igt@i915_hangman@error-state-basic +igt@i915_pm_backlight@basic-brightness +igt@i915_pm_rpm@basic-pci-d3-state +igt@i915_pm_rpm@basic-rte +igt@i915_pm_rps@basic-api igt@kms_addfb_basic@addfb25-bad-modifier igt@kms_addfb_basic@addfb25-framebuffer-vs-set-tiling igt@kms_addfb_basic@addfb25-modifier-no-flag
@@ -82,17 +91,18 @@ igt@kms_addfb_basic@unused-handle igt@kms_addfb_basic@unused-modifier igt@kms_addfb_basic@unused-offsets igt@kms_addfb_basic@unused-pitches +igt@kms_big_fb igt@kms_busy@basic -igt@kms_chamelium@dp-hpd-fast -igt@kms_chamelium@dp-edid-read +igt@kms_chamelium@common-hpd-after-suspend igt@kms_chamelium@dp-crc-fast -igt@kms_chamelium@hdmi-hpd-fast -igt@kms_chamelium@hdmi-edid-read +igt@kms_chamelium@dp-edid-read +igt@kms_chamelium@dp-hpd-fast igt@kms_chamelium@hdmi-crc-fast -igt@kms_chamelium@vga-hpd-fast +igt@kms_chamelium@hdmi-edid-read +igt@kms_chamelium@hdmi-hpd-fast igt@kms_chamelium@vga-edid-read -igt@kms_chamelium@common-hpd-after-suspend -igt@kms_prop_blob@basic +igt@kms_chamelium@vga-hpd-fast +igt@kms_cursor_crc igt@kms_cursor_legacy@basic-busy-flip-before-cursor-atomic igt@kms_cursor_legacy@basic-busy-flip-before-cursor-legacy igt@kms_cursor_legacy@basic-flip-after-cursor-atomic
@@ -101,6 +111,7 @@ igt@kms_cursor_legacy@basic-flip-after-cursor-varying-size igt@kms_cursor_legacy@basic-flip-before-cursor-atomic igt@kms_cursor_legacy@basic-flip-before-cursor-legacy igt@kms_cursor_legacy@basic-flip-before-cursor-varying-size +igt@kms_draw_crc igt@kms_flip@basic-flip-vs-dpms igt@kms_flip@basic-flip-vs-modeset igt@kms_flip@basic-flip-vs-wf_vblank
@@ -109,24 +120,23 @@ igt@kms_force_connector_basic@force-connector-state igt@kms_force_connector_basic@force-edid igt@kms_force_connector_basic@force-load-detect igt@kms_force_connector_basic@prune-stale-modes +igt@kms_frontbuffer_tracking igt@kms_frontbuffer_tracking@basic igt@kms_pipe_crc_basic@hang-read-crc-pipe-a igt@kms_pipe_crc_basic@nonblocking-crc-pipe-a igt@kms_pipe_crc_basic@nonblocking-crc-pipe-a-frame-sequence igt@kms_pipe_crc_basic@read-crc-pipe-a +igt@kms_pipe_crc_basic@read-crc-pipe-a-frame-sequence igt@kms_pipe_crc_basic@read-crc-pipe-b igt@kms_pipe_crc_basic@read-crc-pipe-c -igt@kms_pipe_crc_basic@read-crc-pipe-a-frame-sequence igt@kms_pipe_crc_basic@suspend-read-crc-pipe-a -igt@kms_psr@primary_page_flip +igt@kms_prop_blob@basic +igt@kms_psr igt@kms_psr@cursor_plane_move -igt@kms_psr@sprite_plane_onoff igt@kms_psr@primary_mmap_gtt +igt@kms_psr@primary_page_flip +igt@kms_psr@sprite_plane_onoff igt@kms_setmode@basic-clone-single-crtc -igt@i915_pm_backlight@basic-brightness -igt@i915_pm_rpm@basic-pci-d3-state -igt@i915_pm_rpm@basic-rte -igt@i915_pm_rps@basic-api igt@prime_self_import@basic-llseek-bad igt@prime_self_import@basic-llseek-size igt@prime_self_import@basic-with_fd_dup
@@ -139,7 +149,6 @@ igt@prime_vgem@basic-fence-read igt@prime_vgem@basic-gtt igt@prime_vgem@basic-read igt@prime_vgem@basic-write -igt@vgem_basic@setversion igt@vgem_basic@create igt@vgem_basic@debugfs igt@vgem_basic@dmabuf-export
@@ -148,6 +157,7 @@ igt@vgem_basic@dmabuf-fence-before igt@vgem_basic@dmabuf-mmap igt@vgem_basic@mmap igt@vgem_basic@second-client +igt@vgem_basic@setversion igt@vgem_basic@sysfs # All tests that do module unloading and reloading are executed last.
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
Patchwork
CI[igt-dev] ✗ GitLab.Pipeline: warning for Remove libdrm in rendercopy (rev2)
In reply to Zbigniew Kempczyński== Series Details ==
== Series Details ==
Series: Remove libdrm in rendercopy (rev2)
URL : https://patchwork.freedesktop.org/series/79823/
State : warning
== Summary ==
Did not get list of undocumented tests for this run, something is wrong!
Other than that, pipeline status: FAILED.
see https://gitlab.freedesktop.org/gfx-ci/igt-ci-tags/-/pipelines/181568 for the overview.
build-containers:build-debian-armhf has failed (https://gitlab.freedesktop.org/gfx-ci/igt-ci-tags/-/jobs/3782654):
Using Docker executor with image registry.freedesktop.org/wayland/ci-templates/buildah:2019-08-13.0 ...
Authenticating with credentials from job payload (GitLab Registry)
Pulling docker image registry.freedesktop.org/wayland/ci-templates/buildah:2019-08-13.0 ...
Using docker image sha256:594aa868d31ee3304dee8cae8a3433c89a6fcfcf6c7d420c04cce22f60147176 for registry.freedesktop.org/wayland/ci-templates/buildah:2019-08-13.0 ... section_end:1595573041:prepare_executor
section_start:1595573041:prepare_script
Preparing environment
Running on runner-j4lrg1of-project-3185-concurrent-1 via gst-htz-1...
section_end:1595573042:prepare_script
section_start:1595573042:get_sources
Getting source from Git repository
$ eval "$CI_PRE_CLONE_SCRIPT" Fetching changes... Initialized empty Git repository in /builds/gfx-ci/igt-ci-tags/.git/ Created fresh repository. error: RPC failed; curl 92 HTTP/2 stream 0 was not closed cleanly: Unknown error code (err 1) fatal: the remote end hung up unexpectedly section_end:1595573104:get_sources ERROR: Job failed: exit code 1
== Logs ==
For more details see: https://gitlab.freedesktop.org/gfx-ci/igt-ci-tags/-/pipelines/181568
_______________________________________________
igt-dev mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/igt-dev
Patchwork
CI[igt-dev] ✗ Fi.CI.BAT: failure for Remove libdrm in rendercopy (rev2)
In reply to Zbigniew Kempczyński== Series Details ==
== Series Details ==
Series: Remove libdrm in rendercopy (rev2)
URL : https://patchwork.freedesktop.org/series/79823/
State : failure
== Summary ==
CI Bug Log - changes from CI_DRM_8783 -> IGTPW_4797
====================================================
Summary
-------
**FAILURE**
Serious unknown changes coming with IGTPW_4797 absolutely need to be verified manually.
If you think the reported changes have nothing to do with the changes introduced in IGTPW_4797, please notify your bug team to allow them to document this new failure mode, which will reduce false positives in CI.
External URL: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/index.html
Possible new issues
-------------------
Here are the unknown changes that may have been introduced in IGTPW_4797:
### IGT changes ###
#### Possible regressions ####
* igt@gem_ppgtt@blt-vs-render-ctx0:
- fi-ilk-650: NOTRUN -> [FAIL][1] +5 similar issues
[1]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-ilk-650/igt@[email protected]
- fi-pnv-d510: NOTRUN -> [FAIL][2] +7 similar issues
[2]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-pnv-d510/igt@[email protected]
- fi-bsw-nick: NOTRUN -> [FAIL][3] +1 similar issue
[3]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-bsw-nick/igt@[email protected]
* igt@gem_ppgtt@blt-vs-render-ctxn:
- fi-cfl-8700k: NOTRUN -> [DMESG-FAIL][4]
[4]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-cfl-8700k/igt@[email protected]
* {igt@gem_read_read_speed@read-write-1024x1024} (NEW):
- fi-snb-2520m: NOTRUN -> [FAIL][5] +34 similar issues
[5]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-snb-2520m/igt@[email protected]
* igt@gem_render_tiled_blits@basic:
- fi-gdg-551: [PASS][6] -> [FAIL][7]
[6]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8783/fi-gdg-551/igt@[email protected]
[7]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-gdg-551/igt@[email protected]
* igt@kms_big_fb@linear-64bpp-rotate-0:
- fi-hsw-4770: NOTRUN -> [FAIL][8] +3 similar issues
[8]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-hsw-4770/igt@[email protected]
- fi-cml-s: NOTRUN -> [FAIL][9] +5 similar issues
[9]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-cml-s/igt@[email protected]
- fi-icl-y: NOTRUN -> [FAIL][10] +5 similar issues
[10]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-icl-y/igt@[email protected]
- fi-bdw-5557u: NOTRUN -> [FAIL][11] +4 similar issues
[11]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-bdw-5557u/igt@[email protected]
* igt@kms_big_fb@linear-64bpp-rotate-180:
- fi-cfl-8700k: NOTRUN -> [FAIL][12] +5 similar issues
[12]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-cfl-8700k/igt@[email protected]
- fi-icl-u2: NOTRUN -> [FAIL][13] +5 similar issues
[13]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-icl-u2/igt@[email protected]
* igt@kms_big_fb@linear-64bpp-rotate-270:
- fi-elk-e7500: NOTRUN -> [FAIL][14] +24 similar issues
[14]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-elk-e7500/igt@[email protected]
* igt@kms_big_fb@linear-8bpp-rotate-270:
- fi-blb-e6850: NOTRUN -> [FAIL][15] +7 similar issues
[15]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-blb-e6850/igt@[email protected]
- fi-gdg-551: NOTRUN -> [FAIL][16] +7 similar issues
[16]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-gdg-551/igt@[email protected]
* igt@kms_big_fb@x-tiled-16bpp-rotate-270:
- fi-bwr-2160: NOTRUN -> [FAIL][17] +24 similar issues
[17]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-bwr-2160/igt@[email protected]
* igt@kms_big_fb@x-tiled-64bpp-rotate-0:
- fi-skl-6700k2: NOTRUN -> [FAIL][18] +5 similar issues
[18]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-skl-6700k2/igt@[email protected]
- fi-ivb-3770: NOTRUN -> [FAIL][19] +3 similar issues
[19]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-ivb-3770/igt@[email protected]
* igt@kms_big_fb@x-tiled-64bpp-rotate-180:
- fi-byt-j1900: NOTRUN -> [FAIL][20] +5 similar issues
[20]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-byt-j1900/igt@[email protected]
- fi-bsw-n3050: NOTRUN -> [FAIL][21] +5 similar issues
[21]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-bsw-n3050/igt@[email protected]
- fi-cml-u2: NOTRUN -> [FAIL][22] +5 similar issues
[22]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-cml-u2/igt@[email protected]
- fi-bsw-kefka: NOTRUN -> [FAIL][23] +5 similar issues
[23]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-bsw-kefka/igt@[email protected]
- fi-kbl-7500u: NOTRUN -> [FAIL][24] +5 similar issues
[24]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-kbl-7500u/igt@[email protected]
* igt@kms_big_fb@y-tiled-64bpp-rotate-0:
- fi-kbl-x1275: NOTRUN -> [FAIL][25] +5 similar issues
[25]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-kbl-x1275/igt@[email protected]
* igt@kms_big_fb@y-tiled-64bpp-rotate-180:
- fi-tgl-u2: NOTRUN -> [FAIL][26] +38 similar issues
[26]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-tgl-u2/igt@[email protected]
- fi-skl-guc: NOTRUN -> [FAIL][27] +5 similar issues
[27]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-skl-guc/igt@[email protected]
- fi-cfl-guc: NOTRUN -> [FAIL][28] +5 similar issues
[28]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-cfl-guc/igt@[email protected]
- fi-skl-lmem: NOTRUN -> [FAIL][29] +5 similar issues
[29]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-skl-lmem/igt@[email protected]
- fi-cfl-8109u: NOTRUN -> [FAIL][30] +5 similar issues
[30]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-cfl-8109u/igt@[email protected]
* igt@kms_cursor_crc@pipe-a-cursor-512x512-random:
- fi-icl-y: NOTRUN -> [SKIP][31] +22 similar issues
[31]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-icl-y/igt@[email protected]
* igt@kms_cursor_crc@pipe-b-cursor-512x170-sliding:
- fi-cml-s: NOTRUN -> [SKIP][32] +30 similar issues
[32]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-cml-s/igt@[email protected]
* igt@kms_cursor_crc@pipe-c-cursor-512x170-onscreen:
- fi-cml-u2: NOTRUN -> [SKIP][33] +30 similar issues
[33]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-cml-u2/igt@[email protected]
* igt@kms_cursor_crc@pipe-c-cursor-512x512-rapid-movement:
- fi-icl-u2: NOTRUN -> [SKIP][34] +30 similar issues
[34]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-icl-u2/igt@[email protected]
* {igt@kms_cursor_crc@pipe-e-cursor-64x64-rapid-movement} (NEW):
- fi-tgl-u2: NOTRUN -> [SKIP][35] +261 similar issues
[35]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-tgl-u2/igt@[email protected]
* igt@kms_draw_crc@draw-method-rgb565-render-untiled:
- fi-kbl-x1275: NOTRUN -> [INCOMPLETE][36]
[36]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-kbl-x1275/igt@[email protected]
- fi-ivb-3770: NOTRUN -> [INCOMPLETE][37]
[37]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-ivb-3770/igt@[email protected]
- fi-blb-e6850: NOTRUN -> [INCOMPLETE][38]
[38]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-blb-e6850/igt@[email protected]
- fi-ilk-650: NOTRUN -> [INCOMPLETE][39]
[39]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-ilk-650/igt@[email protected]
* igt@kms_draw_crc@draw-method-xrgb8888-render-untiled:
- fi-snb-2520m: NOTRUN -> [CRASH][40] +1 similar issue
[40]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-snb-2520m/igt@[email protected]
- fi-skl-6600u: NOTRUN -> [CRASH][41]
[41]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-skl-6600u/igt@[email protected]
* igt@kms_frontbuffer_tracking@basic:
- fi-snb-2520m: [PASS][42] -> [FAIL][43]
[42]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8783/fi-snb-2520m/igt@[email protected]
[43]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-snb-2520m/igt@[email protected]
* igt@kms_frontbuffer_tracking@drrs-1p-primscrn-pri-indfb-draw-render (NEW):
- fi-bsw-kefka: NOTRUN -> [CRASH][44] +1 similar issue
[44]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-bsw-kefka/igt@kms_frontbuffer_tracking@drrs-1p-primscrn-pri-indfb-draw-render.html
* igt@kms_frontbuffer_tracking@drrs-rgb565-draw-render (NEW):
- fi-bsw-kefka: NOTRUN -> [INCOMPLETE][45] +1 similar issue
[45]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-bsw-kefka/igt@[email protected]
* igt@kms_frontbuffer_tracking@fbc-1p-offscren-pri-indfb-draw-render:
- fi-cfl-8109u: NOTRUN -> [CRASH][46]
[46]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-cfl-8109u/igt@kms_frontbuffer_tracking@fbc-1p-offscren-pri-indfb-draw-render.html
- fi-skl-lmem: NOTRUN -> [CRASH][47]
[47]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-skl-lmem/igt@kms_frontbuffer_tracking@fbc-1p-offscren-pri-indfb-draw-render.html
- fi-cfl-8700k: NOTRUN -> [CRASH][48]
[48]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-cfl-8700k/igt@kms_frontbuffer_tracking@fbc-1p-offscren-pri-indfb-draw-render.html
- fi-icl-y: NOTRUN -> [CRASH][49]
[49]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-icl-y/igt@kms_frontbuffer_tracking@fbc-1p-offscren-pri-indfb-draw-render.html
- fi-kbl-x1275: NOTRUN -> [CRASH][50]
[50]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-kbl-x1275/igt@kms_frontbuffer_tracking@fbc-1p-offscren-pri-indfb-draw-render.html
- fi-hsw-4770: NOTRUN -> [CRASH][51]
[51]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-hsw-4770/igt@kms_frontbuffer_tracking@fbc-1p-offscren-pri-indfb-draw-render.html
- fi-cfl-guc: NOTRUN -> [CRASH][52]
[52]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-cfl-guc/igt@kms_frontbuffer_tracking@fbc-1p-offscren-pri-indfb-draw-render.html
- fi-tgl-u2: NOTRUN -> [CRASH][53]
[53]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-tgl-u2/igt@kms_frontbuffer_tracking@fbc-1p-offscren-pri-indfb-draw-render.html
- fi-bdw-5557u: NOTRUN -> [CRASH][54]
[54]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-bdw-5557u/igt@kms_frontbuffer_tracking@fbc-1p-offscren-pri-indfb-draw-render.html
- fi-cml-s: NOTRUN -> [CRASH][55]
[55]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-cml-s/igt@kms_frontbuffer_tracking@fbc-1p-offscren-pri-indfb-draw-render.html
* igt@kms_frontbuffer_tracking@fbc-1p-primscrn-indfb-pgflip-blt:
- fi-skl-6700k2: NOTRUN -> [INCOMPLETE][56]
[56]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-skl-6700k2/igt@[email protected]
* igt@kms_frontbuffer_tracking@fbc-1p-primscrn-pri-indfb-draw-render:
- fi-skl-6600u: NOTRUN -> [INCOMPLETE][57] +1 similar issue
[57]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-skl-6600u/igt@kms_frontbuffer_tracking@fbc-1p-primscrn-pri-indfb-draw-render.html
- fi-kbl-r: NOTRUN -> [INCOMPLETE][58]
[58]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-kbl-r/igt@kms_frontbuffer_tracking@fbc-1p-primscrn-pri-indfb-draw-render.html
* igt@kms_frontbuffer_tracking@fbc-2p-primscrn-pri-shrfb-draw-render:
- fi-snb-2600: NOTRUN -> [FAIL][59] +36 similar issues
[59]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-snb-2600/igt@kms_frontbuffer_tracking@fbc-2p-primscrn-pri-shrfb-draw-render.html
* igt@kms_frontbuffer_tracking@fbc-modesetfrombusy:
- fi-cfl-8700k: NOTRUN -> [INCOMPLETE][60]
[60]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-cfl-8700k/igt@[email protected]
- fi-hsw-4770: NOTRUN -> [INCOMPLETE][61] +1 similar issue
[61]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-hsw-4770/igt@[email protected]
- fi-snb-2520m: NOTRUN -> [INCOMPLETE][62] +1 similar issue
[62]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-snb-2520m/igt@[email protected]
* igt@kms_frontbuffer_tracking@fbcdrrs-slowdraw (NEW):
- fi-icl-y: NOTRUN -> [INCOMPLETE][63]
[63]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-icl-y/igt@[email protected]
* igt@kms_frontbuffer_tracking@fbcpsr-1p-primscrn-shrfb-pgflip-blt:
- fi-tgl-u2: NOTRUN -> [INCOMPLETE][64]
[64]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-tgl-u2/igt@kms_frontbuffer_tracking@fbcpsr-1p-primscrn-shrfb-pgflip-blt.html
* igt@kms_frontbuffer_tracking@psr-2p-primscrn-cur-indfb-draw-pwrite:
- fi-cml-u2: NOTRUN -> [INCOMPLETE][65]
[65]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-cml-u2/igt@kms_frontbuffer_tracking@psr-2p-primscrn-cur-indfb-draw-pwrite.html
* igt@kms_frontbuffer_tracking@psr-2p-primscrn-pri-shrfb-draw-mmap-cpu:
- fi-icl-u2: NOTRUN -> [INCOMPLETE][66]
[66]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-icl-u2/igt@kms_frontbuffer_tracking@psr-2p-primscrn-pri-shrfb-draw-mmap-cpu.html
* igt@kms_frontbuffer_tracking@psr-2p-scndscrn-cur-indfb-draw-mmap-wc:
- fi-cml-s: NOTRUN -> [INCOMPLETE][67]
[67]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-cml-s/igt@kms_frontbuffer_tracking@psr-2p-scndscrn-cur-indfb-draw-mmap-wc.html
* igt@kms_frontbuffer_tracking@psrdrrs-2p-rte (NEW):
- {fi-ehl-1}: NOTRUN -> [SKIP][68] +3 similar issues
[68]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-ehl-1/igt@[email protected]
* igt@kms_pipe_crc_basic@read-crc-pipe-b:
- fi-bsw-kefka: [PASS][69] -> [INCOMPLETE][70]
[69]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8783/fi-bsw-kefka/igt@[email protected]
[70]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-bsw-kefka/igt@[email protected]
* igt@kms_psr@cursor_blt:
- fi-kbl-r: NOTRUN -> [FAIL][71] +6 similar issues
[71]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-kbl-r/igt@kms_psr@cursor_blt.html
* igt@kms_psr@sprite_blt:
- fi-skl-6600u: NOTRUN -> [FAIL][72] +6 similar issues
[72]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-skl-6600u/igt@kms_psr@sprite_blt.html
#### Warnings ####
* igt@kms_frontbuffer_tracking@basic:
- fi-kbl-x1275: [DMESG-WARN][73] ([i915#62] / [i915#92]) -> [DMESG-WARN][74]
[73]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_8783/fi-kbl-x1275/igt@[email protected]
[74]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-kbl-x1275/igt@[email protected]
#### Suppressed ####
The following results come from untrusted machines, tests, or statuses. They do not affect the overall result.
* igt@kms_big_fb@x-tiled-64bpp-rotate-180:
- {fi-kbl-7560u}: NOTRUN -> [FAIL][75] +6 similar issues
[75]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-kbl-7560u/igt@[email protected]
- {fi-ehl-1}: NOTRUN -> [FAIL][76] +5 similar issues
[76]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-ehl-1/igt@[email protected]
* igt@kms_cursor_crc@pipe-b-cursor-512x170-sliding:
- {fi-ehl-1}: NOTRUN -> [SKIP][77] +59 similar issues
[77]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-ehl-1/igt@[email protected]
* igt@kms_draw_crc@draw-method-rgb565-render-untiled:
- {fi-kbl-7560u}: NOTRUN -> [INCOMPLETE][78] +1 similar issue
[78]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-kbl-7560u/igt@[email protected]
* igt@kms_draw_crc@draw-method-xrgb8888-render-untiled:
- {fi-kbl-7560u}: NOTRUN -> [CRASH][79]
[79]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-kbl-7560u/igt@[email protected]
* igt@kms_frontbuffer_tracking@fbc-1p-primscrn-pri-indfb-draw-render:
- {fi-ehl-1}: NOTRUN -> [INCOMPLETE][80] +1 similar issue
[80]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/fi-ehl-1/igt@kms_frontbuffer_tracking@fbc-1p-primscrn-pri-indfb-draw-render.html
New tests
---------
New tests have been introduced between CI_DRM_8783 and IGTPW_4797:
### New IGT tests (694) ###
* igt@api_intel_bb@render-ccs:
- Statuses : 1 fail(s) 20 pass(s) 16 skip(s)
- Exec time: [0.0, 0.49] s
* igt@api_intel_bb@render-none:
- Statuses : 37 pass(s)
- Exec time: [0.17, 1.35] s
* igt@api_intel_bb@render-x:
- Statuses : 37 pass(s)
- Exec time: [0.17, 0.95] s
* igt@api_intel_bb@render-y:
- Statuses : 37 pass(s)
- Exec time: [0.17, 0.90] s
* igt@gem_ppgtt:
- Statuses :
- Exec time: [None] s
* igt@gem_read_read_speed:
- Statuses :
- Exec time: [None] s
* igt@gem_read_read_speed@read-read-1024x1024:
- Statuses : 2 fail(s) 28 pass(s) 6 skip(s)
- Exec time: [0.0, 0.07] s
* igt@gem_read_read_speed@read-read-128x128:
- Statuses : 2 fail(s) 28 pass(s) 6 skip(s)
- Exec time: [0.0, 0.69] s
* igt@gem_read_read_speed@read-read-2048x2048:
- Statuses : 2 fail(s) 28 pass(s) 6 skip(s)
- Exec time: [0.0, 0.30] s
* igt@gem_read_read_speed@read-read-256x256:
- Statuses : 2 fail(s) 28 pass(s) 6 skip(s)
- Exec time: [0.0, 0.02] s
* igt@gem_read_read_speed@read-read-4096x4096:
- Statuses : 2 fail(s) 28 pass(s) 6 skip(s)
- Exec time: [0.0, 0.92] s
* igt@gem_read_read_speed@read-read-512x512:
- Statuses : 2 fail(s) 28 pass(s) 6 skip(s)
- Exec time: [0.0, 0.03] s
* igt@gem_read_read_speed@read-read-8192x8192:
- Statuses : 2 fail(s) 28 pass(s) 6 skip(s)
- Exec time: [0.0, 3.69] s
* igt@gem_read_read_speed@read-write-1024x1024:
- Statuses : 2 fail(s) 28 pass(s) 6 skip(s)
- Exec time: [0.0, 0.21] s
* igt@gem_read_read_speed@read-write-128x128:
- Statuses : 2 fail(s) 28 pass(s) 6 skip(s)
- Exec time: [0.0, 0.01] s
* igt@gem_read_read_speed@read-write-2048x2048:
- Statuses : 2 fail(s) 28 pass(s) 6 skip(s)
- Exec time: [0.0, 0.29] s
* igt@gem_read_read_speed@read-write-256x256:
- Statuses : 2 fail(s) 28 pass(s) 6 skip(s)
- Exec time: [0.0, 0.02] s
* igt@gem_read_read_speed@read-write-4096x4096:
- Statuses : 2 fail(s) 28 pass(s) 6 skip(s)
- Exec time: [0.0, 1.13] s
* igt@gem_read_read_speed@read-write-512x512:
- Statuses : 2 fail(s) 28 pass(s) 6 skip(s)
- Exec time: [0.0, 0.03] s
* igt@gem_read_read_speed@read-write-8192x8192:
- Statuses : 2 fail(s) 28 pass(s) 6 skip(s)
- Exec time: [0.0, 4.43] s
* igt@gem_read_read_speed@write-read-1024x1024:
- Statuses : 2 fail(s) 28 pass(s) 6 skip(s)
- Exec time: [0.0, 0.65] s
* igt@gem_read_read_speed@write-read-128x128:
- Statuses : 2 fail(s) 28 pass(s) 6 skip(s)
- Exec time: [0.0, 0.01] s
* igt@gem_read_read_speed@write-read-2048x2048:
- Statuses : 2 fail(s) 28 pass(s) 6 skip(s)
- Exec time: [0.0, 0.52] s
* igt@gem_read_read_speed@write-read-256x256:
- Statuses : 2 fail(s) 28 pass(s) 6 skip(s)
- Exec time: [0.0, 0.02] s
* igt@gem_read_read_speed@write-read-4096x4096:
- Statuses : 2 fail(s) 28 pass(s) 6 skip(s)
- Exec time: [0.0, 1.21] s
* igt@gem_read_read_speed@write-read-512x512:
- Statuses : 2 fail(s) 28 pass(s) 6 skip(s)
- Exec time: [0.0, 0.03] s
* igt@gem_read_read_speed@write-read-8192x8192:
- Statuses : 2 fail(s) 28 pass(s) 6 skip(s)
- Exec time: [0.0, 6.07] s
* igt@gem_read_read_speed@write-write-1024x1024:
- Statuses : 2 fail(s) 28 pass(s) 6 skip(s)
- Exec time: [0.0, 0.38] s
* igt@gem_read_read_speed@write-write-128x128:
- Statuses : 2 fail(s) 28 pass(s) 6 skip(s)
- Exec time: [0.0, 0.01] s
* igt@gem_read_read_speed@write-write-2048x2048:
- Statuses : 2 fail(s) 28 pass(s) 6 skip(s)
- Exec time: [0.0, 0.29] s
* igt@gem_read_read_speed@write-write-256x256:
- Statuses : 2 fail(s) 28 pass(s) 6 skip(s)
- Exec time: [0.0, 0.02] s
* igt@gem_read_read_speed@write-write-4096x4096:
- Statuses : 2 fail(s) 28 pass(s) 6 skip(s)
- Exec time: [0.0, 1.04] s
* igt@gem_read_read_speed@write-write-512x512:
- Statuses : 2 fail(s) 28 pass(s) 6 skip(s)
- Exec time: [0.0, 0.03] s
* igt@gem_read_read_speed@write-write-8192x8192:
- Statuses : 2 fail(s) 28 pass(s) 6 skip(s)
- Exec time: [0.0, 18.49] s
* igt@gem_render_copy:
- Statuses :
- Exec time: [None] s
* igt@kms_big_fb:
- Statuses :
- Exec time: [None] s
* igt@kms_cursor_crc:
- Statuses :
- Exec time: [None] s
* igt@kms_cursor_crc@pipe-e-cursor-128x128-offscreen:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-128x128-onscreen:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-128x128-random:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-128x128-rapid-movement:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-128x128-sliding:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-128x42-offscreen:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-128x42-onscreen:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-128x42-random:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-128x42-sliding:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-256x256-offscreen:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-256x256-onscreen:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-256x256-random:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-256x256-rapid-movement:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-256x256-sliding:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-256x85-offscreen:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-256x85-onscreen:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-256x85-random:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-256x85-sliding:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-512x170-offscreen:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-512x170-onscreen:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-512x170-random:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-512x170-sliding:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-512x512-offscreen:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-512x512-onscreen:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-512x512-random:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-512x512-rapid-movement:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-512x512-sliding:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-64x21-offscreen:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-64x21-onscreen:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-64x21-random:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-64x21-sliding:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-64x64-offscreen:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-64x64-onscreen:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-64x64-random:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-64x64-rapid-movement:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-64x64-sliding:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-alpha-opaque:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-alpha-transparent:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-dpms:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-size-change:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-e-cursor-suspend:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-f-cursor-128x128-offscreen:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-f-cursor-128x128-onscreen:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-f-cursor-128x128-random:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-f-cursor-128x128-rapid-movement:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-f-cursor-128x128-sliding:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-f-cursor-128x42-offscreen:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-f-cursor-128x42-onscreen:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-f-cursor-128x42-random:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-f-cursor-128x42-sliding:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-f-cursor-256x256-offscreen:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-f-cursor-256x256-onscreen:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-f-cursor-256x256-random:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-f-cursor-256x256-rapid-movement:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-f-cursor-256x256-sliding:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-f-cursor-256x85-offscreen:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-f-cursor-256x85-onscreen:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-f-cursor-256x85-random:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-f-cursor-256x85-sliding:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-f-cursor-512x170-offscreen:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-f-cursor-512x170-onscreen:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-f-cursor-512x170-random:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-f-cursor-512x170-sliding:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-f-cursor-512x512-offscreen:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-f-cursor-512x512-onscreen:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-f-cursor-512x512-random:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-f-cursor-512x512-rapid-movement:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-f-cursor-512x512-sliding:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-f-cursor-64x21-offscreen:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-f-cursor-64x21-onscreen:
- Statuses : 36 skip(s)
- Exec time: [0.0] s
* igt@kms_cursor_crc@pipe-f-cursor-64x21-random:
- Statuses : 36 skip(s)
- Exec tim
== Logs ==
For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_4797/index.html
_______________________________________________
igt-dev mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/igt-dev