fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2025-12-27 19:10:14 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

gallium/draw: use list.h instead of simple_list.h

Browse source 
Reviewed-by: Roland Scheidegger <sroland@vmware.com>
Reviewed-by: Jason Ekstrand <jason.ekstrand@collabora.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/15418>
This commit is contained in:
Dylan Baker 2022-02-22 12:07:51 -08:00
parent d9d092696d
commit 04082fbe24
6 changed files with 59 additions and 81 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
src/gallium/auxiliary/draw/draw_gs.c
View file

@ -772,7 +772,7 @@ draw_create_geometry_shader(struct draw_context *draw,
gs = &llvm_gs->base;
make_empty_list(&llvm_gs->variants);
list_inithead(&llvm_gs->variants.list);
} else
#endif
{
@ -931,13 +931,10 @@ void draw_delete_geometry_shader(struct draw_context *draw,
#ifdef DRAW_LLVM_AVAILABLE
if (draw->llvm) {
struct llvm_geometry_shader *shader = llvm_geometry_shader(dgs);
struct draw_gs_llvm_variant_list_item *li;
struct draw_gs_llvm_variant_list_item *li, *next;
li = first_elem(&shader->variants);
while(!at_end(&shader->variants, li)) {
struct draw_gs_llvm_variant_list_item *next = next_elem(li);
LIST_FOR_EACH_ENTRY_SAFE(li, next, &shader->variants.list, list) {
draw_gs_llvm_destroy_variant(li->base);
li = next;
}
assert(shader->variants_cached == 0);

25
src/gallium/auxiliary/draw/draw_llvm.c
View file

@ -58,7 +58,6 @@
#include "util/u_math.h"
#include "util/u_pointer.h"
#include "util/u_string.h"
#include "util/simple_list.h"
#include "nir_serialize.h"
#include "util/mesa-sha1.h"
#define DEBUG_STORE 0
@ -803,16 +802,16 @@ draw_llvm_create(struct draw_context *draw, LLVMContextRef context)
goto fail;
llvm->nr_variants = 0;
make_empty_list(&llvm->vs_variants_list);
list_inithead(&llvm->vs_variants_list.list);
llvm->nr_gs_variants = 0;
make_empty_list(&llvm->gs_variants_list);
list_inithead(&llvm->gs_variants_list.list);
llvm->nr_tcs_variants = 0;
make_empty_list(&llvm->tcs_variants_list);
list_inithead(&llvm->tcs_variants_list.list);
llvm->nr_tes_variants = 0;
make_empty_list(&llvm->tes_variants_list);
list_inithead(&llvm->tes_variants_list.list);
return llvm;
@ -2689,9 +2688,9 @@ draw_llvm_destroy_variant(struct draw_llvm_variant *variant)
gallivm_destroy(variant->gallivm);
remove_from_list(&variant->list_item_local);
list_del(&variant->list_item_local.list);
variant->shader->variants_cached--;
remove_from_list(&variant->list_item_global);
list_del(&variant->list_item_global.list);
llvm->nr_variants--;
FREE(variant);
}
@ -3007,9 +3006,9 @@ draw_gs_llvm_destroy_variant(struct draw_gs_llvm_variant *variant)
gallivm_destroy(variant->gallivm);
remove_from_list(&variant->list_item_local);
list_del(&variant->list_item_local.list);
variant->shader->variants_cached--;
remove_from_list(&variant->list_item_global);
list_del(&variant->list_item_global.list);
llvm->nr_gs_variants--;
FREE(variant);
}
@ -3673,9 +3672,9 @@ draw_tcs_llvm_destroy_variant(struct draw_tcs_llvm_variant *variant)
gallivm_destroy(variant->gallivm);
remove_from_list(&variant->list_item_local);
list_del(&variant->list_item_local.list);
variant->shader->variants_cached--;
remove_from_list(&variant->list_item_global);
list_del(&variant->list_item_global.list);
llvm->nr_tcs_variants--;
FREE(variant);
}
@ -4200,9 +4199,9 @@ draw_tes_llvm_destroy_variant(struct draw_tes_llvm_variant *variant)
gallivm_destroy(variant->gallivm);
remove_from_list(&variant->list_item_local);
list_del(&variant->list_item_local.list);
variant->shader->variants_cached--;
remove_from_list(&variant->list_item_global);
list_del(&variant->list_item_global.list);
llvm->nr_tes_variants--;
FREE(variant);
}

10
src/gallium/auxiliary/draw/draw_llvm.h
View file

@ -38,7 +38,7 @@
#include "gallivm/lp_bld_limits.h"
#include "pipe/p_context.h"
#include "util/simple_list.h"
#include "util/list.h"
struct draw_llvm;
@ -649,26 +649,26 @@ draw_tes_llvm_variant_key_images(struct draw_tes_llvm_variant_key *key)
struct draw_llvm_variant_list_item
{
struct list_head list;
struct draw_llvm_variant *base;
struct draw_llvm_variant_list_item *next, *prev;
};
struct draw_gs_llvm_variant_list_item
{
struct list_head list;
struct draw_gs_llvm_variant *base;
struct draw_gs_llvm_variant_list_item *next, *prev;
};
struct draw_tcs_llvm_variant_list_item
{
struct list_head list;
struct draw_tcs_llvm_variant *base;
struct draw_tcs_llvm_variant_list_item *next, *prev;
};
struct draw_tes_llvm_variant_list_item
{
struct list_head list;
struct draw_tes_llvm_variant *base;
struct draw_tes_llvm_variant_list_item *next, *prev;
};
struct draw_llvm_variant

69
src/gallium/auxiliary/draw/draw_pt_fetch_shade_pipeline_llvm.c
View file

@ -80,23 +80,20 @@ llvm_middle_end_prepare_gs(struct llvm_middle_end *fpme)
struct draw_gs_llvm_variant_list_item *li;
struct llvm_geometry_shader *shader = llvm_geometry_shader(gs);
char store[DRAW_GS_LLVM_MAX_VARIANT_KEY_SIZE];
unsigned i;
key = draw_gs_llvm_make_variant_key(llvm, store);
/* Search shader's list of variants for the key */
li = first_elem(&shader->variants);
while (!at_end(&shader->variants, li)) {
LIST_FOR_EACH_ENTRY(li, &shader->variants.list, list) {
if (memcmp(&li->base->key, key, shader->variant_key_size) == 0) {
variant = li->base;
break;
}
li = next_elem(li);
}
if (variant) {
/* found the variant, move to head of global list (for LRU) */
move_to_head(&llvm->gs_variants_list, &variant->list_item_global);
list_move_to(&variant->list_item_global.list, &llvm->gs_variants_list.list);
}
else {
/* Need to create new variant */
@ -113,12 +110,13 @@ llvm_middle_end_prepare_gs(struct llvm_middle_end *fpme)
/*
* XXX: should we flush here ?
*/
for (i = 0; i < DRAW_MAX_SHADER_VARIANTS / 32; i++) {
struct draw_gs_llvm_variant_list_item *item;
if (is_empty_list(&llvm->gs_variants_list)) {
struct draw_gs_llvm_variant_list_item *item;
for (unsigned i = 0; i < DRAW_MAX_SHADER_VARIANTS / 32; i++) {
if (list_is_empty(&llvm->gs_variants_list.list)) {
break;
}
item = last_elem(&llvm->gs_variants_list);
item = list_last_entry(&llvm->gs_variants_list.list,
struct draw_gs_llvm_variant_list_item, list);
assert(item);
assert(item->base);
draw_gs_llvm_destroy_variant(item->base);
@ -128,9 +126,8 @@ llvm_middle_end_prepare_gs(struct llvm_middle_end *fpme)
variant = draw_gs_llvm_create_variant(llvm, gs->info.num_outputs, key);
if (variant) {
insert_at_head(&shader->variants, &variant->list_item_local);
insert_at_head(&llvm->gs_variants_list,
&variant->list_item_global);
list_add(&variant->list_item_local.list, &shader->variants.list);
list_add(&variant->list_item_global.list, &llvm->gs_variants_list.list);
llvm->nr_gs_variants++;
shader->variants_cached++;
}
@ -155,18 +152,16 @@ llvm_middle_end_prepare_tcs(struct llvm_middle_end *fpme)
key = draw_tcs_llvm_make_variant_key(llvm, store);
/* Search shader's list of variants for the key */
li = first_elem(&shader->variants);
while (!at_end(&shader->variants, li)) {
LIST_FOR_EACH_ENTRY(li, &shader->variants.list, list) {
if (memcmp(&li->base->key, key, shader->variant_key_size) == 0) {
variant = li->base;
break;
}
li = next_elem(li);
}
if (variant) {
/* found the variant, move to head of global list (for LRU) */
move_to_head(&llvm->tcs_variants_list, &variant->list_item_global);
list_move_to(&variant->list_item_global.list, &llvm->tcs_variants_list.list);
}
else {
/* Need to create new variant */
@ -185,10 +180,11 @@ llvm_middle_end_prepare_tcs(struct llvm_middle_end *fpme)
*/
for (i = 0; i < DRAW_MAX_SHADER_VARIANTS / 32; i++) {
struct draw_tcs_llvm_variant_list_item *item;
if (is_empty_list(&llvm->tcs_variants_list)) {
if (list_is_empty(&llvm->tcs_variants_list.list)) {
break;
}
item = last_elem(&llvm->tcs_variants_list);
item = list_last_entry(&llvm->tcs_variants_list.list,
struct draw_tcs_llvm_variant_list_item, list);
assert(item);
assert(item->base);
draw_tcs_llvm_destroy_variant(item->base);
@ -198,9 +194,8 @@ llvm_middle_end_prepare_tcs(struct llvm_middle_end *fpme)
variant = draw_tcs_llvm_create_variant(llvm, 0, key);
if (variant) {
insert_at_head(&shader->variants, &variant->list_item_local);
insert_at_head(&llvm->tcs_variants_list,
&variant->list_item_global);
list_add(&variant->list_item_local.list, &shader->variants.list);
list_add(&variant->list_item_global.list, &llvm->tcs_variants_list.list);
llvm->nr_tcs_variants++;
shader->variants_cached++;
}
@ -225,18 +220,16 @@ llvm_middle_end_prepare_tes(struct llvm_middle_end *fpme)
key = draw_tes_llvm_make_variant_key(llvm, store);
/* Search shader's list of variants for the key */
li = first_elem(&shader->variants);
while (!at_end(&shader->variants, li)) {
LIST_FOR_EACH_ENTRY(li, &shader->variants.list, list) {
if (memcmp(&li->base->key, key, shader->variant_key_size) == 0) {
variant = li->base;
break;
}
li = next_elem(li);
}
if (variant) {
/* found the variant, move to head of global list (for LRU) */
move_to_head(&llvm->tes_variants_list, &variant->list_item_global);
list_move_to(&variant->list_item_global.list, &llvm->tes_variants_list.list);
}
else {
/* Need to create new variant */
@ -255,10 +248,11 @@ llvm_middle_end_prepare_tes(struct llvm_middle_end *fpme)
*/
for (i = 0; i < DRAW_MAX_SHADER_VARIANTS / 32; i++) {
struct draw_tes_llvm_variant_list_item *item;
if (is_empty_list(&llvm->tes_variants_list)) {
if (list_is_empty(&llvm->tes_variants_list.list)) {
break;
}
item = last_elem(&llvm->tes_variants_list);
item = list_last_entry(&llvm->tes_variants_list.list,
struct draw_tes_llvm_variant_list_item, list);
assert(item);
assert(item->base);
draw_tes_llvm_destroy_variant(item->base);
@ -268,9 +262,8 @@ llvm_middle_end_prepare_tes(struct llvm_middle_end *fpme)
variant = draw_tes_llvm_create_variant(llvm, draw_total_tes_outputs(draw), key);
if (variant) {
insert_at_head(&shader->variants, &variant->list_item_local);
insert_at_head(&llvm->tes_variants_list,
&variant->list_item_global);
list_add(&variant->list_item_local.list, &shader->variants.list);
list_add(&variant->list_item_global.list, &llvm->tes_variants_list.list);
llvm->nr_tes_variants++;
shader->variants_cached++;
}
@ -356,18 +349,16 @@ llvm_middle_end_prepare( struct draw_pt_middle_end *middle,
key = draw_llvm_make_variant_key(llvm, store);
/* Search shader's list of variants for the key */
li = first_elem(&shader->variants);
while (!at_end(&shader->variants, li)) {
LIST_FOR_EACH_ENTRY(li, &shader->variants.list, list) {
if (memcmp(&li->base->key, key, shader->variant_key_size) == 0) {
variant = li->base;
break;
}
li = next_elem(li);
}
if (variant) {
/* found the variant, move to head of global list (for LRU) */
move_to_head(&llvm->vs_variants_list, &variant->list_item_global);
list_move_to(&variant->list_item_global.list, &llvm->vs_variants_list.list);
}
else {
/* Need to create new variant */
@ -386,10 +377,11 @@ llvm_middle_end_prepare( struct draw_pt_middle_end *middle,
*/
for (i = 0; i < DRAW_MAX_SHADER_VARIANTS / 32; i++) {
struct draw_llvm_variant_list_item *item;
if (is_empty_list(&llvm->vs_variants_list)) {
if (list_is_empty(&llvm->vs_variants_list.list)) {
break;
}
item = last_elem(&llvm->vs_variants_list);
item = list_last_entry(&llvm->vs_variants_list.list,
struct draw_llvm_variant_list_item, list);
assert(item);
assert(item->base);
draw_llvm_destroy_variant(item->base);
@ -399,9 +391,8 @@ llvm_middle_end_prepare( struct draw_pt_middle_end *middle,
variant = draw_llvm_create_variant(llvm, nr, key);
if (variant) {
insert_at_head(&shader->variants, &variant->list_item_local);
insert_at_head(&llvm->vs_variants_list,
&variant->list_item_global);
list_add(&variant->list_item_local.list, &shader->variants.list);
list_add(&variant->list_item_global.list, &llvm->vs_variants_list.list);
llvm->nr_variants++;
shader->variants_cached++;
}

18
src/gallium/auxiliary/draw/draw_tess.c
View file

@ -431,7 +431,7 @@ draw_create_tess_ctrl_shader(struct draw_context *draw,
tcs = &llvm_tcs->base;
make_empty_list(&llvm_tcs->variants);
list_inithead(&llvm_tcs->variants.list);
} else
#endif
{
@ -489,13 +489,10 @@ void draw_delete_tess_ctrl_shader(struct draw_context *draw,
if (draw->llvm) {
struct llvm_tess_ctrl_shader *shader = llvm_tess_ctrl_shader(dtcs);
struct draw_tcs_llvm_variant_list_item *li;
struct draw_tcs_llvm_variant_list_item *li, *next;
li = first_elem(&shader->variants);
while(!at_end(&shader->variants, li)) {
struct draw_tcs_llvm_variant_list_item *next = next_elem(li);
LIST_FOR_EACH_ENTRY_SAFE(li, next, &shader->variants.list, list) {
draw_tcs_llvm_destroy_variant(li->base);
li = next;
}
assert(shader->variants_cached == 0);
@ -535,7 +532,7 @@ draw_create_tess_eval_shader(struct draw_context *draw,
return NULL;
tes = &llvm_tes->base;
make_empty_list(&llvm_tes->variants);
list_inithead(&llvm_tes->variants.list);
} else
#endif
{
@ -619,13 +616,10 @@ void draw_delete_tess_eval_shader(struct draw_context *draw,
#ifdef DRAW_LLVM_AVAILABLE
if (draw->llvm) {
struct llvm_tess_eval_shader *shader = llvm_tess_eval_shader(dtes);
struct draw_tes_llvm_variant_list_item *li;
struct draw_tes_llvm_variant_list_item *li, *next;
li = first_elem(&shader->variants);
while(!at_end(&shader->variants, li)) {
struct draw_tes_llvm_variant_list_item *next = next_elem(li);
LIST_FOR_EACH_ENTRY_SAFE(li, next, &shader->variants.list, list) {
draw_tes_llvm_destroy_variant(li->base);
li = next;
}
assert(shader->variants_cached == 0);

9
src/gallium/auxiliary/draw/draw_vs_llvm.c
View file

@ -68,13 +68,10 @@ static void
vs_llvm_delete( struct draw_vertex_shader *dvs )
{
struct llvm_vertex_shader *shader = llvm_vertex_shader(dvs);
struct draw_llvm_variant_list_item *li;
struct draw_llvm_variant_list_item *li, *next;
li = first_elem(&shader->variants);
while(!at_end(&shader->variants, li)) {
struct draw_llvm_variant_list_item *next = next_elem(li);
LIST_FOR_EACH_ENTRY_SAFE(li, next, &shader->variants.list, list) {
draw_llvm_destroy_variant(li->base);
li = next;
}
assert(shader->variants_cached == 0);
@ -126,7 +123,7 @@ draw_create_vs_llvm(struct draw_context *draw,
vs->base.delete = vs_llvm_delete;
vs->base.create_variant = draw_vs_create_variant_generic;
make_empty_list(&vs->variants);
list_inithead(&vs->variants.list);
return &vs->base;
}