#include "util/u_surface.h"
#include "util/u_pack_color.h"
#include "util/u_string.h"
+#include "util/u_thread.h"
-#include "os/os_time.h"
+#include "util/os_time.h"
#include "lp_scene_queue.h"
#include "lp_context.h"
#include "lp_query.h"
#include "lp_rast.h"
#include "lp_rast_priv.h"
+#include "gallivm/lp_bld_format.h"
#include "gallivm/lp_bld_debug.h"
#include "lp_scene.h"
#include "lp_tex_sample.h"
/**
- * Begining rasterization of a tile.
+ * Beginning rasterization of a tile.
* \param x window X position of the tile, in pixels
* \param y window Y position of the tile, in pixels
*/
const struct cmd_bin *bin,
int x, int y)
{
+ unsigned i;
+ struct lp_scene *scene = task->scene;
+
LP_DBG(DEBUG_RAST, "%s %d,%d\n", __FUNCTION__, x, y);
task->bin = bin;
task->scene->fb.height - y * TILE_SIZE : TILE_SIZE;
task->thread_data.vis_counter = 0;
- task->ps_invocations = 0;
+ task->thread_data.ps_invocations = 0;
- /* reset pointers to color and depth tile(s) */
- memset(task->color_tiles, 0, sizeof(task->color_tiles));
- task->depth_tile = NULL;
+ for (i = 0; i < task->scene->fb.nr_cbufs; i++) {
+ if (task->scene->fb.cbufs[i]) {
+ task->color_tiles[i] = scene->cbufs[i].map +
+ scene->cbufs[i].stride * task->y +
+ scene->cbufs[i].format_bytes * task->x;
+ }
+ }
+ if (task->scene->fb.zsbuf) {
+ task->depth_tile = scene->zsbuf.map +
+ scene->zsbuf.stride * task->y +
+ scene->zsbuf.format_bytes * task->x;
+ }
}
if (scene->fb.zsbuf) {
unsigned layer;
- uint8_t *dst_layer = lp_rast_get_depth_tile_pointer(task, LP_TEX_USAGE_READ_WRITE);
+ uint8_t *dst_layer = task->depth_tile;
block_size = util_format_get_blocksize(scene->fb.zsbuf->format);
clear_value &= clear_mask;
* allocated 4x4 blocks hence need to filter them out here.
*/
if ((x % TILE_SIZE) < task->width && (y % TILE_SIZE) < task->height) {
- /* not very accurate would need a popcount on the mask */
- /* always count this not worth bothering? */
- task->ps_invocations += 1 * variant->ps_inv_multiplier;
-
/* Propagate non-interpolated raster state. */
task->thread_data.raster_state.viewport_index = inputs->viewport_index;
switch (pq->type) {
case PIPE_QUERY_OCCLUSION_COUNTER:
case PIPE_QUERY_OCCLUSION_PREDICATE:
+ case PIPE_QUERY_OCCLUSION_PREDICATE_CONSERVATIVE:
pq->start[task->thread_index] = task->thread_data.vis_counter;
break;
case PIPE_QUERY_PIPELINE_STATISTICS:
- pq->start[task->thread_index] = task->ps_invocations;
+ pq->start[task->thread_index] = task->thread_data.ps_invocations;
break;
default:
assert(0);
switch (pq->type) {
case PIPE_QUERY_OCCLUSION_COUNTER:
case PIPE_QUERY_OCCLUSION_PREDICATE:
+ case PIPE_QUERY_OCCLUSION_PREDICATE_CONSERVATIVE:
pq->end[task->thread_index] +=
task->thread_data.vis_counter - pq->start[task->thread_index];
pq->start[task->thread_index] = 0;
break;
case PIPE_QUERY_PIPELINE_STATISTICS:
pq->end[task->thread_index] +=
- task->ps_invocations - pq->start[task->thread_index];
+ task->thread_data.ps_invocations - pq->start[task->thread_index];
pq->start[task->thread_index] = 0;
break;
default:
{
task->scene = scene;
- if (!task->rast->no_rast && !scene->discard) {
+ /* Clear the cache tags. This should not always be necessary but
+ simpler for now. */
+#if LP_USE_TEXTURE_CACHE
+ memset(task->thread_data.cache->cache_tags, 0,
+ sizeof(task->thread_data.cache->cache_tags));
+#if LP_BUILD_FORMAT_CACHE_DEBUG
+ task->thread_data.cache->cache_access_total = 0;
+ task->thread_data.cache->cache_access_miss = 0;
+#endif
+#endif
+
+ if (!task->rast->no_rast) {
/* loop over scene bins, rasterize each */
{
struct cmd_bin *bin;
}
+#if LP_BUILD_FORMAT_CACHE_DEBUG
+ {
+ uint64_t total, miss;
+ total = task->thread_data.cache->cache_access_total;
+ miss = task->thread_data.cache->cache_access_miss;
+ if (total) {
+ debug_printf("thread %d cache access %llu miss %llu hit rate %f\n",
+ task->thread_index, (long long unsigned)total,
+ (long long unsigned)miss,
+ (float)(total - miss)/(float)total);
+ }
+ }
+#endif
+
if (scene->fence) {
lp_fence_signal(scene->fence);
}
* 2. do work
* 3. signal that we're done
*/
-static PIPE_THREAD_ROUTINE( thread_function, init_data )
+static int
+thread_function(void *init_data)
{
struct lp_rasterizer_task *task = (struct lp_rasterizer_task *) init_data;
struct lp_rasterizer *rast = task->rast;
unsigned fpstate;
util_snprintf(thread_name, sizeof thread_name, "llvmpipe-%u", task->thread_index);
- pipe_thread_setname(thread_name);
+ u_thread_setname(thread_name);
/* Make sure that denorms are treated like zeros. This is
* the behavior required by D3D10. OpenGL doesn't care.
/* Wait for all threads to get here so that threads[1+] don't
* get a null rast->curr_scene pointer.
*/
- pipe_barrier_wait( &rast->barrier );
+ util_barrier_wait( &rast->barrier );
/* do work */
if (debug)
rast->curr_scene);
/* wait for all threads to finish with this scene */
- pipe_barrier_wait( &rast->barrier );
+ util_barrier_wait( &rast->barrier );
/* XXX: shouldn't be necessary:
*/
for (i = 0; i < rast->num_threads; i++) {
pipe_semaphore_init(&rast->tasks[i].work_ready, 0);
pipe_semaphore_init(&rast->tasks[i].work_done, 0);
- rast->threads[i] = pipe_thread_create(thread_function,
+ rast->threads[i] = u_thread_create(thread_function,
(void *) &rast->tasks[i]);
}
}
goto no_full_scenes;
}
- for (i = 0; i < Elements(rast->tasks); i++) {
+ for (i = 0; i < MAX2(1, num_threads); i++) {
struct lp_rasterizer_task *task = &rast->tasks[i];
task->rast = rast;
task->thread_index = i;
+ task->thread_data.cache = align_malloc(sizeof(struct lp_build_format_cache),
+ 16);
+ if (!task->thread_data.cache) {
+ goto no_thread_data_cache;
+ }
}
rast->num_threads = num_threads;
create_rast_threads(rast);
/* for synchronizing rasterization threads */
- pipe_barrier_init( &rast->barrier, rast->num_threads );
+ if (rast->num_threads > 0) {
+ util_barrier_init( &rast->barrier, rast->num_threads );
+ }
memset(lp_dummy_tile, 0, sizeof lp_dummy_tile);
return rast;
+no_thread_data_cache:
+ for (i = 0; i < MAX2(1, rast->num_threads); i++) {
+ if (rast->tasks[i].thread_data.cache) {
+ align_free(rast->tasks[i].thread_data.cache);
+ }
+ }
+
+ lp_scene_queue_destroy(rast->full_scenes);
no_full_scenes:
FREE(rast);
no_rast:
#ifdef _WIN32
pipe_semaphore_wait(&rast->tasks[i].work_done);
#else
- pipe_thread_wait(rast->threads[i]);
+ thrd_join(rast->threads[i], NULL);
#endif
}
pipe_semaphore_destroy(&rast->tasks[i].work_ready);
pipe_semaphore_destroy(&rast->tasks[i].work_done);
}
+ for (i = 0; i < MAX2(1, rast->num_threads); i++) {
+ align_free(rast->tasks[i].thread_data.cache);
+ }
/* for synchronizing rasterization threads */
- pipe_barrier_destroy( &rast->barrier );
+ if (rast->num_threads > 0) {
+ util_barrier_destroy( &rast->barrier );
+ }
lp_scene_queue_destroy(rast->full_scenes);
projects / mesa.git / blobdiff