#define CELL_CMD_STATE_VERTEX_INFO 13
-#define CELL_NUM_BATCH_BUFFERS 3
-#define CELL_BATCH_BUFFER_SIZE 1024 /**< 16KB would be the max */
+#define CELL_NUM_BUFFERS 4
+#define CELL_BUFFER_SIZE (4*1024) /**< 16KB would be the max */
#define CELL_BUFFER_STATUS_FREE 10
#define CELL_BUFFER_STATUS_USED 20
unsigned id;
unsigned num_spus;
struct cell_command *cmd;
- ubyte *batch_buffers[CELL_NUM_BATCH_BUFFERS];
+
+ /** Buffers for command batches, vertex/index data */
+ ubyte *buffers[CELL_NUM_BUFFERS];
uint *buffer_status; /**< points at cell_context->buffer_status */
} ALIGN16_ATTRIB;
#include "cell_spu.h"
+
+uint
+cell_get_empty_buffer(struct cell_context *cell)
+{
+ uint buf = 0;
+
+ /* Find a buffer that's marked as free by all SPUs */
+ while (1) {
+ uint spu, num_free = 0;
+
+ for (spu = 0; spu < cell->num_spus; spu++) {
+ if (cell->buffer_status[spu][buf][0] == CELL_BUFFER_STATUS_FREE) {
+ num_free++;
+
+ if (num_free == cell->num_spus) {
+ /* found a free buffer, now mark status as used */
+ for (spu = 0; spu < cell->num_spus; spu++) {
+ cell->buffer_status[spu][buf][0] = CELL_BUFFER_STATUS_USED;
+ }
+ return buf;
+ }
+ }
+ else {
+ break;
+ }
+ }
+
+ /* try next buf */
+ buf = (buf + 1) % CELL_NUM_BUFFERS;
+ }
+}
+
+
+
void
cell_batch_flush(struct cell_context *cell)
{
static boolean flushing = FALSE;
uint batch = cell->cur_batch;
- const uint size = cell->batch_buffer_size[batch];
+ const uint size = cell->buffer_size[batch];
uint spu, cmd_word;
assert(!flushing);
flushing = TRUE;
- assert(batch < CELL_NUM_BATCH_BUFFERS);
+ assert(batch < CELL_NUM_BUFFERS);
/*
printf("cell_batch_dispatch: buf %u at %p, size %u\n",
* array indicating that the PPU can re-use the buffer.
*/
+ batch = cell_get_empty_buffer(cell);
- /* Find a buffer that's marked as free by all SPUs */
- while (1) {
- uint num_free = 0;
-
- batch = (batch + 1) % CELL_NUM_BATCH_BUFFERS;
-
- for (spu = 0; spu < cell->num_spus; spu++) {
- if (cell->buffer_status[spu][batch][0] == CELL_BUFFER_STATUS_FREE)
- num_free++;
- }
-
- if (num_free == cell->num_spus) {
- /* found a free buffer, now mark status as used */
- for (spu = 0; spu < cell->num_spus; spu++) {
- cell->buffer_status[spu][batch][0] = CELL_BUFFER_STATUS_USED;
- }
- break;
- }
- }
-
- cell->batch_buffer_size[batch] = 0; /* empty */
+ cell->buffer_size[batch] = 0; /* empty */
cell->cur_batch = batch;
flushing = FALSE;
uint
cell_batch_free_space(const struct cell_context *cell)
{
- uint free = CELL_BATCH_BUFFER_SIZE
- - cell->batch_buffer_size[cell->cur_batch];
+ uint free = CELL_BUFFER_SIZE - cell->buffer_size[cell->cur_batch];
return free;
}
assert(length % 4 == 0);
assert(cell->cur_batch >= 0);
- size = cell->batch_buffer_size[cell->cur_batch];
+ size = cell->buffer_size[cell->cur_batch];
- if (size + length > CELL_BATCH_BUFFER_SIZE) {
+ if (size + length > CELL_BUFFER_SIZE) {
cell_batch_flush(cell);
size = 0;
}
- assert(size + length <= CELL_BATCH_BUFFER_SIZE);
+ assert(size + length <= CELL_BUFFER_SIZE);
- memcpy(cell->batch_buffer[cell->cur_batch] + size, cmd, length);
+ memcpy(cell->buffer[cell->cur_batch] + size, cmd, length);
- cell->batch_buffer_size[cell->cur_batch] = size + length;
+ cell->buffer_size[cell->cur_batch] = size + length;
}
assert(cell->cur_batch >= 0);
- size = cell->batch_buffer_size[cell->cur_batch];
+ size = cell->buffer_size[cell->cur_batch];
- if (size + bytes > CELL_BATCH_BUFFER_SIZE) {
+ if (size + bytes > CELL_BUFFER_SIZE) {
cell_batch_flush(cell);
size = 0;
}
- assert(size + bytes <= CELL_BATCH_BUFFER_SIZE);
+ assert(size + bytes <= CELL_BUFFER_SIZE);
- pos = (void *) (cell->batch_buffer[cell->cur_batch] + size);
+ pos = (void *) (cell->buffer[cell->cur_batch] + size);
- cell->batch_buffer_size[cell->cur_batch] = size + bytes;
+ cell->buffer_size[cell->cur_batch] = size + bytes;
return pos;
}
struct cell_context;
+extern uint
+cell_get_empty_buffer(struct cell_context *cell);
+
extern void
cell_batch_flush(struct cell_context *cell);
cell_start_spus(cell);
- for (buf = 0; buf < CELL_NUM_BATCH_BUFFERS; buf++) {
- cell->batch_buffer_size[buf] = 0;
+ /* init command, vertex/index buffer info */
+ for (buf = 0; buf < CELL_NUM_BUFFERS; buf++) {
+ cell->buffer_size[buf] = 0;
/* init batch buffer status values,
* mark 0th buffer as used, rest as free.
uint num_spus;
- uint batch_buffer_size[CELL_NUM_BATCH_BUFFERS];
- ubyte batch_buffer[CELL_NUM_BATCH_BUFFERS][CELL_BATCH_BUFFER_SIZE] ALIGN16_ATTRIB;
- int cur_batch; /**< which batch buffer is being filled */
+ /** Buffers for command batches, vertex/index data */
+ uint buffer_size[CELL_NUM_BUFFERS];
+ ubyte buffer[CELL_NUM_BUFFERS][CELL_BUFFER_SIZE] ALIGN16_ATTRIB;
+
+ int cur_batch; /**< which buffer is being filled w/ commands */
/** [4] to ensure 16-byte alignment for each status word */
- uint buffer_status[CELL_MAX_SPUS][CELL_NUM_BATCH_BUFFERS][4] ALIGN16_ATTRIB;
+ uint buffer_status[CELL_MAX_SPUS][CELL_NUM_BUFFERS][4] ALIGN16_ATTRIB;
};
cell_global.inits[i].id = i;
cell_global.inits[i].num_spus = cell->num_spus;
cell_global.inits[i].cmd = &cell_global.command[i];
- for (j = 0; j < CELL_NUM_BATCH_BUFFERS; j++) {
- cell_global.inits[i].batch_buffers[j] = cell->batch_buffer[j];
+ for (j = 0; j < CELL_NUM_BUFFERS; j++) {
+ cell_global.inits[i].buffers[j] = cell->buffer[j];
}
cell_global.inits[i].buffer_status = &cell->buffer_status[0][0][0];
/**
- * Tell the PPU that this SPU has finished copying a batch buffer to
+ * Tell the PPU that this SPU has finished copying a buffer to
* local store and that it may be reused by the PPU.
* This is done by writting a 16-byte batch-buffer-status block back into
- * main memory (in cell_contex->buffer_status[]).
+ * main memory (in cell_context->buffer_status[]).
*/
static void
-release_batch_buffer(uint buffer)
+release_buffer(uint buffer)
{
/* Evidently, using less than a 16-byte status doesn't work reliably */
static const uint status[4] ALIGN16_ATTRIB
= {CELL_BUFFER_STATUS_FREE, 0, 0, 0};
- const uint index = 4 * (spu.init.id * CELL_NUM_BATCH_BUFFERS + buffer);
+ const uint index = 4 * (spu.init.id * CELL_NUM_BUFFERS + buffer);
uint *dst = spu.init.buffer_status + index;
- ASSERT(buffer < CELL_NUM_BATCH_BUFFERS);
+ ASSERT(buffer < CELL_NUM_BUFFERS);
/*
printf("SPU %u: Set batch status buf=%u, index %u, at %p to FREE\n",
{
const uint buf = (opcode >> 8) & 0xff;
uint size = (opcode >> 16);
- uint buffer[CELL_BATCH_BUFFER_SIZE / 4] ALIGN16_ATTRIB;
+ uint buffer[CELL_BUFFER_SIZE / 4] ALIGN16_ATTRIB;
const uint usize = size / sizeof(uint);
uint pos;
if (Debug)
printf("SPU %u: BATCH buffer %u, len %u, from %p\n",
- spu.init.id, buf, size, spu.init.batch_buffers[buf]);
+ spu.init.id, buf, size, spu.init.buffers[buf]);
ASSERT((opcode & CELL_CMD_OPCODE_MASK) == CELL_CMD_BATCH);
- ASSERT_ALIGN16(spu.init.batch_buffers[buf]);
+ ASSERT_ALIGN16(spu.init.buffers[buf]);
size = ROUNDUP16(size);
- ASSERT_ALIGN16(spu.init.batch_buffers[buf]);
+ ASSERT_ALIGN16(spu.init.buffers[buf]);
mfc_get(buffer, /* dest */
- (unsigned int) spu.init.batch_buffers[buf], /* src */
+ (unsigned int) spu.init.buffers[buf], /* src */
size,
TAG_BATCH_BUFFER,
0, /* tid */
wait_on_mask(1 << TAG_BATCH_BUFFER);
/* Tell PPU we're done copying the buffer to local store */
- release_batch_buffer(buf);
+ release_buffer(buf);
for (pos = 0; pos < usize; /* no incr */) {
switch (buffer[pos]) {
projects / platform / upstream / mesa.git / commitdiff