Scheduler tests
v2 cover Scheduler tests
This patch set adds scheduler tests.
Patch 1 Makes gem_has_ring() non static as the test will need to call it Patch 2 Separate ring BSD1 from BSD2 in gem_require_ring() to prevent the BSD1 specific tests from skipping if there is no BSD2 ring. Based on a patch originally submitted by Gabriel Feceoru.
Patch 3 adds library code used by the tests. There are other tests under development which are planned to reuse some of these libraries. Patch 4 adds some basic tests, read dependency tests and write dependency tests. Patch 5 Is the patch previously submitted by John Harrison to update gem_ctx_param_basic with ioctls to set context priorities. It is included as part of this patch set as Patch 6 & 7 are dependant on it.
Patch 6 adds tests to check sheduler behaviour for batch buffers submitted at differing priorities.
Patch 7 adds tests to check priority bumping behaviour.
v2: Updates for comments from Daniele Ceraolo Spurio and Daniel Vetter
Added tests requested by Joonas Lahtinen
Derek Morton (6):
ioctl_wrappers: make gem_has_ring non static lib/ioctl_wrappers: Separate ring BSD1 from BSD2 checks lib/intel_batchbuffer: Add functions to be used in the scheduler test tests/gem_scheduler: Add gem_scheduler test tests/gem_scheduler: Add subtests to test batch priority behaviour
gem_scheduler: Added subtests to test priority bumping
John Harrison (1):
igt/gem_ctx_param_basic: Updated to support scheduler priority
interface
lib/intel_batchbuffer.c | 384 ++++++++++++++++++++++++++- lib/intel_batchbuffer.h | 14 + lib/ioctl_wrappers.c | 6 +- lib/ioctl_wrappers.h | 2 + tests/Makefile.sources | 1 + tests/gem_ctx_param_basic.c | 34 ++- tests/gem_scheduler.c | 622 ++++++++++++++++++++++++++++++++++++++++++++ 7 files changed, 1055 insertions(+), 8 deletions(-) create mode 100644 tests/gem_scheduler.c
Signature · 6 lines
1.9.1 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH v2 1/7 ioctl_wrappers: make gem_has_ring non static
For tests that use multiple rings to test interactions it is useful to know if a ring exists without triggering the test to skip.
--- lib/ioctl_wrappers.c | 2 +- lib/ioctl_wrappers.h | 1 + 2 files changed, 2 insertions(+), 1 deletion(-)
lib/ioctl_wrappers.c +1 -1
@@ -1396,7 +1396,7 @@ void gem_require_caching(int fd) errno =0 ; } -static int gem_has_ring (int fd,int ring) +int gem_has_ring (int fd,int ring) {uint32_t bbe =MI_BATCH_BUFFER_END ;struct drm_i915_gem_execbuffer2 execbuf;
lib/ioctl_wrappers.h +1 -0
@@ -150,6 +150,7 @@ uint64_t gem_global_aperture_size(int fd);uint64_t gem_mappable_aperture_size (void );bool gem_has_softpin (int fd); +int gem_has_ring (int fd,int ring);/* check functions which auto-skip tests by calling igt_skip() */ void gem_require_caching (int fd);void gem_require_ring (int fd,int ring_id);
Signature · 6 lines
1.9.1 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH v2 2/7 lib/ioctl_wrappers: Separate ring BSD1 from BSD2 checks
In reply to Derek MortonSome platforms have ring BSD available but no BSD2. Because of the current verification, tests involving ring BSD1 will be skipped if no BSD2 is available.
Decoupling the checks will allow running the BSD1 specific tests on these platforms.
Based on a patch originally submitted by Gabriel Feceoru to patchwork-hook-test branch.
--- lib/ioctl_wrappers.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
lib/ioctl_wrappers.c +3 -1
@@ -1432,8 +1432,10 @@ void gem_require_ring(int fd, int ring_id)/* silly ABI, the kernel thinks everyone who has BSD also has BSD2 */ if ((ring_id & ~(3 <<13 )) ==I915_EXEC_BSD ) { -if (ring_id & (3 <<13 )) +if (ring_id & (2 <<13 ))igt_require (gem_has_bsd2 (fd)); +if (ring_id & (1 <<13 )) +igt_require (gem_has_bsd (fd)); } }
Signature · 6 lines
1.9.1 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
Re: [PATCH i-g-t v2 2/7] lib/ioctl_wrappers: Separate ring BSD1 from BSD2 checks
Quoted 3 lines · Derek Morton
Some platforms have ring BSD available but no BSD2. Because of the current verification, tests involving ring BSD1 will be skipped if no BSD2 is available.
The code does what exactly what we want. We run
BSD or BSD, BSD1, BSD2 (because in this case we have no idea what BSD actually is).
-Chris
Signature · 5 lines
Chris Wilson, Intel Open Source Technology Centre _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
Re: [PATCH i-g-t v2 2/7] lib/ioctl_wrappers: Separate ring BSD1 from BSD2 checks
I need to control exactly which ring each batchbuffer is submitted to if there is more than 1 BSD ring as I need to fill the queues in a known manner. My understanding is that if I submit to BSD when there is BSD1 and BSD2 the kernel will choose which ring it gets submitted to. If this logic breaks other tests I will remove this patch and put the logic in the scheduler test.
//Derek
-----Original Message-----
From: Chris Wilson [mailto:[email protected]]
Sent: Wednesday, March 2, 2016 6:42 PM
To: Morton, Derek J <[email protected]>
Cc: [email protected]; [email protected]
Subject: Re: [Intel-gfx] [PATCH i-g-t v2 2/7] lib/ioctl_wrappers: Separate ring BSD1 from BSD2 checks
Quoted 3 lines · Derek Morton
Some platforms have ring BSD available but no BSD2.
Because of the current verification, tests involving ring BSD1 will be skipped if no BSD2 is available.
The code does what exactly what we want. We run BSD or BSD, BSD1, BSD2 (because in this case we have no idea what BSD actually is). -Chris
--
Chris Wilson, Intel Open Source Technology Centre
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
Re: [PATCH i-g-t v2 2/7] lib/ioctl_wrappers: Separate ring BSD1 from BSD2 checks
In reply to Derek MortonQuoted 21 lines · Derek Morton
Some platforms have ring BSD available but no BSD2. Because of the current verification, tests involving ring BSD1 will be skipped if no BSD2 is available.
Decoupling the checks will allow running the BSD1 specific tests on these platforms.
Based on a patch originally submitted by Gabriel Feceoru to patchwork-hook-test branch.
Signed-off-by Derek Morton <[email protected]>--- lib/ioctl_wrappers.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)lib/ioctl_wrappers.c +0
-0@@ -1432,8 +1432,10 @@ void gem_require_ring(int fd, int ring_id)
lib/ioctl_wrappers.c void gem_require_ring(int fd, int ring_id) · line 1441
Quoted 10 lines
lib/ioctl_wrappers.c +3
-1/* silly ABI, the kernel thinks everyone who has BSD also has BSD2 */ if ((ring_id & ~(3 <<13 )) ==I915_EXEC_BSD ) { -if (ring_id & (3 <<13 )) +if (ring_id & (2 <<13 ))igt_require (gem_has_bsd2 (fd)); +if (ring_id & (1 <<13 )) +igt_require (gem_has_bsd (fd)); } }
Isn't the first (unchanged) line rather unclear? Why not test for (ring_id & I915_EXEC_BSD)? And then you only need to additionally test bit 14.
if (ring_id & I915_EXEC_BSD) {
/* require at least one BSD ring */
igt_require(gem_has_bsd(fd));
if (ring_id & (2 << 13)) {
/* specifically require BSD2 */
igt_require(gem_has_bsd2(fd));
}
}.Dave.
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
Re: [PATCH i-g-t v2 2/7] lib/ioctl_wrappers: Separate ring BSD1 from BSD2 checks
Quoted 38 lines · Dave Gordon
Quoted 25 lines · Derek Morton
Some platforms have ring BSD available but no BSD2. Because of the current verification, tests involving ring BSD1 will be skipped if no BSD2 is available.
Decoupling the checks will allow running the BSD1 specific tests on these platforms.
Based on a patch originally submitted by Gabriel Feceoru to patchwork-hook-test branch.
Signed-off-by Derek Morton <[email protected]>--- lib/ioctl_wrappers.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)lib/ioctl_wrappers.c +0
-0@@ -1432,8 +1432,10 @@ void gem_require_ring(int fd, int ring_id)/* silly ABI, the kernel thinks everyone who has BSD also has BSD2 */
if ((ring_id & ~(3<<13)) == I915_EXEC_BSD) {lib/ioctl_wrappers.c void gem_require_ring(int fd, int ring_id) · line 1440
Quoted 7 lines
lib/ioctl_wrappers.c +3
-1-if (ring_id & (3 <<13 )) +if (ring_id & (2 <<13 ))igt_require (gem_has_bsd2 (fd)); +if (ring_id & (1 <<13 )) +igt_require (gem_has_bsd (fd)); } }Isn't the first (unchanged) line rather unclear? Why not test for (
ring_id&I915_EXEC_BSD)? And then you only need to additionally test bit 14.
Quoted 1 line
if (ring_id & I915_EXEC_BSD) {Oops, no, this should be:
if ((ring_id & I915_EXEC_RING_MASK) == I915_EXEC_BSD) {Quoted 4 lines
/* require at least one BSD ring */
igt_require(gem_has_bsd(fd));
if (ring_id & (2 << 13)) {Or better (and symbolically):
if ((ring_id & I915_EXEC_BSD_MASK) == I915_EXEC_BSD_RING2) {Quoted 6 lines
/* specifically require BSD2 */ igt_require(gem_has_bsd2(fd)); } }.Dave.
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH v2 3/7 lib/intel_batchbuffer: Add functions to be used in the scheduler test
In reply to Derek MortonAdds functions to create a number of different batch buffers to perform several functions including:
Batch buffer which will run for a long duration to provide a delay on a specified ring.
Function to calibrate the delay batch buffer to run for a specified period of time.
Function to create a batch buffer which writes timestamps to a buffer object. Function to compare timestamps allowing for wrapping of the values.
v2: Moved code to intel_batchbuffer (Daniel Vetter)
Addressed review comments from Daniele Ceraolo Spurio
--- lib/intel_batchbuffer.c | 384 +++++++++++++++++++++++++++++++++++++++++++++++- lib/intel_batchbuffer.h | 14 ++ 2 files changed, 393 insertions(+), 5 deletions(-)
lib/intel_batchbuffer.c +379 -5
@@ -1,8 +1,8 @@/************************************************************************** -* +* * Copyright 2006 Tungsten Graphics, Inc., Cedar Park, Texas. * All Rights Reserved. -* +* * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the * "Software"), to deal in the Software without restriction, including
@@ -10,11 +10,11 @@* distribute, sub license, and/or sell copies of the Software, and to * permit persons to whom the Software is furnished to do so, subject to * the following conditions: -* +* * The above copyright notice and this permission notice (including the * next paragraph) shall be included in all copies or substantial portions * of the Software. -* +* * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
@@ -22,7 +22,7 @@* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -* +* **************************************************************************/ #include <inttypes.h>
@@ -30,6 +30,8 @@#include <stdio.h> #include <string.h> #include <assert.h> +#include <stdint.h> +#include <time.h> #include "drm.h" #include "drmtest.h"
@@ -42,6 +44,7 @@#include "ioctl_wrappers.h" #include "media_spin.h" #include "gpgpu_fill.h" +#include "igt_gt.h" #include <i915_drm.h>
@@ -817,3 +820,374 @@ igt_media_spinfunc_t igt_get_media_spinfunc(int devid)return spin; } + +#define SEC_TO_NSEC (1000 * 1000 * 1000) +#define DWORDS_TO_BYTES (x) ((x)*4) + +#define MI_STORE_REGISTER_MEM (LENGTH ) ((0x024 << 23) | ((LENGTH - 2) & 0xff)) +#define MI_MATH (NrInst) ((0x01A << 23) | ((NrInst - 1) & 0x3f)) +#define MI_CONDITIONAL_BATCH_BUFFER_END ((0x036 << 23) | (1 << 21) | 2) +#define MI_COPY_MEM_MEM ((0x02E << 23) | (3)) + +#define ALU_LOAD (TO ,FROM ) ((0x080 << 20) | ((TO) << 10) | (FROM)) +#define ALU_SUB ( 0x101 << 20) +#define ALU_STORE (TO ,FROM ) ((0x180 << 20) | ((TO) << 10) | (FROM)) + +#define TIMESTAMP_offset (0x358)/* Elapsed time from system start */ +#define CTX_TIMESTAMP_offset (0x3A8)/* Elapsed Time from context creation */ +#define ALU_GPU_R0_LSB_offset (0x600) +#define ALU_GPU_R0_MSB_offset (0x604) +#define ALU_GPU_R1_LSB_offset (0x608) +#define ALU_GPU_R1_MSB_offset (0x60C) +#define ALU_GPU_R2_LSB_offset (0x610) +#define ALU_GPU_R2_MSB_offset (0x614) + +#define ALU_R0_ENCODING (0x00) +#define ALU_R1_ENCODING (0x01) +#define ALU_SRCA_ENCODING (0x20) +#define ALU_SRCB_ENCODING (0x21) +#define ALU_ACCU_ENCODING (0x31) + +static int bb_address_size_dw (int fd) +{ +if (intel_gen (intel_get_drm_devid (fd)) >=8 ) +return 2 ; +else +return 1 ; +} + +static uint32_t get_mmio_base (int ringid) +{ +switch (ringid) { +case I915_EXEC_RENDER : +return 0x02000 ; +case I915_EXEC_BSD : +case I915_EXEC_BSD |1 <<13 :/* BSD1 */ +return 0x12000 ; +case I915_EXEC_BSD |2 <<13 :/* BSD2 */ +return 0x1c000 ; +case I915_EXEC_BLT : +return 0x22000 ; +case I915_EXEC_VEBOX : +return 0x1A000 ; +default : +igt_assert_f (0 ,"Invalid ringid %d passed to get_mmio_base()\n" , ringid); + } +} + +/** +* igt_batch_used +* @batch batchbuffer to get offset from +* +* This returns the number of bytes of the batchbuffer that have been used. +* e.g. The offset into the batchbuffer that the next OUT_BATCH would write to. +* +* Returns: +* The number of bytes of the batchbuffer that have been used. +*/ +uint32_t igt_batch_used (struct intel_batchbuffer *batch) +{ +return batch->ptr - batch->buffer; +} + +/** +* igt_create_delay_bb: +* @fd: file descriptor for i915 driver instance +* @batch: Batch buffer to write to +* ringid: Ring to create batch buffer for. e.g. I915_EXEC_RENDER +* loops: Number of times to loop +* dest: Buffer to use for saving the current loop count and timestamp. +* +* This creates a batch buffer which will iterate a loop a specified number +* of times. Intended for creating batch buffers which take an arbitarily +* long time to execute. This can be useful to keep a ring busy while +* constructing a test scenario. +* +* The dest buffer will have a number of Dwords written by the batch buffer +* when it runs. They are: +* DW0 & DW1 - These are loaded with the value of 'loops' and are decremented +* as the batch buffer executes. They will be 0 after the batch +* buffer completes if it finished succesfully. +* DW2 Timestamp - An indication of when the batch buffer ran allowing a +* comparison between batch buffers to show execution order. +* May wrap so igt_compare_timestamps() should be used to +* compare timestamps. +* The timestamp will wrap every few minutes. +* +*/ +void igt_create_delay_bb (int fd,struct intel_batchbuffer *batch, +int ringid,uint32_t loops,drm_intel_bo *dest) +{ +int addr_size_dw; +uint32_t mmio_base, jump_offset; + +/* CMD parser blocks reading TIMESTAMP register on gen 7.5 */ +igt_require (intel_gen (intel_get_drm_devid (fd)) >=8 ); + + addr_size_dw =bb_address_size_dw (fd); + mmio_base =get_mmio_base (ringid); +igt_assert (batch); +BEGIN_BATCH (32 ,5 ); + +/* store current timestamp in DW2 */ +OUT_BATCH (MI_STORE_REGISTER_MEM (addr_size_dw +2 )); +OUT_BATCH (mmio_base + TIMESTAMP_offset); +OUT_RELOC (dest,I915_GEM_DOMAIN_INSTRUCTION ,I915_GEM_DOMAIN_INSTRUCTION ,DWORDS_TO_BYTES (2 )); + +/* Load R0 with loops */ +OUT_BATCH (MI_LOAD_REGISTER_IMM ); +OUT_BATCH (mmio_base + ALU_GPU_R0_LSB_offset); +OUT_BATCH (loops); +OUT_BATCH (MI_LOAD_REGISTER_IMM ); +OUT_BATCH (mmio_base + ALU_GPU_R0_MSB_offset); +OUT_BATCH (0x00000000 ); +/* Load R1 with 1 */ +OUT_BATCH (MI_LOAD_REGISTER_IMM ); +OUT_BATCH (mmio_base + ALU_GPU_R1_LSB_offset); +OUT_BATCH (0x00000001 ); +OUT_BATCH (MI_LOAD_REGISTER_IMM ); +OUT_BATCH (mmio_base + ALU_GPU_R1_MSB_offset); +OUT_BATCH (0x00000000 ); +/* Copy R0 / R1 into SRCA / SRCB, Perform R0 - R1, Store result in R0 */ +/* e.g. R0 -= 1 */ + jump_offset=igt_batch_used (batch); +OUT_BATCH (MI_MATH (4 )); +OUT_BATCH (ALU_LOAD (ALU_SRCA_ENCODING ,ALU_R0_ENCODING )); +OUT_BATCH (ALU_LOAD (ALU_SRCB_ENCODING ,ALU_R1_ENCODING )); +OUT_BATCH (ALU_SUB ); +OUT_BATCH (ALU_STORE (ALU_R0_ENCODING ,ALU_ACCU_ENCODING )); +/* Copy R0 to dest +* On Gen8 MI_CONDITIONAL_BATCH_BUFFER_END BSD ring Compare address +* points to 2 Dwords, a mask (DW0) and data (DW1) which are ANDed +* together. +* On Gen9+, and the other rings on Gen8 Compare address points to +* just Data (DW0). For simplicity always copy R0 LSB to DW0 and DW1. +*/ +OUT_BATCH (MI_STORE_REGISTER_MEM (addr_size_dw +2 )); +OUT_BATCH (mmio_base + ALU_GPU_R0_LSB_offset); +OUT_RELOC (dest,I915_GEM_DOMAIN_INSTRUCTION ,I915_GEM_DOMAIN_INSTRUCTION ,0 ); +OUT_BATCH (MI_STORE_REGISTER_MEM (addr_size_dw +2 )); +OUT_BATCH (mmio_base + ALU_GPU_R0_LSB_offset); +OUT_RELOC (dest,I915_GEM_DOMAIN_INSTRUCTION ,I915_GEM_DOMAIN_INSTRUCTION ,DWORDS_TO_BYTES (1 )); +/* Repeat until R0 == 0 */ +OUT_BATCH (MI_CONDITIONAL_BATCH_BUFFER_END ); +OUT_BATCH (0x00000000 ); +OUT_RELOC (dest,I915_GEM_DOMAIN_INSTRUCTION ,I915_GEM_DOMAIN_INSTRUCTION ,0 ); +OUT_BATCH (MI_BATCH_BUFFER_START | (addr_size_dw -1 )); +OUT_RELOC (batch->bo,I915_GEM_DOMAIN_INSTRUCTION ,0 , jump_offset); + +/* Should never get here, but end if it happens */ +OUT_BATCH (MI_BATCH_BUFFER_END ); +ADVANCE_BATCH (); +} + +/** +* igt_create_timestamp_bb: +* @fd: file descriptor for i915 driver instance +* @batch: Batch buffer to write to +* ringid: Ring to create batch buffer for. e.g. I915_EXEC_RENDER +* dest: Buffer to use for saving the timestamps. +* load: Buffer to access. Set NULL if not required. +* write: If true and load is not NULL, will also write a timestamp to load +* buffer. If false and load is not NULL, will read from load buffer into dest. +* Intended for dependency checking. +* +* This creates a batch buffer which writes timestamps into a buffer object. +* If 'load' is non null, data is either written to 'load' or copied from 'load' +* depending on whether 'write' is set. +* +* The dest buffer will have a number of Dwords written by the batch buffer +* when it runs. They are: +* DW0 Reported timestamp - An indication of when the batch buffer ran allowing a +* comparison between batch buffers to show execution order. +* May wrap so igt_compare_timestamps() should be used to +* compare timestamps. +* The timestamp will wrap every few minutes. +* DW2 Value copied from DW0 of load if write == false +* +*/ +void igt_create_timestamp_bb (int fd,struct intel_batchbuffer *batch,int ringid, +drm_intel_bo *dest,drm_intel_bo *load,bool write) +{ +int addr_size_dw; +uint32_t mmio_base; + +/* CMD parser blocks reading TIMESTAMP register on gen 7.5 */ +igt_require (intel_gen (intel_get_drm_devid (fd)) >=8 ); + + addr_size_dw =bb_address_size_dw (fd); + mmio_base =get_mmio_base (ringid); +igt_assert (batch); + +BEGIN_BATCH (3 ,1 ); +/* store current reported timestamp in DW0 */ +OUT_BATCH (MI_STORE_REGISTER_MEM (addr_size_dw +2 )); +OUT_BATCH (mmio_base + TIMESTAMP_offset); +OUT_RELOC (dest,I915_GEM_DOMAIN_INSTRUCTION ,I915_GEM_DOMAIN_INSTRUCTION ,DWORDS_TO_BYTES (0 )); + +ADVANCE_BATCH (); + +if (load !=NULL ) { +if (write) { +BEGIN_BATCH (3 ,1 ); +OUT_BATCH (MI_STORE_REGISTER_MEM (addr_size_dw +2 )); +OUT_BATCH (mmio_base + TIMESTAMP_offset); +OUT_RELOC (load,I915_GEM_DOMAIN_INSTRUCTION ,I915_GEM_DOMAIN_INSTRUCTION ,DWORDS_TO_BYTES (0 )); +ADVANCE_BATCH (); + } +else { +BEGIN_BATCH (3 ,2 ); +OUT_BATCH (MI_COPY_MEM_MEM ); +OUT_RELOC (dest,I915_GEM_DOMAIN_INSTRUCTION ,I915_GEM_DOMAIN_INSTRUCTION ,DWORDS_TO_BYTES (2 )); +OUT_RELOC (load,I915_GEM_DOMAIN_INSTRUCTION ,0 ,DWORDS_TO_BYTES (0 )); +ADVANCE_BATCH (); + } + } + +BEGIN_BATCH (1 ,0 ); +OUT_BATCH (MI_BATCH_BUFFER_END ); +ADVANCE_BATCH (); +} + +/** +* igt_create_noop_bb: +* @batch: Batch buffer to write to +* noops: Number of MI_NOOP instructions to add to the batch buffer. +* +* This creates a batch buffer with a specified number of MI_NOOP instructions. +*/ +void igt_create_noop_bb (struct intel_batchbuffer *batch,int noops) +{ +int loop; + +igt_assert (batch); + +BEGIN_BATCH (noops +1 ,0 ); +for (loop =0 ; loop < noops; loop++) +OUT_BATCH (MI_NOOP ); +OUT_BATCH (MI_BATCH_BUFFER_END ); +ADVANCE_BATCH (); + +} + +/* Store calibrated values so they only need calculating once. +* Use intel_execution_engines array as list of supported rings +*/ +static uint32_t *calibrated_ring_value =NULL ; + +/** +* igt_calibrate_delay_bb: +* @fd: file descriptor for i915 driver instance +* @bufmgr: Buffer manager to be used for creation of batch buffers +* ringid: Ring to calibrate. e.g. I915_EXEC_RENDER +* +* This calculates the value of loops that would need to be passed to +* igt_create_delay_bb() to create a delay of about 1 second on the specified +* ring. +* +* Returns: +* uint32_t to be passed to igt_create_delay_bb(). +*/ +/* 0x100000 will run for about 0.6 - 0.8 seconds (dependant on ring) on BXT HW */ +#define CAL_SEED (0x100000) +uint32_t igt_calibrate_delay_bb (int fd,drm_intel_bufmgr *bufmgr,int ringid) +{ +uint32_t buf[2 ]; +struct intel_batchbuffer *bb; +struct timespec start, end; +uint64_t duration; +uint64_t calibrated; +drm_intel_bo *target_bo; +int ring_index=0 ; + +/* igt_assert(ringid < 8); +if(calibrated_ring_value[ringid] != 0) +return calibrated_ring_value[ringid];*/ + +if (calibrated_ring_value ==NULL ) { +int count; +for (count =0 ; intel_execution_engines[count].name !=NULL ; count++) {} + calibrated_ring_value =calloc (count,sizeof (uint32_t )); +igt_assert (calibrated_ring_value); + } + +/* Check if there is already a calibration value for this ring */ +while (intel_execution_engines[ring_index].name !=NULL ) { +if ((intel_execution_engines[ring_index].exec_id | + intel_execution_engines[ring_index].flags) == ringid) { +if (calibrated_ring_value[ring_index] !=0 ) { +return calibrated_ring_value[ring_index]; + } +break ; + } + ring_index++; + } + + target_bo =drm_intel_bo_alloc (bufmgr,"target bo" ,BATCH_SZ ,BATCH_SZ ); +igt_assert (target_bo); + +/* Put some non zero values in the target bo */ + { +uint32_t data=0xffffffff ; +drm_intel_bo_subdata (target_bo,0 ,4 , &data); + } + + bb =intel_batchbuffer_alloc (bufmgr,intel_get_drm_devid (fd)); +igt_assert (bb); +igt_create_delay_bb (fd, bb, ringid,CAL_SEED , target_bo); + +gem_quiescent_gpu (fd); +clock_gettime (CLOCK_MONOTONIC , &start); +intel_batchbuffer_flush_on_ring (bb, ringid); +/* This will not return until the bo has finished executing */ +drm_intel_bo_wait_rendering (target_bo); +clock_gettime (CLOCK_MONOTONIC , &end); + +drm_intel_bo_get_subdata (target_bo,0 ,4 , (void *)buf); + +/* buf[0] in the target buffer should be 0 if the batch buffer completed */ +igt_assert_f (buf[0 ] ==0 ,"buf[0] expected 0x0, got 0x%x\n" , buf[0 ]); + + duration = ((((uint64_t )end.tv_sec - (uint64_t )start.tv_sec) *SEC_TO_NSEC ) + + (uint64_t )end.tv_nsec) - (uint64_t )start.tv_nsec; + + calibrated = (((uint64_t )(CAL_SEED ) *SEC_TO_NSEC ) / duration); +igt_debug ("Uncalibrated run took %" PRIu64".%04" PRIu64"s\n" , + duration /SEC_TO_NSEC , + (duration %SEC_TO_NSEC ) /100000 ); +drm_intel_bo_unreference (target_bo); +intel_batchbuffer_free (bb); + +/* Sanity check. If duration < 100ms, something has clearly gone wrong */ +igt_assert (duration > (SEC_TO_NSEC /10 )); + +igt_assert_f (calibrated <=UINT32_MAX ,"Calibrated value > UINT32_MAX\n" ); + +if (intel_execution_engines[ring_index].name !=NULL ) + calibrated_ring_value[ring_index] = (uint32_t )calibrated; +return (uint32_t )calibrated; +} + +/** +* igt_compare_timestamps: +* @ts1: timestamp 1 +* @ts2: timestamp 2 +* +* This compares two uint32_t timestamps. To handle wrapping it assumes the +* difference between the two timestamps is less than 1/4 the max elapsed time +* represented by the counters. +* It also assumes the timestamps are samples from the same counter. +* +* Returns: +* True if ts2 > ts1, allowing for counter wrapping, false otherwise. +*/ + +bool igt_compare_timestamps (uint32_t ts1,uint32_t ts2) +{ +if (ts2 > ts1) +return true; +else if ((ts1 >0x80000000 ) && (ts2 <0x40000000 )) +return true;/* Assuming timestamp counter wrapped */ +else +return false; +}
lib/intel_batchbuffer.h +14 -0
@@ -323,4 +323,18 @@ typedef void (*igt_media_spinfunc_t)(struct intel_batchbuffer *batch,igt_media_spinfunc_t igt_get_media_spinfunc (int devid); +uint32_t igt_batch_used (struct intel_batchbuffer *batch); + +void igt_create_delay_bb (int fd,struct intel_batchbuffer *batch, +int ringid,uint32_t loops,drm_intel_bo *dest); + +void igt_create_timestamp_bb (int fd,struct intel_batchbuffer *batch,int ringid, +drm_intel_bo *dest,drm_intel_bo *load,bool write); + +void igt_create_noop_bb (struct intel_batchbuffer *batch,int noops); + +uint32_t igt_calibrate_delay_bb (int fd,drm_intel_bufmgr *bufmgr,int ringid); + +bool igt_compare_timestamps (uint32_t ts1,uint32_t ts2); +#endif
Signature · 6 lines
1.9.1 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH v2 4/7 tests/gem_scheduler: Add gem_scheduler test
In reply to Derek MortonThis is intended to test the scheduler behaviour is correct.
The subtests are
<ring>-basic
Tests that batch buffers of the same priority submitted to a ring execute in the order they are submitted.
<ring>-read
Submits a batch buffer with a read dependency to a buffer object to a ring which is held in the scheduler queue by a long running batch buffer. Submit batch buffers to other rings that have a read dependency to the same buffer object. Ensure they execute before the batch buffer being held up behind the long running batch buffer.
<ring>-write
Submits a batch buffer with a write dependency to a buffer object to a ring which is held in the scheduler queue by a long running batch buffer. Submit batch buffers to other rings that have a write dependency to the same buffer object. Submit batch buffers with no interdependencies to all rings. Ensure the batch buffers that have write dependencies are executed in submission order but the batch buffers without interdependencies do not get held up.
v2: Addressed review comments from Daniele Ceraolo Spurio
--- tests/Makefile.sources | 1 + tests/gem_scheduler.c | 451 +++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 452 insertions(+) create mode 100644 tests/gem_scheduler.c
tests/Makefile.sources +1 -0
@@ -66,6 +66,7 @@ TESTS_progs_M = \ gem_request_retire \ gem_reset_stats \ gem_ringfill \ + gem_scheduler \ gem_set_tiling_vs_blt \ gem_softpin \ gem_stolen \
tests/gem_scheduler.c new file +451 -0
451 lines not on this page · raw message
Signature · 6 lines
1.9.1 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
Re: [PATCH i-g-t v2 4/7] tests/gem_scheduler: Add gem_scheduler test
tests/gem_scheduler.c line 59
Quoted 8 lines
tests/gem_scheduler.c new file +8
-0+static struct ring { +const char *name; +int id; +bool exists; +} rings[] = { + {"render" ,I915_EXEC_RENDER , false }, + {"bsd1" ,I915_EXEC_BSD |1 <<13 , false }, + {"bsd2" ,I915_EXEC_BSD |2 <<13 , false },
This is wrong. The timeline is coupled to the exec_id, which is the same for "both" BSD engines. To fix that, properly split up the two rings with separate ids and deprecate HAS_BSD2.
tests/gem_scheduler.c line 64
Quoted 5 lines
tests/gem_scheduler.c new file +5
-0+ { "blt", I915_EXEC_BLT, false }, + { "vebox", I915_EXEC_VEBOX, false }, +}; + +#define NBR_RINGS (sizeof(rings)/sizeof(struct ring))
Also see intel_execution_engines to save on duplicating code. -Chris
Signature · 5 lines
Chris Wilson, Intel Open Source Technology Centre _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
Re: [PATCH i-g-t v2 4/7] tests/gem_scheduler: Add gem_scheduler test
I don't really understand your statement, can you elaborate please. What do you mean by timeline? Are you saying the driver needs changing? By deprecate HAS_BSD2 did you mean some change that would remove the need for gem_has_bsd2()? Doesn't I915_EXEC_BSD | 1<<13 and I915_EXEC_BSD | 2<<13 constitute separate exec_id's?
//Derek
-----Original Message-----
From: Chris Wilson [mailto:[email protected]]
Sent: Wednesday, March 2, 2016 8:15 PM
To: Morton, Derek J <[email protected]>
Cc: [email protected]; [email protected]
Subject: Re: [Intel-gfx] [PATCH i-g-t v2 4/7] tests/gem_scheduler: Add gem_scheduler test
tests/gem_scheduler.c line 59
Quoted 8 lines
tests/gem_scheduler.c new file +8
-0+static struct ring { +const char *name; +int id; +bool exists; +} rings[] = { + {"render" ,I915_EXEC_RENDER , false }, + {"bsd1" ,I915_EXEC_BSD |1 <<13 , false }, + {"bsd2" ,I915_EXEC_BSD |2 <<13 , false },
This is wrong. The timeline is coupled to the exec_id, which is the same for "both" BSD engines. To fix that, properly split up the two rings with separate ids and deprecate HAS_BSD2.
tests/gem_scheduler.c line 64
Quoted 4 lines
tests/gem_scheduler.c new file +4
-0+ { "blt", I915_EXEC_BLT, false }, + { "vebox", I915_EXEC_VEBOX, false }, }; + +#define NBR_RINGS (sizeof(rings)/sizeof(struct ring))
Also see intel_execution_engines to save on duplicating code. -Chris
--
Chris Wilson, Intel Open Source Technology Centre
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
Re: [PATCH i-g-t v2 4/7] tests/gem_scheduler: Add gem_scheduler test
In reply to Chris WilsonQuoted 13 lines · Chris Wilson
tests/gem_scheduler.c line 59
Quoted 8 lines
tests/gem_scheduler.c new file +8
-0+static struct ring { +const char *name; +int id; +bool exists; +} rings[] = { + {"render" ,I915_EXEC_RENDER , false }, + {"bsd1" ,I915_EXEC_BSD |1 <<13 , false }, + {"bsd2" ,I915_EXEC_BSD |2 <<13 , false },This is wrong. The timeline is coupled to the
exec_id, which is the same for "both" BSD engines. To fix that, properly split up the two rings with separate ids and deprecateHAS_BSD2.
Quoted 8 lines
tests/gem_scheduler.c line 64
Quoted 5 lines
tests/gem_scheduler.c new file +5
-0+ { "blt", I915_EXEC_BLT, false }, + { "vebox", I915_EXEC_VEBOX, false }, +}; + +#define NBR_RINGS (sizeof(rings)/sizeof(struct ring))Also see
intel_execution_enginesto save on duplicating code. -Chris
exec_id is indeed the same for both BSD engines, but it is used ONLY ini915_gem_busy_ioctl(), whose result can tell you that "a" BSD engine is busy but not which one -- probably callers don't care anyway.
.Dave.
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH v2 5/7 igt/gem_ctx_param_basic: Updated to support scheduler priority interface
In reply to Derek MortonFrom: John Harrison <[email protected]>
The GPU scheduler has added an execution priority level to the context object. There is an IOCTL interface to allow user apps/libraries to set this priority. This patch updates the context paramter IOCTL test to include the new interface.
For: VIZ-1587
--- lib/ioctl_wrappers.h | 1 + tests/gem_ctx_param_basic.c | 34 +++++++++++++++++++++++++++++++++- 2 files changed, 34 insertions(+), 1 deletion(-)
lib/ioctl_wrappers.h +1 -0
@@ -107,6 +107,7 @@ struct local_i915_gem_context_param {#define LOCAL_CONTEXT_PARAM_BAN_PERIOD 0x1#define LOCAL_CONTEXT_PARAM_NO_ZEROMAP 0x2#define LOCAL_CONTEXT_PARAM_GTT_SIZE 0x3 +#define LOCAL_CONTEXT_PARAM_PRIORITY 0x4uint64_t value; };void gem_context_require_ban_period (int fd);
tests/gem_ctx_param_basic.c +33 -1
@@ -147,10 +147,42 @@ igt_mainTEST_SUCCESS (LOCAL_IOCTL_I915_GEM_CONTEXT_SETPARAM ); } + ctx_param.param =LOCAL_CONTEXT_PARAM_PRIORITY ; + + igt_subtest("priority-root-set") { + ctx_param.context = ctx; + ctx_param.value =2048 ; +TEST_FAIL (LOCAL_IOCTL_I915_GEM_CONTEXT_SETPARAM ,EINVAL ); + ctx_param.value =-2048 ; +TEST_FAIL (LOCAL_IOCTL_I915_GEM_CONTEXT_SETPARAM ,EINVAL ); + ctx_param.value =512 ; +TEST_SUCCESS (LOCAL_IOCTL_I915_GEM_CONTEXT_SETPARAM ); + ctx_param.value =-512 ; +TEST_SUCCESS (LOCAL_IOCTL_I915_GEM_CONTEXT_SETPARAM ); + ctx_param.value =0 ; +TEST_SUCCESS (LOCAL_IOCTL_I915_GEM_CONTEXT_SETPARAM ); + } + + igt_subtest("priority-non-root-set") { + igt_fork(child, 1) { +igt_drop_root (); + + ctx_param.context = ctx; + ctx_param.value =512 ; +TEST_FAIL (LOCAL_IOCTL_I915_GEM_CONTEXT_SETPARAM ,EPERM ); + ctx_param.value =-512 ; +TEST_SUCCESS (LOCAL_IOCTL_I915_GEM_CONTEXT_SETPARAM ); + ctx_param.value =0 ; +TEST_SUCCESS (LOCAL_IOCTL_I915_GEM_CONTEXT_SETPARAM ); + } + +igt_waitchildren (); + } +/* NOTE: This testcase intentionally tests for the next free parameter * to catch ABI extensions. Don't "fix" this testcase without adding all * the tests for the new param first. */ - ctx_param.param =LOCAL_CONTEXT_PARAM_GTT_SIZE +1 ; + ctx_param.param =LOCAL_CONTEXT_PARAM_PRIORITY +1 ; igt_subtest("invalid-param-get") { ctx_param.context = ctx;
Signature · 6 lines
1.9.1 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH v2 6/7 tests/gem_scheduler: Add subtests to test batch priority behaviour
In reply to Derek MortonAdd subtests to test each ring to check batch buffers of a higher priority will be executed before batch buffers of a lower priority.
v2: Addressed review comments from Daniele Ceraolo Spurio
--- tests/gem_scheduler.c | 53 +++++++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 45 insertions(+), 8 deletions(-)
tests/gem_scheduler.c +45 -8
@@ -39,7 +39,8 @@IGT_TEST_DESCRIPTION ("Check scheduler behaviour. Basic tests ensure independant " "batch buffers of the same priority are executed in " -"submission order. Read-read tests ensure " +"submission order. Priority tests ensure higher priority " +"batch buffers are executed first. Read-read tests ensure " "batch buffers with a read dependency to the same buffer " "object do not block each other. Write-write dependency " "tests ensure batch buffers with a write dependency to a "
@@ -128,11 +129,23 @@ static void init_context(int *fd, drm_intel_bufmgr **bufmgr, int ringid)intel_batchbuffer_free (noop_bb); } -/* Basic test. Check batch buffers of the same priority and with no dependencies -* are executed in the order they are submitted. +static void set_priority (int fd,int value) +{ +struct local_i915_gem_context_param param; + param.context =0 ;/* Default context */ + param.size =0 ; + param.param =LOCAL_CONTEXT_PARAM_PRIORITY ; + param.value = (uint64_t )value; +gem_context_set_param (fd, ¶m); +} + +/* If 'priority' is 0, check batch buffers of the same priority and with +* no dependencies are executed in the order they are submitted. +* If 'priority' is set !0, check batch buffers of higher priority are +* executed before batch buffers of lower priority. */ #define NBR_BASIC_FDs (3) -static void run_test_basic (int in_flight,int ringid) +static void run_test_basic (int in_flight,int ringid,int priority) {int fd[NBR_BASIC_FDs];int loop;
@@ -152,6 +165,13 @@ static void run_test_basic(int in_flight, int ringid)for (loop=0 ; loop < NBR_BASIC_FDs; loop++)init_context (&(fd[loop]), &(bufmgr[loop]), ringid); +/* For high priority set priority of second context to overtake first +* For low priority set priority of first context to be overtaxen by second +*/ +if (priority >0 ) +set_priority (fd[2 ], priority); +else if (priority <0 ) +set_priority (fd[1 ], priority);/* Create buffer objects */ delay_bo =create_and_check_bo (bufmgr[0 ],"delay bo" );
@@ -201,9 +221,14 @@ static void run_test_basic(int in_flight, int ringid)igt_assert_f (igt_compare_timestamps (delay_buf[2 ], ts1_buf[0 ]),"Delay ts (0x%08" PRIx32") > TS1 ts (0x%08" PRIx32")\n" , delay_buf[2 ], ts1_buf[0 ]); -igt_assert_f (igt_compare_timestamps (ts1_buf[0 ], ts2_buf[0 ]), -"TS1 ts (0x%08" PRIx32") > TS2 ts (0x%08" PRIx32")\n" , - ts1_buf[0 ], ts2_buf[0 ]); +if (priority) +igt_assert_f (igt_compare_timestamps (ts2_buf[0 ], ts1_buf[0 ]), +"TS2 ts (0x%08" PRIx32") > TS1 ts (0x%08" PRIx32")\n" , + ts2_buf[0 ], ts1_buf[0 ]); +else +igt_assert_f (igt_compare_timestamps (ts1_buf[0 ], ts2_buf[0 ]), +"TS1 ts (0x%08" PRIx32") > TS2 ts (0x%08" PRIx32")\n" , + ts1_buf[0 ], ts2_buf[0 ]);/* Cleanup */ for (loop =0 ; loop < in_flight; loop++)
@@ -430,7 +455,19 @@ igt_mainfor (loop=0 ; loop <NBR_RINGS ; loop++) igt_subtest_f("%s-basic", rings[loop].name) {gem_require_ring (fd, rings[loop].id); -run_test_basic (in_flight, rings[loop].id); +run_test_basic (in_flight, rings[loop].id, false); + } + +for (loop=0 ; loop <NBR_RINGS ; loop++) + igt_subtest_f("%s-priority-high", rings[loop].name) { +gem_require_ring (fd, rings[loop].id); +run_test_basic (in_flight, rings[loop].id,1000 ); + } + +for (loop=0 ; loop <NBR_RINGS ; loop++) + igt_subtest_f("%s-priority-low", rings[loop].name) { +gem_require_ring (fd, rings[loop].id); +run_test_basic (in_flight, rings[loop].id,-1000 ); }for (loop=0 ; loop <NBR_RINGS ; loop++)
Signature · 6 lines
1.9.1 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH v2 7/7 gem_scheduler: Added subtests to test priority bumping
In reply to Derek MortonWhen a higher priority batch buffer bumps a lower priority batch buffer all batch buffers in the scheduler queue get a small priority increase. Added a subtest to check this behaviour.
Requested by Joonas Lahtinen during scheduler code review
--- tests/gem_scheduler.c | 134 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 134 insertions(+)
tests/gem_scheduler.c +134 -0
@@ -246,6 +246,134 @@ static void run_test_basic(int in_flight, int ringid, int priority)free (in_flight_bbs); } + +/* Test priority bump behaviour. +* When a batch buffer is bumped by a higher priority batch buffer all other +* batch buffers in the scheduler queue get their priority increased slightly. +* Submit two delay batch buffers then fill the in flight queue. Submit a +* slightly reduced priority batch buffer and a normal priority batch buffer. +* When the first delay batch buffer completes priority bumping should occur. +* Submit another normal priority batch buffer. It should not overtake the +* reduced priority batch buffer as its priority has been bumped. +*/ +#define NBR_PRIO_BUMP_FDs (4) +static void run_test_priority_bump (int in_flight,int ringid) +{ +int fd[NBR_PRIO_BUMP_FDs]; +int loop; +drm_intel_bufmgr *bufmgr[NBR_PRIO_BUMP_FDs]; +uint32_t *delay_buf, *delay2_buf, *ts1_buf, *ts2_buf, *ts3_buf; +struct intel_batchbuffer *ts1_bb, *ts2_bb, *ts3_bb; +struct intel_batchbuffer **in_flight_bbs; +uint32_t calibrated_1s; +drm_intel_bo *delay_bo, *delay2_bo ,*ts1_bo, *ts2_bo, *ts3_bo; + + in_flight_bbs =malloc (in_flight *sizeof (struct intel_batchbuffer *)); +igt_assert (in_flight_bbs); + +/* Need multiple i915 fd's. Scheduler will not change execution order of +* batch buffers from the same context. +*/ +for (loop=0 ; loop < NBR_PRIO_BUMP_FDs; loop++) +init_context (&(fd[loop]), &(bufmgr[loop]), ringid); + +/* Lower priority of first timestamp batch buffer +* Second timestamp batch buffer should overtake the first +* Second should then get bumped so the third does not overtake it +*/ +set_priority (fd[1 ],-1 ); + +/* Create buffer objects */ + delay_bo =create_and_check_bo (bufmgr[0 ],"delay bo" ); + delay2_bo =create_and_check_bo (bufmgr[0 ],"delay bo2" ); + ts1_bo =create_and_check_bo (bufmgr[1 ],"ts1 bo" ); + ts2_bo =create_and_check_bo (bufmgr[2 ],"ts2 bo" ); + ts3_bo =create_and_check_bo (bufmgr[3 ],"ts23 bo" ); + +/* Put some non zero values in the delay bo */ + { +uint32_t data=0xffffffff ; +drm_intel_bo_subdata (delay_bo,0 ,4 , &data); +drm_intel_bo_subdata (delay2_bo,0 ,4 , &data); + } + + calibrated_1s =igt_calibrate_delay_bb (fd[0 ], bufmgr[0 ], ringid); + +/* Batch buffers to fill the in flight queue */ + in_flight_bbs[0 ] =create_delay_bb (fd[0 ], bufmgr[0 ], ringid, calibrated_1s, delay_bo); + in_flight_bbs[1 ] =create_delay_bb (fd[0 ], bufmgr[0 ], ringid, calibrated_1s, delay2_bo); +for (loop =2 ; loop < in_flight; loop++) + in_flight_bbs[loop] =create_noop_bb (fd[0 ], bufmgr[0 ],5 ); + +/* Extra batch buffers in the scheduler queue */ + ts1_bb =create_timestamp_bb (fd[1 ], bufmgr[1 ], ringid, ts1_bo,NULL , false); + ts2_bb =create_timestamp_bb (fd[2 ], bufmgr[2 ], ringid, ts2_bo,NULL , false); + ts3_bb =create_timestamp_bb (fd[3 ], bufmgr[3 ], ringid, ts3_bo,NULL , false); + +/* Flush batchbuffers */ +for (loop =0 ; loop < in_flight; loop++) +intel_batchbuffer_flush_on_ring (in_flight_bbs[loop], ringid); +intel_batchbuffer_flush_on_ring (ts1_bb, ringid); +intel_batchbuffer_flush_on_ring (ts2_bb, ringid); + +/* This will not return until the bo has finished executing */ +drm_intel_bo_map (delay_bo,0 ); +/* Once the first delay is complete and any bumping has occured, submit +* the final batch buffer +*/ +intel_batchbuffer_flush_on_ring (ts3_bb, ringid); + +drm_intel_bo_map (delay2_bo,0 ); +drm_intel_bo_map (ts1_bo,0 ); +drm_intel_bo_map (ts2_bo,0 ); +drm_intel_bo_map (ts3_bo,0 ); + + delay_buf = delay_bo->virtual; + delay2_buf = delay2_bo->virtual; + ts1_buf = ts1_bo->virtual; + ts2_buf = ts2_bo->virtual; + ts3_buf = ts3_bo->virtual; + +igt_debug ("Delay Timestamp = 0x%08" PRIx32"\n" , delay_buf[2 ]); +igt_debug ("Delay Timestamp = 0x%08" PRIx32"\n" , delay2_buf[2 ]); +igt_debug ("TS1 Timestamp = 0x%08" PRIx32"\n" , ts1_buf[0 ]); +igt_debug ("TS2 Timestamp = 0x%08" PRIx32"\n" , ts2_buf[0 ]); +igt_debug ("TS3 Timestamp = 0x%08" PRIx32"\n" , ts3_buf[0 ]); + +/* buf[0] in the target buffer should be 0 if the batch buffer completed */ +igt_assert_f (delay_buf[0 ] ==0 , +"delay_buf[0] expected 0x0, got 0x%" PRIx32"\n" , delay_buf[0 ]); + +igt_assert_f (igt_compare_timestamps (delay_buf[2 ], ts1_buf[0 ]), +"Delay ts (0x%08" PRIx32") > TS1 ts (0x%08" PRIx32")\n" , + delay_buf[2 ], ts1_buf[0 ]); + +igt_assert_f (igt_compare_timestamps (ts2_buf[0 ], ts1_buf[0 ]), +"TS2 ts (0x%08" PRIx32") > TS1 ts (0x%08" PRIx32")\n" , + ts2_buf[0 ], ts1_buf[0 ]); + +igt_assert_f (igt_compare_timestamps (ts1_buf[0 ], ts3_buf[0 ]), +"TS1 ts (0x%08" PRIx32") > TS3 ts (0x%08" PRIx32")\n" , + ts1_buf[0 ], ts3_buf[0 ]); + +/* Cleanup */ +for (loop =0 ; loop < in_flight; loop++) +intel_batchbuffer_free (in_flight_bbs[loop]); +intel_batchbuffer_free (ts1_bb); +intel_batchbuffer_free (ts2_bb); + +drm_intel_bo_unreference (delay_bo); +drm_intel_bo_unreference (delay2_bo); +drm_intel_bo_unreference (ts1_bo); +drm_intel_bo_unreference (ts2_bo); +drm_intel_bo_unreference (ts3_bo); +for (loop =0 ; loop < NBR_PRIO_BUMP_FDs; loop++) { +drm_intel_bufmgr_destroy (bufmgr[loop]); +close (fd[loop]); + } +free (in_flight_bbs); +} +/* Dependency test. * write=0, Submit batch buffers with read dependencies to all rings. Delay one * with a long executing batch buffer. Check the others are not held up.
@@ -482,6 +610,12 @@ igt_mainrun_test_dependency (in_flight, loop, true); } +for (loop=0 ; loop <NBR_RINGS ; loop++) + igt_subtest_f("%s-priority-bump", rings[loop].name) { +gem_require_ring (fd, rings[loop].id); +run_test_priority_bump (in_flight, rings[loop].id); + } + igt_fixture {close (fd); }
Signature · 6 lines
1.9.1 _______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx