[Piglit] [PATCH] varying-packing: add arrays of arrays support
Timothy Arceri
t_arceri at yahoo.com.au
Tue May 12 14:31:40 PDT 2015
Anyone brave enough to to give this a quick review? It's been on the
list since mid last year I'd really like to push it so I can move on :)
Thanks,
Tim
On Sun, 2015-04-26 at 16:13 +1000, Timothy Arceri wrote:
> V3: rebase and test double types
>
> V2: renamed variables from 'inner' that should have been 'outer'
> ---
> tests/all.py | 4 +-
> .../glsl-1.10/execution/varying-packing/simple.c | 137 +++++++++++++++------
> 2 files changed, 100 insertions(+), 41 deletions(-)
>
> diff --git a/tests/all.py b/tests/all.py
> index 18124b7..85b622f 100755
> --- a/tests/all.py
> +++ b/tests/all.py
> @@ -1290,7 +1290,7 @@ with profile.group_manager(
> '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']:
> g(['varying-packing-simple', type_, arrayspec],
> 'simple {} {}'.format(type_, arrayspec))
>
> @@ -2062,7 +2062,7 @@ with profile.group_manager(
> for type in ['double', 'dvec2', 'dvec3', 'dvec4', 'dmat2', 'dmat3',
> 'dmat4', 'dmat2x3', 'dmat2x4', 'dmat3x2', 'dmat3x4',
> 'dmat4x2', 'dmat4x3']:
> - for arrayspec in ['array', 'separate']:
> + for arrayspec in ['array', 'separate', 'arrays_of_arrays']:
> g(['varying-packing-simple', type, arrayspec],
> 'simple {0} {1}'.format(type, arrayspec))
>
> 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 e9935c7..2b1c010 100644
> --- a/tests/spec/glsl-1.10/execution/varying-packing/simple.c
> +++ b/tests/spec/glsl-1.10/execution/varying-packing/simple.c
> @@ -100,6 +100,8 @@
> static void
> parse_args(int argc, char *argv[], struct piglit_gl_test_config *config);
>
> +static const int outer_dim_size = 2;
> +
> PIGLIT_GL_TEST_CONFIG_BEGIN
>
> config.window_visual = PIGLIT_GL_VISUAL_RGB | PIGLIT_GL_VISUAL_DOUBLE;
> @@ -118,6 +120,13 @@ enum base_type
> BASE_TYPE_DOUBLE,
> };
>
> +enum test_array_type
> +{
> + SEPARATE,
> + ARRAY,
> + ARRAYS_OF_ARRAYS,
> +};
> +
> static const char *
> get_base_type_name(enum base_type t)
> {
> @@ -219,7 +228,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;
> };
>
> /**
> @@ -228,12 +238,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;
> @@ -249,6 +259,8 @@ 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");
> for (i = 0; i < num_varyings; ++i) {
> const char *opt_flat_keyword = "";
> if (!fp64 && varyings[i].type->base == BASE_TYPE_DOUBLE) {
> @@ -257,11 +269,17 @@ get_shader(bool is_vs, unsigned glsl_version, int num_varyings,
> }
> 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%03u[%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%03u[%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%03u;\n",
> opt_flat_keyword, varying_keyword,
> @@ -282,31 +300,42 @@ 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, "failed = failed || ");
> - text += sprintf(text, "var%03u", 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);\n",
> - base_type_name,
> - offset++);
> + 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, "failed = failed || ");
> + text += sprintf(text, "var%03u", 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);\n",
> + base_type_name,
> + offset++);
> + }
> }
> }
> }
> @@ -334,7 +363,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;
> @@ -343,24 +373,43 @@ choose_varyings(struct varying_desc *varyings,
> = test_type->num_cols * test_type->num_rows * element_size;
> 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;
> }
>
> @@ -377,6 +426,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);
> }
> @@ -414,36 +465,44 @@ parse_args(int argc, char *argv[], struct piglit_gl_test_config *config)
> void
> piglit_init(int argc, char **argv)
> {
> - 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)
> print_usage_and_exit(argv[0]);
>
> + glsl_version = test_type->glsl_version_required;
> +
> 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);
> if (test_type->base == BASE_TYPE_DOUBLE)
> piglit_require_extension("GL_ARB_gpu_shader_fp64");
> 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);
> + array_type, max_varying_floats);
>
> vs = get_shader(true, test_type->glsl_version_required,
> - num_varyings, varyings);
> + num_varyings, varyings, array_type);
> fs = get_shader(false, test_type->glsl_version_required,
> - num_varyings, varyings);
> + num_varyings, varyings, array_type);
> prog = piglit_link_simple_program(vs, fs);
> i_location = glGetUniformLocation(prog, "i");
> free(varyings);
More information about the Piglit
mailing list