cell_batch.h File Reference

Include dependency graph for cell_batch.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
uint	cell_get_empty_buffer (struct cell_context *cell)
	Search the buffer pool for an empty/free buffer and return its index.
void	cell_batch_flush (struct cell_context *cell)
	Flush the current batch buffer to the SPUs.
uint	cell_batch_free_space (const struct cell_context *cell)
	Return the number of bytes free in the current batch buffer.
void	cell_batch_append (struct cell_context *cell, const void *data, uint bytes)
	Append data to the current batch buffer.
void *	cell_batch_alloc (struct cell_context *cell, uint bytes)
	Allocate space in the current batch buffer for 'bytes' space.
void *	cell_batch_alloc_aligned (struct cell_context *cell, uint bytes, uint alignment)
	Same as.
void	cell_init_batch_buffers (struct cell_context *cell)
	One-time init of batch buffers.

---

Function Documentation

void* cell_batch_alloc	(	struct cell_context *	cell,
		uint	bytes
	)

Allocate space in the current batch buffer for 'bytes' space.

Returns:

address in batch buffer to put data

Definition at line 190 of file cell_batch.c.

References cell_batch_alloc_aligned().

{
   return cell_batch_alloc_aligned(cell, bytes, 1);
}

void* cell_batch_alloc_aligned	(	struct cell_context *	cell,
		uint	bytes,
		uint	alignment
	)

Same as.

See also:

cell_batch_alloc, but return an address at a particular alignment.

Definition at line 201 of file cell_batch.c.

References ASSERT, cell_context::buffer_size, cell_batch_flush(), CELL_BUFFER_SIZE, CELL_BUFFER_STATUS_USED, cell_context::cur_batch, cell_context::num_spus, and spu.

{
   void *pos;
   uint size, padbytes;

   ASSERT(bytes % 8 == 0);
   ASSERT(bytes <= CELL_BUFFER_SIZE);
   ASSERT(alignment > 0);
   ASSERT(cell->cur_batch >= 0);

#ifdef ASSERT
   {
      uint spu;
      for (spu = 0; spu < cell->num_spus; spu++) {
         ASSERT(cell->buffer_status[spu][cell->cur_batch][0]
                 == CELL_BUFFER_STATUS_USED);
      }
   }
#endif

   size = cell->buffer_size[cell->cur_batch];

   padbytes = (alignment - (size % alignment)) % alignment;

   if (padbytes + size + bytes > CELL_BUFFER_SIZE) {
      cell_batch_flush(cell);
      size = 0;
   }
   else {
      size += padbytes;
   }

   ASSERT(size % alignment == 0);
   ASSERT(size + bytes <= CELL_BUFFER_SIZE);

   pos = (void *) (cell->buffer[cell->cur_batch] + size);

   cell->buffer_size[cell->cur_batch] = size + bytes;

   return pos;
}

void cell_batch_append	(	struct cell_context *	cell,
		const void *	data,
		uint	bytes
	)

Append data to the current batch buffer.

Parameters:

	data	address of block of bytes to append
	bytes	size of block of bytes

Definition at line 152 of file cell_batch.c.

References ASSERT, cell_context::buffer_size, cell_batch_flush(), CELL_BUFFER_SIZE, CELL_BUFFER_STATUS_USED, cell_context::cur_batch, cell_context::num_spus, and spu.

{
   uint size;

   ASSERT(bytes % 8 == 0);
   ASSERT(bytes <= CELL_BUFFER_SIZE);
   ASSERT(cell->cur_batch >= 0);

#ifdef ASSERT
   {
      uint spu;
      for (spu = 0; spu < cell->num_spus; spu++) {
         ASSERT(cell->buffer_status[spu][cell->cur_batch][0]
                 == CELL_BUFFER_STATUS_USED);
      }
   }
#endif

   size = cell->buffer_size[cell->cur_batch];

   if (size + bytes > CELL_BUFFER_SIZE) {
      cell_batch_flush(cell);
      size = 0;
   }

   ASSERT(size + bytes <= CELL_BUFFER_SIZE);

   memcpy(cell->buffer[cell->cur_batch] + size, data, bytes);

   cell->buffer_size[cell->cur_batch] = size + bytes;
}

void cell_batch_flush

(

struct cell_context *

cell

)

Flush the current batch buffer to the SPUs.

An empty buffer will be found and set as the new current batch buffer for subsequent commands/data.

Definition at line 90 of file cell_batch.c.

References assert, cell_context::buffer_size, CELL_BUFFER_STATUS_USED, CELL_CMD_BATCH, cell_get_empty_buffer(), cell_global, CELL_NUM_BUFFERS, cell_context::cur_batch, FALSE, cell_context::num_spus, send_mbox_message(), cell_global_info::spe_contexts, spu, and TRUE.

{
   static boolean flushing = FALSE;
   uint batch = cell->cur_batch;
   const uint size = cell->buffer_size[batch];
   uint spu, cmd_word;

   assert(!flushing);

   if (size == 0)
      return;

   flushing = TRUE;

   assert(batch < CELL_NUM_BUFFERS);

   /*
   printf("cell_batch_dispatch: buf %u at %p, size %u\n",
          batch, &cell->buffer[batch][0], size);
   */
     
   /*
    * Build "BATCH" command and send to all SPUs.
    */
   cmd_word = CELL_CMD_BATCH | (batch << 8) | (size << 16);

   for (spu = 0; spu < cell->num_spus; spu++) {
      assert(cell->buffer_status[spu][batch][0] == CELL_BUFFER_STATUS_USED);
      send_mbox_message(cell_global.spe_contexts[spu], cmd_word);
   }

   /* When the SPUs are done copying the buffer into their locals stores
    * they'll write a BUFFER_STATUS_FREE message into the buffer_status[]
    * array indicating that the PPU can re-use the buffer.
    */

   batch = cell_get_empty_buffer(cell);

   cell->buffer_size[batch] = 0;  /* empty */
   cell->cur_batch = batch;

   flushing = FALSE;
}

uint cell_batch_free_space

(

const struct cell_context *

cell

)

Return the number of bytes free in the current batch buffer.

Definition at line 139 of file cell_batch.c.

References cell_context::buffer_size, CELL_BUFFER_SIZE, and cell_context::cur_batch.

{
   uint free = CELL_BUFFER_SIZE - cell->buffer_size[cell->cur_batch];
   return free;
}

uint cell_get_empty_buffer

(

struct cell_context *

cell

)

Search the buffer pool for an empty/free buffer and return its index.

Buffers are used for storing vertex data, state and commands which will be sent to the SPUs. If no empty buffers are available, wait for one.

Returns:

buffer index in [0, CELL_NUM_BUFFERS-1]

Definition at line 43 of file cell_batch.c.

References CELL_BUFFER_STATUS_FREE, CELL_BUFFER_STATUS_USED, CELL_NUM_BUFFERS, cell_context::num_spus, and spu.

{
   uint buf = 0, tries = 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;
               }
               /*
               printf("PPU: ALLOC BUFFER %u\n", buf);
               */
               return buf;
            }
         }
         else {
            break;
         }
      }

      /* try next buf */
      buf = (buf + 1) % CELL_NUM_BUFFERS;

      tries++;
      if (tries == 100) {
         /*
         printf("PPU WAITING for buffer...\n");
         */
      }
   }
}

void cell_init_batch_buffers

(

struct cell_context *

cell

)

One-time init of batch buffers.

Definition at line 249 of file cell_batch.c.

References cell_context::buffer_size, CELL_BUFFER_STATUS_FREE, CELL_BUFFER_STATUS_USED, CELL_NUM_BUFFERS, cell_context::num_spus, and spu.

{
   uint spu, buf;

   /* 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.
       */
      for (spu = 0; spu < cell->num_spus; spu++) {
         if (buf == 0)
            cell->buffer_status[spu][buf][0] = CELL_BUFFER_STATUS_USED;
         else
            cell->buffer_status[spu][buf][0] = CELL_BUFFER_STATUS_FREE;
      }
   }
}

---