tests/spec/arb_compute_variable_group_size/errors.c

   1 /*
   2  * Copyright (C) 2016 Samuel Pitoiset
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  */
  23
  24 /** \file
  25  *
  26  * Test cases in which the ARB_compute_variable_group_size API is expected to
  27  * generate an error.
  28  */
  29
  30 #include "piglit-util-gl.h"
  31 #include "piglit-shader.h"
  32
  33 static struct piglit_gl_test_config *piglit_config;
  34
  35 PIGLIT_GL_TEST_CONFIG_BEGIN
  36
  37         piglit_config = &config;
  38         config.supports_gl_compat_version = 33;
  39         config.supports_gl_core_version = 33;
  40         config.khr_no_error_support = PIGLIT_HAS_ERRORS;
  41
  42 PIGLIT_GL_TEST_CONFIG_END
  43
  44 static const char *variable_work_group_size_shader =
  45         "#version 330\n"
  46         "#extension GL_ARB_compute_shader: enable\n"
  47         "#extension GL_ARB_compute_variable_group_size: enable\n"
  48         "\n"
  49         "layout(local_size_variable) in;\n"
  50         "\n"
  51         "void main()\n"
  52         "{\n"
  53         "}\n";
  54
  55 static const char *fixed_work_group_size_shader =
  56         "#version 330\n"
  57         "#extension GL_ARB_compute_shader: enable\n"
  58         "\n"
  59         "layout(local_size_x = 1) in;\n"
  60         "\n"
  61         "void main()\n"
  62         "{\n"
  63         "}\n";
  64
  65 static enum piglit_result
  66 use_variable_work_group_size_normal(void *data)
  67 {
  68         /* The ARB_compute_variable_group_size spec says:
  69          *
  70          *    An INVALID_OPERATION error is generated by DispatchCompute or
  71          *    DispatchComputeIndirect if the active program for the compute
  72          *    shader stage has a variable work group size.
  73          */
  74         GLint prog = piglit_build_simple_program_multiple_shaders(
  75                 GL_COMPUTE_SHADER, variable_work_group_size_shader, 0);
  76         glUseProgram(prog);
  77         glDispatchCompute(1, 1, 1);
  78         if (!piglit_check_gl_error(GL_INVALID_OPERATION))
  79                 return PIGLIT_FAIL;
  80         return PIGLIT_PASS;
  81 }
  82
  83 static enum piglit_result
  84 use_variable_work_group_size_indirect(void *data)
  85 {
  86         /* The ARB_compute_variable_group_size spec says:
  87          *
  88          *    An INVALID_OPERATION error is generated by DispatchCompute or
  89          *    DispatchComputeIndirect if the active program for the compute
  90          *    shader stage has a variable work group size.
  91          */
  92         GLuint indirect_buf[3] = { 1, 1, 1 };
  93         GLuint indirect_bo = 0;
  94         GLint prog;
  95
  96         glGenBuffers(1, &indirect_bo);
  97         if (!piglit_check_gl_error(GL_NO_ERROR))
  98                 return PIGLIT_FAIL;
  99
 100         glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, indirect_bo);
 101         glBufferData(GL_DISPATCH_INDIRECT_BUFFER, sizeof(indirect_buf),
 102                      indirect_buf, GL_STREAM_READ);
 103
 104         prog = piglit_build_simple_program_multiple_shaders(
 105                 GL_COMPUTE_SHADER, variable_work_group_size_shader, 0);
 106         glUseProgram(prog);
 107
 108         glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, indirect_bo);
 109         glDispatchComputeIndirect(0);
 110         if (!piglit_check_gl_error(GL_INVALID_OPERATION))
 111                 return PIGLIT_FAIL;
 112
 113         glDeleteBuffers(1, &indirect_bo);
 114         return PIGLIT_PASS;
 115 }
 116
 117 static enum piglit_result
 118 use_fixed_work_group_size(void *data)
 119 {
 120         /* The ARB_compute_variable_group_size spec says:
 121          *
 122          *     An INVALID_OPERATION error is generated by
 123          *     DispatchComputeGroupSizeARB if the active program for the
 124          *     compute shader stage has a fixed work group size.
 125          */
 126         GLint prog = piglit_build_simple_program_multiple_shaders(
 127                 GL_COMPUTE_SHADER, fixed_work_group_size_shader, 0);
 128         glUseProgram(prog);
 129         glDispatchComputeGroupSizeARB(1, 1, 1, 1, 1, 1);
 130         if (!piglit_check_gl_error(GL_INVALID_OPERATION))
 131                 return PIGLIT_FAIL;
 132         return PIGLIT_PASS;
 133 }
 134
 135 static enum piglit_result
 136 use_invalid_work_group_count_values(void *data)
 137 {
 138         GLint prog, v[3];
 139
 140         /* The ARB_compute_variable_group_size spec says:
 141          *
 142          *     An INVALID_VALUE error is generated if any of num_groups_x,
 143          *     num_groups_y and num_groups_z are greater than or equal to the
 144          *     maximum work group count for the corresponding dimension.
 145          */
 146         prog = piglit_build_simple_program_multiple_shaders(
 147                 GL_COMPUTE_SHADER, variable_work_group_size_shader, 0);
 148         glUseProgram(prog);
 149
 150         /* Use values greater than the maximum work group count. */
 151         glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_COUNT, 0, &v[0]);
 152         glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_COUNT, 1, &v[1]);
 153         glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_COUNT, 2, &v[2]);
 154
 155         glDispatchComputeGroupSizeARB(v[0] + 1, v[1] + 1, v[2] + 1, 1, 1, 1);
 156         if (!piglit_check_gl_error(GL_INVALID_VALUE))
 157                 return PIGLIT_FAIL;
 158         return PIGLIT_PASS;
 159 }
 160
 161 static enum piglit_result
 162 use_invalid_variable_work_group_size_values(void *data)
 163 {
 164         /* The ARB_compute_variable_group_size spec says:
 165          *
 166          *     An INVALID_VALUE error is generated by
 167          *     DispatchComputeGroupSizeARB if any of <group_size_x>,
 168          *     <group_size_y>, or <group_size_z> is less than or equal to zero
 169          *     or greater than the maximum local work group size for compute
 170          *     shaders with variable group size
 171          *     (MAX_COMPUTE_VARIABLE_GROUP_SIZE_ARB) in the corresponding
 172          *     dimension.
 173          */
 174         GLint prog, v[3];
 175
 176         prog = piglit_build_simple_program_multiple_shaders(
 177                 GL_COMPUTE_SHADER, variable_work_group_size_shader, 0);
 178         glUseProgram(prog);
 179
 180         /* Use values equal to zero (because "less than" is a spec bug). */
 181         glDispatchComputeGroupSizeARB(1, 1, 1, 0, 0, 0);
 182         if (!piglit_check_gl_error(GL_INVALID_VALUE))
 183                 return PIGLIT_FAIL;
 184
 185         /* Use values greater than the maximum local work group size. */
 186         glGetIntegeri_v(GL_MAX_COMPUTE_VARIABLE_GROUP_SIZE_ARB, 0, &v[0]);
 187         glGetIntegeri_v(GL_MAX_COMPUTE_VARIABLE_GROUP_SIZE_ARB, 1, &v[1]);
 188         glGetIntegeri_v(GL_MAX_COMPUTE_VARIABLE_GROUP_SIZE_ARB, 2, &v[2]);
 189         glDispatchComputeGroupSizeARB(1, 1, 1, v[0] + 1, v[1] + 1, v[0] + 1);
 190         if (!piglit_check_gl_error(GL_INVALID_VALUE))
 191                 return PIGLIT_FAIL;
 192         return PIGLIT_PASS;
 193 }
 194
 195 static enum piglit_result
 196 use_invalid_variable_group_invocations_values(void *data)
 197 {
 198         /* The ARB_compute_variable_group_size spec says:
 199          *
 200          *    An INVALID_VALUE error is generated by
 201          *    DispatchComputeGroupSizeARB if the product of <group_size_x>,
 202          *    <group_size_y>, and <group_size_z> exceeds the
 203          *    implementation-dependent maximum local work group invocation
 204          *    count for compute shaders with variable group size
 205          *    (MAX_COMPUTE_VARIABLE_GROUP_INVOCATIONS_ARB).
 206          */
 207         GLint prog, v;
 208
 209         prog = piglit_build_simple_program_multiple_shaders(
 210                 GL_COMPUTE_SHADER, variable_work_group_size_shader, 0);
 211         glUseProgram(prog);
 212
 213         glGetIntegerv(GL_MAX_COMPUTE_VARIABLE_GROUP_INVOCATIONS_ARB, &v);
 214         glDispatchComputeGroupSizeARB(1, 1, 1, v, v, v);
 215         if (!piglit_check_gl_error(GL_INVALID_VALUE))
 216                 return PIGLIT_FAIL;
 217         return PIGLIT_PASS;
 218 }
 219
 220 static const struct piglit_subtest subtests[] = {
 221         {
 222                 "Use a variable work group size with DispatchCompute",
 223                 "use_variable_work_group_size_normal",
 224                 use_variable_work_group_size_normal,
 225                 NULL
 226         },
 227         {
 228                 "Use a variable work group size with DispatchComputeIndirect",
 229                 "use_variable_work_group_size_indirect",
 230                 use_variable_work_group_size_indirect,
 231                 NULL
 232         },
 233
 234         {
 235                 "Use a fixed work group size with DispatchComputeGroupSizeARB",
 236                 "use_fixed_work_group_size",
 237                 use_fixed_work_group_size,
 238                 NULL
 239         },
 240         {
 241                 "Use invalid work group count values",
 242                 "use_invalid_work_group_count_values",
 243                 use_invalid_work_group_count_values,
 244                 NULL
 245         },
 246         {
 247                 "Use invalid variable work group size values",
 248                 "use_invalid_variable_work_group_size_values",
 249                 use_invalid_variable_work_group_size_values,
 250                 NULL
 251         },
 252         {
 253                 "Use invalid variable group invocations values",
 254                 "use_invalid_variable_group_invocations_values",
 255                 use_invalid_variable_group_invocations_values,
 256                 NULL
 257         },
 258         {
 259                 NULL,
 260                 NULL,
 261                 NULL,
 262                 NULL
 263         }
 264 };
 265
 266 enum piglit_result
 267 piglit_display(void)
 268 {
 269         return PIGLIT_FAIL;
 270 }
 271
 272 void
 273 piglit_init(int argc, char **argv)
 274 {
 275         enum piglit_result result;
 276
 277         piglit_require_extension("GL_ARB_compute_variable_group_size");
 278         result = piglit_run_selected_subtests(subtests,
 279                                               piglit_config->selected_subtests,
 280                                               piglit_config->num_selected_subtests,
 281                                               PIGLIT_SKIP);
 282         piglit_report_result(result);
 283 }