Initial implementation of surface tile caching.

Instead of using read/write_quad() functions, do framebuffer accesses via
get/put_tile().  A cache of tiles is used to avoid frequent get/put() calls.
Only implemented for color buffers right now.

9 files changed, 129 insertions, 72 deletions

diff --git a/src/mesa/pipe/softpipe/Makefile b/src/mesa/pipe/softpipe/Makefile
index 63eb6b57615..2cbd9e5b515 100644
--- a/src/mesa/pipe/softpipe/Makefile
+++ b/src/mesa/pipe/softpipe/Makefile
@@ -35,6 +35,7 @@ DRIVER_SOURCES = \
 	sp_state_vertex.c \
 	sp_tex_layout.c \
 	sp_tex_sample.c \
+	sp_tile_cache.c \
 	sp_surface.c 
 
 C_SOURCES = \
diff --git a/src/mesa/pipe/softpipe/sp_clear.c b/src/mesa/pipe/softpipe/sp_clear.c
index 539da1d58b3..46370b4ed9a 100644
--- a/src/mesa/pipe/softpipe/sp_clear.c
+++ b/src/mesa/pipe/softpipe/sp_clear.c
@@ -35,6 +35,7 @@
 #include "sp_context.h"
 #include "sp_surface.h"
 #include "sp_state.h"
+#include "sp_tile_cache.h"
 
 
 /**
@@ -46,6 +47,7 @@ softpipe_clear(struct pipe_context *pipe, struct pipe_surface *ps,
                unsigned clearValue)
 {
    struct softpipe_context *softpipe = softpipe_context(pipe);
+   struct softpipe_surface *sps = softpipe_surface(ps);
    unsigned x, y, w, h;
 
    softpipe_update_derived(softpipe); /* not needed?? */
@@ -64,5 +66,8 @@ softpipe_clear(struct pipe_context *pipe, struct pipe_surface *ps,
    assert(w <= ps->region->pitch);
    assert(h <= ps->region->height);
 
+   /* XXX skip this fill if we're using tile cache */
    pipe->region_fill(pipe, ps->region, 0, x, y, w, h, clearValue);
+
+   sp_clear_tile_cache(sps, clearValue);
 }
diff --git a/src/mesa/pipe/softpipe/sp_flush.c b/src/mesa/pipe/softpipe/sp_flush.c
index cdf4a53c837..d4eada82287 100644
--- a/src/mesa/pipe/softpipe/sp_flush.c
+++ b/src/mesa/pipe/softpipe/sp_flush.c
@@ -33,8 +33,11 @@
 #include "pipe/p_defines.h"
 #include "sp_flush.h"
 #include "sp_context.h"
+#include "sp_surface.h"
+#include "sp_tile_cache.h"
 #include "sp_winsys.h"
 
+
 /* There will be actual work to do here.  In future we may want a
  * fence-like interface instead of finish, and perhaps flush will take
  * flags to indicate what type of flush is required.
@@ -43,9 +46,18 @@ void
 softpipe_flush( struct pipe_context *pipe,
 		unsigned flags )
 {
+   struct softpipe_context *softpipe = softpipe_context(pipe);
+   uint i;
+
    /* - flush the quad pipeline
     * - flush the texture cache
     * - flush the render cache
     */
+
+   for (i = 0; i < softpipe->framebuffer.num_cbufs; i++) {
+      struct softpipe_surface *sps = softpipe_surface(softpipe->framebuffer.cbufs[i]);
+      if (sps)
+         sp_flush_tile_cache(sps);
+   }
 }
 
diff --git a/src/mesa/pipe/softpipe/sp_quad_blend.c b/src/mesa/pipe/softpipe/sp_quad_blend.c
index 3af5ab5b291..43294e4cd4d 100644
--- a/src/mesa/pipe/softpipe/sp_quad_blend.c
+++ b/src/mesa/pipe/softpipe/sp_quad_blend.c
@@ -35,6 +35,7 @@
 #include "sp_context.h"
 #include "sp_headers.h"
 #include "sp_surface.h"
+#include "sp_tile_cache.h"
 #include "sp_quad.h"
 
 
@@ -106,10 +107,19 @@ logicop_quad(struct quad_stage *qs, struct quad_header *quad)
    uint *src4 = (uint *) src;
    uint *dst4 = (uint *) dst;
    uint *res4 = (uint *) res;
-   uint j;
+   struct softpipe_cached_tile *
+      tile = sp_get_cached_tile(sps, quad->x0, quad->y0);
+   uint i, j;
+
+   /* get/swizzle dest colors */
+   for (j = 0; j < QUAD_SIZE; j++) {
+      int x = (quad->x0 & (TILE_SIZE-1)) + (j & 1);
+      int y = (quad->y0 & (TILE_SIZE-1)) + (j >> 1);
+      for (i = 0; i < 4; i++) {
+         dest[i][j] = tile->data.color[y][x][i];
+      }
+   }
 
-   /* get colors from framebuffer */
-   sps->read_quad_f_swz(sps, quad->x0, quad->y0, dest);
    /* convert to ubyte */
    for (j = 0; j < 4; j++) { /* loop over R,G,B,A channels */
       UNCLAMPED_FLOAT_TO_UBYTE(dst[j][0], dest[j][0]); /* P0 */
@@ -209,19 +219,28 @@ logicop_quad(struct quad_stage *qs, struct quad_header *quad)
 static void
 blend_quad(struct quad_stage *qs, struct quad_header *quad)
 {
-   static const float zero[4] = { 0, 0, 0, 0 };
-   static const float one[4] = { 1, 1, 1, 1 };
    struct softpipe_context *softpipe = qs->softpipe;
    struct softpipe_surface *sps = softpipe_surface(softpipe->cbuf);
+   static const float zero[4] = { 0, 0, 0, 0 };
+   static const float one[4] = { 1, 1, 1, 1 };
    float source[4][QUAD_SIZE], dest[4][QUAD_SIZE];
+   struct softpipe_cached_tile *
+      tile = sp_get_cached_tile(sps, quad->x0, quad->y0);
+   uint i, j;
 
    if (softpipe->blend->logicop_enable) {
       logicop_quad(qs, quad);
       return;
    }
 
-   /* get colors from framebuffer */
-   sps->read_quad_f_swz(sps, quad->x0, quad->y0, dest);
+   /* get/swizzle dest colors */
+   for (j = 0; j < QUAD_SIZE; j++) {
+      int x = (quad->x0 & (TILE_SIZE-1)) + (j & 1);
+      int y = (quad->y0 & (TILE_SIZE-1)) + (j >> 1);
+      for (i = 0; i < 4; i++) {
+         dest[i][j] = tile->data.color[y][x][i];
+      }
+   }
 
    /*
     * Compute src/first term RGB
diff --git a/src/mesa/pipe/softpipe/sp_quad_colormask.c b/src/mesa/pipe/softpipe/sp_quad_colormask.c
index c3e110532a1..aa69f53580e 100644
--- a/src/mesa/pipe/softpipe/sp_quad_colormask.c
+++ b/src/mesa/pipe/softpipe/sp_quad_colormask.c
@@ -36,17 +36,31 @@
 #include "sp_headers.h"
 #include "sp_surface.h"
 #include "sp_quad.h"
+#include "sp_tile_cache.h"
 
 
 
+/**
+ * XXX colormask could be rolled into blending...
+ */
 static void
 colormask_quad(struct quad_stage *qs, struct quad_header *quad)
 {
    struct softpipe_context *softpipe = qs->softpipe;
    struct softpipe_surface *sps = softpipe_surface(softpipe->cbuf);
    float dest[4][QUAD_SIZE];
-   
-   sps->read_quad_f_swz(sps, quad->x0, quad->y0, dest);
+   struct softpipe_cached_tile *
+      tile = sp_get_cached_tile(sps, quad->x0, quad->y0);
+   uint i, j;
+
+   /* get/swizzle dest colors */
+   for (j = 0; j < QUAD_SIZE; j++) {
+      int x = (quad->x0 & (TILE_SIZE-1)) + (j & 1);
+      int y = (quad->y0 & (TILE_SIZE-1)) + (j >> 1);
+      for (i = 0; i < 4; i++) {
+         dest[i][j] = tile->data.color[y][x][i];
+      }
+   }
 
    /* R */
    if (!(softpipe->blend->colormask & PIPE_MASK_R))
diff --git a/src/mesa/pipe/softpipe/sp_quad_depth_test.c b/src/mesa/pipe/softpipe/sp_quad_depth_test.c
index ff1d84a02dd..efd08b981cf 100644
--- a/src/mesa/pipe/softpipe/sp_quad_depth_test.c
+++ b/src/mesa/pipe/softpipe/sp_quad_depth_test.c
@@ -32,6 +32,7 @@
 #include "sp_headers.h"
 #include "sp_surface.h"
 #include "sp_quad.h"
+#include "sp_tile_cache.h"
 
 
 /**
@@ -48,6 +49,9 @@ sp_depth_test_quad(struct quad_stage *qs, struct quad_header *quad)
    unsigned zmask = 0;
    unsigned j;
    float scale;
+#if 0
+   struct cached_tile *tile = sp_get_cached_tile(softpipe, quad->x0, quad->y0);
+#endif
 
    assert(sps); /* shouldn't get here if there's no zbuffer */
 
@@ -74,8 +78,16 @@ sp_depth_test_quad(struct quad_stage *qs, struct quad_header *quad)
       qzzzz[j] = (unsigned) (quad->outputs.depth[j] * scale);
    }
 
+#if 0
+   for (j = 0; j < 4; j++) {
+      int x = quad->x0 % TILE_SIZE + (j & 1);
+      int y = quad->y0 % TILE_SIZE + (j >> 1);
+      bzzzz[j] = tile->depth[y][x];
+   }
+#else
    /* get zquad from zbuffer */
    sps->read_quad_z(sps, quad->x0, quad->y0, bzzzz);
+#endif
 
    switch (softpipe->depth_stencil->depth.func) {
    case PIPE_FUNC_NEVER:
@@ -139,8 +151,16 @@ sp_depth_test_quad(struct quad_stage *qs, struct quad_header *quad)
 	 }
       }
 
+#if 1
       /* write updated zquad to zbuffer */
       sps->write_quad_z(sps, quad->x0, quad->y0, bzzzz);
+#else
+      for (j = 0; j < 4; j++) {
+         int x = quad->x0 % TILE_SIZE + (j & 1);
+         int y = quad->y0 % TILE_SIZE + (j >> 1);
+         tile->depth[y][x] = bzzzz[j];
+      }
+#endif
    }
 }
 
diff --git a/src/mesa/pipe/softpipe/sp_quad_output.c b/src/mesa/pipe/softpipe/sp_quad_output.c
index 49420c4fe7d..01ee06a69c1 100644
--- a/src/mesa/pipe/softpipe/sp_quad_output.c
+++ b/src/mesa/pipe/softpipe/sp_quad_output.c
@@ -1,57 +1,36 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5
- *
- * Copyright (C) 1999-2005  Brian Paul   All Rights Reserved.
- *
+/**************************************************************************
+ * 
+ * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
+ * All Rights Reserved.
+ * 
  * 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 shall be included
- * in all copies or substantial portions of the Software.
- *
+ * 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, sub license, 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
- * BRIAN PAUL 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.
- */
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS 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.
+ * 
+ **************************************************************************/
 
-/* Vertices are just an array of floats, with all the attributes
- * packed.  We currently assume a layout like:
- *
- * attr[0][0..3] - window position
- * attr[1..n][0..3] - remaining attributes.
- *
- * Attributes are assumed to be 4 floats wide but are packed so that
- * all the enabled attributes run contiguously.
- */
 #include "pipe/p_util.h"
 #include "sp_context.h"
 #include "sp_headers.h"
 #include "sp_surface.h"
 #include "sp_quad.h"
-
-
-static void mask_copy( float (*dest)[4],
-		       float (*src)[4],
-		       unsigned mask )
-{
-   unsigned i, j;
-
-   for (i = 0; i < 4; i++) {
-      if (mask & (1<<i)) {
-	 for (j = 0; j < 4; j++) {
-	    dest[j][i] = src[j][i];
-	 }
-      }
-   }
-}
+#include "sp_tile_cache.h"
 
 
 /**
@@ -64,20 +43,22 @@ output_quad(struct quad_stage *qs, struct quad_header *quad)
 {
    struct softpipe_context *softpipe = qs->softpipe;
    struct softpipe_surface *sps = softpipe_surface(softpipe->cbuf);
-
-   if (quad->mask != MASK_ALL) {
-      float tmp[4][QUAD_SIZE];
-
-      /* XXX probably add a masked-write function someday */
-
-      sps->read_quad_f_swz(sps, quad->x0, quad->y0, tmp);
-
-      mask_copy( tmp, quad->outputs.color, quad->mask );
-
-      sps->write_quad_f_swz(sps, quad->x0, quad->y0, tmp);
-   }
-   else if (quad->mask) {
-      sps->write_quad_f_swz(sps, quad->x0, quad->y0, quad->outputs.color);
+   struct softpipe_cached_tile *tile
+      = sp_get_cached_tile(sps, quad->x0, quad->y0);
+   /* in-tile pos: */
+   const int itx = quad->x0 % TILE_SIZE;
+   const int ity = quad->y0 % TILE_SIZE;
+   int i, j;
+
+   /* get/swizzle dest colors */
+   for (j = 0; j < QUAD_SIZE; j++) {
+      if (quad->mask & (1 << j)) {
+         int x = itx + (j & 1);
+         int y = ity + (j >> 1);
+         for (i = 0; i < 4; i++) { /* loop over color chans */
+            tile->data.color[y][x][i] = quad->outputs.color[i][j];
+         }
+      }
    }
 }
 
diff --git a/src/mesa/pipe/softpipe/sp_surface.c b/src/mesa/pipe/softpipe/sp_surface.c
index 292676a302a..e5b4f249fa5 100644
--- a/src/mesa/pipe/softpipe/sp_surface.c
+++ b/src/mesa/pipe/softpipe/sp_surface.c
@@ -25,12 +25,12 @@
  * 
  **************************************************************************/
 
+#include "pipe/p_defines.h"
+#include "pipe/p_util.h"
 #include "sp_context.h"
 #include "sp_state.h"
 #include "sp_surface.h"
-#include "pipe/p_defines.h"
-#include "pipe/p_util.h"
-
+#include "sp_tile_cache.h"
 
 /**
  * Softpipe surface functions.
@@ -871,6 +871,8 @@ s8_write_quad_stencil(struct softpipe_surface *sps,
 void
 softpipe_init_surface_funcs(struct softpipe_surface *sps)
 {
+   sps->tc = sp_create_tile_cache();
+
    assert(sps->surface.format);
 
    switch (sps->surface.format) {
diff --git a/src/mesa/pipe/softpipe/sp_surface.h b/src/mesa/pipe/softpipe/sp_surface.h
index 545983f4317..431303553fb 100644
--- a/src/mesa/pipe/softpipe/sp_surface.h
+++ b/src/mesa/pipe/softpipe/sp_surface.h
@@ -37,6 +37,7 @@
 struct pipe_context;
 struct softpipe_surface;
 struct softpipe_context;
+struct softpipe_tile_cache;
 
 
 /**
@@ -45,6 +46,8 @@ struct softpipe_context;
 struct softpipe_surface {
    struct pipe_surface surface;
 
+   struct softpipe_tile_cache *tc;
+
    /**
     * Functions for read/writing surface data
     */