Skip to contentSkip to conversation

Scheduler tests

PATCH Superseded Derek Morton 2 participants 15 messages Mar 10, 2016 – Mar 30, 2016 Library code

v3 of 4 Superseded Latest is v4 →

lore
Share & tools
lore
#0 lore raw

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
#1 lore raw

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
index 5d49729..f42e2c9 100644
@@ -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
index f59eafb..e095c41 100644
@@ -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
#2 lore raw

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.

---
  lib/ioctl_wrappers.c | 2 +-
  lib/ioctl_wrappers.h | 1 +
  2 files changed, 2 insertions(+), 1 deletion(-)
lib/ioctl_wrappers.c +0 -0
index 5d49729..f42e2c9 100644

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
index f59eafb..e095c41 100644

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

#3 lore raw

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: make gem_has_ring non static

Quoted 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.

---
  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 -0

5d49729..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,
Daniele

Quoted 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.h b/lib/ioctl_wrappers.h index f59eafb..e095c41 100644

lib/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

#4 lore raw

PATCH v3 2/6 lib/intel_batchbuffer: Add functions to be used in the scheduler test

In reply to 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 Spurio

---
 lib/intel_batchbuffer.c | 384 +++++++++++++++++++++++++++++++++++++++++++++++-
 lib/intel_batchbuffer.h |  14 ++
 2 files changed, 393 insertions(+), 5 deletions(-)
lib/intel_batchbuffer.c +379 -5
index 692521f..30e78c5 100644
@@ -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
index 869747d..5b66fa3 100644
@@ -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
#5 lore raw

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 Spurio

---
  lib/intel_batchbuffer.c | 384 +++++++++++++++++++++++++++++++++++++++++++++++-
  lib/intel_batchbuffer.h |  14 ++
  2 files changed, 393 insertions(+), 5 deletions(-)
lib/intel_batchbuffer.c +73 -5
index 692521f..30e78c5 100644
@@ -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
index 869747d..5b66fa3 100644
@@ -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

#6 lore raw

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 test

Quoted 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 Spurio

---
  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 -0

692521f..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 specified

lib/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, 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.

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_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

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 = 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:

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,
Daniele

Quoted 9 lines
lib/intel_batchbuffer.h index renamed from lib/intel_batchbuffer.h +0 -0

869747d..5b66fa3 100644

lib/intel_batchbuffer.h +0 -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);
 
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

#7 lore raw

PATCH v3 3/6 tests/gem_scheduler: Add gem_scheduler test

In reply to 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.
---
 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
index f8b18b0..c88e045 100644
@@ -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
#8 lore raw

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.
---
  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
index f8b18b0..c88e045 100644
@@ -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
new file mode 100644
index 0000000..436440a
@@ -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

#9 lore raw

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.
---
  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
index f8b18b0..c88e045 100644
@@ -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
new file mode 100644
index 0000000..436440a
@@ -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 ensure 

independant "
+ "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 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 "

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_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 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_t loops,

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, 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

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], "ts2 

bo");

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 " vs 

0x%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 " vs 

0x%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_RINGSinto one.

Regards,
Daniele

Quoted 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
scheduler

tests/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 from 

i915_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

#10 lore raw

PATCH v3 4/6 igt/gem_ctx_param_basic: Updated to support scheduler priority interface

In reply to Derek Morton

From: 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
index e095c41..9e6337e 100644
@@ -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	0x4
 	uint64_t value;
 };
 void gem_context_require_ban_period(int fd);
tests/gem_ctx_param_basic.c +33 -1
index b75800c..585a1a8 100644
@@ -147,10 +147,42 @@ igt_main
 		TEST_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
#11 lore raw

PATCH v3 5/6 tests/gem_scheduler: Add subtests to test batch priority behaviour

In reply to 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

---
 tests/gem_scheduler.c | 53 +++++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 45 insertions(+), 8 deletions(-)
tests/gem_scheduler.c +45 -8
index 436440a..126ee97 100644
@@ -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, &param);
+}
+
+/* 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_main
 	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);
+			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
#12 lore raw

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

---
  tests/gem_scheduler.c | 53 +++++++++++++++++++++++++++++++++++++++++++--------
  1 file changed, 45 insertions(+), 8 deletions(-)
tests/gem_scheduler.c +32 -7
index 436440a..126ee97 100644
@@ -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, &param);
+}
+
+/* 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_main
  	for (loop=0; loop < NBR_RINGS; loop++)

tests/gem_scheduler.c igt_main · line 472

Quoted 10 lines
tests/gem_scheduler.c +7 -1
  		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);

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

#13 lore raw

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 behaviour

Quoted 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

---
  tests/gem_scheduler.c | 53 +++++++++++++++++++++++++++++++++++++++++++--------
  1 file changed, 45 insertions(+), 8 deletions(-)
tests/gem_scheduler.c index renamed from tests/gem_scheduler.c +0 -0

436440a..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, &param);
+}
+
+/* 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,
Daniele

Quoted 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

#14 lore raw

PATCH v3 6/6 gem_scheduler: Added subtests to test priority bumping

In reply to Derek Morton

When 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
index 126ee97..0fbc6e9 100644
@@ -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_main
 			run_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