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

draw llvmpipe: lots of fixes for fetch/emit

Browse Source 
the values passed are still not right, but the general scheme
is looking good.
This commit is contained in:
Zack Rusin
2010-03-29 13:19:16 -04:00
parent 275c4bd364
commit f44af927ff
4 changed files with 161 additions and 171 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/gallium/auxiliary/draw/draw_llvm.c
+142 -13
View File
@@ -114,6 +114,10 @@ init_globals(struct draw_llvm *llvm)
llvm->context_ptr_type = LLVMPointerType(context_type, 0);
}
{
LLVMTypeRef buffer_ptr = LLVMPointerType(LLVMOpaqueType(), 0);
llvm->buffer_ptr_type = LLVMArrayType(buffer_ptr, PIPE_MAX_ATTRIBS);
}
}
struct draw_llvm *
@@ -171,6 +175,7 @@ draw_llvm_destroy(struct draw_llvm *llvm)
void
draw_llvm_prepare(struct draw_llvm *llvm)
{
draw_llvm_generate(llvm);
}
@@ -194,14 +199,14 @@ fail:
static void
generate_vs(struct draw_llvm *llvm,
LLVMBuilderRef builder,
LLVMValueRef (*outputs)[NUM_CHANNELS],
const LLVMValueRef (*inputs)[NUM_CHANNELS],
LLVMValueRef context_ptr,
LLVMValueRef io)
{
const struct tgsi_token *tokens = llvm->draw->vs.vertex_shader->state.tokens;
struct lp_type vs_type = lp_type_float(32);
LLVMValueRef vs_consts;
const LLVMValueRef (*inputs)[NUM_CHANNELS];
LLVMValueRef (*outputs)[NUM_CHANNELS];
lp_build_tgsi_soa(builder,
tokens,
@@ -214,28 +219,129 @@ generate_vs(struct draw_llvm *llvm,
NULL/*sampler*/);
}
static void
generate_fetch(LLVMBuilderRef builder,
const LLVMValueRef vbuffers_ptr,
LLVMValueRef *res,
struct pipe_vertex_element *velem,
struct pipe_vertex_buffer *vbuf,
LLVMValueRef index)
{
LLVMValueRef indices = LLVMConstInt(LLVMInt32Type(),
velem->vertex_buffer_index, 0);
LLVMValueRef vbuffer_ptr = LLVMBuildGEP(builder, vbuffers_ptr,
&indices, 1, "");
LLVMValueRef stride = LLVMBuildMul(builder,
LLVMConstInt(LLVMInt32Type(), vbuf->stride, 0),
index, "");
stride = LLVMBuildAdd(builder, stride,
LLVMConstInt(LLVMInt32Type(), vbuf->buffer_offset, 0),
"");
stride = LLVMBuildAdd(builder, stride,
LLVMConstInt(LLVMInt32Type(), velem->src_offset, 0),
"");
vbuffer_ptr = LLVMBuildGEP(builder, vbuffer_ptr, &stride, 1, "");
*res = draw_llvm_translate_from(builder, vbuffer_ptr, velem->src_format);
}
static LLVMValueRef
aos_to_soa(LLVMBuilderRef builder,
LLVMValueRef val0,
LLVMValueRef val1,
LLVMValueRef val2,
LLVMValueRef val3,
LLVMValueRef channel)
{
LLVMValueRef ex, res;
ex = LLVMBuildExtractElement(builder, val0,
channel, "");
res = LLVMBuildInsertElement(builder,
LLVMConstNull(LLVMTypeOf(val0)),
ex,
LLVMConstInt(LLVMInt32Type(), 0, 0),
"");
ex = LLVMBuildExtractElement(builder, val1,
channel, "");
res = LLVMBuildInsertElement(builder,
res, ex,
LLVMConstInt(LLVMInt32Type(), 1, 0),
"");
ex = LLVMBuildExtractElement(builder, val2,
channel, "");
res = LLVMBuildInsertElement(builder,
res, ex,
LLVMConstInt(LLVMInt32Type(), 2, 0),
"");
ex = LLVMBuildExtractElement(builder, val3,
channel, "");
res = LLVMBuildInsertElement(builder,
res, ex,
LLVMConstInt(LLVMInt32Type(), 3, 0),
"");
return res;
}
static void
convert_to_soa(LLVMBuilderRef builder,
LLVMValueRef (*aos)[NUM_CHANNELS],
LLVMValueRef (*soa)[NUM_CHANNELS],
int num_attribs)
{
int i;
debug_assert(NUM_CHANNELS == 4);
for (i = 0; i < num_attribs; ++i) {
LLVMValueRef val0 = aos[i][0];
LLVMValueRef val1 = aos[i][1];
LLVMValueRef val2 = aos[i][2];
LLVMValueRef val3 = aos[i][3];
soa[i][0] = aos_to_soa(builder, val0, val1, val2, val3,
LLVMConstInt(LLVMInt32Type(), 0, 0));
soa[i][1] = aos_to_soa(builder, val0, val1, val2, val3,
LLVMConstInt(LLVMInt32Type(), 1, 0));
soa[i][2] = aos_to_soa(builder, val0, val1, val2, val3,
LLVMConstInt(LLVMInt32Type(), 2, 0));
soa[i][3] = aos_to_soa(builder, val0, val1, val2, val3,
LLVMConstInt(LLVMInt32Type(), 3, 0));
}
}
void
draw_llvm_generate(struct draw_llvm *llvm)
{
LLVMTypeRef arg_types[5];
LLVMTypeRef arg_types[6];
LLVMTypeRef func_type;
LLVMValueRef context_ptr;
LLVMBasicBlockRef block;
LLVMBuilderRef builder;
LLVMValueRef function;
LLVMValueRef start, end, count, stride, step;
LLVMValueRef io_ptr;
unsigned i;
LLVMValueRef io_ptr, vbuffers_ptr;
struct draw_context *draw = llvm->draw;
unsigned i, j;
unsigned chan;
struct lp_build_context bld;
struct lp_build_loop_state lp_loop;
struct lp_type vs_type = lp_type_float(32);
struct lp_type vs_type = lp_type_float_vec(32);
const int max_vertices = 4;
LLVMValueRef outputs[PIPE_MAX_SHADER_OUTPUTS][NUM_CHANNELS];
arg_types[0] = llvm->context_ptr_type; /* context */
arg_types[1] = llvm->vertex_header_ptr_type; /* vertex_header */
arg_types[2] = LLVMInt32Type(); /* start */
arg_types[3] = LLVMInt32Type(); /* count */
arg_types[4] = LLVMInt32Type(); /* stride */
arg_types[2] = llvm->buffer_ptr_type; /* vbuffers */
arg_types[3] = LLVMInt32Type(); /* start */
arg_types[4] = LLVMInt32Type(); /* count */
arg_types[5] = LLVMInt32Type(); /* stride */
func_type = LLVMFunctionType(LLVMVoidType(), arg_types, Elements(arg_types), 0);
@@ -247,12 +353,14 @@ draw_llvm_generate(struct draw_llvm *llvm)
context_ptr = LLVMGetParam(function, 0);
io_ptr = LLVMGetParam(function, 1);
start = LLVMGetParam(function, 2);
count = LLVMGetParam(function, 3);
stride = LLVMGetParam(function, 4);
vbuffers_ptr = LLVMGetParam(function, 2);
start = LLVMGetParam(function, 3);
count = LLVMGetParam(function, 4);
stride = LLVMGetParam(function, 5);
lp_build_name(context_ptr, "context");
lp_build_name(io_ptr, "io");
lp_build_name(vbuffers_ptr, "vbuffers");
lp_build_name(start, "start");
lp_build_name(count, "count");
lp_build_name(stride, "stride");
@@ -269,13 +377,34 @@ draw_llvm_generate(struct draw_llvm *llvm)
end = lp_build_add(&bld, start, count);
step = LLVMConstInt(LLVMInt32Type(), 1, 0);
step = LLVMConstInt(LLVMInt32Type(), max_vertices, 0);
lp_build_loop_begin(builder, start, &lp_loop);
{
LLVMValueRef inputs[PIPE_MAX_SHADER_INPUTS][NUM_CHANNELS];
LLVMValueRef aos_attribs[PIPE_MAX_SHADER_INPUTS][NUM_CHANNELS];
LLVMValueRef io = LLVMBuildGEP(builder, io_ptr, &lp_loop.counter, 1, "");
for (i = 0; i < NUM_CHANNELS; ++i) {
LLVMValueRef true_index = LLVMBuildAdd(
builder,
lp_loop.counter,
LLVMConstInt(LLVMInt32Type(), i, 0), "");
for (j = 0; j < draw->pt.nr_vertex_elements; ++j) {
struct pipe_vertex_element *velem = &draw->pt.vertex_element[j];
struct pipe_vertex_buffer *vbuf = &draw->pt.vertex_buffer[
velem->vertex_buffer_index];
generate_fetch(builder, vbuffers_ptr,
&aos_attribs[j][i], velem, vbuf, true_index);
}
}
convert_to_soa(builder, inputs, aos_attribs,
draw->pt.nr_vertex_elements);
generate_vs(llvm,
builder,
outputs,
inputs,
context_ptr,
io);
}
src/gallium/auxiliary/draw/draw_llvm.h
+7 -1
View File
@@ -78,12 +78,12 @@ struct draw_jit_context
const float *gs_constants;
struct draw_jit_texture textures[PIPE_MAX_SAMPLERS];
const void *vbuffers;
};
void
draw_shader(struct draw_jit_context *context,
struct vertex_header *io,
const void *vbuffers[PIPE_MAX_ATTRIBS],
unsigned start,
unsigned count,
unsigned stride)
@@ -115,6 +115,7 @@ draw_shader(struct draw_jit_context *context,
typedef void
(*draw_jit_vert_func)(struct draw_jit_context *context,
struct vertex_header *io,
const void *vbuffers[PIPE_MAX_ATTRIBS],
unsigned start,
unsigned count,
unsigned stride);
@@ -134,6 +135,7 @@ struct draw_llvm {
LLVMTypeRef context_ptr_type;
LLVMTypeRef vertex_header_ptr_type;
LLVMTypeRef buffer_ptr_type;
};
@@ -150,5 +152,9 @@ draw_llvm_prepare(struct draw_llvm *llvm);
void
draw_llvm_generate(struct draw_llvm *llvm);
LLVMValueRef
draw_llvm_translate_from(LLVMBuilderRef builder,
LLVMValueRef vbuffer,
enum pipe_format from_format);
#endif
src/gallium/auxiliary/draw/draw_llvm_translate.c
+10 -155
View File
@@ -492,162 +492,17 @@ struct draw_llvm_translate {
{PIPE_FORMAT_B8G8R8A8_UNORM, from_8_unorm, to_8_unorm, LLVMIntType(), 4},
};
/**
* Fetch vertex attributes for 'count' vertices.
*/
static void PIPE_CDECL generic_run_elts( struct translate *translate,
const unsigned *elts,
unsigned count,
unsigned instance_id,
void *output_buffer )
LLVMValueRef
draw_llvm_translate_from(LLVMBuilderRef builder,
LLVMValueRef vbuffer,
enum pipe_format from_format)
{
struct translate_generic *tg = translate_generic(translate);
char *vert = output_buffer;
unsigned nr_attrs = tg->nr_attrib;
unsigned attr;
unsigned i;
/* loop over vertex attributes (vertex shader inputs)
*/
for (i = 0; i < count; i++) {
unsigned elt = *elts++;
for (attr = 0; attr < nr_attrs; attr++) {
float data[4];
const char *src;
char *dst = (vert +
tg->attrib[attr].output_offset);
if (tg->attrib[attr].instance_divisor) {
src = tg->attrib[attr].input_ptr +
tg->attrib[attr].input_stride *
(instance_id / tg->attrib[attr].instance_divisor);
} else {
src = tg->attrib[attr].input_ptr +
tg->attrib[attr].input_stride * elt;
}
tg->attrib[attr].fetch( src, data );
if (0) debug_printf("vert %d/%d attr %d: %f %f %f %f\n",
i, elt, attr, data[0], data[1], data[2], data[3]);
tg->attrib[attr].emit( data, dst );
}
vert += tg->translate.key.output_stride;
}
}
static void PIPE_CDECL generic_run( struct translate *translate,
unsigned start,
unsigned count,
unsigned instance_id,
void *output_buffer )
{
struct translate_generic *tg = translate_generic(translate);
char *vert = output_buffer;
unsigned nr_attrs = tg->nr_attrib;
unsigned attr;
unsigned i;
/* loop over vertex attributes (vertex shader inputs)
*/
for (i = 0; i < count; i++) {
unsigned elt = start + i;
for (attr = 0; attr < nr_attrs; attr++) {
float data[4];
char *dst = (vert +
tg->attrib[attr].output_offset);
if (tg->attrib[attr].type == TRANSLATE_ELEMENT_NORMAL) {
const char *src;
if (tg->attrib[attr].instance_divisor) {
src = tg->attrib[attr].input_ptr +
tg->attrib[attr].input_stride *
(instance_id / tg->attrib[attr].instance_divisor);
} else {
src = tg->attrib[attr].input_ptr +
tg->attrib[attr].input_stride * elt;
}
tg->attrib[attr].fetch( src, data );
} else {
data[0] = (float)instance_id;
}
if (0) debug_printf("vert %d attr %d: %f %f %f %f\n",
i, attr, data[0], data[1], data[2], data[3]);
tg->attrib[attr].emit( data, dst );
}
vert += tg->translate.key.output_stride;
}
}
static void generic_set_buffer( struct translate *translate,
unsigned buf,
const void *ptr,
unsigned stride )
{
struct translate_generic *tg = translate_generic(translate);
unsigned i;
for (i = 0; i < tg->nr_attrib; i++) {
if (tg->attrib[i].buffer == buf) {
tg->attrib[i].input_ptr = ((char *)ptr +
tg->attrib[i].input_offset);
tg->attrib[i].input_stride = stride;
int i;
for (i = 0; i < Elements(translates); ++i) {
if (translates[i].format == from_format) {
return translates.from_func(builder, vbuffer, from_format);
}
}
}
static void generic_release( struct translate *translate )
{
/* Refcount?
*/
FREE(translate);
}
struct translate *translate_generic_create( const struct translate_key *key )
{
struct translate_generic *tg = CALLOC_STRUCT(translate_generic);
unsigned i;
if (tg == NULL)
return NULL;
tg->translate.key = *key;
tg->translate.release = generic_release;
tg->translate.set_buffer = generic_set_buffer;
tg->translate.run_elts = generic_run_elts;
tg->translate.run = generic_run;
for (i = 0; i < key->nr_elements; i++) {
tg->attrib[i].type = key->element[i].type;
tg->attrib[i].fetch = get_fetch_func(key->element[i].input_format);
tg->attrib[i].buffer = key->element[i].input_buffer;
tg->attrib[i].input_offset = key->element[i].input_offset;
tg->attrib[i].instance_divisor = key->element[i].instance_divisor;
tg->attrib[i].emit = get_emit_func(key->element[i].output_format);
tg->attrib[i].output_offset = key->element[i].output_offset;
}
tg->nr_attrib = key->nr_elements;
return &tg->translate;
return LLVMGetUndef(LLVMTypeOf(vbuffer));
}
src/gallium/auxiliary/draw/draw_pt_fetch_shade_pipeline_llvm.c
+2 -2
View File
@@ -110,8 +110,7 @@ llvm_middle_end_prepare( struct draw_pt_middle_end *middle,
*/
draw_pt_post_vs_prepare( fpme->post_vs,
(boolean)draw->bypass_clipping,
(boolean)(draw->identity_viewport ||
draw->rasterizer->bypass_vs_clip_and_viewport),
(boolean)(draw->identity_viewport),
(boolean)draw->rasterizer->gl_rasterization_rules,
(draw->vs.edgeflag_output ? true : false) );
@@ -242,6 +241,7 @@ static void llvm_middle_end_linear_run( struct draw_pt_middle_end *middle,
fpme->llvm->jit_func( &fpme->llvm->jit_context,
pipeline_verts,
draw->pt.user.vbuffer,
start,
count,
fpme->vertex_size );