src/gallium/drivers/softpipe/sp_tex_tile_cache.c - platform/external/mesa3d - Git at Google

 /**************************************************************************
  *
  * 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, 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 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.
  *
  **************************************************************************/

 /**
  * Texture tile caching.
  *
  * Author:
  *    Brian Paul
  */

 #include "util/u_inlines.h"
 #include "util/u_memory.h"
 #include "util/u_tile.h"
 #include "util/u_format.h"
 #include "util/u_math.h"
 #include "sp_context.h"
 #include "sp_texture.h"
 #include "sp_tex_tile_cache.h"


 struct softpipe_tex_tile_cache *
 sp_create_tex_tile_cache( struct pipe_context *pipe )
 {
    struct softpipe_tex_tile_cache *tc;
    uint pos;

    /* make sure max texture size works */
    assert((TILE_SIZE << TEX_ADDR_BITS) >= (1 << (SP_MAX_TEXTURE_2D_LEVELS-1)));

    tc = CALLOC_STRUCT( softpipe_tex_tile_cache );
    if (tc) {
       tc->pipe = pipe;
       for (pos = 0; pos < NUM_ENTRIES; pos++) {
          tc->entries[pos].addr.bits.invalid = 1;
       }
       tc->last_tile = &tc->entries[0]; /* any tile */
    }
    return tc;
 }


 void
 sp_destroy_tex_tile_cache(struct softpipe_tex_tile_cache *tc)
 {
    if (tc) {
       uint pos;

       for (pos = 0; pos < NUM_ENTRIES; pos++) {
          /*assert(tc->entries[pos].x < 0);*/
       }
       if (tc->transfer) {
          tc->pipe->transfer_destroy(tc->pipe, tc->transfer);
       }
       if (tc->tex_trans) {
          tc->pipe->transfer_destroy(tc->pipe, tc->tex_trans);
       }

       FREE( tc );
    }
 }


 void
 sp_tex_tile_cache_map_transfers(struct softpipe_tex_tile_cache *tc)
 {
    if (tc->tex_trans && !tc->tex_trans_map)
       tc->tex_trans_map = tc->pipe->transfer_map(tc->pipe, tc->tex_trans);
 }


 void
 sp_tex_tile_cache_unmap_transfers(struct softpipe_tex_tile_cache *tc)
 {
    if (tc->tex_trans_map) {
       tc->pipe->transfer_unmap(tc->pipe, tc->tex_trans);
       tc->tex_trans_map = NULL;
    }
 }

 /**
  * Invalidate all cached tiles for the cached texture.
  * Should be called when the texture is modified.
  */
 void
 sp_tex_tile_cache_validate_texture(struct softpipe_tex_tile_cache *tc)
 {
    unsigned i;

    assert(tc);
    assert(tc->texture);

    for (i = 0; i < NUM_ENTRIES; i++) {
       tc->entries[i].addr.bits.invalid = 1;
    }
 }

 static boolean
 sp_tex_tile_is_compat_view(struct softpipe_tex_tile_cache *tc,
                            struct pipe_sampler_view *view)
 {
    if (!view)
       return FALSE;
    return (tc->texture == view->texture &&
            tc->format == view->format &&
            tc->swizzle_r == view->swizzle_r &&
            tc->swizzle_g == view->swizzle_g &&
            tc->swizzle_b == view->swizzle_b &&
            tc->swizzle_a == view->swizzle_a);
 }

 /**
  * Specify the sampler view to cache.
  */
 void
 sp_tex_tile_cache_set_sampler_view(struct softpipe_tex_tile_cache *tc,
                                    struct pipe_sampler_view *view)
 {
    struct pipe_resource *texture = view ? view->texture : NULL;
    uint i;

    assert(!tc->transfer);

    if (!sp_tex_tile_is_compat_view(tc, view)) {
       pipe_resource_reference(&tc->texture, texture);

       if (tc->tex_trans) {
          if (tc->tex_trans_map) {
             tc->pipe->transfer_unmap(tc->pipe, tc->tex_trans);
             tc->tex_trans_map = NULL;
          }

          tc->pipe->transfer_destroy(tc->pipe, tc->tex_trans);
          tc->tex_trans = NULL;
       }

       if (view) {
          tc->swizzle_r = view->swizzle_r;
          tc->swizzle_g = view->swizzle_g;
          tc->swizzle_b = view->swizzle_b;
          tc->swizzle_a = view->swizzle_a;
          tc->format = view->format;
       }

       /* mark as entries as invalid/empty */
       /* XXX we should try to avoid this when the teximage hasn't changed */
       for (i = 0; i < NUM_ENTRIES; i++) {
          tc->entries[i].addr.bits.invalid = 1;
       }

       tc->tex_face = -1; /* any invalid value here */
    }
 }


 /**
  * Flush the tile cache: write all dirty tiles back to the transfer.
  * any tiles "flagged" as cleared will be "really" cleared.
  */
 void
 sp_flush_tex_tile_cache(struct softpipe_tex_tile_cache *tc)
 {
    int pos;

    if (tc->texture) {
       /* caching a texture, mark all entries as empty */
       for (pos = 0; pos < NUM_ENTRIES; pos++) {
          tc->entries[pos].addr.bits.invalid = 1;
       }
       tc->tex_face = -1;
    }

 }


 /**
  * Given the texture face, level, zslice, x and y values, compute
  * the cache entry position/index where we'd hope to find the
  * cached texture tile.
  * This is basically a direct-map cache.
  * XXX There's probably lots of ways in which we can improve this.
  */
 static INLINE uint
 tex_cache_pos( union tex_tile_address addr )
 {
    uint entry = (addr.bits.x +
                  addr.bits.y * 9 +
                  addr.bits.z * 3 +
                  addr.bits.face +
                  addr.bits.level * 7);

    return entry % NUM_ENTRIES;
 }

 /**
  * Similar to sp_get_cached_tile() but for textures.
  * Tiles are read-only and indexed with more params.
  */
 const struct softpipe_tex_cached_tile *
 sp_find_cached_tile_tex(struct softpipe_tex_tile_cache *tc,
                         union tex_tile_address addr )
 {
    struct softpipe_tex_cached_tile *tile;
    boolean zs = util_format_is_depth_or_stencil(tc->format);

    tile = tc->entries + tex_cache_pos( addr );

    if (addr.value != tile->addr.value) {

       /* cache miss.  Most misses are because we've invaldiated the
        * texture cache previously -- most commonly on binding a new
        * texture.  Currently we effectively flush the cache on texture
        * bind.
        */
 #if 0
       _debug_printf("miss at %u:  x=%d y=%d z=%d face=%d level=%d\n"
                     "   tile %u:  x=%d y=%d z=%d face=%d level=%d\n",
                     pos, x/TILE_SIZE, y/TILE_SIZE, z, face, level,
                     pos, tile->addr.bits.x, tile->addr.bits.y, tile->z, tile->face, tile->level);
 #endif

       /* check if we need to get a new transfer */
       if (!tc->tex_trans ||
           tc->tex_face != addr.bits.face ||
           tc->tex_level != addr.bits.level ||
           tc->tex_z != addr.bits.z) {
          /* get new transfer (view into texture) */
          unsigned width, height, layer;

          if (tc->tex_trans) {
             if (tc->tex_trans_map) {
                tc->pipe->transfer_unmap(tc->pipe, tc->tex_trans);
                tc->tex_trans_map = NULL;
             }

             tc->pipe->transfer_destroy(tc->pipe, tc->tex_trans);
             tc->tex_trans = NULL;
          }

          width = u_minify(tc->texture->width0, addr.bits.level);
          if (tc->texture->target == PIPE_TEXTURE_1D_ARRAY) {
             height = tc->texture->array_size;
             layer = 0;
          }
          else {
             height = u_minify(tc->texture->height0, addr.bits.level);
             layer = addr.bits.face + addr.bits.z;
          }

          tc->tex_trans =
             pipe_get_transfer(tc->pipe, tc->texture,
                               addr.bits.level,
                               layer,
                               PIPE_TRANSFER_READ | PIPE_TRANSFER_UNSYNCHRONIZED,
                               0, 0, width, height);

          tc->tex_trans_map = tc->pipe->transfer_map(tc->pipe, tc->tex_trans);

          tc->tex_face = addr.bits.face;
          tc->tex_level = addr.bits.level;
          tc->tex_z = addr.bits.z;
       }

       /* Get tile from the transfer (view into texture), explicitly passing
        * the image format.
        */
       if (!zs && util_format_is_pure_uint(tc->format)) {
          pipe_get_tile_ui_format(tc->pipe,
                                  tc->tex_trans,
                                  addr.bits.x * TILE_SIZE,
                                  addr.bits.y * TILE_SIZE,
                                  TILE_SIZE,
                                  TILE_SIZE,
                                  tc->format,
                                  (unsigned *) tile->data.colorui);
       } else if (!zs && util_format_is_pure_sint(tc->format)) {
          pipe_get_tile_i_format(tc->pipe,
                                 tc->tex_trans,
                                 addr.bits.x * TILE_SIZE,
                                 addr.bits.y * TILE_SIZE,
                                 TILE_SIZE,
                                  TILE_SIZE,
                                 tc->format,
                                 (int *) tile->data.colori);
       } else {
          pipe_get_tile_rgba_format(tc->pipe,
                                    tc->tex_trans,
                                    addr.bits.x * TILE_SIZE,
                                    addr.bits.y * TILE_SIZE,
                                    TILE_SIZE,
                                    TILE_SIZE,
                                    tc->format,
                                    (float *) tile->data.color);
       }
       tile->addr = addr;
    }

    tc->last_tile = tile;
    return tile;
 }
	/**************************************************************************
	*
	* 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, 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 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.
	*
	**************************************************************************/

	/**
	* Texture tile caching.
	*
	* Author:
	* Brian Paul
	*/

	#include "util/u_inlines.h"
	#include "util/u_memory.h"
	#include "util/u_tile.h"
	#include "util/u_format.h"
	#include "util/u_math.h"
	#include "sp_context.h"
	#include "sp_texture.h"
	#include "sp_tex_tile_cache.h"



	struct softpipe_tex_tile_cache *
	sp_create_tex_tile_cache( struct pipe_context *pipe )
	{
	struct softpipe_tex_tile_cache *tc;
	uint pos;

	/* make sure max texture size works */
	assert((TILE_SIZE << TEX_ADDR_BITS) >= (1 << (SP_MAX_TEXTURE_2D_LEVELS-1)));

	tc = CALLOC_STRUCT( softpipe_tex_tile_cache );
	if (tc) {
	tc->pipe = pipe;
	for (pos = 0; pos < NUM_ENTRIES; pos++) {
	tc->entries[pos].addr.bits.invalid = 1;
	}
	tc->last_tile = &tc->entries[0]; /* any tile */
	}
	return tc;
	}


	void
	sp_destroy_tex_tile_cache(struct softpipe_tex_tile_cache *tc)
	{
	if (tc) {
	uint pos;

	for (pos = 0; pos < NUM_ENTRIES; pos++) {
	/assert(tc->entries[pos].x < 0);/
	}
	if (tc->transfer) {
	tc->pipe->transfer_destroy(tc->pipe, tc->transfer);
	}
	if (tc->tex_trans) {
	tc->pipe->transfer_destroy(tc->pipe, tc->tex_trans);
	}

	FREE( tc );
	}
	}




	void
	sp_tex_tile_cache_map_transfers(struct softpipe_tex_tile_cache *tc)
	{
	if (tc->tex_trans && !tc->tex_trans_map)
	tc->tex_trans_map = tc->pipe->transfer_map(tc->pipe, tc->tex_trans);
	}


	void
	sp_tex_tile_cache_unmap_transfers(struct softpipe_tex_tile_cache *tc)
	{
	if (tc->tex_trans_map) {
	tc->pipe->transfer_unmap(tc->pipe, tc->tex_trans);
	tc->tex_trans_map = NULL;
	}
	}

	/**
	* Invalidate all cached tiles for the cached texture.
	* Should be called when the texture is modified.
	*/
	void
	sp_tex_tile_cache_validate_texture(struct softpipe_tex_tile_cache *tc)
	{
	unsigned i;

	assert(tc);
	assert(tc->texture);

	for (i = 0; i < NUM_ENTRIES; i++) {
	tc->entries[i].addr.bits.invalid = 1;
	}
	}

	static boolean
	sp_tex_tile_is_compat_view(struct softpipe_tex_tile_cache *tc,
	struct pipe_sampler_view *view)
	{
	if (!view)
	return FALSE;
	return (tc->texture == view->texture &&
	tc->format == view->format &&
	tc->swizzle_r == view->swizzle_r &&
	tc->swizzle_g == view->swizzle_g &&
	tc->swizzle_b == view->swizzle_b &&
	tc->swizzle_a == view->swizzle_a);
	}

	/**
	* Specify the sampler view to cache.
	*/
	void
	sp_tex_tile_cache_set_sampler_view(struct softpipe_tex_tile_cache *tc,
	struct pipe_sampler_view *view)
	{
	struct pipe_resource *texture = view ? view->texture : NULL;
	uint i;

	assert(!tc->transfer);

	if (!sp_tex_tile_is_compat_view(tc, view)) {
	pipe_resource_reference(&tc->texture, texture);

	if (tc->tex_trans) {
	if (tc->tex_trans_map) {
	tc->pipe->transfer_unmap(tc->pipe, tc->tex_trans);
	tc->tex_trans_map = NULL;
	}

	tc->pipe->transfer_destroy(tc->pipe, tc->tex_trans);
	tc->tex_trans = NULL;
	}

	if (view) {
	tc->swizzle_r = view->swizzle_r;
	tc->swizzle_g = view->swizzle_g;
	tc->swizzle_b = view->swizzle_b;
	tc->swizzle_a = view->swizzle_a;
	tc->format = view->format;
	}

	/* mark as entries as invalid/empty */
	/* XXX we should try to avoid this when the teximage hasn't changed */
	for (i = 0; i < NUM_ENTRIES; i++) {
	tc->entries[i].addr.bits.invalid = 1;
	}

	tc->tex_face = -1; /* any invalid value here */
	}
	}




	/**
	* Flush the tile cache: write all dirty tiles back to the transfer.
	* any tiles "flagged" as cleared will be "really" cleared.
	*/
	void
	sp_flush_tex_tile_cache(struct softpipe_tex_tile_cache *tc)
	{
	int pos;

	if (tc->texture) {
	/* caching a texture, mark all entries as empty */
	for (pos = 0; pos < NUM_ENTRIES; pos++) {
	tc->entries[pos].addr.bits.invalid = 1;
	}
	tc->tex_face = -1;
	}

	}


	/**
	* Given the texture face, level, zslice, x and y values, compute
	* the cache entry position/index where we'd hope to find the
	* cached texture tile.
	* This is basically a direct-map cache.
	* XXX There's probably lots of ways in which we can improve this.
	*/
	static INLINE uint
	tex_cache_pos( union tex_tile_address addr )
	{
	uint entry = (addr.bits.x +
	addr.bits.y * 9 +
	addr.bits.z * 3 +
	addr.bits.face +
	addr.bits.level * 7);

	return entry % NUM_ENTRIES;
	}

	/**
	* Similar to sp_get_cached_tile() but for textures.
	* Tiles are read-only and indexed with more params.
	*/
	const struct softpipe_tex_cached_tile *
	sp_find_cached_tile_tex(struct softpipe_tex_tile_cache *tc,
	union tex_tile_address addr )
	{
	struct softpipe_tex_cached_tile *tile;
	boolean zs = util_format_is_depth_or_stencil(tc->format);

	tile = tc->entries + tex_cache_pos( addr );

	if (addr.value != tile->addr.value) {

	/* cache miss. Most misses are because we've invaldiated the
	* texture cache previously -- most commonly on binding a new
	* texture. Currently we effectively flush the cache on texture
	* bind.
	*/
	#if 0
	_debug_printf("miss at %u: x=%d y=%d z=%d face=%d level=%d\n"
	" tile %u: x=%d y=%d z=%d face=%d level=%d\n",
	pos, x/TILE_SIZE, y/TILE_SIZE, z, face, level,
	pos, tile->addr.bits.x, tile->addr.bits.y, tile->z, tile->face, tile->level);
	#endif

	/* check if we need to get a new transfer */
	if (!tc->tex_trans \|\|
	tc->tex_face != addr.bits.face \|\|
	tc->tex_level != addr.bits.level \|\|
	tc->tex_z != addr.bits.z) {
	/* get new transfer (view into texture) */
	unsigned width, height, layer;

	if (tc->tex_trans) {
	if (tc->tex_trans_map) {
	tc->pipe->transfer_unmap(tc->pipe, tc->tex_trans);
	tc->tex_trans_map = NULL;
	}

	tc->pipe->transfer_destroy(tc->pipe, tc->tex_trans);
	tc->tex_trans = NULL;
	}

	width = u_minify(tc->texture->width0, addr.bits.level);
	if (tc->texture->target == PIPE_TEXTURE_1D_ARRAY) {
	height = tc->texture->array_size;
	layer = 0;
	}
	else {
	height = u_minify(tc->texture->height0, addr.bits.level);
	layer = addr.bits.face + addr.bits.z;
	}

	tc->tex_trans =
	pipe_get_transfer(tc->pipe, tc->texture,
	addr.bits.level,
	layer,
	PIPE_TRANSFER_READ \| PIPE_TRANSFER_UNSYNCHRONIZED,
	0, 0, width, height);

	tc->tex_trans_map = tc->pipe->transfer_map(tc->pipe, tc->tex_trans);

	tc->tex_face = addr.bits.face;
	tc->tex_level = addr.bits.level;
	tc->tex_z = addr.bits.z;
	}

	/* Get tile from the transfer (view into texture), explicitly passing
	* the image format.
	*/
	if (!zs && util_format_is_pure_uint(tc->format)) {
	pipe_get_tile_ui_format(tc->pipe,
	tc->tex_trans,
	addr.bits.x * TILE_SIZE,
	addr.bits.y * TILE_SIZE,
	TILE_SIZE,
	TILE_SIZE,
	tc->format,
	(unsigned *) tile->data.colorui);
	} else if (!zs && util_format_is_pure_sint(tc->format)) {
	pipe_get_tile_i_format(tc->pipe,
	tc->tex_trans,
	addr.bits.x * TILE_SIZE,
	addr.bits.y * TILE_SIZE,
	TILE_SIZE,
	TILE_SIZE,
	tc->format,
	(int *) tile->data.colori);
	} else {
	pipe_get_tile_rgba_format(tc->pipe,
	tc->tex_trans,
	addr.bits.x * TILE_SIZE,
	addr.bits.y * TILE_SIZE,
	TILE_SIZE,
	TILE_SIZE,
	tc->format,
	(float *) tile->data.color);
	}
	tile->addr = addr;
	}

	tc->last_tile = tile;
	return tile;
	}