KonstantinSeurer
/
mesa
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

llvmpipe: remove tex tile cache and related code

This commit is contained in:
Keith Whitwell 2009-10-08 16:33:12 +01:00
parent d2e2b75633
commit 6b65685def
14 changed files with 33 additions and 2333 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
src/gallium/drivers/llvmpipe/lp_context.c
View File

@ -41,62 +41,12 @@
#include "lp_prim_vbuf.h"
#include "lp_state.h"
#include "lp_surface.h"
#include "lp_tile_cache.h"
#include "lp_tex_cache.h"
#include "lp_texture.h"
#include "lp_winsys.h"
#include "lp_query.h"
/**
* Map any drawing surfaces which aren't already mapped
*/
void
llvmpipe_map_transfers(struct llvmpipe_context *lp)
{
struct pipe_screen *screen = lp->pipe.screen;
struct pipe_surface *zsbuf = lp->framebuffer.zsbuf;
unsigned i;
for (i = 0; i < lp->framebuffer.nr_cbufs; i++) {
lp_tile_cache_map_transfers(lp->cbuf_cache[i]);
}
if(zsbuf) {
if(!lp->zsbuf_transfer)
lp->zsbuf_transfer = screen->get_tex_transfer(screen, zsbuf->texture,
zsbuf->face, zsbuf->level, zsbuf->zslice,
PIPE_TRANSFER_READ_WRITE,
0, 0, zsbuf->width, zsbuf->height);
if(lp->zsbuf_transfer && !lp->zsbuf_map)
lp->zsbuf_map = screen->transfer_map(screen, lp->zsbuf_transfer);
}
}
/**
* Unmap any mapped drawing surfaces
*/
void
llvmpipe_unmap_transfers(struct llvmpipe_context *lp)
{
uint i;
for (i = 0; i < lp->framebuffer.nr_cbufs; i++) {
lp_tile_cache_unmap_transfers(lp->cbuf_cache[i]);
}
if(lp->zsbuf_transfer) {
struct pipe_screen *screen = lp->pipe.screen;
if(lp->zsbuf_map) {
screen->transfer_unmap(screen, lp->zsbuf_transfer);
lp->zsbuf_map = NULL;
}
}
}
static void llvmpipe_destroy( struct pipe_context *pipe )
@ -107,14 +57,16 @@ static void llvmpipe_destroy( struct pipe_context *pipe )
if (llvmpipe->draw)
draw_destroy( llvmpipe->draw );
if (llvmpipe->setup)
lp_setup_destroy( llvmpipe->setup );
for (i = 0; i < PIPE_MAX_COLOR_BUFS; i++) {
lp_destroy_tile_cache(llvmpipe->cbuf_cache[i]);
pipe_surface_reference(&llvmpipe->framebuffer.cbufs[i], NULL);
}
pipe_surface_reference(&llvmpipe->framebuffer.zsbuf, NULL);
for (i = 0; i < PIPE_MAX_SAMPLERS; i++) {
lp_destroy_tex_tile_cache(llvmpipe->tex_cache[i]);
pipe_texture_reference(&llvmpipe->texture[i], NULL);
}
@ -135,7 +87,7 @@ llvmpipe_is_texture_referenced( struct pipe_context *pipe,
struct llvmpipe_context *llvmpipe = llvmpipe_context( pipe );
unsigned i;
if(llvmpipe->dirty_render_cache) {
if (lp_setup_is_active(llvmpipe->setup)) {
for (i = 0; i < llvmpipe->framebuffer.nr_cbufs; i++) {
if(llvmpipe->framebuffer.cbufs[i] &&
llvmpipe->framebuffer.cbufs[i]->texture == texture)
@ -226,21 +178,10 @@ llvmpipe_create( struct pipe_screen *screen )
llvmpipe_init_query_funcs( llvmpipe );
llvmpipe_init_texture_funcs( llvmpipe );
/*
* Alloc caches for accessing drawing surfaces and textures.
*/
for (i = 0; i < PIPE_MAX_COLOR_BUFS; i++)
llvmpipe->cbuf_cache[i] = lp_create_tile_cache( screen );
for (i = 0; i < PIPE_MAX_SAMPLERS; i++)
llvmpipe->tex_cache[i] = lp_create_tex_tile_cache( screen );
/* vertex shader samplers */
for (i = 0; i < PIPE_MAX_SAMPLERS; i++) {
llvmpipe->tgsi.vert_samplers[i].base.get_samples = lp_get_samples;
llvmpipe->tgsi.vert_samplers[i].processor = TGSI_PROCESSOR_VERTEX;
llvmpipe->tgsi.vert_samplers[i].cache = llvmpipe->tex_cache[i];
llvmpipe->tgsi.vert_samplers_list[i] = &llvmpipe->tgsi.vert_samplers[i];
}
@ -248,7 +189,6 @@ llvmpipe_create( struct pipe_screen *screen )
for (i = 0; i < PIPE_MAX_SAMPLERS; i++) {
llvmpipe->tgsi.frag_samplers[i].base.get_samples = lp_get_samples;
llvmpipe->tgsi.frag_samplers[i].processor = TGSI_PROCESSOR_FRAGMENT;
llvmpipe->tgsi.frag_samplers[i].cache = llvmpipe->tex_cache[i];
llvmpipe->tgsi.frag_samplers_list[i] = &llvmpipe->tgsi.frag_samplers[i];
}

21
src/gallium/drivers/llvmpipe/lp_context.h
View File

@ -42,12 +42,10 @@
struct llvmpipe_vbuf_render;
struct draw_context;
struct draw_stage;
struct llvmpipe_tile_cache;
struct llvmpipe_tex_tile_cache;
struct lp_fragment_shader;
struct lp_vertex_shader;
struct lp_blend_state;
struct lp_setup_context;
struct llvmpipe_context {
struct pipe_context pipe; /**< base class */
@ -112,8 +110,6 @@ struct llvmpipe_context {
/** Derived from scissor and surface bounds: */
struct pipe_scissor_state cliprect;
unsigned line_stipple_counter;
/** TGSI exec things */
struct {
struct lp_shader_sampler vert_samplers[PIPE_MAX_SAMPLERS];
@ -122,6 +118,9 @@ struct llvmpipe_context {
struct lp_shader_sampler *frag_samplers_list[PIPE_MAX_SAMPLERS];
} tgsi;
/** The tiling engine */
struct lp_setup_context *setup;
/** The primitive drawing context */
struct draw_context *draw;
@ -129,18 +128,8 @@ struct llvmpipe_context {
struct vbuf_render *vbuf_backend;
struct draw_stage *vbuf;
boolean dirty_render_cache;
struct llvmpipe_tile_cache *cbuf_cache[PIPE_MAX_COLOR_BUFS];
/* TODO: we shouldn't be using external interfaces internally like this */
struct pipe_transfer *zsbuf_transfer;
uint8_t *zsbuf_map;
unsigned tex_timestamp;
struct llvmpipe_tex_tile_cache *tex_cache[PIPE_MAX_SAMPLERS];
unsigned no_rast : 1;
boolean no_rast;
struct lp_jit_context jit_context;
};

3
src/gallium/drivers/llvmpipe/lp_draw_arrays.c
View File

@ -123,7 +123,6 @@ llvmpipe_draw_range_elements(struct pipe_context *pipe,
if (lp->dirty)
llvmpipe_update_derived( lp );
llvmpipe_map_transfers(lp);
llvmpipe_map_constant_buffers(lp);
/*
@ -164,8 +163,6 @@ llvmpipe_draw_range_elements(struct pipe_context *pipe,
/* Note: leave drawing surfaces mapped */
llvmpipe_unmap_constant_buffers(lp);
lp->dirty_render_cache = TRUE;
return TRUE;
}

32
src/gallium/drivers/llvmpipe/lp_flush.c
View File

@ -36,8 +36,6 @@
#include "lp_context.h"
#include "lp_surface.h"
#include "lp_state.h"
#include "lp_tile_cache.h"
#include "lp_tex_cache.h"
#include "lp_winsys.h"
@ -47,40 +45,14 @@ llvmpipe_flush( struct pipe_context *pipe,
struct pipe_fence_handle **fence )
{
struct llvmpipe_context *llvmpipe = llvmpipe_context(pipe);
uint i;
draw_flush(llvmpipe->draw);
if (flags & PIPE_FLUSH_SWAPBUFFERS) {
/* If this is a swapbuffers, just flush color buffers.
*
* The zbuffer changes are not discarded, but held in the cache
* in the hope that a later clear will wipe them out.
*/
for (i = 0; i < llvmpipe->framebuffer.nr_cbufs; i++)
if (llvmpipe->cbuf_cache[i]) {
lp_tile_cache_map_transfers(llvmpipe->cbuf_cache[i]);
lp_flush_tile_cache(llvmpipe->cbuf_cache[i]);
}
/* Need this call for hardware buffers before swapbuffers.
*
* there should probably be another/different flush-type function
* that's called before swapbuffers because we don't always want
* to unmap surfaces when flushing.
*/
llvmpipe_unmap_transfers(llvmpipe);
lp_setup_flush( llvmpipe->setup, FALSE );
}
else if (flags & PIPE_FLUSH_RENDER_CACHE) {
for (i = 0; i < llvmpipe->framebuffer.nr_cbufs; i++)
if (llvmpipe->cbuf_cache[i]) {
lp_tile_cache_map_transfers(llvmpipe->cbuf_cache[i]);
lp_flush_tile_cache(llvmpipe->cbuf_cache[i]);
}
/* FIXME: untile zsbuf! */
llvmpipe->dirty_render_cache = FALSE;
lp_setup_flush( llvmpipe->setup, TRUE );
}
/* Enable to dump BMPs of the color/depth buffers each frame */

9
src/gallium/drivers/llvmpipe/lp_setup.h
View File

@ -41,11 +41,18 @@ struct setup_context;
struct setup_context *
lp_setup_create( void );
void
lp_setup_clear(struct pipe_context *pipe,
unsigned buffers,
const float *rgba,
double depth,
unsigned stencil);
void
lp_setup_triangle(struct setup_context *setup,
const float (*v0)[4],
const float (*v1)[4],
const float (*v1)[4]);
const float (*v2)[4]);
void
lp_setup_line(struct setup_context *setup,

6
src/gallium/drivers/llvmpipe/lp_state.h
View File

@ -207,12 +207,6 @@ void
llvmpipe_set_edgeflags(struct pipe_context *pipe, const unsigned *edgeflags);
void
llvmpipe_map_transfers(struct llvmpipe_context *lp);
void
llvmpipe_unmap_transfers(struct llvmpipe_context *lp);
void
llvmpipe_map_texture_surfaces(struct llvmpipe_context *lp);

7
src/gallium/drivers/llvmpipe/lp_state_derived.c
View File

@ -33,7 +33,6 @@
#include "draw/draw_private.h"
#include "lp_context.h"
#include "lp_screen.h"
#include "lp_tex_cache.h"
#include "lp_state.h"
@ -215,7 +214,7 @@ update_tgsi_samplers( struct llvmpipe_context *llvmpipe )
for (i = 0; i < PIPE_MAX_SAMPLERS; i++) {
llvmpipe->tgsi.vert_samplers[i].sampler = llvmpipe->sampler[i];
llvmpipe->tgsi.vert_samplers[i].texture = llvmpipe->texture[i];
llvmpipe->tgsi.frag_samplers[i].base.get_samples = lp_get_samples;
llvmpipe->tgsi.vert_samplers[i].base.get_samples = lp_get_samples;
}
/* fragment shader samplers */
@ -225,10 +224,6 @@ update_tgsi_samplers( struct llvmpipe_context *llvmpipe )
llvmpipe->tgsi.frag_samplers[i].base.get_samples = lp_get_samples;
}
for (i = 0; i < PIPE_MAX_SAMPLERS; i++) {
lp_tex_tile_cache_validate_texture( llvmpipe->tex_cache[i] );
}
llvmpipe->jit_context.samplers = (struct tgsi_sampler **)llvmpipe->tgsi.frag_samplers_list;
}

2
src/gallium/drivers/llvmpipe/lp_state_sampler.c
View File

@ -37,7 +37,6 @@
#include "lp_context.h"
#include "lp_state.h"
#include "lp_texture.h"
#include "lp_tex_cache.h"
#include "draw/draw_context.h"
@ -97,7 +96,6 @@ llvmpipe_set_sampler_textures(struct pipe_context *pipe,
struct pipe_texture *tex = i < num ? texture[i] : NULL;
pipe_texture_reference(&llvmpipe->texture[i], tex);
lp_tex_tile_cache_set_texture(llvmpipe->tex_cache[i], tex);
if(tex) {
struct llvmpipe_texture *lp_tex = llvmpipe_texture(tex);

41
src/gallium/drivers/llvmpipe/lp_state_surface.c
View File

@ -31,16 +31,12 @@
#include "lp_context.h"
#include "lp_state.h"
#include "lp_surface.h"
#include "lp_tile_cache.h"
#include "draw/draw_context.h"
/**
* XXX this might get moved someday
* Set the framebuffer surface info: color buffers, zbuffer, stencil buffer.
* Here, we flush the old surfaces and update the tile cache to point to the new
* surfaces.
*/
void
llvmpipe_set_framebuffer_state(struct pipe_context *pipe,
@ -48,38 +44,23 @@ llvmpipe_set_framebuffer_state(struct pipe_context *pipe,
{
struct llvmpipe_context *lp = llvmpipe_context(pipe);
uint i;
boolean dirty = FALSE;
for (i = 0; i < PIPE_MAX_COLOR_BUFS; i++) {
/* check if changing cbuf */
if (lp->framebuffer.cbufs[i] != fb->cbufs[i]) {
/* flush old */
lp_tile_cache_map_transfers(lp->cbuf_cache[i]);
lp_flush_tile_cache(lp->cbuf_cache[i]);
/* assign new */
pipe_surface_reference(&lp->framebuffer.cbufs[i], fb->cbufs[i]);
/* update cache */
lp_tile_cache_set_surface(lp->cbuf_cache[i], fb->cbufs[i]);
dirty = TRUE;
}
}
lp->framebuffer.nr_cbufs = fb->nr_cbufs;
if (lp->framebuffer.nr_cbufs != fb->nr_cbufs) {
dirty = TRUE;
lp->framebuffer.nr_cbufs = fb->nr_cbufs;
}
/* zbuf changing? */
if (lp->framebuffer.zsbuf != fb->zsbuf) {
if(lp->zsbuf_transfer) {
struct pipe_screen *screen = pipe->screen;
if(lp->zsbuf_map) {
screen->transfer_unmap(screen, lp->zsbuf_transfer);
lp->zsbuf_map = NULL;
}
screen->tex_transfer_destroy(lp->zsbuf_transfer);
lp->zsbuf_transfer = NULL;
}
dirty = TRUE;
/* assign new */
pipe_surface_reference(&lp->framebuffer.zsbuf, fb->zsbuf);
@ -100,8 +81,8 @@ llvmpipe_set_framebuffer_state(struct pipe_context *pipe,
}
}
lp->framebuffer.width = fb->width;
lp->framebuffer.height = fb->height;
lp->dirty |= LP_NEW_FRAMEBUFFER;
if (dirty) {
lp_setup_set_framebuffer( llvmpipe->setup, fb );
lp->dirty |= LP_NEW_FRAMEBUFFER;
}
}

304
src/gallium/drivers/llvmpipe/lp_tex_cache.c
View File

@ -1,304 +0,0 @@
/**************************************************************************
*
* 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 "pipe/p_inlines.h"
#include "util/u_memory.h"
#include "util/u_tile.h"
#include "util/u_format.h"
#include "lp_context.h"
#include "lp_surface.h"
#include "lp_texture.h"
#include "lp_tex_cache.h"
/**
* Return the position in the cache for the tile that contains win pos (x,y).
* We currently use a direct mapped cache so this is like a hack key.
* At some point we should investige something more sophisticated, like
* a LRU replacement policy.
*/
#define CACHE_POS(x, y) \
(((x) + (y) * 5) % NUM_ENTRIES)
/**
* Is the tile at (x,y) in cleared state?
*/
static INLINE uint
is_clear_flag_set(const uint *bitvec, union tex_tile_address addr)
{
int pos, bit;
pos = addr.bits.y * (MAX_TEX_WIDTH / TEX_TILE_SIZE) + addr.bits.x;
assert(pos / 32 < (MAX_TEX_WIDTH / TEX_TILE_SIZE) * (MAX_TEX_HEIGHT / TEX_TILE_SIZE) / 32);
bit = bitvec[pos / 32] & (1 << (pos & 31));
return bit;
}
/**
* Mark the tile at (x,y) as not cleared.
*/
static INLINE void
clear_clear_flag(uint *bitvec, union tex_tile_address addr)
{
int pos;
pos = addr.bits.y * (MAX_TEX_WIDTH / TEX_TILE_SIZE) + addr.bits.x;
assert(pos / 32 < (MAX_TEX_WIDTH / TEX_TILE_SIZE) * (MAX_TEX_HEIGHT / TEX_TILE_SIZE) / 32);
bitvec[pos / 32] &= ~(1 << (pos & 31));
}
struct llvmpipe_tex_tile_cache *
lp_create_tex_tile_cache( struct pipe_screen *screen )
{
struct llvmpipe_tex_tile_cache *tc;
uint pos;
tc = CALLOC_STRUCT( llvmpipe_tex_tile_cache );
if (tc) {
tc->screen = screen;
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
lp_destroy_tex_tile_cache(struct llvmpipe_tex_tile_cache *tc)
{
struct pipe_screen *screen;
uint pos;
for (pos = 0; pos < NUM_ENTRIES; pos++) {
/*assert(tc->entries[pos].x < 0);*/
}
if (tc->transfer) {
screen = tc->transfer->texture->screen;
screen->tex_transfer_destroy(tc->transfer);
}
if (tc->tex_trans) {
screen = tc->tex_trans->texture->screen;
screen->tex_transfer_destroy(tc->tex_trans);
}
FREE( tc );
}
void
lp_tex_tile_cache_map_transfers(struct llvmpipe_tex_tile_cache *tc)
{
if (tc->transfer && !tc->transfer_map)
tc->transfer_map = tc->screen->transfer_map(tc->screen, tc->transfer);
if (tc->tex_trans && !tc->tex_trans_map)
tc->tex_trans_map = tc->screen->transfer_map(tc->screen, tc->tex_trans);
}
void
lp_tex_tile_cache_unmap_transfers(struct llvmpipe_tex_tile_cache *tc)
{
if (tc->transfer_map) {
tc->screen->transfer_unmap(tc->screen, tc->transfer);
tc->transfer_map = NULL;
}
if (tc->tex_trans_map) {
tc->screen->transfer_unmap(tc->screen, tc->tex_trans);
tc->tex_trans_map = NULL;
}
}
void
lp_tex_tile_cache_validate_texture(struct llvmpipe_tex_tile_cache *tc)
{
if (tc->texture) {
struct llvmpipe_texture *lpt = llvmpipe_texture(tc->texture);
if (lpt->timestamp != tc->timestamp) {
/* texture was modified, invalidate all cached tiles */
uint i;
debug_printf("INV %d %d\n", tc->timestamp, lpt->timestamp);
for (i = 0; i < NUM_ENTRIES; i++) {
tc->entries[i].addr.bits.invalid = 1;
}
tc->timestamp = lpt->timestamp;
}
}
}
/**
* Specify the texture to cache.
*/
void
lp_tex_tile_cache_set_texture(struct llvmpipe_tex_tile_cache *tc,
struct pipe_texture *texture)
{
uint i;
assert(!tc->transfer);
if (tc->texture != texture) {
pipe_texture_reference(&tc->texture, texture);
if (tc->tex_trans) {
struct pipe_screen *screen = tc->tex_trans->texture->screen;
if (tc->tex_trans_map) {
screen->transfer_unmap(screen, tc->tex_trans);
tc->tex_trans_map = NULL;
}
screen->tex_transfer_destroy(tc->tex_trans);
tc->tex_trans = NULL;
}
/* 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 */
}
}
/**
* 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 lp_get_cached_tile() but for textures.
* Tiles are read-only and indexed with more params.
*/
const struct llvmpipe_cached_tex_tile *
lp_find_cached_tex_tile(struct llvmpipe_tex_tile_cache *tc,
union tex_tile_address addr )
{
struct pipe_screen *screen = tc->screen;
struct llvmpipe_cached_tex_tile *tile;
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/TEX_TILE_SIZE, y/TEX_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) */
if (tc->tex_trans) {
if (tc->tex_trans_map) {
tc->screen->transfer_unmap(tc->screen, tc->tex_trans);
tc->tex_trans_map = NULL;
}
screen->tex_transfer_destroy(tc->tex_trans);
tc->tex_trans = NULL;
}
tc->tex_trans =
screen->get_tex_transfer(screen, tc->texture,
addr.bits.face,
addr.bits.level,
addr.bits.z,
PIPE_TRANSFER_READ, 0, 0,
tc->texture->width[addr.bits.level],
tc->texture->height[addr.bits.level]);
tc->tex_trans_map = screen->transfer_map(screen, tc->tex_trans);
tc->tex_face = addr.bits.face;
tc->tex_level = addr.bits.level;
tc->tex_z = addr.bits.z;
}
{
unsigned x = addr.bits.x * TEX_TILE_SIZE;
unsigned y = addr.bits.y * TEX_TILE_SIZE;
unsigned w = TEX_TILE_SIZE;
unsigned h = TEX_TILE_SIZE;
if (pipe_clip_tile(x, y, &w, &h, tc->tex_trans)) {
assert(0);
}
util_format_read_4ub(tc->tex_trans->format,
(uint8_t *)tile->color, sizeof tile->color[0],
tc->tex_trans_map, tc->tex_trans->stride,
x, y, w, h);
}
tile->addr = addr;
}
tc->last_tile = tile;
return tile;
}

151
src/gallium/drivers/llvmpipe/lp_tex_cache.h
View File

@ -1,151 +0,0 @@
/**************************************************************************
*
* 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.
*
**************************************************************************/
#ifndef LP_TEX_CACHE_H
#define LP_TEX_CACHE_H
#include "pipe/p_compiler.h"
struct llvmpipe_context;
struct llvmpipe_tex_tile_cache;
/**
* Cache tile size (width and height). This needs to be a power of two.
*/
#define TEX_TILE_SIZE 64
/* If we need to support > 4096, just expand this to be a 64 bit
* union, or consider tiling in Z as well.
*/
union tex_tile_address {
struct {
unsigned x:6; /* 4096 / TEX_TILE_SIZE */
unsigned y:6; /* 4096 / TEX_TILE_SIZE */
unsigned z:12; /* 4096 -- z not tiled */
unsigned face:3;
unsigned level:4;
unsigned invalid:1;
} bits;
unsigned value;
};
struct llvmpipe_cached_tex_tile
{
union tex_tile_address addr;
uint8_t color[TEX_TILE_SIZE][TEX_TILE_SIZE][4];
};
#define NUM_ENTRIES 50
/** XXX move these */
#define MAX_TEX_WIDTH 2048
#define MAX_TEX_HEIGHT 2048
struct llvmpipe_tex_tile_cache
{
struct pipe_screen *screen;
struct pipe_surface *surface; /**< the surface we're caching */
struct pipe_transfer *transfer;
void *transfer_map;
struct pipe_texture *texture; /**< if caching a texture */
unsigned timestamp;
struct llvmpipe_cached_tex_tile entries[NUM_ENTRIES];
struct pipe_transfer *tex_trans;
void *tex_trans_map;
int tex_face, tex_level, tex_z;
struct llvmpipe_cached_tex_tile *last_tile; /**< most recently retrieved tile */
};
extern struct llvmpipe_tex_tile_cache *
lp_create_tex_tile_cache( struct pipe_screen *screen );
extern void
lp_destroy_tex_tile_cache(struct llvmpipe_tex_tile_cache *tc);
extern void
lp_tex_tile_cache_map_transfers(struct llvmpipe_tex_tile_cache *tc);
extern void
lp_tex_tile_cache_unmap_transfers(struct llvmpipe_tex_tile_cache *tc);
extern void
lp_tex_tile_cache_set_texture(struct llvmpipe_tex_tile_cache *tc,
struct pipe_texture *texture);
void
lp_tex_tile_cache_validate_texture(struct llvmpipe_tex_tile_cache *tc);
extern const struct llvmpipe_cached_tex_tile *
lp_find_cached_tex_tile(struct llvmpipe_tex_tile_cache *tc,
union tex_tile_address addr );
static INLINE const union tex_tile_address
tex_tile_address( unsigned x,
unsigned y,
unsigned z,
unsigned face,
unsigned level )
{
union tex_tile_address addr;
addr.value = 0;
addr.bits.x = x / TEX_TILE_SIZE;
addr.bits.y = y / TEX_TILE_SIZE;
addr.bits.z = z;
addr.bits.face = face;
addr.bits.level = level;
return addr;
}
/* Quickly retrieve tile if it matches last lookup.
*/
static INLINE const struct llvmpipe_cached_tex_tile *
lp_get_cached_tex_tile(struct llvmpipe_tex_tile_cache *tc,
union tex_tile_address addr )
{
if (tc->last_tile->addr.value == addr.value)
return tc->last_tile;
return lp_find_cached_tex_tile( tc, addr );
}
#endif /* LP_TEX_CACHE_H */

3
src/gallium/drivers/llvmpipe/lp_tex_sample.h
View File

@ -34,7 +34,6 @@
#include "tgsi/tgsi_exec.h"
struct llvmpipe_tex_tile_cache;
struct lp_sampler_static_state;
@ -55,8 +54,6 @@ struct lp_shader_sampler
const struct pipe_texture *texture;
const struct pipe_sampler_state *sampler;
struct llvmpipe_tex_tile_cache *cache;
};

1713
src/gallium/drivers/llvmpipe/lp_tex_sample_c.c
View File

File diff suppressed because it is too large Load Diff

4
src/gallium/drivers/llvmpipe/lp_texture.c
View File

@ -40,7 +40,6 @@
#include "lp_context.h"
#include "lp_state.h"
#include "lp_texture.h"
#include "lp_tex_cache.h"
#include "lp_screen.h"
#include "lp_winsys.h"
@ -241,7 +240,7 @@ llvmpipe_get_tex_surface(struct pipe_screen *screen,
if (ps->usage & (PIPE_BUFFER_USAGE_CPU_WRITE |
PIPE_BUFFER_USAGE_GPU_WRITE)) {
/* Mark the surface as dirty. The tile cache will look for this. */
/* Mark the surface as dirty. */
lpt->timestamp++;
llvmpipe_screen(screen)->timestamp++;
}
@ -368,7 +367,6 @@ llvmpipe_transfer_map( struct pipe_screen *_screen,
if (transfer->texture && (transfer->usage & PIPE_TRANSFER_WRITE))
{
/* Do something to notify sharing contexts of a texture change.
* In llvmpipe, that would mean flushing the texture cache.
*/
screen->timestamp++;
}