[Piglit] [PATCH] varying-packing: add arrays of arrays support

Ilia Mirkin imirkin at alum.mit.edu
Tue May 12 14:34:25 PDT 2015


Perhaps in the absence of a brave enough soul to look at this, could you

(a) confirm that the generated shaders don't change at all for the
non-arrays-of-arrays cases or alternatively post the differences
(b) post a couple of sample arrays-of-arrays shaders that are
generated by the new logic

  -ilia

On Tue, May 12, 2015 at 5:31 PM, Timothy Arceri <t_arceri at yahoo.com.au> wrote:
> 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);
>
>
> _______________________________________________
> Piglit mailing list
> Piglit at lists.freedesktop.org
> http://lists.freedesktop.org/mailman/listinfo/piglit


More information about the Piglit mailing list