[Piglit] [PATCH V2 1/2] glsl-1.10: extend to test arrays of arrays
Timothy Arceri
t_arceri at yahoo.com.au
Tue Nov 18 20:06:12 PST 2014
Extends the varying packing tests to support
testing arrays of arrays
V2: renamed variables from 'inner' that should have been 'outer'
Signed-off-by: Timothy Arceri <t_arceri at yahoo.com.au>
---
tests/all.py | 2 +-
.../glsl-1.10/execution/varying-packing/simple.c | 158 ++++++++++++++-------
2 files changed, 109 insertions(+), 51 deletions(-)
This is a resend of a patch from July
Can be tested on mesa using this branch:
https://github.com/tarceri/Mesa_arrays_of_arrays/tree/linking3
Note: Tests for types (vec4) that are not packed currently fail with the
above branch on intel classic driver because of missing arrays of arrays
backend support (a simple solution to finish this off quickly might be
to have a pass that just flatterns out the arrays before they are passed
to the classic drivers, I beleive this is basically what happens in the
gallium state tracker and can easily be tested by having
lower_packed_varyings.cpp just pack everything). The tests pass fine on
gallium.
I understand that arrays of
arrays is not really a glsl-1.10 test but this test also contains tests
for 1.20 and 1.30 so I figured I'd add arrays of arrays too rather than
duplicating the code elsewhere. I'm happy to pull this out and make it
into a stand alone test though. It would also make it possible to clean
it up a bit. The way arrays support works seems a little messy, and my
changes for arrays of arrays add to this, but then again its not likely
to need to change again much in future.
diff --git a/tests/all.py b/tests/all.py
index ea652f4..392f39b 100644
--- a/tests/all.py
+++ b/tests/all.py
@@ -1055,7 +1055,7 @@ spec['glsl-1.10']['execution']['varying-packing'] = {}
for type in ['int', 'uint', 'float', 'vec2', 'vec3', 'vec4', 'ivec2', 'ivec3',
'ivec4', 'uvec2', 'uvec3', 'uvec4', 'mat2', 'mat3', 'mat4',
'mat2x3', 'mat2x4', 'mat3x2', 'mat3x4', 'mat4x2', 'mat4x3']:
- for arrayspec in ['array', 'separate']:
+ for arrayspec in ['array', 'separate', 'arrays_of_arrays']:
cmdline = 'simple {0} {1}'.format(type, arrayspec)
spec['glsl-1.10']['execution']['varying-packing'][cmdline] = \
PiglitGLTest('varying-packing-' + cmdline, run_concurrent=True)
diff --git a/tests/spec/glsl-1.10/execution/varying-packing/simple.c b/tests/spec/glsl-1.10/execution/varying-packing/simple.c
index 6d07a36..c5ff68e 100644
--- a/tests/spec/glsl-1.10/execution/varying-packing/simple.c
+++ b/tests/spec/glsl-1.10/execution/varying-packing/simple.c
@@ -97,6 +97,8 @@
*/
#include "piglit-util-gl.h"
+static const int outer_dim_size = 2;
+
PIGLIT_GL_TEST_CONFIG_BEGIN
config.supports_gl_compat_version = 10;
@@ -115,6 +117,14 @@ enum base_type
BASE_TYPE_INT,
};
+enum test_array_type
+{
+ SEPARATE,
+ ARRAY,
+ ARRAYS_OF_ARRAYS,
+};
+
+
static const char *
get_base_type_name(enum base_type t)
{
@@ -189,7 +199,8 @@ const struct type_desc *all_types[] = {
struct varying_desc
{
const struct type_desc *type;
- unsigned array_elems;
+ unsigned one_dim_array_elems;
+ unsigned two_dim_array_elems;
};
/**
@@ -198,12 +209,12 @@ struct varying_desc
*/
static GLint
get_shader(bool is_vs, unsigned glsl_version, int num_varyings,
- struct varying_desc *varyings)
+ struct varying_desc *varyings, enum test_array_type array_type)
{
GLuint shader;
char *full_text = malloc(1000 * 100 + num_varyings);
char *text = full_text;
- unsigned i, j, k, l;
+ unsigned i, j, k, l, m;
const char *varying_keyword;
unsigned offset = 0;
GLenum shader_type = is_vs ? GL_VERTEX_SHADER : GL_FRAGMENT_SHADER;
@@ -218,16 +229,24 @@ get_shader(bool is_vs, unsigned glsl_version, int num_varyings,
}
text += sprintf(text, "#version %u\n", glsl_version);
+ if (array_type == ARRAYS_OF_ARRAYS)
+ text += sprintf(text, "#extension GL_ARB_arrays_of_arrays: enable\n");
text += sprintf(text, "uniform int i;\n");
for (i = 0; i < num_varyings; ++i) {
const char *opt_flat_keyword = "";
if (varyings[i].type->base != BASE_TYPE_FLOAT)
opt_flat_keyword = "flat ";
- if (varyings[i].array_elems != 0) {
+ if (varyings[i].two_dim_array_elems != 0) {
+ text += sprintf(text, "%s%s %s var%u[%u][%u];\n",
+ opt_flat_keyword, varying_keyword,
+ varyings[i].type->name, i,
+ outer_dim_size,
+ varyings[i].two_dim_array_elems);
+ } else if (varyings[i].one_dim_array_elems != 0) {
text += sprintf(text, "%s%s %s var%u[%u];\n",
opt_flat_keyword, varying_keyword,
varyings[i].type->name, i,
- varyings[i].array_elems);
+ varyings[i].one_dim_array_elems);
} else {
text += sprintf(text, "%s%s %s var%u;\n",
opt_flat_keyword, varying_keyword,
@@ -243,37 +262,47 @@ get_shader(bool is_vs, unsigned glsl_version, int num_varyings,
else
text += sprintf(text, " bool failed = false;\n");
for (i = 0; i < num_varyings; ++i) {
- unsigned array_loop_bound = varyings[i].array_elems;
+ unsigned array_loop_bound;
+ unsigned outer_array_loop_bound = 1;
const char *base_type_name
= get_base_type_name(varyings[i].type->base);
+ if (varyings[i].two_dim_array_elems != 0) {
+ outer_array_loop_bound = outer_dim_size;
+ array_loop_bound = varyings[i].two_dim_array_elems;
+ } else
+ array_loop_bound = varyings[i].one_dim_array_elems;
if (array_loop_bound == 0)
array_loop_bound = 1;
- for (j = 0; j < array_loop_bound; ++j) {
- for (k = 0; k < varyings[i].type->num_cols; ++k) {
- for (l = 0; l < varyings[i].type->num_rows; ++l) {
- text += sprintf(text, " ");
- if (!is_vs)
- text += sprintf(text, "if (");
- text += sprintf(text, "var%u", i);
- if (varyings[i].array_elems)
- text += sprintf(text, "[%u]", j);
- if (varyings[i].type->num_cols > 1)
- text += sprintf(text, "[%u]", k);
- if (varyings[i].type->num_rows > 1)
- text += sprintf(text, "[%u]", l);
- if (is_vs)
- text += sprintf(text, " = ");
- else
- text += sprintf(text, " != ");
- text += sprintf(text, "%s(i + %u)",
- base_type_name,
- offset++);
- if (is_vs) {
- text += sprintf(text, ";\n");
- } else {
- text += sprintf(text,
- ")\n"
- " failed = true;\n");
+ for (j = 0; j < outer_array_loop_bound; ++j) {
+ for (k = 0; k < array_loop_bound; ++k) {
+ for (l = 0; l < varyings[i].type->num_cols; ++l) {
+ for (m = 0; m < varyings[i].type->num_rows; ++m) {
+ text += sprintf(text, " ");
+ if (!is_vs)
+ text += sprintf(text, "if (");
+ text += sprintf(text, "var%u", i);
+ if (varyings[i].two_dim_array_elems)
+ text += sprintf(text, "[%u]", j);
+ if (varyings[i].one_dim_array_elems || varyings[i].two_dim_array_elems)
+ text += sprintf(text, "[%u]", k);
+ if (varyings[i].type->num_cols > 1)
+ text += sprintf(text, "[%u]", l);
+ if (varyings[i].type->num_rows > 1)
+ text += sprintf(text, "[%u]", m);
+ if (is_vs)
+ text += sprintf(text, " = ");
+ else
+ text += sprintf(text, " != ");
+ text += sprintf(text, "%s(i + %u)",
+ base_type_name,
+ offset++);
+ if (is_vs) {
+ text += sprintf(text, ";\n");
+ } else {
+ text += sprintf(text,
+ ")\n"
+ " failed = true;\n");
+ }
}
}
}
@@ -302,7 +331,8 @@ get_shader(bool is_vs, unsigned glsl_version, int num_varyings,
*/
static unsigned
choose_varyings(struct varying_desc *varyings,
- const struct type_desc *test_type, GLboolean test_array,
+ const struct type_desc *test_type,
+ enum test_array_type array_type,
unsigned max_varying_floats)
{
unsigned num_varyings = 0;
@@ -310,24 +340,43 @@ choose_varyings(struct varying_desc *varyings,
= test_type->num_cols * test_type->num_rows;
unsigned num_test_varyings
= max_varying_floats / components_in_test_type;
+ unsigned num_two_dim_test_varyings
+ = num_test_varyings / outer_dim_size;
+ unsigned num_extra_arrays = 0;
unsigned num_extra_varyings
= max_varying_floats
- num_test_varyings * components_in_test_type;
unsigned i;
- if (test_array) {
+ if (array_type == ARRAYS_OF_ARRAYS) {
varyings[num_varyings].type = test_type;
- varyings[num_varyings].array_elems = num_test_varyings;
+ varyings[num_varyings].two_dim_array_elems = num_two_dim_test_varyings;
+ varyings[num_varyings].one_dim_array_elems = 0;
+ num_extra_arrays
+ = num_test_varyings - (num_two_dim_test_varyings * outer_dim_size);
+ ++num_varyings;
+ if (num_extra_arrays > 0) {
+ varyings[num_varyings].type = test_type;
+ varyings[num_varyings].two_dim_array_elems = 0;
+ varyings[num_varyings].one_dim_array_elems = num_extra_arrays;
+ ++num_varyings;
+ }
+ } else if (array_type == ARRAY) {
+ varyings[num_varyings].type = test_type;
+ varyings[num_varyings].two_dim_array_elems = 0;
+ varyings[num_varyings].one_dim_array_elems = num_test_varyings;
++num_varyings;
} else {
for (i = 0; i < num_test_varyings; ++i) {
varyings[num_varyings].type = test_type;
- varyings[num_varyings].array_elems = 0;
+ varyings[num_varyings].two_dim_array_elems = 0;
+ varyings[num_varyings].one_dim_array_elems = 0;
++num_varyings;
}
}
for (i = 0; i < num_extra_varyings; ++i) {
varyings[num_varyings].type = &float_type;
- varyings[num_varyings].array_elems = 0;
+ varyings[num_varyings].two_dim_array_elems = 0;
+ varyings[num_varyings].one_dim_array_elems = 0;
++num_varyings;
}
@@ -344,6 +393,8 @@ NORETURN print_usage_and_exit(const char *prog_name)
printf(" %s\n", all_types[i]->name);
printf(" and <arrayspec> is one of:\n"
" array: test using an array of the above type\n"
+ " arrays_of_arrays: test using a multidimensional array"
+ " of the above type\n"
" separate: test using separately declared varyings\n");
piglit_report_result(PIGLIT_FAIL);
}
@@ -353,10 +404,11 @@ piglit_init(int argc, char **argv)
{
unsigned i;
const struct type_desc *test_type;
- GLboolean test_array;
+ enum test_array_type array_type;
GLint max_varying_floats;
struct varying_desc *varyings;
unsigned num_varyings;
+ unsigned glsl_version;
GLuint vs, fs;
if (argc != 3)
@@ -365,29 +417,35 @@ piglit_init(int argc, char **argv)
if (strcmp(argv[1], all_types[i]->name) == 0)
break;
}
- if (all_types[i])
+ if (all_types[i]) {
test_type = all_types[i];
- else
+ glsl_version = test_type->glsl_version_required;
+ } else
print_usage_and_exit(argv[0]);
if (strcmp(argv[2], "array") == 0)
- test_array = GL_TRUE;
+ array_type = ARRAY;
else if (strcmp(argv[2], "separate") == 0)
- test_array = GL_FALSE;
- else
+ array_type = SEPARATE;
+ else if (strcmp(argv[2], "arrays_of_arrays") == 0) {
+ array_type = ARRAYS_OF_ARRAYS;
+ piglit_require_extension("GL_ARB_arrays_of_arrays");
+ if (glsl_version < 120)
+ glsl_version = 120;
+ } else
print_usage_and_exit(argv[0]);
piglit_require_gl_version(20);
- piglit_require_GLSL_version(test_type->glsl_version_required);
+ piglit_require_GLSL_version(glsl_version);
glGetIntegerv(GL_MAX_VARYING_FLOATS, &max_varying_floats);
varyings = malloc(sizeof(*varyings) * max_varying_floats);
- num_varyings = choose_varyings(varyings, test_type,
- test_array, max_varying_floats);
+ num_varyings = choose_varyings(varyings, test_type, array_type,
+ max_varying_floats);
- vs = get_shader(true, test_type->glsl_version_required,
- num_varyings, varyings);
- fs = get_shader(false, test_type->glsl_version_required,
- num_varyings, varyings);
+ vs = get_shader(true, glsl_version,
+ num_varyings, varyings, array_type);
+ fs = get_shader(false, glsl_version,
+ num_varyings, varyings, array_type);
prog = piglit_link_simple_program(vs, fs);
i_location = glGetUniformLocation(prog, "i");
free(varyings);
--
1.9.3
More information about the Piglit
mailing list