Scheduler tests
v3 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 adds library code used by the tests. There are other tests under development which are planned to reuse some of these libraries. Patch 3 adds some basic tests, read dependency tests and write dependency tests. Patch 4 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 5 adds subtests to check sheduler behaviour for batch buffers submitted at differing priorities.
Patch 6 adds subtests to check priority bumping behaviour.
v2: Updates for comments from Daniele Ceraolo Spurio and Daniel Vetter
Added tests requested by Joonas Lahtinen
v3: Removed the patch to update gem_has_ring() and updated the test to
use BSD if there is 1 ring and BSD1 / BSD2 if there are two.
Derek Morton (5):
ioctl_wrappers: make gem_has_ring non static 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 | 2 +- lib/ioctl_wrappers.h | 2 + tests/Makefile.sources | 1 + tests/gem_ctx_param_basic.c | 34 ++- tests/gem_scheduler.c | 630 ++++++++++++++++++++++++++++++++++++++++++++ 7 files changed, 1060 insertions(+), 7 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 v3 1/6 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
Re: [PATCH i-g-t v3 1/6] ioctl_wrappers: make gem_has_ring non static
Quoted 14 lines · Derek Morton
For tests that use multiple rings to test interactions it is useful to know if a ring exists without triggering the test to skip.
Signed-off-by Derek Morton <[email protected]>--- lib/ioctl_wrappers.c | 2 +- lib/ioctl_wrappers.h | 1 + 2 files changed, 2 insertions(+), 1 deletion(-)lib/ioctl_wrappers.c +0
-0
lib/ioctl_wrappers.c void gem_require_caching(int fd) · line 1399
Quoted 5 lines
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)
If this becomes non-static it will need documentation, also to explain how it differs from gem_has_enable_ring.
Regards,
Daniele
Quoted 8 lines
lib/ioctl_wrappers.c +0
-0{uint32_t bbe =MI_BATCH_BUFFER_END ;struct drm_i915_gem_execbuffer2 execbuf;lib/ioctl_wrappers.h +0
-0
lib/ioctl_wrappers.h uint64_t gem_global_aperture_size(int fd); · line 156
Quoted 7 lines
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);
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
Re: [PATCH i-g-t v3 1/6] ioctl_wrappers: make gem_has_ring non static
Quoted 27 lines
-----Original Message-----
From: Ceraolo Spurio, Daniele
Sent: Monday, March 14, 2016 12:30 PM
To: Morton, Derek J <[email protected]>; [email protected]
Subject: Re: [PATCH i-g-t v3 1/6]ioctl_wrappers: makegem_has_ringnon staticQuoted 17 lines · Derek Morton
For tests that use multiple rings to test interactions it is useful to know if a ring exists without triggering the test to skip.
Signed-off-by Derek Morton <[email protected]>--- lib/ioctl_wrappers.c | 2 +- lib/ioctl_wrappers.h | 1 + 2 files changed, 2 insertions(+), 1 deletion(-)lib/ioctl_wrappers.c index renamed from lib/ioctl_wrappers.c +0
-05d49729..f42e2c9 100644
lib/ioctl_wrappers.c +0
-0@@ -1396,7 +1396,7 @@ void gem_require_caching(int fd) errno =0 ; }
Quoted 4 lines
lib/ioctl_wrappers.c void gem_require_caching(int fd) · line 1399
Quoted 2 lines
lib/ioctl_wrappers.c +1
-1-static int gem_has_ring (int fd,int ring) +int gem_has_ring (int fd,int ring)If this becomes non-static it will need documentation, also to explain how it differs from
gem_has_enable_ring.
This patch is no longer needed. Chris Wilson has separately pushed a patch which makes this function non static. Chase him for the documentation :-)
//Derek
Quoted 15 lines
Regards,
DanieleQuoted 11 lines
lib/ioctl_wrappers.c +0
-0{uint32_t bbe =MI_BATCH_BUFFER_END ; struct drm_i915_gem_execbuffer2 execbuf; diff --git
a/lib/ioctl_wrappers.hb/lib/ioctl_wrappers.hindex f59eafb..e095c41 100644lib/ioctl_wrappers.h +0
-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);
Quoted 6 lines
lib/ioctl_wrappers.h uint64_t gem_global_aperture_size(int fd); · line 156
Quoted 4 lines
lib/ioctl_wrappers.h +1
-0+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);
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH v3 2/6 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
Re: [PATCH i-g-t v3 2/6] lib/intel_batchbuffer: Add functions to be used in the scheduler test
Quoted 142 lines · Derek Morton
Adds 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 SpurioSigned-off-by Derek Morton <[email protected]>--- lib/intel_batchbuffer.c | 384 +++++++++++++++++++++++++++++++++++++++++++++++- lib/intel_batchbuffer.h | 14 ++ 2 files changed, 393 insertions(+), 5 deletions(-)lib/intel_batchbuffer.c +73
-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. +*/
lib/intel_batchbuffer.c igt_media_spinfunc_t igt_get_media_spinfunc(int devid) · line 897
Quoted 10 lines
lib/intel_batchbuffer.c +10
-0+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
ringid is the execution flag of the ring
Quoted 11 lines
lib/intel_batchbuffer.c +11
-0+* 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
lib/intel_batchbuffer.c igt_media_spinfunc_t igt_get_media_spinfunc(int devid) · line 918
Quoted 10 lines
lib/intel_batchbuffer.c +10
-0+* 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,
Now that you're passing the batch from the outside you're only using the fd to get the gen. However, the gen is already saved inside the batch so you could get it from there and drop the fd parameter. the bb_address_size_dw would need to be modified to get the batch or the gen as a parameter, but it looks like an ok change to me. Same reasoning applies to other functions you've added.
Quoted 25 lines
lib/intel_batchbuffer.c +25
-0+ 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 );
lib/intel_batchbuffer.c igt_media_spinfunc_t igt_get_media_spinfunc(int devid) · line 953
Quoted 10 lines
lib/intel_batchbuffer.c +10
-0+/* 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);
for clarity the sampling of jump offset could go above the ALU comment (and have a comment of its own)
Quoted 47 lines
lib/intel_batchbuffer.c +47
-0+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:
lib/intel_batchbuffer.c igt_media_spinfunc_t igt_get_media_spinfunc(int devid) · line 1010
Quoted 10 lines
lib/intel_batchbuffer.c +10
-0+* 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)
I still think that the timestamp capture should be its own function, because it could be useful to add it multiple time in the same batch. You could split that out in a separate function and then call it from igt_create_timestamp_bb, i.e. something like:
igt_emit_timestamp_sample(struct intel_batchbuffer *batch, int ringid, drm_intel_bo *dest, unsigned dest_offset);
Personally I also still don't really like the "load" handling, which is not related to timestamps in any way. won't oppose it if other people are ok with it though.
Quoted 10 lines
lib/intel_batchbuffer.c +10
-0+{ +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);
lib/intel_batchbuffer.c igt_media_spinfunc_t igt_get_media_spinfunc(int devid) · line 1030
Quoted 10 lines
lib/intel_batchbuffer.c +10
-0+ +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 ) {
style: we tend to put a space between if/while/for and the parenthesis, but you didn't anywhere in this patch
lib/intel_batchbuffer.c igt_media_spinfunc_t igt_get_media_spinfunc(int devid) · line 1038
Quoted 8 lines
lib/intel_batchbuffer.c +8
-0+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 {
weird indent
Quoted 57 lines
lib/intel_batchbuffer.c +57
-0+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 ];
lib/intel_batchbuffer.c igt_media_spinfunc_t igt_get_media_spinfunc(int devid) · line 1105
Quoted 10 lines
lib/intel_batchbuffer.c +10
-0+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];*/
dead code
lib/intel_batchbuffer.c igt_media_spinfunc_t igt_get_media_spinfunc(int devid) · line 1109
Quoted 4 lines
lib/intel_batchbuffer.c +4
-0+ +if (calibrated_ring_value ==NULL ) { +int count; +for (count =0 ; intel_execution_engines[count].name !=NULL ; count++) {}
Can you add a comment to explain why this loop is required to count the engines? it could also be possible to add a function in igt_gt to return the exec_engines count, but I'm not sure that's worth the effort. Also, BSD1 and BSD2 will have the same calibration value so you can calibrate only once for I915_EXEC_BSD
Quoted 4 lines
lib/intel_batchbuffer.c +4
-0+ calibrated_ring_value =calloc (count,sizeof (uint32_t )); +igt_assert (calibrated_ring_value); + } +
lib/intel_batchbuffer.c igt_media_spinfunc_t igt_get_media_spinfunc(int devid) · line 1123
Quoted 10 lines
lib/intel_batchbuffer.c +10
-0+/* 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++;
Could use a for loop instead of incrementing on each iteration.
lib/intel_batchbuffer.c igt_media_spinfunc_t igt_get_media_spinfunc(int devid) · line 1130
Quoted 7 lines
lib/intel_batchbuffer.c +7
-0+ } + + 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 */ + {
This bracket used to give scope to the data variable doesn't look essential as there are no other uses of a variable named data in this function
lib/intel_batchbuffer.c igt_media_spinfunc_t igt_get_media_spinfunc(int devid) · line 1131
Quoted 1 line
lib/intel_batchbuffer.c +1
-0+uint32_t data=0xffffffff ;
style: spaces around "="
lib/intel_batchbuffer.c igt_media_spinfunc_t igt_get_media_spinfunc(int devid) · line 1132
Quoted 1 line
lib/intel_batchbuffer.c +1
-0+drm_intel_bo_subdata (target_bo,0 ,4 , &data);
the subdata call can fail. In the tree we don't check the return code on every usage, but I believe it is safer to do it. do_or_die() should do the trick.
Quoted 4 lines
lib/intel_batchbuffer.c +4
-0+ } + + bb =intel_batchbuffer_alloc (bufmgr,intel_get_drm_devid (fd)); +igt_assert (bb);
lib/intel_batchbuffer.c igt_media_spinfunc_t igt_get_media_spinfunc(int devid) · line 1146
Quoted 10 lines
lib/intel_batchbuffer.c +10
-0+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);
Why are you using a 2 words array to read only 1 word? what's the purpose of buf[1]? if you don't need it you could reuse the data variable from above
Quoted 31 lines
lib/intel_batchbuffer.c +31
-0+ +/* 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
lib/intel_batchbuffer.c igt_media_spinfunc_t igt_get_media_spinfunc(int devid) · line 1187
Quoted 10 lines
lib/intel_batchbuffer.c +10
-0+* 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)
This will return true if ts2 = 0xFFFFFFFF and ts1 = 0x00000001 even if ts1 came after ts2 due to wrapping.
lib/intel_batchbuffer.c igt_media_spinfunc_t igt_get_media_spinfunc(int devid) · line 1193
Quoted 6 lines
lib/intel_batchbuffer.c +6
-0+return true; + else if ((ts1 > 0x80000000) && (ts2 < 0x40000000)) +return true;/* Assuming timestamp counter wrapped */ + else + return false; +}
You could use something like:
return (int32_t)(ts2 - ts1) > 0;
This should give you the right result as long as the 2 samples are not more than ~50% of the timestamp period apart
Regards,
Daniele
Quoted 13 lines
lib/intel_batchbuffer.h +5
-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); +
lib/intel_batchbuffer.h typedef void (*igt_media_spinfunc_t)(struct intel_batchbuffer *batch, · line 340
Quoted 10 lines
lib/intel_batchbuffer.h +9
-0+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
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
Re: [PATCH i-g-t v3 2/6] lib/intel_batchbuffer: Add functions to be used in the scheduler test
Quoted 157 lines
-----Original Message-----
From: Ceraolo Spurio, Daniele
Sent: Monday, March 14, 2016 12:16 PM
To: Morton, Derek J <[email protected]>; [email protected]
Subject: Re: [PATCH i-g-t v3 2/6]lib/intel_batchbuffer: Add functions to be used in the scheduler testQuoted 146 lines · Derek Morton
Adds 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 SpurioSigned-off-by Derek Morton <[email protected]>--- lib/intel_batchbuffer.c | 384 +++++++++++++++++++++++++++++++++++++++++++++++- lib/intel_batchbuffer.h | 14 ++ 2 files changed, 393 insertions(+), 5 deletions(-)lib/intel_batchbuffer.c index renamed from lib/intel_batchbuffer.c +0
-0692521f..30e78c5 100644
lib/intel_batchbuffer.c +2
-2@@ -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.lib/intel_batchbuffer.c +1
-1@@ -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>lib/intel_batchbuffer.c +67
-0@@ -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; +}
Quoted 8 lines
lib/intel_batchbuffer.c igt_media_spinfunc_t igt_get_media_spinfunc(int devid) · line 897
Quoted 6 lines
lib/intel_batchbuffer.c +6
-0+ +/** +* 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 ringid is the execution flag of the ring
Ok
Quoted 19 lines
Quoted 19 lines
+ * 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 specifiedlib/intel_batchbuffer.c +14
-0+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.
Quoted 8 lines
Quoted 6 lines
+ * 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, structintel_batchbuffer*batch,Now that you're passing the batch from the outside you're only using the fd to get the gen. However, the gen is already saved inside the batch so you could get it from there and drop the fd parameter. the
bb_address_size_dwwould need to be modified to get the batch or the gen as a parameter, but it looks like an ok change to me. Same reasoning applies to other functions you've added.
Ok
Quoted 31 lines
Quoted 31 lines
lib/intel_batchbuffer.c +30
-0+ 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 );
Quoted 8 lines
lib/intel_batchbuffer.c igt_media_spinfunc_t igt_get_media_spinfunc(int devid) · line 953
Quoted 6 lines
lib/intel_batchbuffer.c +6
-0+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);for clarity the sampling of jump offset could go above the ALU comment (and have a comment of its own)
Ok
Quoted 65 lines
Quoted 51 lines
lib/intel_batchbuffer.c +50
-0+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 lib/intel_batchbuffer.c igt_media_spinfunc_t igt_get_media_spinfunc(int devid)
Quoted 10 lines
lib/intel_batchbuffer.c +10
-0+* 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)I still think that the timestamp capture should be its own function, because it could be useful to add it multiple time in the same batch. You could split that out in a separate function and then call it from
igt_create_timestamp_bb, i.e. something like:
Quoted 1 line
igt_emit_timestamp_sample(struct intel_batchbuffer *batch, int ringid, drm_intel_bo *dest, unsigned dest_offset);
I can create a separate function. Will make it static for now as it is not needed outside this file.
Quoted 18 lines
Personally I also still don't really like the "load" handling, which is not related to timestamps in any way. won't oppose it if other people are ok with it though.
Quoted 15 lines
lib/intel_batchbuffer.c +15
-0+{ +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);
Quoted 8 lines
lib/intel_batchbuffer.c igt_media_spinfunc_t igt_get_media_spinfunc(int devid) · line 1030
Quoted 6 lines
lib/intel_batchbuffer.c +6
-0+OUT_RELOC (dest,I915_GEM_DOMAIN_INSTRUCTION , +I915_GEM_DOMAIN_INSTRUCTION ,DWORDS_TO_BYTES (0 )); + +ADVANCE_BATCH (); + +if (load !=NULL ) {style: we tend to put a space between if/while/for and the parenthesis, but you didn't anywhere in this patch
Ok
Quoted 11 lines
lib/intel_batchbuffer.c igt_media_spinfunc_t igt_get_media_spinfunc(int devid) · line 1038
Quoted 9 lines
lib/intel_batchbuffer.c +8
-0+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 {weird indent
What is weird? The if and else line up and it is all tabs.
Quoted 61 lines
Quoted 61 lines
lib/intel_batchbuffer.c +60
-0+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;
Quoted 8 lines
lib/intel_batchbuffer.c igt_media_spinfunc_t igt_get_media_spinfunc(int devid) · line 1105
Quoted 6 lines
lib/intel_batchbuffer.c +6
-0+drm_intel_bo *target_bo; +int ring_index=0 ; + +/* igt_assert(ringid < 8); +if(calibrated_ring_value[ringid] != 0) +return calibrated_ring_value[ringid];*/ dead code
Removed
Quoted 9 lines
lib/intel_batchbuffer.c igt_media_spinfunc_t igt_get_media_spinfunc(int devid)
Quoted 6 lines
lib/intel_batchbuffer.c +5
-0+ +if (calibrated_ring_value ==NULL ) { +int count; +for (count =0 ; intel_execution_engines[count].name !=NULL ; +count++) {}Can you add a comment to explain why this loop is required to count the engines? it could also be possible to add a function in
igt_gtto return theexec_enginescount, but I'm not sure that's worth the effort. Also, BSD1 and BSD2 will have the same calibration value so you can calibrate only once forI915_EXEC_BSD
Can add a comment. It will require adding a load of logic to use a single calibration value for BSD1 and BSD2, and that would then make the assumption that they would have the same calibration value. I would prefer not to make such assumptions.
Quoted 17 lines
Quoted 5 lines
lib/intel_batchbuffer.c +4
-0+ calibrated_ring_value =calloc (count,sizeof (uint32_t )); +igt_assert (calibrated_ring_value); + } +lib/intel_batchbuffer.c igt_media_spinfunc_t igt_get_media_spinfunc(int devid) · line 1123
Quoted 10 lines
lib/intel_batchbuffer.c +10
-0+/* 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++;Could use a for loop instead of incrementing on each iteration.
Ok
Quoted 93 lines
lib/intel_batchbuffer.c igt_media_spinfunc_t igt_get_media_spinfunc(int devid) · line 1130
Quoted 8 lines
lib/intel_batchbuffer.c +7
-0+ } + + 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 */ + {This bracket used to give scope to the data variable doesn't look essential as there are no other uses of a variable named data in this function
lib/intel_batchbuffer.c igt_media_spinfunc_t igt_get_media_spinfunc(int devid) · line 1131
Quoted 1 line
lib/intel_batchbuffer.c +1
-0+uint32_t data=0xffffffff ;style: spaces around "="
lib/intel_batchbuffer.c igt_media_spinfunc_t igt_get_media_spinfunc(int devid) · line 1132
Quoted 1 line
lib/intel_batchbuffer.c +1
-0+drm_intel_bo_subdata (target_bo,0 ,4 , &data);the subdata call can fail. In the tree we don't check the return code on every usage, but I believe it is safer to do it.
do_or_die()should do the trick.Quoted 4 lines
lib/intel_batchbuffer.c +4
-0+ } + + bb =intel_batchbuffer_alloc (bufmgr,intel_get_drm_devid (fd)); +igt_assert (bb);lib/intel_batchbuffer.c igt_media_spinfunc_t igt_get_media_spinfunc(int devid) · line 1146
Quoted 10 lines
lib/intel_batchbuffer.c +10
-0+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);Why are you using a 2 words array to read only 1 word? what's the purpose of buf[1]? if you don't need it you could reuse the data variable from above
Quoted 34 lines
lib/intel_batchbuffer.c +34
-0+ +/* 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 lib/intel_batchbuffer.c igt_media_spinfunc_t igt_get_media_spinfunc(int devid) · line 1187
Quoted 10 lines
lib/intel_batchbuffer.c +10
-0+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)This will return true if ts2 =
0xFFFFFFFFand ts1 =0x00000001even if ts1 came after ts2 due to wrapping.lib/intel_batchbuffer.c igt_media_spinfunc_t igt_get_media_spinfunc(int devid) · line 1193
Quoted 6 lines
lib/intel_batchbuffer.c +6
-0+return true; + else if ((ts1 > 0x80000000) && (ts2 < 0x40000000)) +return true;/* Assuming timestamp counter wrapped */ + else + return false; +}You could use something like:
Quoted 1 line
return (int32_t)(ts2 - ts1) > 0;
Ok
Quoted 15 lines
This should give you the right result as long as the 2 samples are not more than ~50% of the timestamp period apart
Regards,
DanieleQuoted 9 lines
lib/intel_batchbuffer.h index renamed from lib/intel_batchbuffer.h +0
-0869747d..5b66fa3 100644
lib/intel_batchbuffer.h +0
-0@@ -323,4 +323,18 @@ typedef void (*igt_media_spinfunc_t)(structintel_batchbuffer *batch, igt_media_spinfunc_t igt_get_media_spinfunc(int devid);
Quoted 18 lines
Quoted 6 lines
lib/intel_batchbuffer.h +6
-0+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,lib/intel_batchbuffer.h typedef void (*igt_media_spinfunc_t)(struct intel_batchbuffer *batch, · line 340
Quoted 10 lines
lib/intel_batchbuffer.h +9
-0+ 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
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH v3 3/6 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
v3: Added logic to use generic BSD ring if there is 1 and BSD1 / BSD2 if there
are 2.
--- tests/Makefile.sources | 1 + tests/gem_scheduler.c | 459 +++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 460 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 +459 -0
459 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 v3 3/6] tests/gem_scheduler: Add gem_scheduler test
Quoted 102 lines · Derek Morton
This 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
v3: Added logic to use generic BSD ring if there is 1 and BSD1 / BSD2 if there
are 2.Signed-off-by Derek Morton<[email protected]>--- tests/Makefile.sources | 1 + tests/gem_scheduler.c | 459 +++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 460 insertions(+)create mode 100644
tests/gem_scheduler.ctests/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 +52
-0@@ -0,0 +1,459 @@ +/* +* Copyright © 2016 Intel Corporation +* +* 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 without limitation +* the rights to use, copy, modify, merge, publish, distribute, sublicense, +* 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 NONINFRINGEMENT. IN NO EVENT SHALL +* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR 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. +* +* Authors: +* Derek Morton<[email protected]> +* +*/ + +#include "igt.h" +#include <unistd.h> +#include <stdlib.h> +#include <stdint.h> +#include <stdio.h> +#include <string.h> +#include <inttypes.h> +#include <time.h> +#include <sys/stat.h> +#include <sys/ioctl.h> +#include <fcntl.h> + +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 " +"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 " +"buffer object will be executed in submission order but " +"will not block execution of other independant batch " +"buffers." ); + +#define SEC_TO_NSEC (1000 * 1000 * 1000) + +static struct ring {
tests/gem_scheduler.c line 62
Quoted 10 lines
tests/gem_scheduler.c new file +10
-0+const char *name; +int id; +bool exists; +} rings[] = { + { "render", I915_EXEC_RENDER, false }, + { "bsd", I915_EXEC_BSD , false }, + { "bsd2", I915_EXEC_BSD | 2<<13, false }, + { "blt", I915_EXEC_BLT, false }, + { "vebox", I915_EXEC_VEBOX, false }, +};
If you can't use intel_execution_engines could you add a comment to explain why? also considering the renaming going on in the kernel you cold replace "ring" with "engine"
tests/gem_scheduler.c line 68
Quoted 6 lines
tests/gem_scheduler.c new file +6
-0+ +#define NBR_RINGS (sizeof(rings)/sizeof(struct ring)) + +static void check_rings (int fd) { +int loop; +for (loop=0 ; loop <NBR_RINGS ; loop++) {
Style: space between for/if and "(" in this file
tests/gem_scheduler.c line 74
Quoted 6 lines
tests/gem_scheduler.c new file +6
-0+if (gem_has_ring (fd, rings[loop].id)) { +if (rings[loop].id == (I915_EXEC_BSD |2 <<13 )) { + rings[loop].exists =gem_has_bsd2 (fd); + } +else { + rings[loop].exists = true;
You're marking the VEBOX as existing so adding a gen requirement in this function would be nice. I know that the library you're using already requires gen8, but the requirement doesn't look to be explicit anywhere in this file so it would be nice to add it for clarity.
Quoted 41 lines
tests/gem_scheduler.c new file +41
-0+if (rings[loop].id ==I915_EXEC_BSD ) +/* If there is BSD2, need to make BSD1 +* explicit. +*/ +if (gem_has_bsd2 (fd)) + rings[loop].id |= (1 <<13 ); + } + } + } +} + +static drm_intel_bo *create_and_check_bo (drm_intel_bufmgr *bufmgr,const char *desc) +{ +drm_intel_bo *bo =drm_intel_bo_alloc (bufmgr, desc,BATCH_SZ ,BATCH_SZ ); +igt_assert_f (bo,"Failed allocating %s\n" , desc); +return bo; +} + +static struct intel_batchbuffer *create_delay_bb (int fd,drm_intel_bufmgr *bufmgr, +int ringid,uint32_t loops, +drm_intel_bo *dest) +{ +struct intel_batchbuffer *buffer; + buffer =intel_batchbuffer_alloc (bufmgr,intel_get_drm_devid (fd)); +igt_assert (buffer); +igt_create_delay_bb (fd, buffer, ringid, loops, dest); +return buffer; +} + +static struct intel_batchbuffer *create_timestamp_bb (int fd,drm_intel_bufmgr *bufmgr, +int ringid,drm_intel_bo *dest, +drm_intel_bo *load,bool write) +{ +struct intel_batchbuffer *buffer; + buffer =intel_batchbuffer_alloc (bufmgr,intel_get_drm_devid (fd)); +igt_assert (buffer); +igt_create_timestamp_bb (fd, buffer, ringid, dest, load, write); +return buffer; +} + +static struct intel_batchbuffer *create_noop_bb(int fd, drm_intel_bufmgr *bufmgr,
tests/gem_scheduler.c line 125
Quoted 10 lines
tests/gem_scheduler.c new file +10
-0+ int noops) +{ +struct intel_batchbuffer *buffer; + buffer =intel_batchbuffer_alloc (bufmgr,intel_get_drm_devid (fd)); +igt_assert (buffer); +igt_create_noop_bb (buffer, noops); +return buffer; +} + +static void init_context (int *fd,drm_intel_bufmgr **bufmgr,int ringid)
init_context might be a bit misleading as a name as you're not init_context might be a bit misleading as a name as you're not init_context might be a bit misleading as a name as you're not init_context might be a bit misleading as a name as you're not init_context might be a bit misleading as a name as you're not init_context might be a bit misleading as a name as you're not init_context might be a bit misleading as a name as you're not init_context might be a bit misleading as a name as you're not a ctx directly, although initializing
Quoted 34 lines
tests/gem_scheduler.c new file +34
-0+{ +struct intel_batchbuffer *noop_bb; + *fd =drm_open_driver (DRIVER_INTEL ); +igt_assert (*fd >=0 ); + *bufmgr =drm_intel_bufmgr_gem_init (*fd,BATCH_SZ ); +igt_assert (*bufmgr); +drm_intel_bufmgr_gem_enable_reuse (*bufmgr); +/* Send a noop batch buffer to force any deferred initialisation */ + noop_bb =create_noop_bb (*fd, *bufmgr,5 ); +intel_batchbuffer_flush_on_ring (noop_bb, 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. +*/ +#define NBR_BASIC_FDs (3) +static void run_test_basic (int in_flight,int ringid) +{ +int fd[NBR_BASIC_FDs]; +int loop; +drm_intel_bufmgr *bufmgr[NBR_BASIC_FDs]; +uint32_t *delay_buf, *ts1_buf, *ts2_buf; +struct intel_batchbuffer *ts1_bb, *ts2_bb; +struct intel_batchbuffer **in_flight_bbs; +uint32_t calibrated_1s; +drm_intel_bo *delay_bo, *ts1_bo, *ts2_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. +*/
tests/gem_scheduler.c line 169
Quoted 10 lines
tests/gem_scheduler.c new file +10
-0+for (loop=0 ; loop < NBR_BASIC_FDs; loop++) +init_context (&(fd[loop]), &(bufmgr[loop]), ringid); + + +/* Create buffer objects */ + delay_bo =create_and_check_bo (bufmgr[0 ],"delay bo" ); + ts1_bo =create_and_check_bo (bufmgr[1 ],"ts1 bo" ); + ts2_bo =create_and_check_bo (bufmgr[2 ],"ts2 bo" ); + +/* Put some non zero values in the delay bo */
You do this write for every delay batch, so you could move it to create_delay_bb (or to the library function)
tests/gem_scheduler.c line 170
Quoted 1 line
tests/gem_scheduler.c new file +1
-0+ {
Why is this extra scope needed? "data" doesn't clash with any other variable name
Quoted 78 lines
tests/gem_scheduler.c new file +78
-0+uint32_t data=0xffffffff ; +drm_intel_bo_subdata (delay_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); +for (loop =1 ; 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); + +/* 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 ); +drm_intel_bo_map (ts1_bo,0 ); +drm_intel_bo_map (ts2_bo,0 ); + + delay_buf = delay_bo->virtual; + ts1_buf = ts1_bo->virtual; + ts2_buf = ts2_bo->virtual; + +igt_debug ("Delay Timestamp = 0x%08" PRIx32"\n" , delay_buf[2 ]); +igt_debug ("TS1 Timestamp = 0x%08" PRIx32"\n" , ts1_buf[0 ]); +igt_debug ("TS2 Timestamp = 0x%08" PRIx32"\n" , ts2_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 (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++) +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 (ts1_bo); +drm_intel_bo_unreference (ts2_bo); +for (loop =0 ; loop < NBR_BASIC_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. +* write=1, Submit batch buffers with write dependencies to all rings. Delay one +* with a long executing batch buffer. Also submit batch buffers with no +* dependencies to all rings. Batch buffers with write dependencies should be +* executed in submission order. The batch buffers with no dependencies should +* not be held up. +*/ +static void run_test_dependency (int in_flight,int ring,bool write) +{ +int fd[NBR_RINGS ], fd2[NBR_RINGS ]; +int loop; +int prime_fd; +uint32_t *delay_buf, *ts_buf[NBR_RINGS ], *ts2_buf[NBR_RINGS ], *shared_buf; +uint32_t calibrated_1s; +drm_intel_bufmgr *bufmgr[NBR_RINGS ], *bufmgr2[NBR_RINGS ];
tests/gem_scheduler.c line 258
Quoted 10 lines
tests/gem_scheduler.c new file +10
-0+struct intel_batchbuffer *ts_bb[NBR_RINGS ], *ts2_bb[NBR_RINGS ], **in_flight_bbs; +drm_intel_bo *delay_bo, *ts_bo[NBR_RINGS ], *ts2_bo[NBR_RINGS ], *shared_bo[NBR_RINGS ]; + + 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_RINGS ; loop++) {
You have several loops on all engines but with a bit of reordering you should be able to fit everything in less loops. Unless I've missed a dependency, you should be able to do something like:
for (loop=0; loop < NBR_RINGS; loop++) {
init_context(&(fd[loop]), &(bufmgr[loop]), rings[loop].id);
ts_bo[loop] = create_and_check_bo(bufmgr[loop], "ts bo");
if (loop == 0)
shared_bo[0] = create_and_check_bo(...);
drm_intel_bo_gem_export_to_prime(...);
else
shared_bo[loop] = drm_intel_bo_gem_create_from_prime(...);
ts_bb[loop] = create_timestamp_bb(..);
if (write) {
....
}
}Also the operations performed in the "if (write)" case are the same of the ones in the main loop with the exception of the shared bo so potentially you could move the whole block in a separate function if it doesn't get too messy.
Quoted 23 lines
tests/gem_scheduler.c new file +23
-0+init_context (&(fd[loop]), &(bufmgr[loop]), rings[loop].id); +if (write) +init_context (&(fd2[loop]), &(bufmgr2[loop]), rings[loop].id); + } + +/* Create buffer objects */ + delay_bo =create_and_check_bo (bufmgr[ring],"delay bo" ); +for (loop =0 ; loop <NBR_RINGS ; loop++) { + ts_bo[loop] =create_and_check_bo (bufmgr[loop],"ts bo" ); +if (write) + ts2_bo[loop] =create_and_check_bo (bufmgr2[loop],"ts2 bo" ); + } + +/* Create shared buffer object */ + shared_bo[0 ] =create_and_check_bo (bufmgr[0 ],"shared bo" ); + +drm_intel_bo_gem_export_to_prime (shared_bo[0 ], &prime_fd); +for (loop =1 ; loop <NBR_RINGS ; loop++) { + shared_bo[loop] =drm_intel_bo_gem_create_from_prime (bufmgr[loop], + prime_fd,BATCH_SZ ); +igt_assert (shared_bo[loop]); + } +close (prime_fd);
tests/gem_scheduler.c line 291
Quoted 10 lines
tests/gem_scheduler.c new file +10
-0+ +/* Put some non zero values in the delay and shared bo */ +drm_intel_bo_map (delay_bo,1 ); + delay_buf = delay_bo->virtual; + delay_buf[0 ] =0xff ; +drm_intel_bo_unmap (delay_bo); +drm_intel_bo_map (shared_bo[0 ],1 ); + shared_buf = shared_bo[0 ]->virtual; + shared_buf[0 ] =0xff00ff00 ; +drm_intel_bo_unmap (shared_bo[0 ]);
using subdata might be cleaner here as well
Quoted 92 lines
tests/gem_scheduler.c new file +92
-0+ + calibrated_1s =igt_calibrate_delay_bb (fd[ring], bufmgr[ring], rings[ring].id); + +/* Batch buffers to fill the in flight queue */ + in_flight_bbs[0 ] =create_delay_bb (fd[ring], bufmgr[ring], rings[ring].id, + calibrated_1s, delay_bo); +for (loop =1 ; loop < in_flight; loop++) + in_flight_bbs[loop] =create_noop_bb (fd[ring], bufmgr[ring],5 ); + +for (loop =0 ; loop <NBR_RINGS ; loop++) { + ts_bb[loop] =create_timestamp_bb (fd[loop], bufmgr[loop], + rings[loop].id, ts_bo[loop], + shared_bo[loop], write); +if (write) + ts2_bb[loop] =create_timestamp_bb (fd2[loop], bufmgr2[loop], + rings[loop].id, ts2_bo[loop], +NULL , false); + } + +/* Flush batchbuffers */ +for (loop =0 ; loop < in_flight; loop++) +intel_batchbuffer_flush_on_ring (in_flight_bbs[loop], rings[ring].id); + +intel_batchbuffer_flush_on_ring (ts_bb[ring], rings[ring].id); +for (loop =0 ; loop <NBR_RINGS ; loop++) +if ((loop != ring) && rings[loop].exists) +intel_batchbuffer_flush_on_ring (ts_bb[loop], rings[loop].id); + +if (write) { +intel_batchbuffer_flush_on_ring (ts2_bb[ring], rings[ring].id); +for (loop =0 ; loop <NBR_RINGS ; loop++) +if ((loop != ring) && rings[loop].exists) +intel_batchbuffer_flush_on_ring (ts2_bb[loop], rings[loop].id); + } + +/* This will not return until the bo has finished executing */ +drm_intel_bo_map (delay_bo,0 ); + delay_buf = delay_bo->virtual; +for (loop =0 ; loop <NBR_RINGS ; loop++) { +drm_intel_bo_map (ts_bo[loop],0 ); + ts_buf[loop] = ts_bo[loop]->virtual; +if (write) { +drm_intel_bo_map (ts2_bo[loop],0 ); + ts2_buf[loop] = ts2_bo[loop]->virtual; + } + } + +/* 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_debug ("%6s delay timestamp = 0x%08" PRIx32"\n" , + rings[ring].name, delay_buf[2 ]); +for (loop =0 ; loop <NBR_RINGS ; loop++) +igt_debug ("%6s batch timestamp = 0x%08" PRIx32"\n" , + rings[loop].name, ts_buf[loop][0 ]); + +if (write) { +igt_debug ("Independant batch buffers\n" ); +for (loop =0 ; loop <NBR_RINGS ; loop++) +igt_debug ("%6s batch timestamp = 0x%08" PRIx32"\n" , + rings[loop].name, ts2_buf[loop][0 ]); + } + +for (loop =0 ; loop <NBR_RINGS ; loop++) { +if ((loop != ring) && rings[loop].exists) { +if (write) { +/* Write dependency, delayed ring should run first */ +igt_assert_f (igt_compare_timestamps (ts_buf[ring][0 ], ts_buf[loop][0 ]), +"%s ran before %s - 0x%08" PRIx32" vs 0x%08" PRIx32"\n" , + rings[loop].name, rings[ring].name, + ts_buf[loop][0 ], ts_buf[ring][0 ]); +/* Second bb without dependency should run first */ +igt_assert_f (igt_compare_timestamps (ts2_buf[loop][0 ], ts_buf[loop][0 ]), +"(%s) independant bb was held up - 0x%08" PRIx32" vs 0x%08" PRIx32"\n" , + rings[loop].name, ts_buf[loop][0 ], ts2_buf[loop][0 ]); + } +else +/* Read dependency, delayed ring should run last */ +igt_assert_f (igt_compare_timestamps (ts_buf[loop][0 ], ts_buf[ring][0 ]), +"%s ran after %s - 0x%08" PRIx32" vs 0x%08" PRIx32"\n" , + rings[loop].name, rings[ring].name, + ts_buf[loop][0 ], ts_buf[ring][0 ]); + } + } + +/* Cleanup */ +for (loop =0 ; loop < in_flight; loop++) +intel_batchbuffer_free (in_flight_bbs[loop]); + +for (loop =0 ; loop <NBR_RINGS ; loop++) {
tests/gem_scheduler.c line 393
Quoted 10 lines
tests/gem_scheduler.c new file +10
-0+intel_batchbuffer_free (ts_bb[loop]); +drm_intel_bo_unreference (ts_bo[loop]); +drm_intel_bo_unreference (shared_bo[loop]); +if (write) { +intel_batchbuffer_free (ts2_bb[loop]); +drm_intel_bo_unreference (ts2_bo[loop]); + } + } + +drm_intel_bo_unreference (delay_bo);
You can move this unreferencing to before the above loop and then squash the 2 loops onNBR_RINGSinto one.
Regards,
Daniele
Quoted 56 lines
tests/gem_scheduler.c new file +56
-0+ +for (loop =0 ; loop <NBR_RINGS ; loop++) { +drm_intel_bufmgr_destroy (bufmgr[loop]); +close (fd[loop]); +if (write) { +drm_intel_bufmgr_destroy (bufmgr2[loop]); +close (fd2[loop]); + } + } + +free (in_flight_bbs); +} + +igt_main +{ +int loop; +int in_flight; +int fd; + + igt_fixture { +int debug_fd; +int l; +char buf[6 ]; +/* Get nbr of batch buffers that the scheduler will queue in the +* HW. If this debugfs file does not exist there is no scheduler +* so skip the test. +*/ + debug_fd =igt_debugfs_open ("i915_scheduler_min_flying" ,O_RDONLY ); +igt_skip_on (debug_fd ==-1 ); + l =read (debug_fd, buf,sizeof (buf)-1 ); +igt_assert (l >0 ); +igt_assert (l <sizeof (buf)); + buf[l] ='\0' ; +/* May be a decimal or hex number depending on scheduler version */ +if (sscanf (buf,"0x%2x" , &in_flight) !=1 ) +igt_assert_f (sscanf (buf,"%2d" , &in_flight) ==1 , +"Error reading from i915_scheduler_min_flying\n" ); +close (debug_fd); +igt_debug ("in flight = %d\n" , in_flight); + fd =drm_open_driver (DRIVER_INTEL ); +igt_assert (fd >=0 ); +check_rings (fd); + } + +for (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); + } + +for (loop=0 ; loop <NBR_RINGS ; loop++) + igt_subtest_f("%s-read", rings[loop].name) { +gem_require_ring (fd, rings[loop].id); +run_test_dependency (in_flight, loop, false); + } +
tests/gem_scheduler.c line 459
Quoted 10 lines
tests/gem_scheduler.c new file +10
-0+for (loop=0 ; loop <NBR_RINGS ; loop++) + igt_subtest_f("%s-write", rings[loop].name) { +gem_require_ring (fd, rings[loop].id); +run_test_dependency (in_flight, loop, true); + } + + igt_fixture { +close (fd); + } +}
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
Re: [PATCH i-g-t v3 3/6] tests/gem_scheduler: Add gem_scheduler test
Quoted 210 lines · Daniele Ceraolo Spurio
Quoted 123 lines · Derek Morton
This 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
v3: Added logic to use generic BSD ring if there is 1 and BSD1 / BSD2 if there
are 2.Signed-off-by Derek Morton<[email protected]>--- tests/Makefile.sources | 1 + tests/gem_scheduler.c | 459 +++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 460 insertions(+)create mode 100644
tests/gem_scheduler.ctests/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 +4
-0@@ -0,0 +1,459 @@ +/* +* Copyright © 2016 Intel Corporation +* +* 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 without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * 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 NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR 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.
+ *
+ * Authors:
+ * Derek Morton<[email protected]>
+ *
+ */tests/gem_scheduler.c new file +14
-0+ +#include "igt.h" +#include <unistd.h> +#include <stdlib.h> +#include <stdint.h> +#include <stdio.h> +#include <string.h> +#include <inttypes.h> +#include <time.h> +#include <sys/stat.h> +#include <sys/ioctl.h> +#include <fcntl.h> + +IGT_TEST_DESCRIPTION("Check scheduler behaviour. Basic tests ensureindependant "
+ "batch buffers of the same priority are
executed in "tests/gem_scheduler.c new file +2
-0+"submission order. Read-read tests ensure " + "batch buffers with a read dependency to thesame buffer "
+ "object do not block each other. Write-write
dependency "
+ "tests ensure batch buffers with a write
dependency to a "
+ "buffer object will be executed in submission
order but "
+ "will not block execution of other independant
batch "tests/gem_scheduler.c new file +5
-0+ "buffers."); + +#define SEC_TO_NSEC (1000 * 1000 * 1000) + +static struct ring {tests/gem_scheduler.c line 62
Quoted 10 lines
tests/gem_scheduler.c new file +10
-0+const char *name; +int id; +bool exists; +} rings[] = { + { "render", I915_EXEC_RENDER, false }, + { "bsd", I915_EXEC_BSD , false }, + { "bsd2", I915_EXEC_BSD | 2<<13, false }, + { "blt", I915_EXEC_BLT, false }, + { "vebox", I915_EXEC_VEBOX, false }, +};If you can't use
intel_execution_enginescould you add a comment to explain why? also considering the renaming going on in the kernel you cold replace "ring" with "engine"tests/gem_scheduler.c line 68
Quoted 6 lines
tests/gem_scheduler.c new file +6
-0+ +#define NBR_RINGS (sizeof(rings)/sizeof(struct ring)) + +static void check_rings (int fd) { +int loop; +for (loop=0 ; loop <NBR_RINGS ; loop++) {Style: space between for/if and "(" in this file
tests/gem_scheduler.c line 74
Quoted 6 lines
tests/gem_scheduler.c new file +6
-0+if (gem_has_ring (fd, rings[loop].id)) { +if (rings[loop].id == (I915_EXEC_BSD |2 <<13 )) { + rings[loop].exists =gem_has_bsd2 (fd); + } +else { + rings[loop].exists = true;You're marking the VEBOX as existing so adding a gen requirement in this function would be nice. I know that the library you're using already requires gen8, but the requirement doesn't look to be explicit anywhere in this file so it would be nice to add it for clarity.
Quoted 53 lines
tests/gem_scheduler.c new file +12
-0+if (rings[loop].id ==I915_EXEC_BSD ) +/* If there is BSD2, need to make BSD1 +* explicit. +*/ +if (gem_has_bsd2 (fd)) + rings[loop].id |= (1 <<13 ); + } + } + } +} + +static drm_intel_bo *create_and_check_bo(drm_intel_bufmgr *bufmgr,const char *desc)
tests/gem_scheduler.c new file +2
-0+{ + drm_intel_bo *bo = drm_intel_bo_alloc(bufmgr, desc, BATCH_SZ,
BATCH_SZ);tests/gem_scheduler.c new file +5
-0+igt_assert_f (bo,"Failed allocating %s\n" , desc); +return bo; +} + +static struct intel_batchbuffer *create_delay_bb(int fd,
drm_intel_bufmgr*bufmgr,
+ int ringid,uint32_tloops,tests/gem_scheduler.c new file +10
-0+ drm_intel_bo *dest) +{ +struct intel_batchbuffer *buffer; + buffer =intel_batchbuffer_alloc (bufmgr,intel_get_drm_devid (fd)); +igt_assert (buffer); +igt_create_delay_bb (fd, buffer, ringid, loops, dest); +return buffer; +} + +static struct intel_batchbuffer *create_timestamp_bb(int fd,
drm_intel_bufmgr*bufmgr,
+ int ringid,drm_intel_bo*dest,
+drm_intel_bo*load, bool write)tests/gem_scheduler.c new file +9
-0+{ +struct intel_batchbuffer *buffer; + buffer =intel_batchbuffer_alloc (bufmgr,intel_get_drm_devid (fd)); +igt_assert (buffer); +igt_create_timestamp_bb (fd, buffer, ringid, dest, load, write); +return buffer; +} + +static struct intel_batchbuffer *create_noop_bb(int fd,
drm_intel_bufmgr*bufmgr,tests/gem_scheduler.c new file +5
-0+ int noops) +{ +struct intel_batchbuffer *buffer; + buffer =intel_batchbuffer_alloc (bufmgr,intel_get_drm_devid (fd)); +igt_assert (buffer);
Quoted 8 lines
Quoted 6 lines
tests/gem_scheduler.c new file +5
-0+igt_create_noop_bb (buffer, noops); +return buffer; +} + +static void init_context(int *fd, drm_intel_bufmgr **bufmgr, intringid)
init_contextmight be a bit misleading as a name as you're notinit_contextmight be a bit misleading as a name as you're notinit_contextmight be a bit misleading as a name as you're notinit_contextmight be a bit misleading as a name as you're notinit_contextmight be a bit misleading as a name as you're notinit_contextmight be a bit misleading as a name as you're notinit_contextmight be a bit misleading as a name as you're notinit_contextmight be a bit misleading as a name as you're not a ctx directly, although initializing
Not really sure how this mess ended up in the email :-P
What I wanted to say is:
init_context might be a bit misleading as a name as you're not initializing a ctx directly, although initializing the fd and doing a submission you aim to initialize the default context so I'm not sure what to suggest as an alternative name.
Regards,
Daniele
Quoted 414 lines
Quoted 38 lines
tests/gem_scheduler.c new file +14
-0+{ +struct intel_batchbuffer *noop_bb; + *fd =drm_open_driver (DRIVER_INTEL ); +igt_assert (*fd >=0 ); + *bufmgr =drm_intel_bufmgr_gem_init (*fd,BATCH_SZ ); +igt_assert (*bufmgr); +drm_intel_bufmgr_gem_enable_reuse (*bufmgr); +/* Send a noop batch buffer to force any deferred initialisation */ + noop_bb =create_noop_bb (*fd, *bufmgr,5 ); +intel_batchbuffer_flush_on_ring (noop_bb, 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.
+ */tests/gem_scheduler.c new file +13
-0+#define NBR_BASIC_FDs (3) +static void run_test_basic (int in_flight,int ringid) +{ +int fd[NBR_BASIC_FDs]; +int loop; +drm_intel_bufmgr *bufmgr[NBR_BASIC_FDs]; +uint32_t *delay_buf, *ts1_buf, *ts2_buf; +struct intel_batchbuffer *ts1_bb, *ts2_bb; +struct intel_batchbuffer **in_flight_bbs; +uint32_t calibrated_1s; +drm_intel_bo *delay_bo, *ts1_bo, *ts2_bo; + + in_flight_bbs = malloc(in_flight * sizeof(struct
intel_batchbuffer*));tests/gem_scheduler.c new file +3
-0+igt_assert (in_flight_bbs); + +/* Need multiple i915 fd's. Scheduler will not change execution order of
tests/gem_scheduler.c new file +2
-0+* batch buffers from the same context. +*/ tests/gem_scheduler.c line 169
Quoted 10 lines
tests/gem_scheduler.c new file +10
-0+for (loop=0 ; loop < NBR_BASIC_FDs; loop++) +init_context (&(fd[loop]), &(bufmgr[loop]), ringid); + + +/* Create buffer objects */ + delay_bo =create_and_check_bo (bufmgr[0 ],"delay bo" ); + ts1_bo =create_and_check_bo (bufmgr[1 ],"ts1 bo" ); + ts2_bo =create_and_check_bo (bufmgr[2 ],"ts2 bo" ); + +/* Put some non zero values in the delay bo */ You do this write for every delay batch, so you could move it to
create_delay_bb(or to the library function)Quoted 1 line
+ {
Why is this extra scope needed? "data" doesn't clash with any other variable name
Quoted 103 lines
tests/gem_scheduler.c new file +8
-0+uint32_t data=0xffffffff ; +drm_intel_bo_subdata (delay_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);tests/gem_scheduler.c new file +5
-0+for (loop =1 ; 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);tests/gem_scheduler.c new file +21
-0+ +/* 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 ); +drm_intel_bo_map (ts1_bo,0 ); +drm_intel_bo_map (ts2_bo,0 ); + + delay_buf = delay_bo->virtual; + ts1_buf = ts1_bo->virtual; + ts2_buf = ts2_bo->virtual; + +igt_debug ("Delay Timestamp = 0x%08" PRIx32"\n" , delay_buf[2 ]); +igt_debug ("TS1 Timestamp = 0x%08" PRIx32"\n" , ts1_buf[0 ]); +igt_debug ("TS2 Timestamp = 0x%08" PRIx32"\n" , ts2_buf[0 ]); + +/* buf[0] in the target buffer should be 0 if the batch buffer completed */
tests/gem_scheduler.c new file +2
-0+ igt_assert_f(delay_buf[0] == 0, + "delay_buf[0] expected 0x0, got 0x%" PRIx32 "\n",delay_buf[0]);
tests/gem_scheduler.c new file +3
-0+ +igt_assert_f (igt_compare_timestamps (delay_buf[2 ], ts1_buf[0 ]), + "Delay ts (0x%08" PRIx32 ") > TS1 ts (0x%08" PRIx32")\n",
tests/gem_scheduler.c new file +3
-0+ 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",
tests/gem_scheduler.c new file +20
-0+ ts1_buf[0], ts2_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 (ts1_bo); +drm_intel_bo_unreference (ts2_bo); +for (loop =0 ; loop < NBR_BASIC_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.
+ * write=1, Submit batch buffers with write dependencies to all rings. Delay one
+ * with a long executing batch buffer. Also submit batch buffers with no
+ * dependencies to all rings. Batch buffers with write dependencies should be
+ * executed in submission order. The batch buffers with no dependencies should
+ * not be held up.
+ */tests/gem_scheduler.c new file +6
-0+static void run_test_dependency (int in_flight,int ring,bool write) +{ +int fd[NBR_RINGS ], fd2[NBR_RINGS ]; +int loop; +int prime_fd; + uint32_t *delay_buf, *ts_buf[NBR_RINGS], *ts2_buf[NBR_RINGS],
*shared_buf;tests/gem_scheduler.c new file +3
-0+uint32_t calibrated_1s; +drm_intel_bufmgr *bufmgr[NBR_RINGS ], *bufmgr2[NBR_RINGS ]; + struct intel_batchbuffer *ts_bb[NBR_RINGS], *ts2_bb[NBR_RINGS],**in_flight_bbs;
+drm_intel_bo*delay_bo, *ts_bo[NBR_RINGS], *ts2_bo[NBR_RINGS],
*shared_bo[NBR_RINGS];tests/gem_scheduler.c new file +2
-0+ + in_flight_bbs = malloc(in_flight * sizeof(struct
intel_batchbuffer*));tests/gem_scheduler.c new file +3
-0+igt_assert (in_flight_bbs); + +/* Need multiple i915 fd's. Scheduler will not change execution order of
tests/gem_scheduler.c line 258
Quoted 3 lines
tests/gem_scheduler.c new file +3
-0+* batch buffers from the same context. +*/ +for (loop=0 ; loop <NBR_RINGS ; loop++) {You have several loops on all engines but with a bit of reordering you should be able to fit everything in less loops. Unless I've missed a dependency, you should be able to do something like:
for (loop=0; loop < NBR_RINGS; loop++) { init_context(&(fd[loop]), &(bufmgr[loop]), rings[loop].id); ts_bo[loop] = create_and_check_bo(bufmgr[loop], "ts bo"); if (loop == 0) shared_bo[0] = create_and_check_bo(...); drm_intel_bo_gem_export_to_prime(...); else shared_bo[loop] = drm_intel_bo_gem_create_from_prime(...); ts_bb[loop] = create_timestamp_bb(..); if (write) { .... } }Also the operations performed in the "if (write)" case are the same of the ones in the main loop with the exception of the shared bo so potentially you could move the whole block in a separate function if it doesn't get too messy.
Quoted 26 lines
tests/gem_scheduler.c new file +3
-0+init_context (&(fd[loop]), &(bufmgr[loop]), rings[loop].id); +if (write) + init_context(&(fd2[loop]), &(bufmgr2[loop]),rings[loop].id);
tests/gem_scheduler.c new file +8
-0+ } + +/* Create buffer objects */ + delay_bo =create_and_check_bo (bufmgr[ring],"delay bo" ); +for (loop =0 ; loop <NBR_RINGS ; loop++) { + ts_bo[loop] =create_and_check_bo (bufmgr[loop],"ts bo" ); +if (write) + ts2_bo[loop] = create_and_check_bo(bufmgr2[loop], "ts2bo");
tests/gem_scheduler.c new file +8
-0+ } + +/* Create shared buffer object */ + shared_bo[0 ] =create_and_check_bo (bufmgr[0 ],"shared bo" ); + +drm_intel_bo_gem_export_to_prime (shared_bo[0 ], &prime_fd); +for (loop =1 ; loop <NBR_RINGS ; loop++) { + shared_bo[loop] =drm_intel_bo_gem_create_from_prime(bufmgr[loop],
+prime_fd,BATCH_SZ);tests/gem_scheduler.c new file +3
-0+igt_assert (shared_bo[loop]); + } +close (prime_fd);tests/gem_scheduler.c line 291
Quoted 10 lines
tests/gem_scheduler.c new file +10
-0+ +/* Put some non zero values in the delay and shared bo */ +drm_intel_bo_map (delay_bo,1 ); + delay_buf = delay_bo->virtual; + delay_buf[0 ] =0xff ; +drm_intel_bo_unmap (delay_bo); +drm_intel_bo_map (shared_bo[0 ],1 ); + shared_buf = shared_bo[0 ]->virtual; + shared_buf[0 ] =0xff00ff00 ; +drm_intel_bo_unmap (shared_bo[0 ]);using subdata might be cleaner here as well
Quoted 106 lines
tests/gem_scheduler.c new file +2
-0+ + calibrated_1s = igt_calibrate_delay_bb(fd[ring], bufmgr[ring],rings[ring].id);
tests/gem_scheduler.c new file +3
-0+ +/* Batch buffers to fill the in flight queue */ + in_flight_bbs[0] = create_delay_bb(fd[ring], bufmgr[ring],rings[ring].id,
tests/gem_scheduler.c new file +3
-0+ calibrated_1s, delay_bo); +for (loop =1 ; loop < in_flight; loop++) + in_flight_bbs[loop] = create_noop_bb(fd[ring], bufmgr[ring],5);
tests/gem_scheduler.c new file +7
-0+ +for (loop =0 ; loop <NBR_RINGS ; loop++) { + ts_bb[loop] =create_timestamp_bb (fd[loop], bufmgr[loop], + rings[loop].id, ts_bo[loop], + shared_bo[loop], write); +if (write) + ts2_bb[loop] = create_timestamp_bb(fd2[loop],bufmgr2[loop],
+ rings[loop].id,
ts2_bo[loop],tests/gem_scheduler.c new file +6
-0+ NULL, false); + } + +/* Flush batchbuffers */ +for (loop =0 ; loop < in_flight; loop++) + intel_batchbuffer_flush_on_ring(in_flight_bbs[loop],rings[ring].id);
tests/gem_scheduler.c new file +5
-0+ +intel_batchbuffer_flush_on_ring (ts_bb[ring], rings[ring].id); +for (loop =0 ; loop <NBR_RINGS ; loop++) +if ((loop != ring) && rings[loop].exists) + intel_batchbuffer_flush_on_ring(ts_bb[loop],rings[loop].id);
tests/gem_scheduler.c new file +6
-0+ +if (write) { +intel_batchbuffer_flush_on_ring (ts2_bb[ring], rings[ring].id); +for (loop =0 ; loop <NBR_RINGS ; loop++) +if ((loop != ring) && rings[loop].exists) + intel_batchbuffer_flush_on_ring(ts2_bb[loop],rings[loop].id);
tests/gem_scheduler.c new file +15
-0+ } + +/* This will not return until the bo has finished executing */ +drm_intel_bo_map (delay_bo,0 ); + delay_buf = delay_bo->virtual; +for (loop =0 ; loop <NBR_RINGS ; loop++) { +drm_intel_bo_map (ts_bo[loop],0 ); + ts_buf[loop] = ts_bo[loop]->virtual; +if (write) { +drm_intel_bo_map (ts2_bo[loop],0 ); + ts2_buf[loop] = ts2_bo[loop]->virtual; + } + } + +/* buf[0] in the target buffer should be 0 if the batch buffer completed */
tests/gem_scheduler.c new file +23
-0+ igt_assert_f(delay_buf[0] == 0, + "delay_buf[0] expected 0x0, got 0x%" PRIx32 "\n", + delay_buf[0]); + + igt_debug("%6s delay timestamp = 0x%08" PRIx32 "\n", + rings[ring].name, delay_buf[2]); + for(loop = 0; loop < NBR_RINGS; loop++) + igt_debug("%6s batch timestamp = 0x%08" PRIx32 "\n", + rings[loop].name, ts_buf[loop][0]); + + if(write) { + igt_debug("Independant batch buffers\n"); + for(loop = 0; loop < NBR_RINGS; loop++) + igt_debug("%6s batch timestamp = 0x%08" PRIx32 "\n", + rings[loop].name, ts2_buf[loop][0]); + } + + for(loop = 0; loop < NBR_RINGS; loop++) { + if((loop != ring) && rings[loop].exists) { + if(write) { + /* Write dependency, delayed ring should run first */ + igt_assert_f(igt_compare_timestamps(ts_buf[ring][0], ts_buf[loop][0]), + "%s ran before %s - 0x%08" PRIx32 " vs0x%08" PRIx32 "\n",
tests/gem_scheduler.c new file +4
-0+ rings[loop].name, rings[ring].name, + ts_buf[loop][0], ts_buf[ring][0]); +/* Second bb without dependency should run first */ + igt_assert_f(igt_compare_timestamps(ts2_buf[loop][0],ts_buf[loop][0]),
+ "(%s) independant bb was held up -
0x%08" PRIx32 " vs 0x%08" PRIx32 "\n",
+ rings[loop].name, ts_buf[loop][0],
ts2_buf[loop][0]);tests/gem_scheduler.c new file +5
-0+ } + else +/* Read dependency, delayed ring should run last */ +igt_assert_f (igt_compare_timestamps (ts_buf[loop][0 ], ts_buf[ring][0 ]), + "%s ran after %s - 0x%08" PRIx32 " vs0x%08" PRIx32 "\n",
tests/gem_scheduler.c new file +10
-0+ rings[loop].name, rings[ring].name, + ts_buf[loop][0], ts_buf[ring][0]); + } + } + +/* Cleanup */ +for (loop =0 ; loop < in_flight; loop++) +intel_batchbuffer_free (in_flight_bbs[loop]); + +for (loop =0 ; loop <NBR_RINGS ; loop++) {tests/gem_scheduler.c line 393
Quoted 10 lines
tests/gem_scheduler.c new file +10
-0+intel_batchbuffer_free (ts_bb[loop]); +drm_intel_bo_unreference (ts_bo[loop]); +drm_intel_bo_unreference (shared_bo[loop]); +if (write) { +intel_batchbuffer_free (ts2_bb[loop]); +drm_intel_bo_unreference (ts2_bo[loop]); + } + } + +drm_intel_bo_unreference (delay_bo);You can move this unreferencing to before the above loop and then squash the 2 loops
onNBR_RINGSintoone.Regards,
DanieleQuoted 68 lines
tests/gem_scheduler.c new file +24
-0+ +for (loop =0 ; loop <NBR_RINGS ; loop++) { +drm_intel_bufmgr_destroy (bufmgr[loop]); +close (fd[loop]); +if (write) { +drm_intel_bufmgr_destroy (bufmgr2[loop]); +close (fd2[loop]); + } + } + +free (in_flight_bbs); +} + +igt_main +{ +int loop; +int in_flight; +int fd; + + igt_fixture { +int debug_fd; +int l; +char buf[6 ]; +/* Get nbr of batch buffers that the scheduler will queue in the
+ * HW. If this debugfs file does not exist there is no
schedulertests/gem_scheduler.c new file +3
-0+* so skip the test. +*/ + debug_fd = igt_debugfs_open("i915_scheduler_min_flying",
O_RDONLY);tests/gem_scheduler.c new file +6
-0+igt_skip_on (debug_fd ==-1 ); + l =read (debug_fd, buf,sizeof (buf)-1 ); +igt_assert (l >0 ); +igt_assert (l <sizeof (buf)); + buf[l] ='\0' ; +/* May be a decimal or hex number depending on scheduler version */
tests/gem_scheduler.c new file +3
-0+if (sscanf (buf,"0x%2x" , &in_flight) !=1 ) + igt_assert_f(sscanf(buf, "%2d", &in_flight) == 1, + "Error reading fromi915_scheduler_min_flying\n");
tests/gem_scheduler.c new file +26
-0+close (debug_fd); +igt_debug ("in flight = %d\n" , in_flight); + fd =drm_open_driver (DRIVER_INTEL ); +igt_assert (fd >=0 ); +check_rings (fd); + } + +for (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); + } + +for (loop=0 ; loop <NBR_RINGS ; loop++) + igt_subtest_f("%s-read", rings[loop].name) { +gem_require_ring (fd, rings[loop].id); +run_test_dependency (in_flight, loop, false); + } + +for (loop=0 ; loop <NBR_RINGS ; loop++) + igt_subtest_f("%s-write", rings[loop].name) { +gem_require_ring (fd, rings[loop].id); +run_test_dependency (in_flight, loop, true); + } + + igt_fixture {
Quoted 8 lines
tests/gem_scheduler.c line 459
Quoted 3 lines
tests/gem_scheduler.c new file +3
-0+close (fd); + } +}_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH v3 4/6 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 v3 5/6 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 "
@@ -136,11 +137,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;
@@ -160,6 +173,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" );
@@ -209,9 +229,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++)
@@ -438,7 +463,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
Re: [PATCH i-g-t v3 5/6] tests/gem_scheduler: Add subtests to test batch priority behaviour
Quoted 85 lines · Derek Morton
Add 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
Signed-off-by Derek Morton <[email protected]>--- tests/gem_scheduler.c | 53 +++++++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 45 insertions(+), 8 deletions(-)tests/gem_scheduler.c +32
-7@@ -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 "@@ -136,11 +137,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;@@ -160,6 +173,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" );@@ -209,9 +229,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++)@@ -438,7 +463,19 @@ igt_mainfor (loop=0 ; loop <NBR_RINGS ; loop++)
tests/gem_scheduler.c igt_main · line 472
Quoted 10 lines
tests/gem_scheduler.c +7
-1igt_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 );
1000 is a very high priority and it could cause a preemption (when the support lands). That shouldn't fail the test because the second batch will still overtake the first one but we might end up testing a different scenario that the one we're trying to test here, so we could use a smaller priority value here and use 1000+ in future preemption specific tests.
Regards,
Daniele
tests/gem_scheduler.c igt_main · line 481
Quoted 9 lines
tests/gem_scheduler.c +6
-0+ } + +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++)
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
Re: [PATCH i-g-t v3 5/6] tests/gem_scheduler: Add subtests to test batch priority behaviour
Quoted 94 lines
-----Original Message-----
From: Ceraolo Spurio, Daniele
Sent: Thursday, March 17, 2016 8:58 AM
To: Morton, Derek J <[email protected]>; [email protected]
Subject: Re: [PATCH i-g-t v3 5/6] tests/gem_scheduler: Add subtests to test batch priority behaviourQuoted 83 lines · Derek Morton
Add 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
Signed-off-by Derek Morton <[email protected]>--- tests/gem_scheduler.c | 53 +++++++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 45 insertions(+), 8 deletions(-)tests/gem_scheduler.c index renamed from tests/gem_scheduler.c +0
-0436440a..126ee97 100644
tests/gem_scheduler.c +2
-2@@ -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 "@@ -136,11 +137,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.tests/gem_scheduler.c +32
-4+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;@@ -160,6 +173,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"); @@ -209,9 +229,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 ]);
Quoted 16 lines
Quoted 6 lines
/* Cleanup */
for(loop = 0; loop < in_flight; loop++)@@ -438,7 +463,19 @@igt_main
for (loop=0; loop <NBR_RINGS; loop++)
igt_subtest_f("%s-basic", rings[loop].name){
gem_require_ring(fd, rings[loop].id);tests/gem_scheduler.c igt_main · line 472
Quoted 8 lines
tests/gem_scheduler.c +7
-1-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 );1000 is a very high priority and it could cause a preemption (when the support lands). That shouldn't fail the test because the second batch will still overtake the first one but we might end up testing a different scenario that the one we're trying to test here, so we could use a smaller priority value here and use 1000+ in future preemption specific tests.
Ok will try 200
Quoted 11 lines
Regards,
DanieleQuoted 8 lines
tests/gem_scheduler.c +6
-0+ } + +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 ); }
Quoted 3 lines
Quoted 1 line
for (loop=0; loop <
NBR_RINGS; loop++)
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH v3 6/6 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
@@ -254,6 +254,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.
@@ -490,6 +618,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