cell_context.h File Reference

Include dependency graph for cell_context.h:

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

Go to the source code of this file.

Data Structures
struct	cell_vertex_shader_state
	Cell vertex shader state, subclass of pipe_shader_state. More...
struct	cell_fragment_shader_state
	Cell fragment shader state, subclass of pipe_shader_state. More...
struct	cell_blend_state
	Cell blend state atom, subclass of pipe_blend_state. More...
struct	cell_depth_stencil_alpha_state
	Cell depth/stencil/alpha state atom, subclass of pipe_depth_stencil_alpha_state. More...
struct	cell_context
	Per-context state, subclass of pipe_context. More...
Functions
static struct cell_context *	cell_context (struct pipe_context *pipe)
struct pipe_context *	cell_create_context (struct pipe_screen *screen, struct cell_winsys *cws)
void	cell_vertex_shader_queue_flush (struct draw_context *draw)
	Run the vertex shader on all vertices in the vertex queue.
void	cell_update_vertex_fetch (struct draw_context *draw)

---

Function Documentation

static struct cell_context* cell_context

(

struct pipe_context *

pipe

)

[static, read]

Definition at line 175 of file cell_context.h.

{
   return (struct cell_context *) pipe;
}

struct pipe_context* cell_create_context	(	struct pipe_screen *	screen,
		struct cell_winsys *	cws
	)			[read]

Definition at line 98 of file cell_context.c.

References align_malloc(), pipe_context::begin_query, cell_clear_surface(), cell_destroy_context(), cell_draw_create(), cell_flush(), cell_init_batch_buffers(), cell_init_draw_functions(), cell_init_shader_functions(), cell_init_state_functions(), cell_init_surface_functions(), cell_init_texture_functions(), cell_init_vbuf(), cell_init_vertex_functions(), cell_start_spus(), pipe_context::clear, cell_context::debug_flags, debug_get_flags_option(), pipe_context::destroy, cell_context::draw, draw_set_rasterize_stage(), draw_wide_line_threshold(), draw_wide_point_threshold(), pipe_context::end_query, pipe_context::flush, cell_context::num_spus, cell_context::pipe, pipe_context::screen, cell_context::vbuf, pipe_screen::winsys, pipe_context::winsys, and cell_context::winsys.

{
   struct cell_context *cell;

   /* some fields need to be 16-byte aligned, so align the whole object */
   cell = (struct cell_context*) align_malloc(sizeof(struct cell_context), 16);
   if (!cell)
      return NULL;

   memset(cell, 0, sizeof(*cell));

   cell->winsys = cws;
   cell->pipe.winsys = screen->winsys;
   cell->pipe.screen = screen;
   cell->pipe.destroy = cell_destroy_context;

   cell->pipe.clear = cell_clear_surface;
   cell->pipe.flush = cell_flush;

#if 0
   cell->pipe.begin_query = cell_begin_query;
   cell->pipe.end_query = cell_end_query;
   cell->pipe.wait_query = cell_wait_query;
#endif

   cell_init_draw_functions(cell);
   cell_init_state_functions(cell);
   cell_init_shader_functions(cell);
   cell_init_surface_functions(cell);
   cell_init_texture_functions(cell);
   cell_init_vertex_functions(cell);

   cell->draw = cell_draw_create(cell);

   cell_init_vbuf(cell);

   draw_set_rasterize_stage(cell->draw, cell->vbuf);

   /* convert all points/lines to tris for the time being */
   draw_wide_point_threshold(cell->draw, 0.0);
   draw_wide_line_threshold(cell->draw, 0.0);

   /* get env vars or read config file to get debug flags */
   cell->debug_flags = debug_get_flags_option("CELL_DEBUG", 
                                              cell_debug_flags, 
                                              0 );

   /*
    * SPU stuff
    */
   cell->num_spus = 6;
   /* XXX is this in SDK 3.0 only?
   cell->num_spus = spe_cpu_info_get(SPE_COUNT_PHYSICAL_SPES, -1);
   */

   cell_start_spus(cell);

   cell_init_batch_buffers(cell);

   return &cell->pipe;
}

void cell_update_vertex_fetch

(

struct draw_context *

draw

)

Definition at line 261 of file cell_vertex_fetch.c.

References align(), assert, cell_context::attrib_fetch, cell_context::attrib_fetch_offsets, draw_context::driver_private, emit_fetch(), offset(), PIPE_MAX_ATTRIBS, spe_allocate_register(), spe_bi(), spe_init_func(), SPE_INST_SIZE, pipe_vertex_element::src_format, and draw_context::vertex_element.

{
#if 0
   struct cell_context *const cell =
       (struct cell_context *) draw->driver_private;
   struct spe_function *p = &cell->attrib_fetch;
   unsigned function_index[PIPE_MAX_ATTRIBS];
   unsigned unique_attr_formats;
   int out_ptr;
   int in_ptr;
   int shuf_ptr;
   unsigned i;
   unsigned j;


   /* Determine how many unique input attribute formats there are.  At the
    * same time, store the index of the lowest numbered attribute that has
    * the same format as any non-unique format.
    */
   unique_attr_formats = 1;
   function_index[0] = 0;
   for (i = 1; i < draw->vertex_fetch.nr_attrs; i++) {
      const enum pipe_format curr_fmt = draw->vertex_element[i].src_format;

      for (j = 0; j < i; j++) {
         if (curr_fmt == draw->vertex_element[j].src_format) {
            break;
         }
      }
      
      if (j == i) {
         unique_attr_formats++;
      }

      function_index[i] = j;
   }


   /* Each fetch function can be a maximum of 34 instructions (note: this is
    * actually a slight over-estimate).
    */
   spe_init_func(p, 34 * SPE_INST_SIZE * unique_attr_formats);


   /* Allocate registers for the function's input parameters.
    */
   out_ptr = spe_allocate_register(p, 3);
   in_ptr = spe_allocate_register(p, 4);
   shuf_ptr = spe_allocate_register(p, 5);


   /* Generate code for the individual attribute fetch functions.
    */
   for (i = 0; i < draw->vertex_fetch.nr_attrs; i++) {
      unsigned offset;

      if (function_index[i] == i) {
         cell->attrib_fetch_offsets[i] = (unsigned) ((void *) p->csr 
                                                     - (void *) p->store);

         offset = 0;
         emit_fetch(p, in_ptr, &offset, out_ptr, shuf_ptr,
                    draw->vertex_element[i].src_format);
         spe_bi(p, 0, 0, 0);

         /* Round up to the next 16-byte boundary.
          */
         if ((((unsigned) p->store) & 0x0f) != 0) {
            const unsigned align = ((unsigned) p->store) & 0x0f;
            p->store = (uint32_t *) (((void *) p->store) + align);
         }
      } else {
         /* Use the same function entry-point as a previously seen attribute
          * with the same format.
          */
         cell->attrib_fetch_offsets[i] = 
             cell->attrib_fetch_offsets[function_index[i]];
      }
   }
#else
   assert(0);
#endif
}

void cell_vertex_shader_queue_flush

(

struct draw_context *

draw

)

Run the vertex shader on all vertices in the vertex queue.

Called by the draw module when the vertx cache needs to be flushed.

Definition at line 52 of file cell_vertex_shader.c.

References assert, cell_context::attrib_fetch, cell_context::attrib_fetch_offsets, cell_batch_alloc(), cell_batch_flush(), CELL_CMD_STATE_ATTRIB_FETCH, CELL_CMD_STATE_UNIFORMS, CELL_CMD_STATE_VIEWPORT, CELL_CMD_STATE_VS_ARRAY_INFO, CELL_CMD_VS_EXECUTE, cell_flush_int(), CELL_FLUSH_WAIT, cell_global, cell_update_vertex_fetch(), cell_global_info::command, draw_context::driver_private, draw_context::elts, MIN2, draw_context::nr_planes, pf_size_w, pf_size_x, pf_size_y, pf_size_z, draw_context::plane, ROUNDUP16, send_mbox_message(), cell_attribute_fetch_code::size, cell_global_info::spe_contexts, SPU_VERTS_PER_BATCH, pipe_vertex_element::src_format, spe_function::store, draw_context::user, draw_context::vertex_element, draw_context::viewport, draw_context::vs, cell_command::vs, and cell_context::vs.

{
#if 0
   struct cell_context *const cell =
       (struct cell_context *) draw->driver_private;
   struct cell_command_vs *const vs = &cell_global.command[0].vs;
   uint64_t *batch;
   struct cell_array_info *array_info;
   unsigned i, j;
   struct cell_attribute_fetch_code *cf;

   assert(draw->vs.queue_nr != 0);

   /* XXX: do this on statechange: 
    */
   draw_update_vertex_fetch(draw);
   cell_update_vertex_fetch(draw);


   batch = cell_batch_alloc(cell, sizeof(batch[0]) + sizeof(*cf));
   batch[0] = CELL_CMD_STATE_ATTRIB_FETCH;
   cf = (struct cell_attribute_fetch_code *) (&batch[1]);
   cf->base = (uint64_t) cell->attrib_fetch.store;
   cf->size = ROUNDUP16((unsigned)((void *) cell->attrib_fetch.csr 
                                   - (void *) cell->attrib_fetch.store));


   for (i = 0; i < draw->vertex_fetch.nr_attrs; i++) {
      const enum pipe_format format = draw->vertex_element[i].src_format;
      const unsigned count = ((pf_size_x(format) != 0)
                              + (pf_size_y(format) != 0)
                              + (pf_size_z(format) != 0)
                              + (pf_size_w(format) != 0));
      const unsigned size = pf_size_x(format) * count;

      batch = cell_batch_alloc(cell, sizeof(batch[0]) + sizeof(*array_info));

      batch[0] = CELL_CMD_STATE_VS_ARRAY_INFO;

      array_info = (struct cell_array_info *) &batch[1];
      assert(draw->vertex_fetch.src_ptr[i] != NULL);
      array_info->base = (uintptr_t) draw->vertex_fetch.src_ptr[i];
      array_info->attr = i;
      array_info->pitch = draw->vertex_fetch.pitch[i];
      array_info->size = size;
      array_info->function_offset = cell->attrib_fetch_offsets[i];
   }

   batch = cell_batch_alloc(cell, sizeof(batch[0])
                            + sizeof(struct pipe_viewport_state));
   batch[0] = CELL_CMD_STATE_VIEWPORT;
   (void) memcpy(&batch[1], &draw->viewport,
                 sizeof(struct pipe_viewport_state));

   {
      uint64_t uniforms = (uintptr_t) draw->user.constants;

      batch = cell_batch_alloc(cell, 2 *sizeof(batch[0]));
      batch[0] = CELL_CMD_STATE_UNIFORMS;
      batch[1] = uniforms;
   }

   cell_batch_flush(cell);

   vs->opcode = CELL_CMD_VS_EXECUTE;
   vs->nr_attrs = draw->vertex_fetch.nr_attrs;

   (void) memcpy(vs->plane, draw->plane, sizeof(draw->plane));
   vs->nr_planes = draw->nr_planes;

   for (i = 0; i < draw->vs.queue_nr; i += SPU_VERTS_PER_BATCH) {
      const unsigned n = MIN2(SPU_VERTS_PER_BATCH, draw->vs.queue_nr - i);

      for (j = 0; j < n; j++) {
         vs->elts[j] = draw->vs.queue[i + j].elt;
         vs->vOut[j] = (uintptr_t) draw->vs.queue[i + j].vertex;
      }

      for (/* empty */; j < SPU_VERTS_PER_BATCH; j++) {
         vs->elts[j] = vs->elts[0];
         vs->vOut[j] = (uintptr_t) draw->vs.queue[i + j].vertex;
      }

      vs->num_elts = n;
      send_mbox_message(cell_global.spe_contexts[0], CELL_CMD_VS_EXECUTE);

      cell_flush_int(cell, CELL_FLUSH_WAIT);
   }

   draw->vs.post_nr = draw->vs.queue_nr;
   draw->vs.queue_nr = 0;
#else
   assert(0);
#endif
}

---