mirror of
https://gitlab.freedesktop.org/mesa/mesa.git
synced 2026-05-25 14:48:12 +02:00
4ffbab5ae0
This commit allows for us to create a whole new surface state buffer when the old one runs out of room. We simply re-emit the state base address for the new state, re-emit binding tables, and keep going.
310 lines
9.2 KiB
C
310 lines
9.2 KiB
C
/*
|
|
* Copyright © 2015 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.
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <assert.h>
|
|
#include <sys/types.h>
|
|
#include <sys/mman.h>
|
|
|
|
#include <drm.h>
|
|
#include <i915_drm.h>
|
|
|
|
#include "private.h"
|
|
#include "aub.h"
|
|
|
|
struct anv_aub_writer {
|
|
FILE *file;
|
|
uint32_t offset;
|
|
int gen;
|
|
};
|
|
|
|
static void
|
|
aub_out(struct anv_aub_writer *writer, uint32_t data)
|
|
{
|
|
fwrite(&data, 1, 4, writer->file);
|
|
}
|
|
|
|
static void
|
|
aub_out_data(struct anv_aub_writer *writer, const void *data, size_t size)
|
|
{
|
|
fwrite(data, 1, size, writer->file);
|
|
}
|
|
|
|
static struct anv_aub_writer *
|
|
get_anv_aub_writer(struct anv_device *device)
|
|
{
|
|
struct anv_aub_writer *writer = device->aub_writer;
|
|
int entry = 0x200003;
|
|
int i;
|
|
int gtt_size = 0x10000;
|
|
const char *filename;
|
|
|
|
if (geteuid() != getuid())
|
|
return NULL;
|
|
|
|
if (writer)
|
|
return writer;
|
|
|
|
writer = malloc(sizeof(*writer));
|
|
if (writer == NULL)
|
|
return NULL;
|
|
|
|
filename = "intel.aub";
|
|
writer->gen = device->info.gen;
|
|
writer->file = fopen(filename, "w+");
|
|
if (!writer->file) {
|
|
free(writer);
|
|
return NULL;
|
|
}
|
|
|
|
/* Start allocating objects from just after the GTT. */
|
|
writer->offset = gtt_size;
|
|
|
|
/* Start with a (required) version packet. */
|
|
aub_out(writer, CMD_AUB_HEADER | (13 - 2));
|
|
aub_out(writer,
|
|
(4 << AUB_HEADER_MAJOR_SHIFT) |
|
|
(0 << AUB_HEADER_MINOR_SHIFT));
|
|
for (i = 0; i < 8; i++) {
|
|
aub_out(writer, 0); /* app name */
|
|
}
|
|
aub_out(writer, 0); /* timestamp */
|
|
aub_out(writer, 0); /* timestamp */
|
|
aub_out(writer, 0); /* comment len */
|
|
|
|
/* Set up the GTT. The max we can handle is 256M */
|
|
aub_out(writer, CMD_AUB_TRACE_HEADER_BLOCK | ((writer->gen >= 8 ? 6 : 5) - 2));
|
|
aub_out(writer,
|
|
AUB_TRACE_MEMTYPE_GTT_ENTRY |
|
|
AUB_TRACE_TYPE_NOTYPE | AUB_TRACE_OP_DATA_WRITE);
|
|
aub_out(writer, 0); /* subtype */
|
|
aub_out(writer, 0); /* offset */
|
|
aub_out(writer, gtt_size); /* size */
|
|
if (writer->gen >= 8)
|
|
aub_out(writer, 0);
|
|
for (i = 0x000; i < gtt_size; i += 4, entry += 0x1000) {
|
|
aub_out(writer, entry);
|
|
}
|
|
|
|
return device->aub_writer = writer;
|
|
}
|
|
|
|
void
|
|
anv_aub_writer_destroy(struct anv_aub_writer *writer)
|
|
{
|
|
fclose(writer->file);
|
|
free(writer);
|
|
}
|
|
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
static void
|
|
aub_write_trace_block(struct anv_aub_writer *writer, uint32_t type,
|
|
void *virtual, uint32_t size, uint32_t gtt_offset)
|
|
{
|
|
uint32_t block_size;
|
|
uint32_t offset;
|
|
uint32_t subtype = 0;
|
|
static const char null_block[8 * 4096];
|
|
|
|
for (offset = 0; offset < size; offset += block_size) {
|
|
block_size = size - offset;
|
|
|
|
if (block_size > 8 * 4096)
|
|
block_size = 8 * 4096;
|
|
|
|
aub_out(writer,
|
|
CMD_AUB_TRACE_HEADER_BLOCK |
|
|
((writer->gen >= 8 ? 6 : 5) - 2));
|
|
aub_out(writer,
|
|
AUB_TRACE_MEMTYPE_GTT |
|
|
type | AUB_TRACE_OP_DATA_WRITE);
|
|
aub_out(writer, subtype);
|
|
aub_out(writer, gtt_offset + offset);
|
|
aub_out(writer, ALIGN_U32(block_size, 4));
|
|
if (writer->gen >= 8)
|
|
aub_out(writer, 0);
|
|
|
|
if (virtual)
|
|
aub_out_data(writer, (char *) virtual + offset, block_size);
|
|
else
|
|
aub_out_data(writer, null_block, block_size);
|
|
|
|
/* Pad to a multiple of 4 bytes. */
|
|
aub_out_data(writer, null_block, -block_size & 3);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Make a ringbuffer on fly and dump it
|
|
*/
|
|
static void
|
|
aub_build_dump_ringbuffer(struct anv_aub_writer *writer,
|
|
uint32_t batch_offset, uint32_t offset,
|
|
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;
|
|
else if (ring_flag == I915_EXEC_BLT)
|
|
ring = AUB_TRACE_TYPE_RING_PRB2;
|
|
|
|
/* Make a ring buffer to execute our batchbuffer. */
|
|
memset(ringbuffer, 0, sizeof(ringbuffer));
|
|
if (writer->gen >= 8) {
|
|
ringbuffer[ring_count++] = AUB_MI_BATCH_BUFFER_START | (3 - 2);
|
|
ringbuffer[ring_count++] = batch_offset;
|
|
ringbuffer[ring_count++] = 0;
|
|
} else {
|
|
ringbuffer[ring_count++] = AUB_MI_BATCH_BUFFER_START;
|
|
ringbuffer[ring_count++] = batch_offset;
|
|
}
|
|
|
|
/* Write out the ring. This appears to trigger execution of
|
|
* the ring in the simulator.
|
|
*/
|
|
aub_out(writer,
|
|
CMD_AUB_TRACE_HEADER_BLOCK |
|
|
((writer->gen >= 8 ? 6 : 5) - 2));
|
|
aub_out(writer,
|
|
AUB_TRACE_MEMTYPE_GTT | ring | AUB_TRACE_OP_COMMAND_WRITE);
|
|
aub_out(writer, 0); /* general/surface subtype */
|
|
aub_out(writer, offset);
|
|
aub_out(writer, ring_count * 4);
|
|
if (writer->gen >= 8)
|
|
aub_out(writer, 0);
|
|
|
|
/* FIXME: Need some flush operations here? */
|
|
aub_out_data(writer, ringbuffer, ring_count * 4);
|
|
}
|
|
|
|
struct aub_bo {
|
|
uint32_t offset;
|
|
void *map;
|
|
void *relocated;
|
|
};
|
|
|
|
static void
|
|
relocate_bo(struct anv_bo *bo, struct drm_i915_gem_relocation_entry *relocs,
|
|
size_t num_relocs, struct aub_bo *bos)
|
|
{
|
|
struct aub_bo *aub_bo = &bos[bo->index];
|
|
struct drm_i915_gem_relocation_entry *reloc;
|
|
uint32_t *dw;
|
|
|
|
aub_bo->relocated = malloc(bo->size);
|
|
memcpy(aub_bo->relocated, aub_bo->map, bo->size);
|
|
for (size_t i = 0; i < num_relocs; i++) {
|
|
reloc = &relocs[i];
|
|
assert(reloc->offset < bo->size);
|
|
dw = aub_bo->relocated + reloc->offset;
|
|
*dw = bos[reloc->target_handle].offset + reloc->delta;
|
|
}
|
|
}
|
|
|
|
void
|
|
anv_cmd_buffer_dump(struct anv_cmd_buffer *cmd_buffer)
|
|
{
|
|
struct anv_device *device = cmd_buffer->device;
|
|
struct anv_batch *batch = &cmd_buffer->batch;
|
|
struct anv_aub_writer *writer;
|
|
struct anv_bo *bo;
|
|
uint32_t ring_flag = 0;
|
|
uint32_t offset;
|
|
struct aub_bo *aub_bos;
|
|
|
|
writer = get_anv_aub_writer(device);
|
|
if (writer == NULL)
|
|
return;
|
|
|
|
aub_bos = malloc(cmd_buffer->bo_count * sizeof(aub_bos[0]));
|
|
offset = writer->offset;
|
|
for (uint32_t i = 0; i < cmd_buffer->bo_count; i++) {
|
|
bo = cmd_buffer->exec2_bos[i];
|
|
if (bo->map)
|
|
aub_bos[i].map = bo->map;
|
|
else
|
|
aub_bos[i].map = anv_gem_mmap(device, bo->gem_handle, 0, bo->size);
|
|
aub_bos[i].relocated = aub_bos[i].map;
|
|
aub_bos[i].offset = offset;
|
|
offset = ALIGN_U32(offset + bo->size + 4095, 4096);
|
|
}
|
|
|
|
struct anv_batch_bo *first_bbo;
|
|
for (struct anv_batch_bo *bbo = cmd_buffer->last_batch_bo;
|
|
bbo != NULL; bbo = bbo->prev_batch_bo) {
|
|
/* Keep stashing the current BO until we get to the beginning */
|
|
first_bbo = bbo;
|
|
|
|
/* Handle relocations for this batch BO */
|
|
relocate_bo(&bbo->bo, &batch->relocs.relocs[bbo->first_reloc],
|
|
bbo->num_relocs, aub_bos);
|
|
}
|
|
assert(first_bbo->prev_batch_bo == NULL);
|
|
|
|
for (struct anv_batch_bo *bbo = cmd_buffer->surface_batch_bo;
|
|
bbo != NULL; bbo = bbo->prev_batch_bo) {
|
|
|
|
/* Handle relocations for this surface state BO */
|
|
relocate_bo(&bbo->bo,
|
|
&cmd_buffer->surface_relocs.relocs[bbo->first_reloc],
|
|
bbo->num_relocs, aub_bos);
|
|
}
|
|
|
|
for (uint32_t i = 0; i < cmd_buffer->bo_count; i++) {
|
|
bo = cmd_buffer->exec2_bos[i];
|
|
if (i == cmd_buffer->bo_count - 1) {
|
|
assert(bo == &first_bbo->bo);
|
|
aub_write_trace_block(writer, AUB_TRACE_TYPE_BATCH,
|
|
aub_bos[i].relocated,
|
|
first_bbo->length, aub_bos[i].offset);
|
|
} else {
|
|
aub_write_trace_block(writer, AUB_TRACE_TYPE_NOTYPE,
|
|
aub_bos[i].relocated,
|
|
bo->size, aub_bos[i].offset);
|
|
}
|
|
if (aub_bos[i].relocated != aub_bos[i].map)
|
|
free(aub_bos[i].relocated);
|
|
if (aub_bos[i].map != bo->map)
|
|
anv_gem_munmap(aub_bos[i].map, bo->size);
|
|
}
|
|
|
|
/* Dump ring buffer */
|
|
aub_build_dump_ringbuffer(writer, aub_bos[first_bbo->bo.index].offset,
|
|
offset, ring_flag);
|
|
|
|
free(aub_bos);
|
|
|
|
fflush(writer->file);
|
|
}
|