Skip to contentSkip to conversation

intel: Add support for overriding the PCI ID via an environment variable

PATCH In review Eric Anholt 4 participants 8 messages Mar 7, 2012 – Mar 9, 2012

lore
Share & tools
lore
#0 lore raw

PATCH 1/2 intel: Add support for overriding the PCI ID via an environment variable

From: Kenneth Graunke <[email protected]>

For example:

    export INTEL_DEVID_OVERRIDE=0x162

If this variable is set, don't actually submit the batchbuffer to the GPU, it probably contains commands for the wrong generation of hardware.

v2: Introduce a getter for the overridden devid, and avoid getenv per exec.

---
 intel/intel_bufmgr.h     |    1 +
 intel/intel_bufmgr_gem.c |   56 ++++++++++++++++++++++++++++++++++++++-------
 2 files changed, 48 insertions(+), 9 deletions(-)
intel/intel_bufmgr.h +1 -0
index 85da8b9..8036031 100644
@@ -157,6 +157,7 @@ void drm_intel_gem_bo_start_gtt_access(drm_intel_bo *bo, int write_enable);
 int drm_intel_get_pipe_from_crtc_id(drm_intel_bufmgr *bufmgr, int crtc_id);
 
 int drm_intel_get_aperture_sizes(int fd, size_t *mappable, size_t *total);
+int drm_intel_bufmgr_gem_get_devid(drm_intel_bufmgr *bufmgr);
 
 /* drm_intel_bufmgr_fake.c */
 drm_intel_bufmgr *drm_intel_bufmgr_fake_init(int fd,
intel/intel_bufmgr_gem.c +47 -9

92 lines not on this page · raw message

Signature · 1 line
1.7.9.1
#1 lore raw

PATCH 2/2 intel: Add .aub file output support.

From: Kenneth Graunke <[email protected]>

This will allow the driver to capture all of its execution state to a file for later debugging. intel_gpu_dump is limited in that it only captures batchbuffers, and Mesa's captures, while more complete, still capture only a portion of the state involved in execution.

It also enables us to load traces in our internal simulator.

---
 intel/Makefile.am        |    1 +
 intel/intel_aub.h        |  123 ++++++++++++++++++
 intel/intel_bufmgr.h     |   14 ++
 intel/intel_bufmgr_gem.c |  315 ++++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 453 insertions(+), 0 deletions(-)
 create mode 100644 intel/intel_aub.h
intel/Makefile.am +1 -0
index 06362b6..dc01a96 100644
@@ -53,6 +53,7 @@ intel_bufmgr_gem_o_CFLAGS = $(AM_CFLAGS) -c99
 
 libdrm_intelincludedir = ${includedir}/libdrm
 libdrm_intelinclude_HEADERS = intel_bufmgr.h \
+			      intel_aub.h \
 			      intel_debug.h
 
 # This may be interesting even outside of "make check", due to the -dump option.
intel/intel_aub.h new file +123 -0

123 lines not on this page · raw message

intel/intel_bufmgr.h +14 -0
index 8036031..fa6f2b8 100644
@@ -36,6 +36,7 @@
 
 #include <stdio.h>
 #include <stdint.h>
+#include <stdio.h>
 
 struct drm_clip_rect;
 
@@ -84,6 +85,13 @@ struct _drm_intel_bo {
 	int handle;
 };
 
+enum aub_dump_bmp_format {
+	AUB_DUMP_BMP_FORMAT_8BIT = 1,
+	AUB_DUMP_BMP_FORMAT_ARGB_4444 = 4,
+	AUB_DUMP_BMP_FORMAT_ARGB_0888 = 6,
+	AUB_DUMP_BMP_FORMAT_ARGB_8888 = 7,
+};
+
 #define BO_ALLOC_FOR_RENDER (1<<0)
 
 drm_intel_bo *drm_intel_bo_alloc(drm_intel_bufmgr *bufmgr, const char *name,
@@ -154,6 +162,12 @@ int drm_intel_gem_bo_get_reloc_count(drm_intel_bo *bo);
 void drm_intel_gem_bo_clear_relocs(drm_intel_bo *bo, int start);
 void drm_intel_gem_bo_start_gtt_access(drm_intel_bo *bo, int write_enable);
 
+void drm_intel_bufmgr_gem_set_aub_dump(drm_intel_bufmgr *bufmgr, int enable);
+void drm_intel_gem_bo_aub_dump_bmp(drm_intel_bo *bo,
+				   int x1, int y1, int width, int height,
+				   enum aub_dump_bmp_format format,
+				   int pitch, int offset);
+
 int drm_intel_get_pipe_from_crtc_id(drm_intel_bufmgr *bufmgr, int crtc_id);
 
 int drm_intel_get_aperture_sizes(int fd, size_t *mappable, size_t *total);
intel/intel_bufmgr_gem.c +315 -0

351 lines not on this page · raw message

Signature · 6 lines
1.7.9.1

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
#2 lore raw

Re: [PATCH 2/2] intel: Add .aub file output support.

Quoted 508 lines · Eric Anholt

From: Kenneth Graunke <[email protected]>

This will allow the driver to capture all of its execution state to a file for later debugging. intel_gpu_dump is limited in that it only captures batchbuffers, and Mesa's captures, while more complete, still capture only a portion of the state involved in execution.

It also enables us to load traces in our internal simulator.

---
 intel/Makefile.am        |    1 +
 intel/intel_aub.h        |  123 ++++++++++++++++++
 intel/intel_bufmgr.h     |   14 ++
 intel/intel_bufmgr_gem.c |  315 ++++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 453 insertions(+), 0 deletions(-)
 create mode 100644 intel/intel_aub.h
intel/Makefile.am +1 -0
index 06362b6..dc01a96 100644
@@ -53,6 +53,7 @@ intel_bufmgr_gem_o_CFLAGS = $(AM_CFLAGS) -c99
 
 libdrm_intelincludedir = ${includedir}/libdrm
 libdrm_intelinclude_HEADERS = intel_bufmgr.h \
+			      intel_aub.h \
 			      intel_debug.h
 
 # This may be interesting even outside of "make check", due to the -dump option.
intel/intel_aub.h new file +123 -0
new file mode 100644
index 0000000..a36fd53
@@ -0,0 +1,123 @@
+/*
+ * Copyright © 2010 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:
+ *    Eric Anholt <[email protected]>
+ *
+ */
+
+/** @file intel_aub.h
+ *
+ * The AUB file is a file format used by Intel's internal simulation
+ * and other validation tools.  It can be used at various levels by a
+ * driver to input state to the simulated hardware or a replaying
+ * debugger.
+ *
+ * We choose to dump AUB files using the trace block format for ease
+ * of implementation -- dump out the blocks of memory as plain blobs
+ * and insert ring commands to execute the batchbuffer blob.
+ */
+
+#ifndef _INTEL_AUB_H
+#define _INTEL_AUB_H
+
+#define AUB_MI_NOOP			(0)
+#define AUB_MI_BATCH_BUFFER_START 	(0x31 << 23)
+#define AUB_PIPE_CONTROL		(0x7a000002)
+
+/* DW0: instruction type. */
+
+#define CMD_AUB			(7 << 29)
+
+#define CMD_AUB_HEADER		(CMD_AUB | (1 << 23) | (0x05 << 16))
+/* DW1 */
+# define AUB_HEADER_MAJOR_SHIFT		24
+# define AUB_HEADER_MINOR_SHIFT		16
+
+#define CMD_AUB_TRACE_HEADER_BLOCK (CMD_AUB | (1 << 23) | (0x41 << 16))
+#define CMD_AUB_DUMP_BMP           (CMD_AUB | (1 << 23) | (0x9e << 16))
+
+/* DW1 */
+#define AUB_TRACE_OPERATION_MASK	0x000000ff
+#define AUB_TRACE_OP_COMMENT		0x00000000
+#define AUB_TRACE_OP_DATA_WRITE		0x00000001
+#define AUB_TRACE_OP_COMMAND_WRITE	0x00000002
+#define AUB_TRACE_OP_MMIO_WRITE		0x00000003
+// operation = TRACE_DATA_WRITE, Type
+#define AUB_TRACE_TYPE_MASK		0x0000ff00
+#define AUB_TRACE_TYPE_NOTYPE		(0 << 8)
+#define AUB_TRACE_TYPE_BATCH		(1 << 8)
+#define AUB_TRACE_TYPE_VERTEX_BUFFER	(5 << 8)
+#define AUB_TRACE_TYPE_2D_MAP		(6 << 8)
+#define AUB_TRACE_TYPE_CUBE_MAP		(7 << 8)
+#define AUB_TRACE_TYPE_VOLUME_MAP	(9 << 8)
+#define AUB_TRACE_TYPE_1D_MAP		(10 << 8)
+#define AUB_TRACE_TYPE_CONSTANT_BUFFER	(11 << 8)
+#define AUB_TRACE_TYPE_CONSTANT_URB	(12 << 8)
+#define AUB_TRACE_TYPE_INDEX_BUFFER	(13 << 8)
+#define AUB_TRACE_TYPE_GENERAL		(14 << 8)
+#define AUB_TRACE_TYPE_SURFACE		(15 << 8)
+
+
+// operation = TRACE_COMMAND_WRITE, Type =
+#define AUB_TRACE_TYPE_RING_HWB		(1 << 8)
+#define AUB_TRACE_TYPE_RING_PRB0	(2 << 8)
+#define AUB_TRACE_TYPE_RING_PRB1	(3 << 8)
+#define AUB_TRACE_TYPE_RING_PRB2	(4 << 8)
+
+// Address space
+#define AUB_TRACE_ADDRESS_SPACE_MASK	0x00ff0000
+#define AUB_TRACE_MEMTYPE_GTT		(0 << 16)
+#define AUB_TRACE_MEMTYPE_LOCAL		(1 << 16)
+#define AUB_TRACE_MEMTYPE_NONLOCAL	(2 << 16)
+#define AUB_TRACE_MEMTYPE_PCI		(3 << 16)
+#define AUB_TRACE_MEMTYPE_GTT_ENTRY     (4 << 16)
+
+/* DW2 */
+// operation = TRACE_DATA_WRITE, Type = TRACE_DATA_WRITE_GENERAL_STATE
+#define AUB_TRACE_GENERAL_STATE_MASK	0x000000ff
+
+#define AUB_TRACE_VS_STATE		0x00000001
+#define AUB_TRACE_GS_STATE		0x00000002
+#define AUB_TRACE_CL_STATE		0x00000003
+#define AUB_TRACE_SF_STATE		0x00000004
+#define AUB_TRACE_WM_STATE		0x00000005
+#define AUB_TRACE_CC_STATE		0x00000006
+#define AUB_TRACE_CL_VP			0x00000007
+#define AUB_TRACE_SF_VP			0x00000008
+#define AUB_TRACE_CC_VP			0x00000009
+#define AUB_TRACE_SAMPLER_STATE		0x0000000a
+#define AUB_TRACE_KERNEL		0x0000000b
+#define AUB_TRACE_SCRATCH		0x0000000c
+#define AUB_TRACE_SDC			0x0000000d
+#define AUB_TRACE_BLEND_STATE		0x00000016
+#define AUB_TRACE_DEPTH_STENCIL_STATE	0x00000017
+
+// operation = TRACE_DATA_WRITE, Type = TRACE_DATA_WRITE_SURFACE_STATE
+#define AUB_TRACE_SURFACE_STATE_MASK	0x00000ff00
+#define AUB_TRACE_BINDING_TABLE		0x000000100
+#define AUB_TRACE_SURFACE_STATE		0x000000200
+
+/* DW3: address */
+/* DW4: len */
+
+#endif /* _INTEL_AUB_H */
intel/intel_bufmgr.h +14 -0
index 8036031..fa6f2b8 100644
@@ -36,6 +36,7 @@
 
 #include <stdio.h>
 #include <stdint.h>
+#include <stdio.h>
 
 struct drm_clip_rect;
 
@@ -84,6 +85,13 @@ struct _drm_intel_bo {
 	int handle;
 };
 
+enum aub_dump_bmp_format {
+	AUB_DUMP_BMP_FORMAT_8BIT = 1,
+	AUB_DUMP_BMP_FORMAT_ARGB_4444 = 4,
+	AUB_DUMP_BMP_FORMAT_ARGB_0888 = 6,
+	AUB_DUMP_BMP_FORMAT_ARGB_8888 = 7,
+};
+
 #define BO_ALLOC_FOR_RENDER (1<<0)
 
 drm_intel_bo *drm_intel_bo_alloc(drm_intel_bufmgr *bufmgr, const char *name,
@@ -154,6 +162,12 @@ int drm_intel_gem_bo_get_reloc_count(drm_intel_bo *bo);
 void drm_intel_gem_bo_clear_relocs(drm_intel_bo *bo, int start);
 void drm_intel_gem_bo_start_gtt_access(drm_intel_bo *bo, int write_enable);
 
+void drm_intel_bufmgr_gem_set_aub_dump(drm_intel_bufmgr *bufmgr, int enable);
+void drm_intel_gem_bo_aub_dump_bmp(drm_intel_bo *bo,
+				   int x1, int y1, int width, int height,
+				   enum aub_dump_bmp_format format,
+				   int pitch, int offset);
+
 int drm_intel_get_pipe_from_crtc_id(drm_intel_bufmgr *bufmgr, int crtc_id);
 
 int drm_intel_get_aperture_sizes(int fd, size_t *mappable, size_t *total);
intel/intel_bufmgr_gem.c +265 -0
index ba38e50..45585f7 100644
@@ -58,6 +58,7 @@
 #include "intel_bufmgr.h"
 #include "intel_bufmgr_priv.h"
 #include "intel_chipset.h"
+#include "intel_aub.h"
 #include "string.h"
 
 #include "i915_drm.h"
@@ -121,6 +122,9 @@ typedef struct _drm_intel_bufmgr_gem {
 	unsigned int bo_reuse : 1;
 	unsigned int no_exec : 1;
 	bool fenced_relocs;
+
+	FILE *aub_file;
+	uint32_t aub_offset;
 } drm_intel_bufmgr_gem;
 
 #define DRM_INTEL_RELOC_FENCE (1<<0)
@@ -215,6 +219,8 @@ struct _drm_intel_bo_gem {
 
 	/** Flags that we may need to do the SW_FINSIH ioctl on unmap. */
 	bool mapped_cpu_write;
+
+	uint32_t aub_offset;
 };
 
 static unsigned int
@@ -1715,6 +1721,247 @@ drm_intel_update_buffer_offsets2 (drm_intel_bufmgr_gem *bufmgr_gem)
 	}
 }
 
+static void
+aub_out(drm_intel_bufmgr_gem *bufmgr_gem, uint32_t data)
+{
+	fwrite(&data, 1, 4, bufmgr_gem->aub_file);
+}
+
+static void
+aub_out_data(drm_intel_bufmgr_gem *bufmgr_gem, void *data, size_t size)
+{
+	fwrite(data, 1, size, bufmgr_gem->aub_file);
+}
+
+static void
+aub_write_bo_data(drm_intel_bo *bo, uint32_t offset, uint32_t size)
+{
+	drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
+	drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
+	uint32_t *data;
+	unsigned int i;
+
+	data = malloc(bo->size);
+	drm_intel_bo_get_subdata(bo, offset, size, data);
+
+	/* Easy mode: write out bo with no relocations */
+	if (!bo_gem->reloc_count) {
+		aub_out_data(bufmgr_gem, data, size);
+		free(data);
+		return;
+	}
+
+	/* Otherwise, handle the relocations while writing. */
+	for (i = 0; i < size / 4; i++) {
+		int r;
+		for (r = 0; r < bo_gem->reloc_count; r++) {
+			struct drm_i915_gem_relocation_entry *reloc;
+			drm_intel_reloc_target *info;
+
+			reloc = &bo_gem->relocs[r];
+			info = &bo_gem->reloc_target_info[r];
+
+			if (reloc->offset == offset + i * 4) {
+				drm_intel_bo_gem *target_gem;
+				uint32_t val;
+
+				target_gem = (drm_intel_bo_gem *)info->bo;
+
+				val = reloc->delta;
+				val += target_gem->aub_offset;
+
+				aub_out(bufmgr_gem, val);
+				data[i] = val;
+				break;
+			}
+		}
+		if (r == bo_gem->reloc_count) {
+			/* no relocation, just the data */
+			aub_out(bufmgr_gem, data[i]);
+		}
+	}
+
+	free(data);
+}
+
+static void
+aub_bo_get_address(drm_intel_bo *bo)
+{
+	drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
+	drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
+
+	/* Give the object a graphics address in the AUB file.  We
+	 * don't just use the GEM object address because we do AUB
+	 * dumping before execution -- we want to successfully log
+	 * when the hardware might hang, and we might even want to aub
+	 * capture for a driver trying to execute on a different
+	 * generation of hardware by disabling the actual kernel exec
+	 * call.
+	 */
+	bo_gem->aub_offset = bufmgr_gem->aub_offset;
+	bufmgr_gem->aub_offset += bo->size;
+	/* XXX: Handle aperture overflow. */
+	assert(bufmgr_gem->aub_offset < 256 * 1024 * 1024);
+}
+
+static void
+aub_write_trace_block(drm_intel_bo *bo, uint32_t type, uint32_t subtype,
+		      uint32_t offset, uint32_t size)
+{
+	drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
+	drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
+
+	aub_out(bufmgr_gem,
+		CMD_AUB_TRACE_HEADER_BLOCK |
+		(5 - 2));
+	aub_out(bufmgr_gem,
+		AUB_TRACE_MEMTYPE_GTT | type | AUB_TRACE_OP_DATA_WRITE);
+	aub_out(bufmgr_gem, subtype);
+	aub_out(bufmgr_gem, bo_gem->aub_offset + offset);
+	aub_out(bufmgr_gem, size);
+	aub_write_bo_data(bo, offset, size);
+}
+
+static void
+aub_write_bo(drm_intel_bo *bo)
+{
+	uint32_t block_size;
+	uint32_t offset;
+
+	aub_bo_get_address(bo);
+
+	/* Break up large objects into multiple writes.  Otherwise a
+	 * 128kb VBO would overflow the 16 bits of size field in the
+	 * packet header and everything goes badly after that.
+	 */
+	for (offset = 0; offset < bo->size; offset += block_size) {
+		block_size = bo->size - offset;
+
+		if (block_size > 8 * 4096)
+			block_size = 8 * 4096;
+
+		aub_write_trace_block(bo, AUB_TRACE_TYPE_NOTYPE, 0,
+				      offset, block_size);
+	}
+}
+
+/*
+ * Make a ringbuffer on fly and dump it
+ */
+static void
+aub_build_dump_ringbuffer(drm_intel_bufmgr_gem *bufmgr_gem,
+			  uint32_t batch_buffer, int ring_flag)
+{
+	uint32_t ringbuffer[4096];
+	int ring = AUB_TRACE_TYPE_RING_PRB0; /* The default ring */
+	int ring_count = 0;
+
+	if (ring_flag == I915_EXEC_BSD)
+		ring = AUB_TRACE_TYPE_RING_PRB1;
+
+	/* Make a ring buffer to execute our batchbuffer. */
+	memset(ringbuffer, 0, sizeof(ringbuffer));
+	ringbuffer[ring_count++] = AUB_MI_BATCH_BUFFER_START;
+	ringbuffer[ring_count++] = batch_buffer;
+
+	/* Write out the ring.  This appears to trigger execution of
+	 * the ring in the simulator.
+	 */
+	aub_out(bufmgr_gem,
+		CMD_AUB_TRACE_HEADER_BLOCK |
+		(5 - 2));
+	aub_out(bufmgr_gem,
+		AUB_TRACE_MEMTYPE_GTT | ring | AUB_TRACE_OP_COMMAND_WRITE);
+	aub_out(bufmgr_gem, 0); /* general/surface subtype */
+	aub_out(bufmgr_gem, bufmgr_gem->aub_offset);
+	aub_out(bufmgr_gem, ring_count * 4);
+
+	/* FIXME: Need some flush operations here? */
+	aub_out_data(bufmgr_gem, ringbuffer, ring_count * 4);
+
+	/* Update offset pointer */
+	bufmgr_gem->aub_offset += 4096;
+}
+
+void
+drm_intel_gem_bo_aub_dump_bmp(drm_intel_bo *bo,
+			      int x1, int y1, int width, int height,
+			      enum aub_dump_bmp_format format,
+			      int pitch, int offset)
+{
+	drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
+	drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
+	uint32_t cpp;
+
+	switch (format) {
+	case AUB_DUMP_BMP_FORMAT_8BIT:
+		cpp = 1;
+		break;
+	case AUB_DUMP_BMP_FORMAT_ARGB_4444:
+		cpp = 2;
+		break;
+	case AUB_DUMP_BMP_FORMAT_ARGB_0888:
+	case AUB_DUMP_BMP_FORMAT_ARGB_8888:
+		cpp = 4;
+		break;
+	default:
+		printf("Unknown AUB dump format %d\n", format);
+		return;
+	}
+
+	if (!bufmgr_gem->aub_file)
+		return;
+
+	aub_out(bufmgr_gem, CMD_AUB_DUMP_BMP | 4);
+	aub_out(bufmgr_gem, (y1 << 16) | x1);
+	aub_out(bufmgr_gem,
+		(format << 24) |
+		(cpp << 19) |
+		pitch / 4);
+	aub_out(bufmgr_gem, (height << 16) | width);
+	aub_out(bufmgr_gem, bo_gem->aub_offset + offset);
+	aub_out(bufmgr_gem,
+		((bo_gem->tiling_mode != I915_TILING_NONE) ? (1 << 2) : 0) |
+		((bo_gem->tiling_mode == I915_TILING_Y) ? (1 << 3) : 0));
+}
+
+static void
+aub_exec(drm_intel_bo *bo, int ring_flag, int used)
+{
+	drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
+	drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
+	int i;
+
+	if (!bufmgr_gem->aub_file)
+		return;
+
+	/* Write out all but the batchbuffer to AUB memory */
+	for (i = 0; i < bufmgr_gem->exec_count - 1; i++) {
+		if (bufmgr_gem->exec_bos[i] != bo)
+			aub_write_bo(bufmgr_gem->exec_bos[i]);
+	}
+
+	aub_bo_get_address(bo);
+
+	/* Dump the batchbuffer. */
+	aub_write_trace_block(bo, AUB_TRACE_TYPE_BATCH, 0,
+			      0, used);
+	aub_write_trace_block(bo, AUB_TRACE_TYPE_NOTYPE, 0,
+			      used, bo->size - used);
+
+	/* Dump ring buffer */
+	aub_build_dump_ringbuffer(bufmgr_gem, bo_gem->aub_offset, ring_flag);
+
+	fflush(bufmgr_gem->aub_file);
+
+	/*
+	 * One frame has been dumped. So reset the aub_offset for the next frame.
+	 *
+	 * FIXME: Can we do this?
+	 */
+	bufmgr_gem->aub_offset = 0x10000;
+}
+
 static int
 drm_intel_gem_bo_exec(drm_intel_bo *bo, int used,
 		      drm_clip_rect_t * cliprects, int num_cliprects, int DR4)
@@ -1830,6 +2077,8 @@ drm_intel_gem_bo_mrb_exec2(drm_intel_bo *bo, int used,
 	execbuf.rsvd1 = 0;
 	execbuf.rsvd2 = 0;
 
+	aub_exec(bo, flags, used);
+
 	if (bufmgr_gem->no_exec)
 		goto skip_execution;
 
@@ -2360,6 +2609,72 @@ drm_intel_bufmgr_gem_get_devid(drm_intel_bufmgr *bufmgr)
 }
 
 /**
+ * Sets up AUB dumping.
+ *
+ * This is a trace file format that can be used with the simulator.
+ * Packets are emitted in a format somewhat like GPU command packets.
+ * You can set up a GTT and upload your objects into the referenced
+ * space, then send off batchbuffers and get BMPs out the other end.
+ */
+void
+drm_intel_bufmgr_gem_set_aub_dump(drm_intel_bufmgr *bufmgr, int enable)
+{
+	drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
+	int entry = 0x200003;
+	int i;
+	int gtt_size = 0x10000;
+
+	if (!enable) {

intel/intel_bufmgr_gem.c drm_intel_bufmgr_gem_get_devid(drm_intel_bufmgr *bufmgr) · line 2637

Quoted 10 lines
intel/intel_bufmgr_gem.c +10 -0
+		if (bufmgr_gem->aub_file) {
+			fclose(bufmgr_gem->aub_file);
+			bufmgr_gem->aub_file = NULL;
+		}
+	}
+
+	if (geteuid() != getuid())
+		return;
+
+	bufmgr_gem->aub_file = fopen("intel.aub", "w+");

I guess it's would be better that we can name the aub dump file according to the program we are tracing, like if we run:

 $ INTEL_DEBUG=aub glxgears

I guess it would be good if we get a glxgears.aub but not intel.aub. Otherwise, it would override the former one we dumped. It's somehow a little un-convenient.

Quoted 27 lines
intel/intel_bufmgr_gem.c +27 -0
+	if (!bufmgr_gem->aub_file)
+		return;
+
+	/* Start allocating objects from just after the GTT. */
+	bufmgr_gem->aub_offset = gtt_size;
+
+	/* Start with a (required) version packet. */
+	aub_out(bufmgr_gem, CMD_AUB_HEADER | (13 - 2));
+	aub_out(bufmgr_gem,
+		(4 << AUB_HEADER_MAJOR_SHIFT) |
+		(0 << AUB_HEADER_MINOR_SHIFT));
+	for (i = 0; i < 8; i++) {
+		aub_out(bufmgr_gem, 0); /* app name */
+	}
+	aub_out(bufmgr_gem, 0); /* timestamp */
+	aub_out(bufmgr_gem, 0); /* timestamp */
+	aub_out(bufmgr_gem, 0); /* comment len */
+
+	/* Set up the GTT. The max we can handle is 256M */
+	aub_out(bufmgr_gem, CMD_AUB_TRACE_HEADER_BLOCK | (5 - 2));
+	aub_out(bufmgr_gem, AUB_TRACE_MEMTYPE_NONLOCAL | 0 | AUB_TRACE_OP_DATA_WRITE);
+	aub_out(bufmgr_gem, 0); /* subtype */
+	aub_out(bufmgr_gem, 0); /* offset */
+	aub_out(bufmgr_gem, gtt_size); /* size */
+	for (i = 0x000; i < gtt_size; i += 4, entry += 0x1000) {
+		aub_out(bufmgr_gem, entry);
+	}

intel/intel_bufmgr_gem.c drm_intel_bufmgr_gem_get_devid(drm_intel_bufmgr *bufmgr) · line 2674

Quoted 10 lines
intel/intel_bufmgr_gem.c +10 -0
+
+	/* MI_FLUSH enable */
+	if (bufmgr_gem->gen >= 6) {
+		aub_out(bufmgr_gem, CMD_AUB_TRACE_HEADER_BLOCK | (5 - 2));
+		aub_out(bufmgr_gem, AUB_TRACE_OP_MMIO_WRITE);
+		aub_out(bufmgr_gem, 0);
+		aub_out(bufmgr_gem, 0x209c);  /* reg addr */
+		aub_out(bufmgr_gem, 0x04);    /* Length in byte */
+		aub_out(bufmgr_gem, ((1 << 12) << 16) | (1 << 12));
+	}

Zhenyu and me came to an agreement that it's the driver side to do the MI_FLUSH enable stuff. Since using MI_FLUSH is deprecated, and if you still use it, it is your job to set up the MI_FLUSH enable bit.

Quoted 8 lines
intel/intel_bufmgr_gem.c +3 -0
+}
+
+/**
  * Initializes the GEM buffer manager, which uses the kernel to allocate, map,
  * and manage map buffer objections.
  *
Signature · 1 line
1.7.9.1
Reviewed-by
#3 lore raw

Re: [PATCH 2/2] intel: Add .aub file output support.

Quoted 522 lines · Yuanhan Liu
Quoted 508 lines · Eric Anholt

From: Kenneth Graunke<[email protected]>

This will allow the driver to capture all of its execution state to a file for later debugging. intel_gpu_dump is limited in that it only captures batchbuffers, and Mesa's captures, while more complete, still capture only a portion of the state involved in execution.

It also enables us to load traces in our internal simulator.

---
  intel/Makefile.am        |    1 +
  intel/intel_aub.h        |  123 ++++++++++++++++++
  intel/intel_bufmgr.h     |   14 ++
  intel/intel_bufmgr_gem.c |  315 ++++++++++++++++++++++++++++++++++++++++++++++
  4 files changed, 453 insertions(+), 0 deletions(-)

create mode 100644 intel/intel_aub.h

intel/Makefile.am +1 -0
index 06362b6..dc01a96 100644
@@ -53,6 +53,7 @@ intel_bufmgr_gem_o_CFLAGS = $(AM_CFLAGS) -c99
 
  libdrm_intelincludedir = ${includedir}/libdrm
  libdrm_intelinclude_HEADERS = intel_bufmgr.h \
+			      intel_aub.h \
  			      intel_debug.h
 
  # This may be interesting even outside of "make check", due to the -dump option.
intel/intel_aub.h new file +123 -0
new file mode 100644
index 0000000..a36fd53
@@ -0,0 +1,123 @@
+/*
+ * Copyright © 2010 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:
+ *    Eric Anholt<[email protected]>
+ *
+ */
+
+/** @file intel_aub.h
+ *
+ * The AUB file is a file format used by Intel's internal simulation
+ * and other validation tools.  It can be used at various levels by a
+ * driver to input state to the simulated hardware or a replaying
+ * debugger.
+ *
+ * We choose to dump AUB files using the trace block format for ease
+ * of implementation -- dump out the blocks of memory as plain blobs
+ * and insert ring commands to execute the batchbuffer blob.
+ */
+
+#ifndef _INTEL_AUB_H
+#define _INTEL_AUB_H
+
+#define AUB_MI_NOOP			(0)
+#define AUB_MI_BATCH_BUFFER_START 	(0x31<<  23)
+#define AUB_PIPE_CONTROL		(0x7a000002)
+
+/* DW0: instruction type. */
+
+#define CMD_AUB			(7<<  29)
+
+#define CMD_AUB_HEADER		(CMD_AUB | (1<<  23) | (0x05<<  16))
+/* DW1 */
+# define AUB_HEADER_MAJOR_SHIFT		24
+# define AUB_HEADER_MINOR_SHIFT		16
+
+#define CMD_AUB_TRACE_HEADER_BLOCK (CMD_AUB | (1<<  23) | (0x41<<  16))
+#define CMD_AUB_DUMP_BMP           (CMD_AUB | (1<<  23) | (0x9e<<  16))
+
+/* DW1 */
+#define AUB_TRACE_OPERATION_MASK	0x000000ff
+#define AUB_TRACE_OP_COMMENT		0x00000000
+#define AUB_TRACE_OP_DATA_WRITE		0x00000001
+#define AUB_TRACE_OP_COMMAND_WRITE	0x00000002
+#define AUB_TRACE_OP_MMIO_WRITE		0x00000003
+// operation = TRACE_DATA_WRITE, Type
+#define AUB_TRACE_TYPE_MASK		0x0000ff00
+#define AUB_TRACE_TYPE_NOTYPE		(0<<  8)
+#define AUB_TRACE_TYPE_BATCH		(1<<  8)
+#define AUB_TRACE_TYPE_VERTEX_BUFFER	(5<<  8)
+#define AUB_TRACE_TYPE_2D_MAP		(6<<  8)
+#define AUB_TRACE_TYPE_CUBE_MAP		(7<<  8)
+#define AUB_TRACE_TYPE_VOLUME_MAP	(9<<  8)
+#define AUB_TRACE_TYPE_1D_MAP		(10<<  8)
+#define AUB_TRACE_TYPE_CONSTANT_BUFFER	(11<<  8)
+#define AUB_TRACE_TYPE_CONSTANT_URB	(12<<  8)
+#define AUB_TRACE_TYPE_INDEX_BUFFER	(13<<  8)
+#define AUB_TRACE_TYPE_GENERAL		(14<<  8)
+#define AUB_TRACE_TYPE_SURFACE		(15<<  8)
+
+
+// operation = TRACE_COMMAND_WRITE, Type =
+#define AUB_TRACE_TYPE_RING_HWB		(1<<  8)
+#define AUB_TRACE_TYPE_RING_PRB0	(2<<  8)
+#define AUB_TRACE_TYPE_RING_PRB1	(3<<  8)
+#define AUB_TRACE_TYPE_RING_PRB2	(4<<  8)
+
+// Address space
+#define AUB_TRACE_ADDRESS_SPACE_MASK	0x00ff0000
+#define AUB_TRACE_MEMTYPE_GTT		(0<<  16)
+#define AUB_TRACE_MEMTYPE_LOCAL		(1<<  16)
+#define AUB_TRACE_MEMTYPE_NONLOCAL	(2<<  16)
+#define AUB_TRACE_MEMTYPE_PCI		(3<<  16)
+#define AUB_TRACE_MEMTYPE_GTT_ENTRY     (4<<  16)
+
+/* DW2 */
+// operation = TRACE_DATA_WRITE, Type = TRACE_DATA_WRITE_GENERAL_STATE
+#define AUB_TRACE_GENERAL_STATE_MASK	0x000000ff
+
+#define AUB_TRACE_VS_STATE		0x00000001
+#define AUB_TRACE_GS_STATE		0x00000002
+#define AUB_TRACE_CL_STATE		0x00000003
+#define AUB_TRACE_SF_STATE		0x00000004
+#define AUB_TRACE_WM_STATE		0x00000005
+#define AUB_TRACE_CC_STATE		0x00000006
+#define AUB_TRACE_CL_VP			0x00000007
+#define AUB_TRACE_SF_VP			0x00000008
+#define AUB_TRACE_CC_VP			0x00000009
+#define AUB_TRACE_SAMPLER_STATE		0x0000000a
+#define AUB_TRACE_KERNEL		0x0000000b
+#define AUB_TRACE_SCRATCH		0x0000000c
+#define AUB_TRACE_SDC			0x0000000d
+#define AUB_TRACE_BLEND_STATE		0x00000016
+#define AUB_TRACE_DEPTH_STENCIL_STATE	0x00000017
+
+// operation = TRACE_DATA_WRITE, Type = TRACE_DATA_WRITE_SURFACE_STATE
+#define AUB_TRACE_SURFACE_STATE_MASK	0x00000ff00
+#define AUB_TRACE_BINDING_TABLE		0x000000100
+#define AUB_TRACE_SURFACE_STATE		0x000000200
+
+/* DW3: address */
+/* DW4: len */
+
+#endif /* _INTEL_AUB_H */
intel/intel_bufmgr.h +14 -0
index 8036031..fa6f2b8 100644
@@ -36,6 +36,7 @@
 
  #include<stdio.h>
  #include<stdint.h>
+#include<stdio.h>
 
  struct drm_clip_rect;
 
@@ -84,6 +85,13 @@ struct _drm_intel_bo {
  	int handle;
  };
 
+enum aub_dump_bmp_format {
+	AUB_DUMP_BMP_FORMAT_8BIT = 1,
+	AUB_DUMP_BMP_FORMAT_ARGB_4444 = 4,
+	AUB_DUMP_BMP_FORMAT_ARGB_0888 = 6,
+	AUB_DUMP_BMP_FORMAT_ARGB_8888 = 7,
+};
+
  #define BO_ALLOC_FOR_RENDER (1<<0)
 
  drm_intel_bo *drm_intel_bo_alloc(drm_intel_bufmgr *bufmgr, const char *name,
@@ -154,6 +162,12 @@ int drm_intel_gem_bo_get_reloc_count(drm_intel_bo *bo);
  void drm_intel_gem_bo_clear_relocs(drm_intel_bo *bo, int start);
  void drm_intel_gem_bo_start_gtt_access(drm_intel_bo *bo, int write_enable);
 
+void drm_intel_bufmgr_gem_set_aub_dump(drm_intel_bufmgr *bufmgr, int enable);
+void drm_intel_gem_bo_aub_dump_bmp(drm_intel_bo *bo,
+				   int x1, int y1, int width, int height,
+				   enum aub_dump_bmp_format format,
+				   int pitch, int offset);
+
  int drm_intel_get_pipe_from_crtc_id(drm_intel_bufmgr *bufmgr, int crtc_id);
 
  int drm_intel_get_aperture_sizes(int fd, size_t *mappable, size_t *total);
intel/intel_bufmgr_gem.c +265 -0
index ba38e50..45585f7 100644
@@ -58,6 +58,7 @@
  #include "intel_bufmgr.h"
  #include "intel_bufmgr_priv.h"
  #include "intel_chipset.h"
+#include "intel_aub.h"
  #include "string.h"
 
  #include "i915_drm.h"
@@ -121,6 +122,9 @@ typedef struct _drm_intel_bufmgr_gem {
  	unsigned int bo_reuse : 1;
  	unsigned int no_exec : 1;
  	bool fenced_relocs;
+
+	FILE *aub_file;
+	uint32_t aub_offset;
  } drm_intel_bufmgr_gem;
 
  #define DRM_INTEL_RELOC_FENCE (1<<0)
@@ -215,6 +219,8 @@ struct _drm_intel_bo_gem {
 
  	/** Flags that we may need to do the SW_FINSIH ioctl on unmap. */
  	bool mapped_cpu_write;
+
+	uint32_t aub_offset;
  };
 
  static unsigned int
@@ -1715,6 +1721,247 @@ drm_intel_update_buffer_offsets2 (drm_intel_bufmgr_gem *bufmgr_gem)
  	}
  }
 
+static void
+aub_out(drm_intel_bufmgr_gem *bufmgr_gem, uint32_t data)
+{
+	fwrite(&data, 1, 4, bufmgr_gem->aub_file);
+}
+
+static void
+aub_out_data(drm_intel_bufmgr_gem *bufmgr_gem, void *data, size_t size)
+{
+	fwrite(data, 1, size, bufmgr_gem->aub_file);
+}
+
+static void
+aub_write_bo_data(drm_intel_bo *bo, uint32_t offset, uint32_t size)
+{
+	drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
+	drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
+	uint32_t *data;
+	unsigned int i;
+
+	data = malloc(bo->size);
+	drm_intel_bo_get_subdata(bo, offset, size, data);
+
+	/* Easy mode: write out bo with no relocations */
+	if (!bo_gem->reloc_count) {
+		aub_out_data(bufmgr_gem, data, size);
+		free(data);
+		return;
+	}
+
+	/* Otherwise, handle the relocations while writing. */
+	for (i = 0; i<  size / 4; i++) {
+		int r;
+		for (r = 0; r<  bo_gem->reloc_count; r++) {
+			struct drm_i915_gem_relocation_entry *reloc;
+			drm_intel_reloc_target *info;
+
+			reloc =&bo_gem->relocs[r];
+			info =&bo_gem->reloc_target_info[r];
+
+			if (reloc->offset == offset + i * 4) {
+				drm_intel_bo_gem *target_gem;
+				uint32_t val;
+
+				target_gem = (drm_intel_bo_gem *)info->bo;
+
+				val = reloc->delta;
+				val += target_gem->aub_offset;
+
+				aub_out(bufmgr_gem, val);
+				data[i] = val;
+				break;
+			}
+		}
+		if (r == bo_gem->reloc_count) {
+			/* no relocation, just the data */
+			aub_out(bufmgr_gem, data[i]);
+		}
+	}
+
+	free(data);
+}
+
+static void
+aub_bo_get_address(drm_intel_bo *bo)
+{
+	drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
+	drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
+
+	/* Give the object a graphics address in the AUB file.  We
+	 * don't just use the GEM object address because we do AUB
+	 * dumping before execution -- we want to successfully log
+	 * when the hardware might hang, and we might even want to aub
+	 * capture for a driver trying to execute on a different
+	 * generation of hardware by disabling the actual kernel exec
+	 * call.
+	 */
+	bo_gem->aub_offset = bufmgr_gem->aub_offset;
+	bufmgr_gem->aub_offset += bo->size;
+	/* XXX: Handle aperture overflow. */
+	assert(bufmgr_gem->aub_offset<  256 * 1024 * 1024);
+}
+
+static void
+aub_write_trace_block(drm_intel_bo *bo, uint32_t type, uint32_t subtype,
+		      uint32_t offset, uint32_t size)
+{
+	drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
+	drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
+
+	aub_out(bufmgr_gem,
+		CMD_AUB_TRACE_HEADER_BLOCK |
+		(5 - 2));
+	aub_out(bufmgr_gem,
+		AUB_TRACE_MEMTYPE_GTT | type | AUB_TRACE_OP_DATA_WRITE);
+	aub_out(bufmgr_gem, subtype);
+	aub_out(bufmgr_gem, bo_gem->aub_offset + offset);
+	aub_out(bufmgr_gem, size);
+	aub_write_bo_data(bo, offset, size);
+}
+
+static void
+aub_write_bo(drm_intel_bo *bo)
+{
+	uint32_t block_size;
+	uint32_t offset;
+
+	aub_bo_get_address(bo);
+
+	/* Break up large objects into multiple writes.  Otherwise a
+	 * 128kb VBO would overflow the 16 bits of size field in the
+	 * packet header and everything goes badly after that.
+	 */
+	for (offset = 0; offset<  bo->size; offset += block_size) {
+		block_size = bo->size - offset;
+
+		if (block_size>  8 * 4096)
+			block_size = 8 * 4096;
+
+		aub_write_trace_block(bo, AUB_TRACE_TYPE_NOTYPE, 0,
+				      offset, block_size);
+	}
+}
+
+/*
+ * Make a ringbuffer on fly and dump it
+ */
+static void
+aub_build_dump_ringbuffer(drm_intel_bufmgr_gem *bufmgr_gem,
+			  uint32_t batch_buffer, int ring_flag)
+{
+	uint32_t ringbuffer[4096];
+	int ring = AUB_TRACE_TYPE_RING_PRB0; /* The default ring */
+	int ring_count = 0;
+
+	if (ring_flag == I915_EXEC_BSD)
+		ring = AUB_TRACE_TYPE_RING_PRB1;
+
+	/* Make a ring buffer to execute our batchbuffer. */
+	memset(ringbuffer, 0, sizeof(ringbuffer));
+	ringbuffer[ring_count++] = AUB_MI_BATCH_BUFFER_START;
+	ringbuffer[ring_count++] = batch_buffer;
+
+	/* Write out the ring.  This appears to trigger execution of
+	 * the ring in the simulator.
+	 */
+	aub_out(bufmgr_gem,
+		CMD_AUB_TRACE_HEADER_BLOCK |
+		(5 - 2));
+	aub_out(bufmgr_gem,
+		AUB_TRACE_MEMTYPE_GTT | ring | AUB_TRACE_OP_COMMAND_WRITE);
+	aub_out(bufmgr_gem, 0); /* general/surface subtype */
+	aub_out(bufmgr_gem, bufmgr_gem->aub_offset);
+	aub_out(bufmgr_gem, ring_count * 4);
+
+	/* FIXME: Need some flush operations here? */
+	aub_out_data(bufmgr_gem, ringbuffer, ring_count * 4);
+
+	/* Update offset pointer */
+	bufmgr_gem->aub_offset += 4096;
+}
+
+void
+drm_intel_gem_bo_aub_dump_bmp(drm_intel_bo *bo,
+			      int x1, int y1, int width, int height,
+			      enum aub_dump_bmp_format format,
+			      int pitch, int offset)
+{
+	drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
+	drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
+	uint32_t cpp;
+
+	switch (format) {
+	case AUB_DUMP_BMP_FORMAT_8BIT:
+		cpp = 1;
+		break;
+	case AUB_DUMP_BMP_FORMAT_ARGB_4444:
+		cpp = 2;
+		break;
+	case AUB_DUMP_BMP_FORMAT_ARGB_0888:
+	case AUB_DUMP_BMP_FORMAT_ARGB_8888:
+		cpp = 4;
+		break;
+	default:
+		printf("Unknown AUB dump format %d\n", format);
+		return;
+	}
+
+	if (!bufmgr_gem->aub_file)
+		return;
+
+	aub_out(bufmgr_gem, CMD_AUB_DUMP_BMP | 4);
+	aub_out(bufmgr_gem, (y1<<  16) | x1);
+	aub_out(bufmgr_gem,
+		(format<<  24) |
+		(cpp<<  19) |
+		pitch / 4);
+	aub_out(bufmgr_gem, (height<<  16) | width);
+	aub_out(bufmgr_gem, bo_gem->aub_offset + offset);
+	aub_out(bufmgr_gem,
+		((bo_gem->tiling_mode != I915_TILING_NONE) ? (1<<  2) : 0) |
+		((bo_gem->tiling_mode == I915_TILING_Y) ? (1<<  3) : 0));
+}
+
+static void
+aub_exec(drm_intel_bo *bo, int ring_flag, int used)
+{
+	drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
+	drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
+	int i;
+
+	if (!bufmgr_gem->aub_file)
+		return;
+
+	/* Write out all but the batchbuffer to AUB memory */
+	for (i = 0; i<  bufmgr_gem->exec_count - 1; i++) {
+		if (bufmgr_gem->exec_bos[i] != bo)
+			aub_write_bo(bufmgr_gem->exec_bos[i]);
+	}
+
+	aub_bo_get_address(bo);
+
+	/* Dump the batchbuffer. */
+	aub_write_trace_block(bo, AUB_TRACE_TYPE_BATCH, 0,
+			      0, used);
+	aub_write_trace_block(bo, AUB_TRACE_TYPE_NOTYPE, 0,
+			      used, bo->size - used);
+
+	/* Dump ring buffer */
+	aub_build_dump_ringbuffer(bufmgr_gem, bo_gem->aub_offset, ring_flag);
+
+	fflush(bufmgr_gem->aub_file);
+
+	/*
+	 * One frame has been dumped. So reset the aub_offset for the next frame.
+	 *
+	 * FIXME: Can we do this?
+	 */
+	bufmgr_gem->aub_offset = 0x10000;
+}
+
  static int
  drm_intel_gem_bo_exec(drm_intel_bo *bo, int used,
  		      drm_clip_rect_t * cliprects, int num_cliprects, int DR4)
@@ -1830,6 +2077,8 @@ drm_intel_gem_bo_mrb_exec2(drm_intel_bo *bo, int used,
  	execbuf.rsvd1 = 0;
  	execbuf.rsvd2 = 0;
 
+	aub_exec(bo, flags, used);
+
  	if (bufmgr_gem->no_exec)
  		goto skip_execution;
 
@@ -2360,6 +2609,72 @@ drm_intel_bufmgr_gem_get_devid(drm_intel_bufmgr *bufmgr)
  }
 
  /**
+ * Sets up AUB dumping.
+ *
+ * This is a trace file format that can be used with the simulator.
+ * Packets are emitted in a format somewhat like GPU command packets.
+ * You can set up a GTT and upload your objects into the referenced
+ * space, then send off batchbuffers and get BMPs out the other end.
+ */
+void
+drm_intel_bufmgr_gem_set_aub_dump(drm_intel_bufmgr *bufmgr, int enable)
+{
+	drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
+	int entry = 0x200003;
+	int i;
+	int gtt_size = 0x10000;
+
+	if (!enable) {

intel/intel_bufmgr_gem.c drm_intel_bufmgr_gem_get_devid(drm_intel_bufmgr *bufmgr) · line 2637

Quoted 10 lines
intel/intel_bufmgr_gem.c +10 -0
+		if (bufmgr_gem->aub_file) {
+			fclose(bufmgr_gem->aub_file);
+			bufmgr_gem->aub_file = NULL;
+		}
+	}
+
+	if (geteuid() != getuid())
+		return;
+
+	bufmgr_gem->aub_file = fopen("intel.aub", "w+");

I guess it's would be better that we can name the aub dump file according to the program we are tracing, like if we run:

Quoted 5 lines
  $ INTEL_DEBUG=aub glxgears

I guess it would be good if we get a glxgears.aub but not intel.aub. Otherwise, it would override the former one we dumped. It's somehow a little un-convenient.

That would be a nice feature, though I'm okay with intel.aub for now.

Quoted 33 lines
Quoted 33 lines
intel/intel_bufmgr_gem.c +33 -0
+	if (!bufmgr_gem->aub_file)
+		return;
+
+	/* Start allocating objects from just after the GTT. */
+	bufmgr_gem->aub_offset = gtt_size;
+
+	/* Start with a (required) version packet. */
+	aub_out(bufmgr_gem, CMD_AUB_HEADER | (13 - 2));
+	aub_out(bufmgr_gem,
+		(4<<  AUB_HEADER_MAJOR_SHIFT) |
+		(0<<  AUB_HEADER_MINOR_SHIFT));
+	for (i = 0; i<  8; i++) {
+		aub_out(bufmgr_gem, 0); /* app name */
+	}
+	aub_out(bufmgr_gem, 0); /* timestamp */
+	aub_out(bufmgr_gem, 0); /* timestamp */
+	aub_out(bufmgr_gem, 0); /* comment len */
+
+	/* Set up the GTT. The max we can handle is 256M */
+	aub_out(bufmgr_gem, CMD_AUB_TRACE_HEADER_BLOCK | (5 - 2));
+	aub_out(bufmgr_gem, AUB_TRACE_MEMTYPE_NONLOCAL | 0 | AUB_TRACE_OP_DATA_WRITE);
+	aub_out(bufmgr_gem, 0); /* subtype */
+	aub_out(bufmgr_gem, 0); /* offset */
+	aub_out(bufmgr_gem, gtt_size); /* size */
+	for (i = 0x000; i<  gtt_size; i += 4, entry += 0x1000) {
+		aub_out(bufmgr_gem, entry);
+	}
+
+	/* MI_FLUSH enable */
+	if (bufmgr_gem->gen>= 6) {
+		aub_out(bufmgr_gem, CMD_AUB_TRACE_HEADER_BLOCK | (5 - 2));
+		aub_out(bufmgr_gem, AUB_TRACE_OP_MMIO_WRITE);
+		aub_out(bufmgr_gem, 0);
Quoted 8 lines

intel/intel_bufmgr_gem.c drm_intel_bufmgr_gem_get_devid(drm_intel_bufmgr *bufmgr) · line 2674

Quoted 4 lines
intel/intel_bufmgr_gem.c +4 -0
+		aub_out(bufmgr_gem, 0x209c);  /* reg addr */
+		aub_out(bufmgr_gem, 0x04);    /* Length in byte */
+		aub_out(bufmgr_gem, ((1<<  12)<<  16) | (1<<  12));
+	}

Zhenyu and me came to an agreement that it's the driver side to do the MI_FLUSH enable stuff. Since using MI_FLUSH is deprecated, and if you still use it, it is your job to set up the MI_FLUSH enable bit.

Oh...yeah, we should definitely drop that.

Quoted 8 lines
Quoted 8 lines
intel/intel_bufmgr_gem.c +3 -1
+}
+
+/**
   * Initializes the GEM buffer manager, which uses the kernel to allocate, map,
   * and manage map buffer objections.
   *
--

1.7.9.1

Otherwise,

Please set yourself as the author, though - I just squashed this and fixed up a few minor things.

#4 lore raw

Re: [PATCH 2/2] intel: Add .aub file output support.

Quoted 11 lines · Kenneth Graunke
Quoted 10 lines · Yuanhan Liu
Quoted 9 lines · Eric Anholt

From: Kenneth Graunke<[email protected]>

This will allow the driver to capture all of its execution state to a file for later debugging. intel_gpu_dump is limited in that it only captures batchbuffers, and Mesa's captures, while more complete, still capture only a portion of the state involved in execution.

It also enables us to load traces in our internal simulator.

Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
---
 intel/Makefile.am        |    1 +
 intel/intel_aub.h        |  123 ++++++++++++++++++
 intel/intel_bufmgr.h     |   14 ++
 intel/intel_bufmgr_gem.c |  315 ++++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 453 insertions(+), 0 deletions(-)
 create mode 100644 intel/intel_aub.h

[snip]...

Quoted 26 lines
Quoted 5 lines
Quoted 5 lines
intel/intel_bufmgr_gem.c +5 -0
+	/* MI_FLUSH enable */
+	if (bufmgr_gem->gen>= 6) {
+		aub_out(bufmgr_gem, CMD_AUB_TRACE_HEADER_BLOCK | (5 - 2));
+		aub_out(bufmgr_gem, AUB_TRACE_OP_MMIO_WRITE);
+		aub_out(bufmgr_gem, 0);
Quoted 8 lines

intel/intel_bufmgr_gem.c drm_intel_bufmgr_gem_get_devid(drm_intel_bufmgr *bufmgr) · line 2674

Quoted 4 lines
intel/intel_bufmgr_gem.c +4 -0
+		aub_out(bufmgr_gem, 0x209c);  /* reg addr */
+		aub_out(bufmgr_gem, 0x04);    /* Length in byte */
+		aub_out(bufmgr_gem, ((1<<  12)<<  16) | (1<<  12));
+	}

Zhenyu and me came to an agreement that it's the driver side to do the MI_FLUSH enable stuff. Since using MI_FLUSH is deprecated, and if you still use it, it is your job to set up the MI_FLUSH enable bit.

Oh...yeah, we should definitely drop that.

Quoted 8 lines
Quoted 8 lines
intel/intel_bufmgr_gem.c +3 -1
+}
+
+/**
  * Initializes the GEM buffer manager, which uses the kernel to allocate, map,
  * and manage map buffer objections.
  *
--

1.7.9.1

Otherwise,

Quoted 4 lines

Please set yourself as the author, though - I just squashed this and fixed up a few minor things.

Eric wrote the original code, I just made it work. But, of course, feel free to set it if you think it's a need ;)

Thanks,
Yuanhan Liu

#5 lore raw

Re: [PATCH 2/2] intel: Add .aub file output support.

In reply to Eric Anholt

-Am Mittwoch, den 07.03.2012, 11:21 -0800 schrieb Eric Anholt:

Quoted 19 lines

From: Kenneth Graunke <[email protected]>

This will allow the driver to capture all of its execution state to a file for later debugging. intel_gpu_dump is limited in that it only captures batchbuffers, and Mesa's captures, while more complete, still capture only a portion of the state involved in execution.

It also enables us to load traces in our internal simulator.

---
 intel/Makefile.am        |    1 +
 intel/intel_aub.h        |  123 ++++++++++++++++++
 intel/intel_bufmgr.h     |   14 ++
 intel/intel_bufmgr_gem.c |  315 ++++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 453 insertions(+), 0 deletions(-)
 create mode 100644 intel/intel_aub.h

[…]

intel/intel_aub.h line 2

Quoted 8 lines
intel/intel_aub.h new file +2 -0
new file mode 100644
index 0000000..a36fd53
@@ -0,0 +1,123 @@
+/*
+ * Copyright © 2010 Intel Corporation

I guess this should be changed to 2012.

[…]

Thanks,

Paul

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx

#6 lore raw

Re: [PATCH 2/2] intel: Add .aub file output support.

Quoted 23 lines · Paul Menzel

-Am Mittwoch, den 07.03.2012, 11:21 -0800 schrieb Eric Anholt:

Quoted 19 lines

From: Kenneth Graunke <[email protected]>

This will allow the driver to capture all of its execution state to a file for later debugging. intel_gpu_dump is limited in that it only captures batchbuffers, and Mesa's captures, while more complete, still capture only a portion of the state involved in execution.

It also enables us to load traces in our internal simulator.

---
 intel/Makefile.am        |    1 +
 intel/intel_aub.h        |  123 ++++++++++++++++++
 intel/intel_bufmgr.h     |   14 ++
 intel/intel_bufmgr_gem.c |  315 ++++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 453 insertions(+), 0 deletions(-)
 create mode 100644 intel/intel_aub.h

[…]

Quoted 10 lines

intel/intel_aub.h line 2

Quoted 8 lines
intel/intel_aub.h new file +2 -0
new file mode 100644
index 0000000..a36fd53
@@ -0,0 +1,123 @@
+/*
+ * Copyright © 2010 Intel Corporation

I guess this should be changed to 2012.

It was actually written back in 2010. :/

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx

Reviewed-by on v1 1/2
#7 lore raw
In reply to Eric Anholt
Quoted 6 lines · Eric Anholt

From: Kenneth Graunke <[email protected]>

For example:

    export INTEL_DEVID_OVERRIDE=0x162
Quoted 7 lines

If this variable is set, don't actually submit the batchbuffer to the GPU, it probably contains commands for the wrong generation of hardware.

v2: Introduce a getter for the overridden devid, and avoid getenv per exec.

Hi Eric and Kenneth,

Thank you very much for making the whole aub dump stuff in mainline!

(I have some comments about patch 2/2)

Quoted 126 lines
---
 intel/intel_bufmgr.h     |    1 +
 intel/intel_bufmgr_gem.c |   56 ++++++++++++++++++++++++++++++++++++++-------
 2 files changed, 48 insertions(+), 9 deletions(-)
intel/intel_bufmgr.h +1 -0
index 85da8b9..8036031 100644
@@ -157,6 +157,7 @@ void drm_intel_gem_bo_start_gtt_access(drm_intel_bo *bo, int write_enable);
 int drm_intel_get_pipe_from_crtc_id(drm_intel_bufmgr *bufmgr, int crtc_id);
 
 int drm_intel_get_aperture_sizes(int fd, size_t *mappable, size_t *total);
+int drm_intel_bufmgr_gem_get_devid(drm_intel_bufmgr *bufmgr);
 
 /* drm_intel_bufmgr_fake.c */
 drm_intel_bufmgr *drm_intel_bufmgr_fake_init(int fd,
intel/intel_bufmgr_gem.c +47 -9
index 0f33b71..ba38e50 100644
@@ -119,6 +119,7 @@ typedef struct _drm_intel_bufmgr_gem {
 	unsigned int has_relaxed_fencing : 1;
 	unsigned int has_llc : 1;
 	unsigned int bo_reuse : 1;
+	unsigned int no_exec : 1;
 	bool fenced_relocs;
 } drm_intel_bufmgr_gem;
 
@@ -1788,7 +1789,8 @@ drm_intel_gem_bo_mrb_exec2(drm_intel_bo *bo, int used,
 {
 	drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
 	struct drm_i915_gem_execbuffer2 execbuf;
-	int ret, i;
+	int ret = 0;
+	int i;
 
 	switch (flags & 0x7) {
 	default:
@@ -1828,6 +1830,9 @@ drm_intel_gem_bo_mrb_exec2(drm_intel_bo *bo, int used,
 	execbuf.rsvd1 = 0;
 	execbuf.rsvd2 = 0;
 
+	if (bufmgr_gem->no_exec)
+		goto skip_execution;
+
 	ret = drmIoctl(bufmgr_gem->fd,
 		       DRM_IOCTL_I915_GEM_EXECBUFFER2,
 		       &execbuf);
@@ -1845,6 +1850,7 @@ drm_intel_gem_bo_mrb_exec2(drm_intel_bo *bo, int used,
 	}
 	drm_intel_update_buffer_offsets2(bufmgr_gem);
 
+skip_execution:
 	if (bufmgr_gem->bufmgr.debug)
 		drm_intel_gem_dump_validation_list(bufmgr_gem);
 
@@ -2315,6 +2321,45 @@ drm_intel_bufmgr_gem_set_vma_cache_size(drm_intel_bufmgr *bufmgr, int limit)
 }
 
 /**
+ * Get the PCI ID for the device.  This can be overridden by setting the
+ * INTEL_DEVID_OVERRIDE environment variable to the desired ID.
+ */
+static int
+get_pci_device_id(drm_intel_bufmgr_gem *bufmgr_gem)
+{
+	char *devid_override;
+	int devid;
+	int ret;
+	drm_i915_getparam_t gp;
+
+	if (geteuid() == getuid()) {
+		devid_override = getenv("INTEL_DEVID_OVERRIDE");
+		if (devid_override) {
+			bufmgr_gem->no_exec = true;
+			return strtod(devid_override, NULL);
+		}
+	}
+
+	VG_CLEAR(gp);
+	gp.param = I915_PARAM_CHIPSET_ID;
+	gp.value = &devid;
+	ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
+	if (ret) {
+		fprintf(stderr, "get chip id failed: %d [%d]\n", ret, errno);
+		fprintf(stderr, "param: %d, val: %d\n", gp.param, *gp.value);
+	}
+	return devid;
+}
+
+int
+drm_intel_bufmgr_gem_get_devid(drm_intel_bufmgr *bufmgr)
+{
+	drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
+
+	return bufmgr_gem->pci_device;
+}
+
+/**
  * Initializes the GEM buffer manager, which uses the kernel to allocate, map,
  * and manage map buffer objections.
  *
@@ -2356,14 +2401,7 @@ drm_intel_bufmgr_gem_init(int fd, int batch_size)
 			(int)bufmgr_gem->gtt_size / 1024);
 	}
 
-	VG_CLEAR(gp);
-	gp.param = I915_PARAM_CHIPSET_ID;
-	gp.value = &bufmgr_gem->pci_device;
-	ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
-	if (ret) {
-		fprintf(stderr, "get chip id failed: %d [%d]\n", ret, errno);
-		fprintf(stderr, "param: %d, val: %d\n", gp.param, *gp.value);
-	}
+	bufmgr_gem->pci_device = get_pci_device_id(bufmgr_gem);
 
 	if (IS_GEN2(bufmgr_gem->pci_device))
 		bufmgr_gem->gen = 2;
Signature · 6 lines
1.7.9.1

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx