external/openglcts/modules/gl/gl4cComputeShaderTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * OpenGL Conformance Test Suite
   3  * -----------------------------
   4  *
   5  * Copyright (c) 2014-2016 The Khronos Group Inc.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */ /*!
  20  * \file
  21  * \brief
  22  */ /*-------------------------------------------------------------------*/
  23
  24 #include "gl4cComputeShaderTests.hpp"
  25 #include "glwEnums.hpp"
  26 #include "glwFunctions.hpp"
  27 #include "tcuMatrix.hpp"
  28 #include "tcuMatrixUtil.hpp"
  29 #include "tcuRenderTarget.hpp"
  30 #include <cmath>
  31 #include <cstdarg>
  32 #include <sstream>
  33
  34 namespace gl4cts
  35 {
  36
  37 using namespace glw;
  38 using tcu::Vec2;
  39 using tcu::Vec3;
  40 using tcu::Vec4;
  41 using tcu::UVec4;
  42 using tcu::UVec3;
  43 using tcu::Mat4;
  44
  45 namespace
  46 {
  47
  48 typedef Vec3  vec2;
  49 typedef Vec3  vec3;
  50 typedef Vec4  vec4;
  51 typedef UVec3 uvec3;
  52 typedef UVec4 uvec4;
  53 typedef Mat4  mat4;
  54
  55 const char* const kGLSLVer = "#version 430 core\n";
  56
  57 class ComputeShaderBase : public deqp::SubcaseBase
  58 {
  59
  60 public:
  61         virtual ~ComputeShaderBase()
  62         {
  63         }
  64
  65         ComputeShaderBase()
  66                 : renderTarget(m_context.getRenderContext().getRenderTarget()), pixelFormat(renderTarget.getPixelFormat())
  67         {
  68                 float epsilon_zero = 1.f / (1 << 13);
  69                 if (pixelFormat.redBits != 0 && pixelFormat.greenBits != 0 && pixelFormat.blueBits != 0 &&
  70                         pixelFormat.alphaBits != 0)
  71                 {
  72                         g_color_eps = vec4(1.f / ((float)(1 << pixelFormat.redBits) - 1.0f),
  73                                                            1.f / ((float)(1 << pixelFormat.greenBits) - 1.0f),
  74                                                            1.f / ((float)(1 << pixelFormat.blueBits) - 1.0f),
  75                                                            1.f / ((float)(1 << pixelFormat.alphaBits) - 1.0f)) +
  76                                                   vec4(epsilon_zero);
  77                 }
  78                 else if (pixelFormat.redBits != 0 && pixelFormat.greenBits != 0 && pixelFormat.blueBits != 0)
  79                 {
  80                         g_color_eps = vec4(1.f / ((float)(1 << pixelFormat.redBits) - 1.0f),
  81                                                            1.f / ((float)(1 << pixelFormat.greenBits) - 1.0f),
  82                                                            1.f / ((float)(1 << pixelFormat.blueBits) - 1.0f), 1.f) +
  83                                                   vec4(epsilon_zero);
  84                 }
  85                 else
  86                 {
  87                         g_color_eps = vec4(epsilon_zero);
  88                 }
  89         }
  90
  91         const tcu::RenderTarget& renderTarget;
  92         const tcu::PixelFormat&  pixelFormat;
  93         vec4                                     g_color_eps;
  94
  95         uvec3 IndexTo3DCoord(GLuint idx, GLuint max_x, GLuint max_y)
  96         {
  97                 const GLuint x = idx % max_x;
  98                 idx /= max_x;
  99                 const GLuint y = idx % max_y;
 100                 idx /= max_y;
 101                 const GLuint z = idx;
 102                 return uvec3(x, y, z);
 103         }
 104
 105         bool CheckProgram(GLuint program, bool* compile_error = NULL)
 106         {
 107                 GLint compile_status = GL_TRUE;
 108                 GLint status             = GL_TRUE;
 109                 glGetProgramiv(program, GL_LINK_STATUS, &status);
 110
 111                 if (status == GL_FALSE)
 112                 {
 113                         GLint attached_shaders;
 114                         glGetProgramiv(program, GL_ATTACHED_SHADERS, &attached_shaders);
 115
 116                         if (attached_shaders > 0)
 117                         {
 118                                 std::vector<GLuint> shaders(attached_shaders);
 119                                 glGetAttachedShaders(program, attached_shaders, NULL, &shaders[0]);
 120
 121                                 for (GLint i = 0; i < attached_shaders; ++i)
 122                                 {
 123                                         GLenum type;
 124                                         glGetShaderiv(shaders[i], GL_SHADER_TYPE, reinterpret_cast<GLint*>(&type));
 125                                         switch (type)
 126                                         {
 127                                         case GL_VERTEX_SHADER:
 128                                                 m_context.getTestContext().getLog()
 129                                                         << tcu::TestLog::Message << "*** Vertex Shader ***" << tcu::TestLog::EndMessage;
 130                                                 break;
 131                                         case GL_TESS_CONTROL_SHADER:
 132                                                 m_context.getTestContext().getLog()
 133                                                         << tcu::TestLog::Message << "*** Tessellation Control Shader ***"
 134                                                         << tcu::TestLog::EndMessage;
 135                                                 break;
 136                                         case GL_TESS_EVALUATION_SHADER:
 137                                                 m_context.getTestContext().getLog()
 138                                                         << tcu::TestLog::Message << "*** Tessellation Evaluation Shader ***"
 139                                                         << tcu::TestLog::EndMessage;
 140                                                 break;
 141                                         case GL_GEOMETRY_SHADER:
 142                                                 m_context.getTestContext().getLog()
 143                                                         << tcu::TestLog::Message << "*** Geometry Shader ***" << tcu::TestLog::EndMessage;
 144                                                 break;
 145                                         case GL_FRAGMENT_SHADER:
 146                                                 m_context.getTestContext().getLog()
 147                                                         << tcu::TestLog::Message << "*** Fragment Shader ***" << tcu::TestLog::EndMessage;
 148                                                 break;
 149                                         case GL_COMPUTE_SHADER:
 150                                                 m_context.getTestContext().getLog()
 151                                                         << tcu::TestLog::Message << "*** Compute Shader ***" << tcu::TestLog::EndMessage;
 152                                                 break;
 153                                         default:
 154                                                 m_context.getTestContext().getLog()
 155                                                         << tcu::TestLog::Message << "*** Unknown Shader ***" << tcu::TestLog::EndMessage;
 156                                                 break;
 157                                         }
 158
 159                                         GLint res;
 160                                         glGetShaderiv(shaders[i], GL_COMPILE_STATUS, &res);
 161                                         if (res != GL_TRUE)
 162                                                 compile_status = res;
 163
 164                                         GLint length;
 165                                         glGetShaderiv(shaders[i], GL_SHADER_SOURCE_LENGTH, &length);
 166                                         if (length > 0)
 167                                         {
 168                                                 std::vector<GLchar> source(length);
 169                                                 glGetShaderSource(shaders[i], length, NULL, &source[0]);
 170                                                 m_context.getTestContext().getLog()
 171                                                         << tcu::TestLog::Message << &source[0] << tcu::TestLog::EndMessage;
 172                                         }
 173
 174                                         glGetShaderiv(shaders[i], GL_INFO_LOG_LENGTH, &length);
 175                                         if (length > 0)
 176                                         {
 177                                                 std::vector<GLchar> log(length);
 178                                                 glGetShaderInfoLog(shaders[i], length, NULL, &log[0]);
 179                                                 m_context.getTestContext().getLog()
 180                                                         << tcu::TestLog::Message << &log[0] << tcu::TestLog::EndMessage;
 181                                         }
 182                                 }
 183                         }
 184
 185                         GLint length;
 186                         glGetProgramiv(program, GL_INFO_LOG_LENGTH, &length);
 187                         if (length > 0)
 188                         {
 189                                 std::vector<GLchar> log(length);
 190                                 glGetProgramInfoLog(program, length, NULL, &log[0]);
 191                                 m_context.getTestContext().getLog() << tcu::TestLog::Message << &log[0] << tcu::TestLog::EndMessage;
 192                         }
 193                 }
 194
 195                 if (compile_error)
 196                         *compile_error = (compile_status == GL_TRUE ? false : true);
 197                 if (compile_status != GL_TRUE)
 198                         return false;
 199                 return status == GL_TRUE ? true : false;
 200         }
 201
 202         GLuint CreateComputeProgram(const std::string& cs)
 203         {
 204                 const GLuint p = glCreateProgram();
 205
 206                 if (!cs.empty())
 207                 {
 208                         const GLuint sh = glCreateShader(GL_COMPUTE_SHADER);
 209                         glAttachShader(p, sh);
 210                         glDeleteShader(sh);
 211                         const char* const src[2] = { kGLSLVer, cs.c_str() };
 212                         glShaderSource(sh, 2, src, NULL);
 213                         glCompileShader(sh);
 214                 }
 215
 216                 return p;
 217         }
 218
 219         GLuint CreateProgram(const std::string& vs, const std::string& fs)
 220         {
 221                 const GLuint p = glCreateProgram();
 222
 223                 if (!vs.empty())
 224                 {
 225                         const GLuint sh = glCreateShader(GL_VERTEX_SHADER);
 226                         glAttachShader(p, sh);
 227                         glDeleteShader(sh);
 228                         const char* const src[2] = { kGLSLVer, vs.c_str() };
 229                         glShaderSource(sh, 2, src, NULL);
 230                         glCompileShader(sh);
 231                 }
 232                 if (!fs.empty())
 233                 {
 234                         const GLuint sh = glCreateShader(GL_FRAGMENT_SHADER);
 235                         glAttachShader(p, sh);
 236                         glDeleteShader(sh);
 237                         const char* const src[2] = { kGLSLVer, fs.c_str() };
 238                         glShaderSource(sh, 2, src, NULL);
 239                         glCompileShader(sh);
 240                 }
 241
 242                 return p;
 243         }
 244
 245         GLuint BuildShaderProgram(GLenum type, const std::string& source)
 246         {
 247                 const char* const src[2] = { kGLSLVer, source.c_str() };
 248                 return glCreateShaderProgramv(type, 2, src);
 249         }
 250
 251         GLfloat distance(GLfloat p0, GLfloat p1)
 252         {
 253                 return de::abs(p0 - p1);
 254         }
 255
 256         inline bool ColorEqual(const vec4& c0, const vec4& c1, const vec4& epsilon)
 257         {
 258                 if (distance(c0.x(), c1.x()) > epsilon.x())
 259                         return false;
 260                 if (distance(c0.y(), c1.y()) > epsilon.y())
 261                         return false;
 262                 if (distance(c0.z(), c1.z()) > epsilon.z())
 263                         return false;
 264                 if (distance(c0.w(), c1.w()) > epsilon.w())
 265                         return false;
 266                 return true;
 267         }
 268
 269         inline bool ColorEqual(const vec3& c0, const vec3& c1, const vec4& epsilon)
 270         {
 271                 if (distance(c0.x(), c1.x()) > epsilon.x())
 272                         return false;
 273                 if (distance(c0.y(), c1.y()) > epsilon.y())
 274                         return false;
 275                 if (distance(c0.z(), c1.z()) > epsilon.z())
 276                         return false;
 277                 return true;
 278         }
 279
 280         bool ValidateReadBuffer(int x, int y, int w, int h, const vec4& expected)
 281         {
 282                 std::vector<vec4> display(w * h);
 283                 glReadPixels(x, y, w, h, GL_RGBA, GL_FLOAT, &display[0]);
 284
 285                 for (int j = 0; j < h; ++j)
 286                 {
 287                         for (int i = 0; i < w; ++i)
 288                         {
 289                                 if (!ColorEqual(display[j * w + i], expected, g_color_eps))
 290                                 {
 291                                         m_context.getTestContext().getLog()
 292                                                 << tcu::TestLog::Message << "Color at (" << (x + i) << ", " << (y + j) << ") is ["
 293                                                 << display[j * w + i].x() << ", " << display[j * w + i].y() << ", " << display[j * w + i].z()
 294                                                 << ", " << display[j * w + i].w() << "] should be [" << expected.x() << ", " << expected.y()
 295                                                 << ", " << expected.z() << ", " << expected.w() << "]." << tcu::TestLog::EndMessage;
 296                                         return false;
 297                                 }
 298                         }
 299                 }
 300
 301                 return true;
 302         }
 303
 304         bool ValidateReadBufferCenteredQuad(int width, int height, const vec3& expected)
 305         {
 306                 bool                      result = true;
 307                 std::vector<vec3> fb(width * height);
 308                 glReadPixels(0, 0, width, height, GL_RGB, GL_FLOAT, &fb[0]);
 309
 310                 int startx = int(((float)width * 0.1f) + 1);
 311                 int starty = int(((float)height * 0.1f) + 1);
 312                 int endx   = int((float)width - 2 * (((float)width * 0.1f) + 1) - 1);
 313                 int endy   = int((float)height - 2 * (((float)height * 0.1f) + 1) - 1);
 314
 315                 for (int y = starty; y < endy; ++y)
 316                 {
 317                         for (int x = startx; x < endx; ++x)
 318                         {
 319                                 const int idx = y * width + x;
 320                                 if (!ColorEqual(fb[idx], expected, g_color_eps))
 321                                 {
 322                                         return false;
 323                                 }
 324                         }
 325                 }
 326
 327                 if (!ColorEqual(fb[2 * width + 2], vec3(0), g_color_eps))
 328                 {
 329                         result = false;
 330                 }
 331                 if (!ColorEqual(fb[2 * width + (width - 3)], vec3(0), g_color_eps))
 332                 {
 333                         result = false;
 334                 }
 335                 if (!ColorEqual(fb[(height - 3) * width + (width - 3)], vec3(0), g_color_eps))
 336                 {
 337                         result = false;
 338                 }
 339                 if (!ColorEqual(fb[(height - 3) * width + 2], vec3(0), g_color_eps))
 340                 {
 341                         result = false;
 342                 }
 343
 344                 return result;
 345         }
 346
 347         int getWindowWidth()
 348         {
 349                 return renderTarget.getWidth();
 350         }
 351
 352         int getWindowHeight()
 353         {
 354                 return renderTarget.getHeight();
 355         }
 356
 357         bool ValidateWindow4Quads(const vec3& lb, const vec3& rb, const vec3& rt, const vec3& lt)
 358         {
 359                 int                               width  = 100;
 360                 int                               height = 100;
 361                 std::vector<vec3> fb(width * height);
 362                 glReadPixels(0, 0, width, height, GL_RGB, GL_FLOAT, &fb[0]);
 363
 364                 bool status = true;
 365
 366                 // left-bottom quad
 367                 for (int y = 10; y < height / 2 - 10; ++y)
 368                 {
 369                         for (int x = 10; x < width / 2 - 10; ++x)
 370                         {
 371                                 const int idx = y * width + x;
 372                                 if (!ColorEqual(fb[idx], lb, g_color_eps))
 373                                 {
 374                                         m_context.getTestContext().getLog()
 375                                                 << tcu::TestLog::Message << "First bad color (" << x << ", " << y << "): " << fb[idx].x() << " "
 376                                                 << fb[idx].y() << " " << fb[idx].z() << tcu::TestLog::EndMessage;
 377                                         status = false;
 378                                 }
 379                         }
 380                 }
 381                 // right-bottom quad
 382                 for (int y = 10; y < height / 2 - 10; ++y)
 383                 {
 384                         for (int x = width / 2 + 10; x < width - 10; ++x)
 385                         {
 386                                 const int idx = y * width + x;
 387                                 if (!ColorEqual(fb[idx], rb, g_color_eps))
 388                                 {
 389                                         m_context.getTestContext().getLog()
 390                                                 << tcu::TestLog::Message << "Bad color at (" << x << ", " << y << "): " << fb[idx].x() << " "
 391                                                 << fb[idx].y() << " " << fb[idx].z() << tcu::TestLog::EndMessage;
 392                                         status = false;
 393                                 }
 394                         }
 395                 }
 396                 // right-top quad
 397                 for (int y = height / 2 + 10; y < height - 10; ++y)
 398                 {
 399                         for (int x = width / 2 + 10; x < width - 10; ++x)
 400                         {
 401                                 const int idx = y * width + x;
 402                                 if (!ColorEqual(fb[idx], rt, g_color_eps))
 403                                 {
 404                                         m_context.getTestContext().getLog()
 405                                                 << tcu::TestLog::Message << "Bad color at (" << x << ", " << y << "): " << fb[idx].x() << " "
 406                                                 << fb[idx].y() << " " << fb[idx].z() << tcu::TestLog::EndMessage;
 407                                         status = false;
 408                                 }
 409                         }
 410                 }
 411                 // left-top quad
 412                 for (int y = height / 2 + 10; y < height - 10; ++y)
 413                 {
 414                         for (int x = 10; x < width / 2 - 10; ++x)
 415                         {
 416                                 const int idx = y * width + x;
 417                                 if (!ColorEqual(fb[idx], lt, g_color_eps))
 418                                 {
 419                                         m_context.getTestContext().getLog()
 420                                                 << tcu::TestLog::Message << "Bad color at (" << x << ", " << y << "): " << fb[idx].x() << " "
 421                                                 << fb[idx].y() << " " << fb[idx].z() << tcu::TestLog::EndMessage;
 422                                         status = false;
 423                                 }
 424                         }
 425                 }
 426                 // middle horizontal line should be black
 427                 for (int y = height / 2 - 2; y < height / 2 + 2; ++y)
 428                 {
 429                         for (int x = 0; x < width; ++x)
 430                         {
 431                                 const int idx = y * width + x;
 432                                 if (!ColorEqual(fb[idx], vec3(0), g_color_eps))
 433                                 {
 434                                         m_context.getTestContext().getLog()
 435                                                 << tcu::TestLog::Message << "Bad color at (" << x << ", " << y << "): " << fb[idx].x() << " "
 436                                                 << fb[idx].y() << " " << fb[idx].z() << tcu::TestLog::EndMessage;
 437                                         status = false;
 438                                 }
 439                         }
 440                 }
 441                 // middle vertical line should be black
 442                 for (int y = 0; y < height; ++y)
 443                 {
 444                         for (int x = width / 2 - 2; x < width / 2 + 2; ++x)
 445                         {
 446                                 const int idx = y * width + x;
 447                                 if (!ColorEqual(fb[idx], vec3(0), g_color_eps))
 448                                 {
 449                                         m_context.getTestContext().getLog()
 450                                                 << tcu::TestLog::Message << "Bad color at (" << x << ", " << y << "): " << fb[idx].x() << " "
 451                                                 << fb[idx].y() << " " << fb[idx].z() << tcu::TestLog::EndMessage;
 452                                         status = false;
 453                                 }
 454                         }
 455                 }
 456
 457                 return status;
 458         }
 459
 460         bool IsEqual(vec4 a, vec4 b)
 461         {
 462                 return (a.x() == b.x()) && (a.y() == b.y()) && (a.z() == b.z()) && (a.w() == b.w());
 463         }
 464
 465         bool IsEqual(uvec4 a, uvec4 b)
 466         {
 467                 return (a.x() == b.x()) && (a.y() == b.y()) && (a.z() == b.z()) && (a.w() == b.w());
 468         }
 469 };
 470
 471 class SimpleCompute : public ComputeShaderBase
 472 {
 473
 474         virtual std::string Title()
 475         {
 476                 return "Simplest possible Compute Shader";
 477         }
 478
 479         virtual std::string Purpose()
 480         {
 481                 return "1. Verify that CS can be created, compiled and linked.\n"
 482                            "2. Verify that local work size can be queried with GetProgramiv command.\n"
 483                            "3. Verify that CS can be dispatched with DispatchCompute command.\n"
 484                            "4. Verify that CS can write to SSBO.";
 485         }
 486
 487         virtual std::string Method()
 488         {
 489                 return "Create and dispatch CS. Verify SSBO content.";
 490         }
 491
 492         virtual std::string PassCriteria()
 493         {
 494                 return "Everything works as expected.";
 495         }
 496
 497         GLuint m_program;
 498         GLuint m_buffer;
 499
 500         virtual long Setup()
 501         {
 502
 503                 const char* const glsl_cs =
 504                         NL "layout(local_size_x = 1, local_size_y = 1) in;" NL "layout(std430) buffer Output {" NL "  vec4 data;" NL
 505                            "} g_out;" NL "void main() {" NL "  g_out.data = vec4(1.0, 2.0, 3.0, 4.0);" NL "}";
 506                 m_program = CreateComputeProgram(glsl_cs);
 507                 glLinkProgram(m_program);
 508                 if (!CheckProgram(m_program))
 509                         return ERROR;
 510
 511                 GLint v[3];
 512                 glGetProgramiv(m_program, GL_COMPUTE_WORK_GROUP_SIZE, v);
 513                 if (v[0] != 1 || v[1] != 1 || v[2] != 1)
 514                 {
 515                         m_context.getTestContext().getLog()
 516                                 << tcu::TestLog::Message << "Got " << v[0] << ", " << v[1] << ", " << v[2]
 517                                 << ", expected: 1, 1, 1 in GL_COMPUTE_WORK_GROUP_SIZE check" << tcu::TestLog::EndMessage;
 518                         return ERROR;
 519                 }
 520
 521                 glGenBuffers(1, &m_buffer);
 522                 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_buffer);
 523                 glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(vec4), NULL, GL_DYNAMIC_DRAW);
 524                 glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
 525
 526                 return NO_ERROR;
 527         }
 528
 529         virtual long Run()
 530         {
 531                 glUseProgram(m_program);
 532                 glDispatchCompute(1, 1, 1);
 533
 534                 vec4* data;
 535                 glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_buffer);
 536                 glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
 537                 data       = static_cast<vec4*>(glMapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, sizeof(vec4), GL_MAP_READ_BIT));
 538                 long error = NO_ERROR;
 539                 if (!IsEqual(data[0], vec4(1.0f, 2.0f, 3.0f, 4.0f)))
 540                 {
 541                         error = ERROR;
 542                 }
 543                 glUnmapBuffer(GL_SHADER_STORAGE_BUFFER);
 544                 glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
 545                 return error;
 546         }
 547
 548         virtual long Cleanup()
 549         {
 550                 glUseProgram(0);
 551                 glDeleteProgram(m_program);
 552                 glDeleteBuffers(1, &m_buffer);
 553                 return NO_ERROR;
 554         }
 555 };
 556
 557 class BasicOneWorkGroup : public ComputeShaderBase
 558 {
 559
 560         virtual std::string Title()
 561         {
 562                 return "One work group with various local sizes";
 563         }
 564
 565         virtual std::string Purpose()
 566         {
 567                 return NL "1. Verify that declared local work size has correct effect." NL
 568                                   "2. Verify that the number of shader invocations is correct." NL
 569                                   "3. Verify that the built-in variables: gl_WorkGroupSize, gl_WorkGroupID, gl_GlobalInvocationID," NL
 570                                   "    gl_LocalInvocationID and gl_LocalInvocationIndex has correct values." NL
 571                                   "4. Verify that DispatchCompute and DispatchComputeIndirect commands work as expected.";
 572         }
 573
 574         virtual std::string Method()
 575         {
 576                 return NL "1. Create several CS with various local sizes." NL
 577                                   "2. Dispatch each CS with DispatchCompute and DispatchComputeIndirect commands." NL
 578                                   "3. Verify SSBO content.";
 579         }
 580
 581         virtual std::string PassCriteria()
 582         {
 583                 return "Everything works as expected.";
 584         }
 585
 586         GLuint m_program;
 587         GLuint m_storage_buffer;
 588         GLuint m_dispatch_buffer;
 589
 590         std::string GenSource(int x, int y, int z, GLuint binding)
 591         {
 592                 std::stringstream ss;
 593                 ss << NL "layout(local_size_x = " << x << ", local_size_y = " << y << ", local_size_z = " << z
 594                    << ") in;" NL "layout(std430, binding = " << binding
 595                    << ") buffer Output {" NL "  uvec4 local_id[];" NL "} g_out;" NL "void main() {" NL
 596                           "  if (gl_WorkGroupSize == uvec3("
 597                    << x << ", " << y << ", " << z
 598                    << ") && gl_WorkGroupID == uvec3(0) &&" NL "      gl_GlobalInvocationID == gl_LocalInvocationID) {" NL
 599                           "    g_out.local_id[gl_LocalInvocationIndex] = uvec4(gl_LocalInvocationID, 0);" NL "  } else {" NL
 600                           "    g_out.local_id[gl_LocalInvocationIndex] = uvec4(0xffff);" NL "  }" NL "}";
 601                 return ss.str();
 602         }
 603
 604         bool RunIteration(int local_size_x, int local_size_y, int local_size_z, GLuint binding, bool dispatch_indirect)
 605         {
 606                 if (m_program != 0)
 607                         glDeleteProgram(m_program);
 608                 m_program = CreateComputeProgram(GenSource(local_size_x, local_size_y, local_size_z, binding));
 609                 glLinkProgram(m_program);
 610                 if (!CheckProgram(m_program))
 611                         return false;
 612
 613                 GLint v[3];
 614                 glGetProgramiv(m_program, GL_COMPUTE_WORK_GROUP_SIZE, v);
 615                 if (v[0] != local_size_x || v[1] != local_size_y || v[2] != local_size_z)
 616                 {
 617                         m_context.getTestContext().getLog()
 618                                 << tcu::TestLog::Message << "GL_COMPUTE_LOCAL_WORK_SIZE is (" << v[0] << " " << v[1] << " " << v[2]
 619                                 << ") should be (" << local_size_x << " " << local_size_y << " " << local_size_z << ")"
 620                                 << tcu::TestLog::EndMessage;
 621                         return false;
 622                 }
 623
 624                 const int kSize = local_size_x * local_size_y * local_size_z;
 625
 626                 if (m_storage_buffer == 0)
 627                         glGenBuffers(1, &m_storage_buffer);
 628                 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, binding, m_storage_buffer);
 629                 glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(uvec4) * kSize, NULL, GL_DYNAMIC_DRAW);
 630                 glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
 631
 632                 glUseProgram(m_program);
 633                 if (dispatch_indirect)
 634                 {
 635                         const GLuint num_groups[3] = { 1, 1, 1 };
 636                         if (m_dispatch_buffer == 0)
 637                                 glGenBuffers(1, &m_dispatch_buffer);
 638                         glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, m_dispatch_buffer);
 639                         glBufferData(GL_DISPATCH_INDIRECT_BUFFER, sizeof(num_groups), num_groups, GL_STATIC_DRAW);
 640                         glDispatchComputeIndirect(0);
 641                 }
 642                 else
 643                 {
 644                         glDispatchCompute(1, 1, 1);
 645                 }
 646
 647                 uvec4* data;
 648                 glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_storage_buffer);
 649                 glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
 650                 data =
 651                         static_cast<uvec4*>(glMapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, kSize * sizeof(uvec4), GL_MAP_READ_BIT));
 652
 653                 bool ret = true;
 654
 655                 for (int z = 0; z < local_size_z; ++z)
 656                 {
 657                         for (int y = 0; y < local_size_y; ++y)
 658                         {
 659                                 for (int x = 0; x < local_size_x; ++x)
 660                                 {
 661                                         const int index = z * local_size_x * local_size_y + y * local_size_x + x;
 662                                         if (!IsEqual(data[index], uvec4(x, y, z, 0)))
 663                                         {
 664                                                 m_context.getTestContext().getLog()
 665                                                         << tcu::TestLog::Message << "Invalid data at offset " << index << tcu::TestLog::EndMessage;
 666                                                 ret = false;
 667                                         }
 668                                 }
 669                         }
 670                 }
 671                 glUnmapBuffer(GL_SHADER_STORAGE_BUFFER);
 672                 glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
 673                 return ret;
 674         }
 675
 676         virtual long Setup()
 677         {
 678                 m_program                 = 0;
 679                 m_storage_buffer  = 0;
 680                 m_dispatch_buffer = 0;
 681                 return NO_ERROR;
 682         }
 683
 684         virtual long Run()
 685         {
 686                 if (!RunIteration(16, 1, 1, 0, true))
 687                         return ERROR;
 688                 if (!RunIteration(8, 8, 1, 1, false))
 689                         return ERROR;
 690                 if (!RunIteration(4, 4, 4, 2, true))
 691                         return ERROR;
 692                 if (!RunIteration(1, 2, 3, 3, false))
 693                         return ERROR;
 694                 if (!RunIteration(1024, 1, 1, 3, true))
 695                         return ERROR;
 696                 if (!RunIteration(16, 8, 8, 3, false))
 697                         return ERROR;
 698                 if (!RunIteration(32, 1, 32, 7, true))
 699                         return ERROR;
 700                 return NO_ERROR;
 701         }
 702
 703         virtual long Cleanup()
 704         {
 705                 glUseProgram(0);
 706                 glDeleteProgram(m_program);
 707                 glDeleteBuffers(1, &m_storage_buffer);
 708                 glDeleteBuffers(1, &m_dispatch_buffer);
 709                 return NO_ERROR;
 710         }
 711 };
 712
 713 class BasicResourceUBO : public ComputeShaderBase
 714 {
 715
 716         virtual std::string Title()
 717         {
 718                 return "Compute Shader resources - UBOs";
 719         }
 720
 721         virtual std::string Purpose()
 722         {
 723                 return "Verify that CS is able to read data from UBOs and write it to SSBO.";
 724         }
 725
 726         virtual std::string Method()
 727         {
 728                 return NL "1. Create CS which uses array of UBOs." NL
 729                                   "2. Dispatch CS with DispatchCompute and DispatchComputeIndirect commands." NL
 730                                   "3. Read data from each UBO and write it to SSBO." NL "4. Verify SSBO content." NL
 731                                   "5. Repeat for different buffer and CS work sizes.";
 732         }
 733
 734         virtual std::string PassCriteria()
 735         {
 736                 return "Everything works as expected.";
 737         }
 738
 739         GLuint m_program;
 740         GLuint m_storage_buffer;
 741         GLuint m_uniform_buffer[12];
 742         GLuint m_dispatch_buffer;
 743
 744         std::string GenSource(const uvec3& local_size, const uvec3& num_groups)
 745         {
 746                 const uvec3               global_size = local_size * num_groups;
 747                 std::stringstream ss;
 748                 ss << NL "layout(local_size_x = " << local_size.x() << ", local_size_y = " << local_size.y()
 749                    << ", local_size_z = " << local_size.z() << ") in;" NL "const uvec3 kGlobalSize = uvec3(" << global_size.x()
 750                    << ", " << global_size.y() << ", " << global_size.z()
 751                    << ");" NL "layout(std140) uniform InputBuffer {" NL "  vec4 data["
 752                    << global_size.x() * global_size.y() * global_size.z()
 753                    << "];" NL "} g_in_buffer[12];" NL "layout(std430) buffer OutputBuffer {" NL "  vec4 data0["
 754                    << global_size.x() * global_size.y() * global_size.z() << "];" NL "  vec4 data1["
 755                    << global_size.x() * global_size.y() * global_size.z() << "];" NL "  vec4 data2["
 756                    << global_size.x() * global_size.y() * global_size.z() << "];" NL "  vec4 data3["
 757                    << global_size.x() * global_size.y() * global_size.z() << "];" NL "  vec4 data4["
 758                    << global_size.x() * global_size.y() * global_size.z() << "];" NL "  vec4 data5["
 759                    << global_size.x() * global_size.y() * global_size.z() << "];" NL "  vec4 data6["
 760                    << global_size.x() * global_size.y() * global_size.z() << "];" NL "  vec4 data7["
 761                    << global_size.x() * global_size.y() * global_size.z() << "];" NL "  vec4 data8["
 762                    << global_size.x() * global_size.y() * global_size.z() << "];" NL "  vec4 data9["
 763                    << global_size.x() * global_size.y() * global_size.z() << "];" NL "  vec4 data10["
 764                    << global_size.x() * global_size.y() * global_size.z() << "];" NL "  vec4 data11["
 765                    << global_size.x() * global_size.y() * global_size.z()
 766                    << "];" NL "} g_out_buffer;" NL "void main() {" NL "  const uint global_index = gl_GlobalInvocationID.x +" NL
 767                           "                            gl_GlobalInvocationID.y * kGlobalSize.x +" NL
 768                           "                            gl_GlobalInvocationID.z * kGlobalSize.x * kGlobalSize.y;" NL
 769                           "  g_out_buffer.data0[global_index] = g_in_buffer[0].data[global_index];" NL
 770                           "  g_out_buffer.data1[global_index] = g_in_buffer[1].data[global_index];" NL
 771                           "  g_out_buffer.data2[global_index] = g_in_buffer[2].data[global_index];" NL
 772                           "  g_out_buffer.data3[global_index] = g_in_buffer[3].data[global_index];" NL
 773                           "  g_out_buffer.data4[global_index] = g_in_buffer[4].data[global_index];" NL
 774                           "  g_out_buffer.data5[global_index] = g_in_buffer[5].data[global_index];" NL
 775                           "  g_out_buffer.data6[global_index] = g_in_buffer[6].data[global_index];" NL
 776                           "  g_out_buffer.data7[global_index] = g_in_buffer[7].data[global_index];" NL
 777                           "  g_out_buffer.data8[global_index] = g_in_buffer[8].data[global_index];" NL
 778                           "  g_out_buffer.data9[global_index] = g_in_buffer[9].data[global_index];" NL
 779                           "  g_out_buffer.data10[global_index] = g_in_buffer[10].data[global_index];" NL
 780                           "  g_out_buffer.data11[global_index] = g_in_buffer[11].data[global_index];" NL "}";
 781                 return ss.str();
 782         }
 783
 784         bool RunIteration(const uvec3& local_size, const uvec3& num_groups, bool dispatch_indirect)
 785         {
 786                 if (m_program != 0)
 787                         glDeleteProgram(m_program);
 788                 m_program = CreateComputeProgram(GenSource(local_size, num_groups));
 789                 glLinkProgram(m_program);
 790                 if (!CheckProgram(m_program))
 791                         return false;
 792
 793                 for (GLuint i = 0; i < 12; ++i)
 794                 {
 795                         char name[32];
 796                         sprintf(name, "InputBuffer[%u]", i);
 797                         const GLuint index = glGetUniformBlockIndex(m_program, name);
 798                         glUniformBlockBinding(m_program, index, i);
 799                         GLint p = 0;
 800                         glGetActiveUniformBlockiv(m_program, index, GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER, &p);
 801                         if (p == GL_FALSE)
 802                         {
 803                                 m_context.getTestContext().getLog()
 804                                         << tcu::TestLog::Message << "UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER should be TRUE."
 805                                         << tcu::TestLog::EndMessage;
 806                                 return false;
 807                         }
 808                 }
 809
 810                 const GLuint kBufferSize =
 811                         local_size.x() * num_groups.x() * local_size.y() * num_groups.y() * local_size.z() * num_groups.z();
 812
 813                 if (m_storage_buffer == 0)
 814                         glGenBuffers(1, &m_storage_buffer);
 815                 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_storage_buffer);
 816                 glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(vec4) * kBufferSize * 12, NULL, GL_DYNAMIC_DRAW);
 817                 glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
 818
 819                 if (m_uniform_buffer[0] == 0)
 820                         glGenBuffers(12, m_uniform_buffer);
 821                 for (GLuint i = 0; i < 12; ++i)
 822                 {
 823                         std::vector<vec4> data(kBufferSize);
 824                         for (GLuint j = 0; j < kBufferSize; ++j)
 825                         {
 826                                 data[j] = vec4(static_cast<float>(i * kBufferSize + j));
 827                         }
 828                         glBindBufferBase(GL_UNIFORM_BUFFER, i, m_uniform_buffer[i]);
 829                         glBufferData(GL_UNIFORM_BUFFER, sizeof(vec4) * kBufferSize, &data[0], GL_DYNAMIC_DRAW);
 830                 }
 831                 glBindBuffer(GL_UNIFORM_BUFFER, 0);
 832
 833                 glUseProgram(m_program);
 834                 if (dispatch_indirect)
 835                 {
 836                         if (m_dispatch_buffer == 0)
 837                                 glGenBuffers(1, &m_dispatch_buffer);
 838                         glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, m_dispatch_buffer);
 839                         glBufferData(GL_DISPATCH_INDIRECT_BUFFER, sizeof(num_groups), &num_groups[0], GL_STATIC_DRAW);
 840                         glDispatchComputeIndirect(0);
 841                 }
 842                 else
 843                 {
 844                         glDispatchCompute(num_groups.x(), num_groups.y(), num_groups.z());
 845                 }
 846
 847                 std::vector<vec4> data(kBufferSize * 12);
 848                 glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_storage_buffer);
 849                 glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
 850                 glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(vec4) * kBufferSize * 12, &data[0]);
 851
 852                 for (GLuint z = 0; z < local_size.z() * num_groups.z(); ++z)
 853                 {
 854                         for (GLuint y = 0; y < local_size.y() * num_groups.y(); ++y)
 855                         {
 856                                 for (GLuint x = 0; x < local_size.x() * num_groups.x(); ++x)
 857                                 {
 858                                         const GLuint index = z * local_size.x() * num_groups.x() * local_size.y() * num_groups.y() +
 859                                                                                  y * local_size.x() * num_groups.x() + x;
 860                                         for (int i = 0; i < 1; ++i)
 861                                         {
 862                                                 if (!IsEqual(data[index * 12 + i], vec4(static_cast<float>(index * 12 + i))))
 863                                                 {
 864                                                         m_context.getTestContext().getLog() << tcu::TestLog::Message << "Incorrect data at offset "
 865                                                                                                                                 << index * 12 + i << "." << tcu::TestLog::EndMessage;
 866                                                         return false;
 867                                                 }
 868                                         }
 869                                 }
 870                         }
 871                 }
 872                 return true;
 873         }
 874
 875         virtual long Setup()
 876         {
 877                 m_program                = 0;
 878                 m_storage_buffer = 0;
 879                 memset(m_uniform_buffer, 0, sizeof(m_uniform_buffer));
 880                 m_dispatch_buffer = 0;
 881                 return NO_ERROR;
 882         }
 883
 884         virtual long Run()
 885         {
 886                 if (!RunIteration(uvec3(64, 1, 1), uvec3(8, 1, 1), false))
 887                         return ERROR;
 888                 if (!RunIteration(uvec3(2, 2, 2), uvec3(2, 2, 2), true))
 889                         return ERROR;
 890                 if (!RunIteration(uvec3(2, 4, 2), uvec3(2, 4, 1), false))
 891                         return ERROR;
 892                 return NO_ERROR;
 893         }
 894
 895         virtual long Cleanup()
 896         {
 897                 glUseProgram(0);
 898                 glDeleteProgram(m_program);
 899                 glDeleteBuffers(1, &m_storage_buffer);
 900                 glDeleteBuffers(12, m_uniform_buffer);
 901                 glDeleteBuffers(1, &m_dispatch_buffer);
 902                 return NO_ERROR;
 903         }
 904 };
 905
 906 class BasicResourceTexture : public ComputeShaderBase
 907 {
 908
 909         virtual std::string Title()
 910         {
 911                 return NL "Compute Shader resources - Textures";
 912         }
 913
 914         virtual std::string Purpose()
 915         {
 916                 return NL "Verify that texture access works correctly in CS.";
 917         }
 918
 919         virtual std::string Method()
 920         {
 921                 return NL "1. Create CS which uses all sampler types (sampler1D, sampler2D, sampler3D, sampler2DRect," NL
 922                                   "    sampler1DArray, sampler2DArray, samplerBuffer, sampler2DMS, sampler2DMSArray)." NL
 923                                   "2. Dispatch CS with DispatchCompute and DispatchComputeIndirect commands." NL
 924                                   "3. Sample each texture and write sampled value to SSBO." NL "4. Verify SSBO content." NL
 925                                   "5. Repeat for different texture and CS work sizes.";
 926         }
 927
 928         virtual std::string PassCriteria()
 929         {
 930                 return NL "Everything works as expected.";
 931         }
 932
 933         GLuint m_program;
 934         GLuint m_storage_buffer;
 935         GLuint m_texture[9];
 936         GLuint m_texture_buffer;
 937         GLuint m_dispatch_buffer;
 938
 939         std::string GenSource(const uvec3& local_size, const uvec3& num_groups)
 940         {
 941                 const uvec3               global_size = local_size * num_groups;
 942                 std::stringstream ss;
 943                 ss << NL "layout(local_size_x = " << local_size.x() << ", local_size_y = " << local_size.y()
 944                    << ", local_size_z = " << local_size.z() << ") in;" NL "const uvec3 kGlobalSize = uvec3(" << global_size.x()
 945                    << ", " << global_size.y() << ", " << global_size.z()
 946                    << ");" NL "uniform sampler1D g_sampler0;" NL "uniform sampler2D g_sampler1;" NL
 947                           "uniform sampler3D g_sampler2;" NL "uniform sampler2DRect g_sampler3;" NL
 948                           "uniform sampler1DArray g_sampler4;" NL "uniform sampler2DArray g_sampler5;" NL
 949                           "uniform samplerBuffer g_sampler6;" NL "uniform sampler2DMS g_sampler7;" NL
 950                           "uniform sampler2DMSArray g_sampler8;" NL "layout(std430) buffer OutputBuffer {" NL "  vec4 data0["
 951                    << global_size.x() * global_size.y() * global_size.z() << "];" NL "  vec4 data1["
 952                    << global_size.x() * global_size.y() * global_size.z() << "];" NL "  vec4 data2["
 953                    << global_size.x() * global_size.y() * global_size.z() << "];" NL "  vec4 data3["
 954                    << global_size.x() * global_size.y() * global_size.z() << "];" NL "  vec4 data4["
 955                    << global_size.x() * global_size.y() * global_size.z() << "];" NL "  vec4 data5["
 956                    << global_size.x() * global_size.y() * global_size.z() << "];" NL "  vec4 data6["
 957                    << global_size.x() * global_size.y() * global_size.z() << "];" NL "  vec4 data7["
 958                    << global_size.x() * global_size.y() * global_size.z() << "];" NL "  vec4 data8["
 959                    << global_size.x() * global_size.y() * global_size.z()
 960                    << "];" NL "} g_out_buffer;" NL "void main() {" NL "  const uint global_index = gl_GlobalInvocationID.x +" NL
 961                           "                            gl_GlobalInvocationID.y * kGlobalSize.x +" NL
 962                           "                            gl_GlobalInvocationID.z * kGlobalSize.x * kGlobalSize.y;" NL
 963                           "  g_out_buffer.data0[global_index] = texelFetch(g_sampler0, int(gl_GlobalInvocationID), 0);" NL
 964                           "  g_out_buffer.data1[global_index] = texture(g_sampler1, vec2(gl_GlobalInvocationID) / "
 965                           "vec2(kGlobalSize));" NL "  g_out_buffer.data2[global_index] = textureProj(g_sampler2, "
 966                           "vec4(vec3(gl_GlobalInvocationID) / vec3(kGlobalSize), 1.0));" NL
 967                           "  g_out_buffer.data3[global_index] = textureProjOffset(g_sampler3, vec3(vec2(gl_GlobalInvocationID), "
 968                           "1.0), ivec2(0));" NL "  g_out_buffer.data4[global_index] = textureLodOffset(g_sampler4, "
 969                           "vec2(gl_GlobalInvocationID.x / kGlobalSize.x, gl_GlobalInvocationID.y), 0.0, "
 970                           "0);" NL "  g_out_buffer.data5[global_index] = texelFetchOffset(g_sampler5, "
 971                           "ivec3(gl_GlobalInvocationID), 0, ivec2(0));" NL
 972                           "  g_out_buffer.data6[global_index] = texelFetch(g_sampler6, int(global_index));" NL
 973                           "  g_out_buffer.data7[global_index] = texelFetch(g_sampler7, ivec2(gl_GlobalInvocationID), 1);" NL
 974                           "  g_out_buffer.data8[global_index] = texelFetch(g_sampler8, ivec3(gl_GlobalInvocationID), 2);" NL "}";
 975                 return ss.str();
 976         }
 977
 978         bool RunIteration(const uvec3& local_size, const uvec3& num_groups, bool dispatch_indirect)
 979         {
 980                 if (m_program != 0)
 981                         glDeleteProgram(m_program);
 982                 m_program = CreateComputeProgram(GenSource(local_size, num_groups));
 983                 glLinkProgram(m_program);
 984                 if (!CheckProgram(m_program))
 985                         return false;
 986
 987                 glUseProgram(m_program);
 988                 for (int i = 0; i < 9; ++i)
 989                 {
 990                         char name[32];
 991                         sprintf(name, "g_sampler%d", i);
 992                         glUniform1i(glGetUniformLocation(m_program, name), i);
 993                 }
 994                 glUseProgram(0);
 995
 996                 const GLuint kBufferSize =
 997                         local_size.x() * num_groups.x() * local_size.y() * num_groups.y() * local_size.z() * num_groups.z();
 998                 const GLint kWidth  = static_cast<GLint>(local_size.x() * num_groups.x());
 999                 const GLint kHeight = static_cast<GLint>(local_size.y() * num_groups.y());
1000                 const GLint kDepth  = static_cast<GLint>(local_size.z() * num_groups.z());
1001
1002                 std::vector<vec4> buffer_data(kBufferSize * 9);
1003                 if (m_storage_buffer == 0)
1004                         glGenBuffers(1, &m_storage_buffer);
1005                 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_storage_buffer);
1006                 glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(vec4) * kBufferSize * 9, &buffer_data[0], GL_DYNAMIC_DRAW);
1007                 glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
1008
1009                 std::vector<vec4> texture_data(kBufferSize, vec4(123.0f));
1010                 if (m_texture[0] == 0)
1011                         glGenTextures(9, m_texture);
1012                 if (m_texture_buffer == 0)
1013                         glGenBuffers(1, &m_texture_buffer);
1014
1015                 glActiveTexture(GL_TEXTURE0);
1016                 glBindTexture(GL_TEXTURE_1D, m_texture[0]);
1017                 glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1018                 glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1019                 glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA32F, kWidth, 0, GL_RGBA, GL_FLOAT, &texture_data[0]);
1020
1021                 glActiveTexture(GL_TEXTURE1);
1022                 glBindTexture(GL_TEXTURE_2D, m_texture[1]);
1023                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1024                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1025                 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, kWidth, kHeight, 0, GL_RGBA, GL_FLOAT, &texture_data[0]);
1026
1027                 glActiveTexture(GL_TEXTURE2);
1028                 glBindTexture(GL_TEXTURE_3D, m_texture[2]);
1029                 glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1030                 glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1031                 glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA32F, kWidth, kHeight, kDepth, 0, GL_RGBA, GL_FLOAT, &texture_data[0]);
1032
1033                 glActiveTexture(GL_TEXTURE3);
1034                 glBindTexture(GL_TEXTURE_RECTANGLE, m_texture[3]);
1035                 glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1036                 glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1037                 glTexImage2D(GL_TEXTURE_RECTANGLE, 0, GL_RGBA32F, kWidth, kHeight, 0, GL_RGBA, GL_FLOAT, &texture_data[0]);
1038
1039                 glActiveTexture(GL_TEXTURE4);
1040                 glBindTexture(GL_TEXTURE_1D_ARRAY, m_texture[4]);
1041                 glTexParameteri(GL_TEXTURE_1D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1042                 glTexParameteri(GL_TEXTURE_1D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1043                 glTexImage2D(GL_TEXTURE_1D_ARRAY, 0, GL_RGBA32F, kWidth, kHeight, 0, GL_RGBA, GL_FLOAT, &texture_data[0]);
1044
1045                 glActiveTexture(GL_TEXTURE5);
1046                 glBindTexture(GL_TEXTURE_2D_ARRAY, m_texture[5]);
1047                 glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1048                 glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1049                 glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA32F, kWidth, kHeight, kDepth, 0, GL_RGBA, GL_FLOAT,
1050                                          &texture_data[0]);
1051
1052                 glActiveTexture(GL_TEXTURE6);
1053                 glBindBuffer(GL_TEXTURE_BUFFER, m_texture_buffer);
1054                 glBufferData(GL_TEXTURE_BUFFER, kBufferSize * sizeof(vec4), &texture_data[0], GL_DYNAMIC_DRAW);
1055                 glBindBuffer(GL_TEXTURE_BUFFER, 0);
1056                 glBindTexture(GL_TEXTURE_BUFFER, m_texture[6]);
1057                 glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32F, m_texture_buffer);
1058
1059                 glActiveTexture(GL_TEXTURE7);
1060                 glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, m_texture[7]);
1061                 glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, 4, GL_RGBA32F, kWidth, kHeight, GL_FALSE);
1062
1063                 glActiveTexture(GL_TEXTURE8);
1064                 glBindTexture(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, m_texture[8]);
1065                 glTexImage3DMultisample(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, 4, GL_RGBA32F, kWidth, kHeight, kDepth, GL_FALSE);
1066
1067                 // clear MS textures
1068                 GLuint fbo;
1069                 glGenFramebuffers(1, &fbo);
1070                 glBindFramebuffer(GL_FRAMEBUFFER, fbo);
1071                 glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_texture[7], 0);
1072                 glClearBufferfv(GL_COLOR, 0, &vec4(123.0f)[0]);
1073                 glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_texture[8], 0);
1074                 glClearBufferfv(GL_COLOR, 0, &vec4(123.0f)[0]);
1075                 glDeleteFramebuffers(1, &fbo);
1076
1077                 glUseProgram(m_program);
1078                 if (dispatch_indirect)
1079                 {
1080                         if (m_dispatch_buffer == 0)
1081                                 glGenBuffers(1, &m_dispatch_buffer);
1082                         glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, m_dispatch_buffer);
1083                         glBufferData(GL_DISPATCH_INDIRECT_BUFFER, sizeof(num_groups), &num_groups[0], GL_STATIC_DRAW);
1084                         glDispatchComputeIndirect(0);
1085                 }
1086                 else
1087                 {
1088                         glDispatchCompute(num_groups.x(), num_groups.y(), num_groups.z());
1089                 }
1090
1091                 glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_storage_buffer);
1092                 glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
1093                 glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(vec4) * kBufferSize * 9, &buffer_data[0]);
1094                 for (GLuint index = 0; index < kBufferSize * 9; ++index)
1095                 {
1096                         if (!IsEqual(buffer_data[index], vec4(123.0f)))
1097                         {
1098                                 m_context.getTestContext().getLog()
1099                                         << tcu::TestLog::Message << "Incorrect data at index " << index << "." << tcu::TestLog::EndMessage;
1100                                 return false;
1101                         }
1102                 }
1103                 return true;
1104         }
1105
1106         virtual long Setup()
1107         {
1108                 m_program                = 0;
1109                 m_storage_buffer = 0;
1110                 memset(m_texture, 0, sizeof(m_texture));
1111                 m_texture_buffer  = 0;
1112                 m_dispatch_buffer = 0;
1113                 return NO_ERROR;
1114         }
1115
1116         virtual long Run()
1117         {
1118                 if (!RunIteration(uvec3(4, 4, 4), uvec3(8, 1, 1), false))
1119                         return ERROR;
1120                 if (!RunIteration(uvec3(2, 4, 2), uvec3(2, 4, 1), true))
1121                         return ERROR;
1122                 if (!RunIteration(uvec3(2, 2, 2), uvec3(2, 2, 2), false))
1123                         return ERROR;
1124                 return NO_ERROR;
1125         }
1126
1127         virtual long Cleanup()
1128         {
1129                 glActiveTexture(GL_TEXTURE0);
1130                 glUseProgram(0);
1131                 glDeleteProgram(m_program);
1132                 glDeleteBuffers(1, &m_storage_buffer);
1133                 glDeleteTextures(9, m_texture);
1134                 glDeleteBuffers(1, &m_texture_buffer);
1135                 glDeleteBuffers(1, &m_dispatch_buffer);
1136                 return NO_ERROR;
1137         }
1138 };
1139
1140 class BasicResourceImage : public ComputeShaderBase
1141 {
1142
1143         virtual std::string Title()
1144         {
1145                 return NL "Compute Shader resources - Images";
1146         }
1147
1148         virtual std::string Purpose()
1149         {
1150                 return NL "Verify that reading/writing GPU memory via image variables work as expected.";
1151         }
1152
1153         virtual std::string Method()
1154         {
1155                 return NL "1. Create CS which uses two image2D variables to read and write underlying GPU memory." NL
1156                                   "2. Dispatch CS with DispatchCompute and DispatchComputeIndirect commands." NL
1157                                   "3. Verify memory content." NL "4. Repeat for different texture and CS work sizes.";
1158         }
1159
1160         virtual std::string PassCriteria()
1161         {
1162                 return NL "Everything works as expected.";
1163         }
1164
1165         GLuint m_program;
1166         GLuint m_draw_program;
1167         GLuint m_texture[2];
1168         GLuint m_dispatch_buffer;
1169         GLuint m_vertex_array;
1170
1171         std::string GenSource(const uvec3& local_size, const uvec3& num_groups)
1172         {
1173                 const uvec3               global_size = local_size * num_groups;
1174                 std::stringstream ss;
1175                 ss << NL "layout(local_size_x = " << local_size.x() << ", local_size_y = " << local_size.y()
1176                    << ", local_size_z = " << local_size.z()
1177                    << ") in;" NL "layout(rgba32f) coherent uniform image2D g_image1;" NL
1178                           "layout(rgba32f) uniform image2D g_image2;" NL "const uvec3 kGlobalSize = uvec3("
1179                    << global_size.x() << ", " << global_size.y() << ", " << global_size.z()
1180                    << ");" NL "void main() {" NL
1181                           "  if (gl_GlobalInvocationID.x >= kGlobalSize.x || gl_GlobalInvocationID.y >= kGlobalSize.y) return;" NL
1182                           "  vec4 color = vec4(gl_GlobalInvocationID.x + gl_GlobalInvocationID.y) / 255.0;" NL
1183                           "  imageStore(g_image1, ivec2(gl_GlobalInvocationID), color);" NL
1184                           "  vec4 c = imageLoad(g_image1, ivec2(gl_GlobalInvocationID));" NL
1185                           "  imageStore(g_image2, ivec2(gl_GlobalInvocationID), c);" NL "}";
1186                 return ss.str();
1187         }
1188
1189         bool RunIteration(const uvec3& local_size, const uvec3& num_groups, bool dispatch_indirect)
1190         {
1191                 if (m_program != 0)
1192                         glDeleteProgram(m_program);
1193                 m_program = CreateComputeProgram(GenSource(local_size, num_groups));
1194                 glLinkProgram(m_program);
1195                 if (!CheckProgram(m_program))
1196                         return false;
1197
1198                 glUseProgram(m_program);
1199                 glUniform1i(glGetUniformLocation(m_program, "g_image1"), 0);
1200                 glUniform1i(glGetUniformLocation(m_program, "g_image2"), 1);
1201                 glUseProgram(0);
1202
1203                 const GLint  kWidth  = static_cast<GLint>(local_size.x() * num_groups.x());
1204                 const GLint  kHeight = static_cast<GLint>(local_size.y() * num_groups.y());
1205                 const GLint  kDepth  = static_cast<GLint>(local_size.z() * num_groups.z());
1206                 const GLuint kSize   = kWidth * kHeight * kDepth;
1207
1208                 std::vector<vec4> data(kSize);
1209                 if (m_texture[0] == 0)
1210                         glGenTextures(2, m_texture);
1211
1212                 for (int i = 0; i < 2; ++i)
1213                 {
1214                         glBindTexture(GL_TEXTURE_2D, m_texture[i]);
1215                         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1216                         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, kWidth, kHeight, 0, GL_RGBA, GL_FLOAT, &data[0]);
1217                 }
1218                 glBindTexture(GL_TEXTURE_2D, 0);
1219
1220                 glBindImageTexture(0, m_texture[0], 0, GL_FALSE, 0, GL_READ_WRITE, GL_RGBA32F);
1221                 glBindImageTexture(1, m_texture[1], 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA32F);
1222                 glUseProgram(m_program);
1223                 if (dispatch_indirect)
1224                 {
1225                         if (m_dispatch_buffer == 0)
1226                                 glGenBuffers(1, &m_dispatch_buffer);
1227                         glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, m_dispatch_buffer);
1228                         glBufferData(GL_DISPATCH_INDIRECT_BUFFER, sizeof(num_groups), &num_groups[0], GL_STATIC_DRAW);
1229                         glDispatchComputeIndirect(0);
1230                 }
1231                 else
1232                 {
1233                         glDispatchCompute(num_groups.x(), num_groups.y(), num_groups.z());
1234                 }
1235                 glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
1236
1237                 glClear(GL_COLOR_BUFFER_BIT);
1238                 glActiveTexture(GL_TEXTURE0);
1239                 glBindTexture(GL_TEXTURE_2D, m_texture[0]);
1240                 glActiveTexture(GL_TEXTURE1);
1241                 glBindTexture(GL_TEXTURE_2D, m_texture[1]);
1242                 glUseProgram(m_draw_program);
1243                 glBindVertexArray(m_vertex_array);
1244                 glViewport(0, 0, kWidth, kHeight);
1245                 glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4, 1);
1246
1247                 std::vector<vec4> display(kWidth * kHeight);
1248                 glReadPixels(0, 0, kWidth, kHeight, GL_RGBA, GL_FLOAT, &display[0]);
1249
1250                 for (int y = 0; y < kHeight; ++y)
1251                 {
1252                         for (int x = 0; x < kWidth; ++x)
1253                         {
1254                                 if (y >= getWindowHeight() || x >= getWindowWidth())
1255                                 {
1256                                         continue;
1257                                 }
1258                                 const vec4 c = vec4(float(y + x) / 255.0f);
1259                                 if (!ColorEqual(display[y * kWidth + x], c, g_color_eps))
1260                                 {
1261                                         m_context.getTestContext().getLog()
1262                                                 << tcu::TestLog::Message << "Got " << display[y * kWidth + x].x() << ", "
1263                                                 << display[y * kWidth + x].y() << ", " << display[y * kWidth + x].z() << ", "
1264                                                 << display[y * kWidth + x].w() << ", expected " << c.x() << ", " << c.y() << ", " << c.z()
1265                                                 << ", " << c.w() << " at " << x << ", " << y << tcu::TestLog::EndMessage;
1266                                         return false;
1267                                 }
1268                         }
1269                 }
1270
1271                 return true;
1272         }
1273
1274         virtual long Setup()
1275         {
1276                 m_program = 0;
1277                 memset(m_texture, 0, sizeof(m_texture));
1278                 m_dispatch_buffer = 0;
1279                 return NO_ERROR;
1280         }
1281
1282         virtual long Run()
1283         {
1284
1285                 const char* const glsl_vs =
1286                         NL "out StageData {" NL "  vec2 texcoord;" NL "} vs_out;" NL
1287                            "const vec2 g_quad[] = vec2[](vec2(-1, -1), vec2(1, -1), vec2(-1, 1), vec2(1, 1));" NL "void main() {" NL
1288                            "  gl_Position = vec4(g_quad[gl_VertexID], 0, 1);" NL
1289                            "  vs_out.texcoord = 0.5 + 0.5 * g_quad[gl_VertexID];" NL "}";
1290
1291                 const char* glsl_fs =
1292                         NL "in StageData {" NL "  vec2 texcoord;" NL "} fs_in;" NL "layout(location = 0) out vec4 o_color;" NL
1293                            "uniform sampler2D g_image1;" NL "uniform sampler2D g_image2;" NL "void main() {" NL
1294                            "  vec4 c1 = texture(g_image1, fs_in.texcoord);" NL "  vec4 c2 = texture(g_image2, fs_in.texcoord);" NL
1295                            "  if (c1 == c2) o_color = c1;" NL "  else o_color = vec4(1, 0, 0, 1);" NL "}";
1296
1297                 m_draw_program = CreateProgram(glsl_vs, glsl_fs);
1298                 glLinkProgram(m_draw_program);
1299                 if (!CheckProgram(m_draw_program))
1300                         return ERROR;
1301
1302                 glUseProgram(m_draw_program);
1303                 glUniform1i(glGetUniformLocation(m_draw_program, "g_image1"), 0);
1304                 glUniform1i(glGetUniformLocation(m_draw_program, "g_image2"), 1);
1305                 glUseProgram(0);
1306
1307                 glGenVertexArrays(1, &m_vertex_array);
1308
1309                 if (!pixelFormat.alphaBits)
1310                 {
1311                         m_context.getTestContext().getLog()
1312                                 << tcu::TestLog::Message << "Test requires default framebuffer alpha bits" << tcu::TestLog::EndMessage;
1313                         return NO_ERROR;
1314                 }
1315
1316                 if (!RunIteration(uvec3(8, 16, 1), uvec3(8, 4, 1), true))
1317                         return ERROR;
1318                 if (!RunIteration(uvec3(4, 32, 1), uvec3(16, 2, 1), false))
1319                         return ERROR;
1320                 if (!RunIteration(uvec3(16, 4, 1), uvec3(4, 16, 1), false))
1321                         return ERROR;
1322                 if (!RunIteration(uvec3(8, 8, 1), uvec3(8, 8, 1), true))
1323                         return ERROR;
1324
1325                 return NO_ERROR;
1326         }
1327
1328         virtual long Cleanup()
1329         {
1330                 glUseProgram(0);
1331                 glDeleteProgram(m_program);
1332                 glDeleteProgram(m_draw_program);
1333                 glDeleteVertexArrays(1, &m_vertex_array);
1334                 glDeleteTextures(2, m_texture);
1335                 glDeleteBuffers(1, &m_dispatch_buffer);
1336                 glViewport(0, 0, getWindowWidth(), getWindowHeight());
1337                 return NO_ERROR;
1338         }
1339 };
1340
1341 class BasicResourceAtomicCounter : public ComputeShaderBase
1342 {
1343
1344         virtual std::string Title()
1345         {
1346                 return "Compute Shader resources - Atomic Counters";
1347         }
1348
1349         virtual std::string Purpose()
1350         {
1351                 return NL
1352                         "1. Verify that Atomic Counters work as expected in CS." NL
1353                         "2. Verify that built-in functions: atomicCounterIncrement and atomicCounterDecrement work correctly." NL
1354                         "3. Verify that GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER is accepted by" NL
1355                         "    GetActiveAtomicCounterBufferiv command.";
1356         }
1357
1358         virtual std::string Method()
1359         {
1360                 return NL
1361                         "1. Create CS which uses two atomic_uint variables." NL
1362                         "2. In CS write values returned by atomicCounterIncrement and atomicCounterDecrement functions to SSBO." NL
1363                         "3. Dispatch CS with DispatchCompute and DispatchComputeIndirect commands." NL "4. Verify SSBO content." NL
1364                         "5. Repeat for different buffer and CS work sizes.";
1365         }
1366
1367         virtual std::string PassCriteria()
1368         {
1369                 return "Everything works as expected.";
1370         }
1371
1372         GLuint m_program;
1373         GLuint m_storage_buffer;
1374         GLuint m_counter_buffer[2];
1375         GLuint m_dispatch_buffer;
1376
1377         std::string GenSource(const uvec3& local_size, const uvec3& num_groups)
1378         {
1379                 const uvec3               global_size = local_size * num_groups;
1380                 std::stringstream ss;
1381                 ss << NL "layout(local_size_x = " << local_size.x() << ", local_size_y = " << local_size.y()
1382                    << ", local_size_z = " << local_size.z()
1383                    << ") in;" NL "layout(std430, binding = 0) buffer Output {" NL "  uint inc_data["
1384                    << global_size.x() * global_size.y() * global_size.z() << "];" NL "  uint dec_data["
1385                    << global_size.x() * global_size.y() * global_size.z()
1386                    << "];" NL "};" NL "layout(binding = 0, offset = 0) uniform atomic_uint g_inc_counter;" NL
1387                           "layout(binding = 1, offset = 0) uniform atomic_uint g_dec_counter;" NL "void main() {" NL
1388                           "  const uint index = atomicCounterIncrement(g_inc_counter);" NL "  inc_data[index] = index;" NL
1389                           "  dec_data[index] = atomicCounterDecrement(g_dec_counter);" NL "}";
1390                 return ss.str();
1391         }
1392
1393         bool RunIteration(const uvec3& local_size, const uvec3& num_groups, bool dispatch_indirect)
1394         {
1395                 if (m_program != 0)
1396                         glDeleteProgram(m_program);
1397                 m_program = CreateComputeProgram(GenSource(local_size, num_groups));
1398                 glLinkProgram(m_program);
1399                 if (!CheckProgram(m_program))
1400                         return false;
1401
1402                 GLint p[2] = { 0 };
1403                 glGetActiveAtomicCounterBufferiv(m_program, 0, GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER, &p[0]);
1404                 glGetActiveAtomicCounterBufferiv(m_program, 1, GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER, &p[1]);
1405
1406                 if (p[0] == GL_FALSE || p[1] == GL_FALSE)
1407                 {
1408                         m_context.getTestContext().getLog()
1409                                 << tcu::TestLog::Message << "ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER should be TRUE."
1410                                 << tcu::TestLog::EndMessage;
1411                         return false;
1412                 }
1413
1414                 const GLint  kWidth  = static_cast<GLint>(local_size.x() * num_groups.x());
1415                 const GLint  kHeight = static_cast<GLint>(local_size.y() * num_groups.y());
1416                 const GLint  kDepth  = static_cast<GLint>(local_size.z() * num_groups.z());
1417                 const GLuint kSize   = kWidth * kHeight * kDepth;
1418
1419                 if (m_storage_buffer == 0)
1420                         glGenBuffers(1, &m_storage_buffer);
1421                 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_storage_buffer);
1422                 glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(GLuint) * kSize * 2, NULL, GL_DYNAMIC_DRAW);
1423                 glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
1424
1425                 if (m_counter_buffer[0] == 0)
1426                         glGenBuffers(2, m_counter_buffer);
1427
1428                 glBindBufferBase(GL_ATOMIC_COUNTER_BUFFER, 0, m_counter_buffer[0]);
1429                 glBufferData(GL_ATOMIC_COUNTER_BUFFER, sizeof(GLuint), NULL, GL_STREAM_DRAW);
1430                 *static_cast<GLuint*>(glMapBuffer(GL_ATOMIC_COUNTER_BUFFER, GL_WRITE_ONLY)) = 0;
1431                 glUnmapBuffer(GL_ATOMIC_COUNTER_BUFFER);
1432
1433                 glBindBufferBase(GL_ATOMIC_COUNTER_BUFFER, 1, m_counter_buffer[1]);
1434                 glBufferData(GL_ATOMIC_COUNTER_BUFFER, sizeof(GLuint), NULL, GL_STREAM_DRAW);
1435                 *static_cast<GLuint*>(glMapBuffer(GL_ATOMIC_COUNTER_BUFFER, GL_WRITE_ONLY)) = kSize;
1436                 glUnmapBuffer(GL_ATOMIC_COUNTER_BUFFER);
1437
1438                 glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, 0);
1439
1440                 glUseProgram(m_program);
1441                 if (dispatch_indirect)
1442                 {
1443                         if (m_dispatch_buffer == 0)
1444                                 glGenBuffers(1, &m_dispatch_buffer);
1445                         glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, m_dispatch_buffer);
1446                         glBufferData(GL_DISPATCH_INDIRECT_BUFFER, sizeof(num_groups), &num_groups[0], GL_STATIC_DRAW);
1447                         glDispatchComputeIndirect(0);
1448                 }
1449                 else
1450                 {
1451                         glDispatchCompute(num_groups.x(), num_groups.y(), num_groups.z());
1452                 }
1453
1454                 std::vector<GLuint> data(kSize);
1455                 glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_storage_buffer);
1456                 glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
1457                 glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(GLuint) * kSize, &data[0]);
1458
1459                 for (GLuint i = 0; i < kSize; ++i)
1460                 {
1461                         if (data[i] != i)
1462                         {
1463                                 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Value at index " << i << " is "
1464                                                                                                         << data[i] << " should be " << i << "." << tcu::TestLog::EndMessage;
1465                                 return false;
1466                         }
1467                 }
1468
1469                 GLuint value;
1470                 glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, m_counter_buffer[0]);
1471                 glGetBufferSubData(GL_ATOMIC_COUNTER_BUFFER, 0, sizeof(GLuint), &value);
1472                 if (value != kSize)
1473                 {
1474                         m_context.getTestContext().getLog() << tcu::TestLog::Message << "Final atomic counter value (buffer 0) is "
1475                                                                                                 << value << " should be " << kSize << "." << tcu::TestLog::EndMessage;
1476                         return false;
1477                 }
1478
1479                 glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, m_counter_buffer[1]);
1480                 glGetBufferSubData(GL_ATOMIC_COUNTER_BUFFER, 0, sizeof(GLuint), &value);
1481                 if (value != 0)
1482                 {
1483                         m_context.getTestContext().getLog() << tcu::TestLog::Message << "Final atomic counter value (buffer 1) is "
1484                                                                                                 << value << " should be 0." << tcu::TestLog::EndMessage;
1485                         return false;
1486                 }
1487
1488                 return true;
1489         }
1490
1491         virtual long Setup()
1492         {
1493                 m_program                = 0;
1494                 m_storage_buffer = 0;
1495                 memset(m_counter_buffer, 0, sizeof(m_counter_buffer));
1496                 m_dispatch_buffer = 0;
1497                 return NO_ERROR;
1498         }
1499
1500         virtual long Run()
1501         {
1502                 if (!RunIteration(uvec3(4, 3, 2), uvec3(2, 3, 4), false))
1503                         return ERROR;
1504                 if (!RunIteration(uvec3(1, 1, 1), uvec3(1, 1, 1), true))
1505                         return ERROR;
1506                 if (!RunIteration(uvec3(1, 6, 1), uvec3(1, 1, 8), false))
1507                         return ERROR;
1508                 if (!RunIteration(uvec3(4, 1, 2), uvec3(10, 3, 4), true))
1509                         return ERROR;
1510                 return NO_ERROR;
1511         }
1512
1513         virtual long Cleanup()
1514         {
1515                 glUseProgram(0);
1516                 glDeleteProgram(m_program);
1517                 glDeleteBuffers(2, m_counter_buffer);
1518                 glDeleteBuffers(1, &m_dispatch_buffer);
1519                 glDeleteBuffers(1, &m_storage_buffer);
1520                 return NO_ERROR;
1521         }
1522 };
1523
1524 class BasicResourceSubroutine : public ComputeShaderBase
1525 {
1526
1527         virtual std::string Title()
1528         {
1529                 return "Compute Shader resources - Subroutines";
1530         }
1531
1532         virtual std::string Purpose()
1533         {
1534                 return NL "1. Verify that subroutines work as expected in CS." NL
1535                                   "2. Verify that subroutines array can be indexed with gl_WorkGroupID built-in variable." NL
1536                                   "3. Verify that atomicCounterIncrement, imageLoad and texelFetch functions" NL
1537                                   "    work as expected when called in CS from subroutine.";
1538         }
1539
1540         virtual std::string Method()
1541         {
1542                 return NL "1. Create CS which uses array of subroutines." NL
1543                                   "2. In CS index subroutine array with gl_WorkGroupID built-in variable." NL
1544                                   "3. In each subroutine load data from SSBO0 and write it to SSBO1." NL
1545                                   "3. Dispatch CS with DispatchCompute and DispatchComputeIndirect commands." NL
1546                                   "4. Verify SSBO1 content." NL "5. Repeat for different buffer and CS work sizes.";
1547         }
1548
1549         virtual std::string PassCriteria()
1550         {
1551                 return "Everything works as expected.";
1552         }
1553
1554         GLuint m_program;
1555         GLuint m_atomic_counter_buffer;
1556         GLuint m_storage_buffer[2];
1557         GLuint m_buffer[2];
1558         GLuint m_texture_buffer[2];
1559
1560         virtual long Setup()
1561         {
1562                 m_program                               = 0;
1563                 m_atomic_counter_buffer = 0;
1564                 memset(m_storage_buffer, 0, sizeof(m_storage_buffer));
1565                 memset(m_buffer, 0, sizeof(m_buffer));
1566                 memset(m_texture_buffer, 0, sizeof(m_texture_buffer));
1567                 return NO_ERROR;
1568         }
1569
1570         virtual long Run()
1571         {
1572                 const char* const glsl_cs =
1573                         NL "layout(local_size_x = 16) in;" NL "layout(binding = 1, std430) buffer Input {" NL "  uvec4 data[16];" NL
1574                            "} g_input;" NL "layout(std430, binding = 0) buffer Output {" NL "  uvec4 g_output[64];" NL "};" NL
1575                            "subroutine void ComputeType();" NL "subroutine uniform ComputeType Compute[4];" NL
1576                            "layout(binding = 0, offset = 0) uniform atomic_uint g_atomic_counter;" NL
1577                            "layout(rgba32ui) readonly uniform uimageBuffer g_image_buffer;" NL
1578                            "uniform usamplerBuffer g_sampler_buffer;" NL "subroutine(ComputeType)" NL "void Compute0() {" NL
1579                            "  const uint index = atomicCounterIncrement(g_atomic_counter);" NL
1580                            "  g_output[index] = uvec4(index);" NL "}" NL "subroutine(ComputeType)" NL "void Compute1() {" NL
1581                            "  g_output[gl_GlobalInvocationID.x] = g_input.data[gl_LocalInvocationIndex];" NL "}" NL
1582                            "subroutine(ComputeType)" NL "void Compute2() {" NL
1583                            "  g_output[gl_GlobalInvocationID.x] = imageLoad(g_image_buffer, int(gl_LocalInvocationIndex));" NL
1584                            "}" NL "subroutine(ComputeType)" NL "void Compute3() {" NL
1585                            "  g_output[gl_GlobalInvocationID.x] = texelFetch(g_sampler_buffer, int(gl_LocalInvocationIndex));" NL
1586                            "}" NL "void main() {" NL "  Compute[gl_WorkGroupID.x]();" NL "}";
1587                 m_program = CreateComputeProgram(glsl_cs);
1588                 glLinkProgram(m_program);
1589                 if (!CheckProgram(m_program))
1590                         return ERROR;
1591
1592                 glGenBuffers(2, m_storage_buffer);
1593                 /* output buffer */
1594                 {
1595                         std::vector<uvec4> data(64, uvec4(0xffff));
1596                         glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_storage_buffer[0]);
1597                         glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(uvec4) * 64, &data[0], GL_DYNAMIC_DRAW);
1598                 }
1599                 /* input buffer */
1600                 {
1601                         std::vector<uvec4> data(16);
1602                         for (GLuint i = 0; i < 16; ++i)
1603                                 data[i]   = uvec4(i + 16);
1604                         glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_storage_buffer[1]);
1605                         glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(uvec4) * 16, &data[0], GL_DYNAMIC_DRAW);
1606                 }
1607                 glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
1608
1609                 glGenBuffers(1, &m_atomic_counter_buffer);
1610                 glBindBufferBase(GL_ATOMIC_COUNTER_BUFFER, 0, m_atomic_counter_buffer);
1611                 glBufferData(GL_ATOMIC_COUNTER_BUFFER, sizeof(GLuint), NULL, GL_STREAM_DRAW);
1612                 *static_cast<GLuint*>(glMapBuffer(GL_ATOMIC_COUNTER_BUFFER, GL_WRITE_ONLY)) = 0;
1613                 glUnmapBuffer(GL_ATOMIC_COUNTER_BUFFER);
1614
1615                 glGenBuffers(2, m_buffer);
1616                 /* image buffer */
1617                 {
1618                         std::vector<uvec4> data(16);
1619                         for (GLuint i = 0; i < 16; ++i)
1620                                 data[i]   = uvec4(i + 32);
1621                         glBindBuffer(GL_TEXTURE_BUFFER, m_buffer[0]);
1622                         glBufferData(GL_TEXTURE_BUFFER, sizeof(uvec4) * 16, &data[0], GL_STATIC_DRAW);
1623                 }
1624                 /* texture buffer */
1625                 {
1626                         std::vector<uvec4> data(16);
1627                         for (GLuint i = 0; i < 16; ++i)
1628                                 data[i]   = uvec4(i + 48);
1629                         glBindBuffer(GL_TEXTURE_BUFFER, m_buffer[1]);
1630                         glBufferData(GL_TEXTURE_BUFFER, sizeof(uvec4) * 16, &data[0], GL_STATIC_DRAW);
1631                 }
1632                 glBindBuffer(GL_TEXTURE_BUFFER, 0);
1633
1634                 glGenTextures(2, m_texture_buffer);
1635                 glBindTexture(GL_TEXTURE_BUFFER, m_texture_buffer[0]);
1636                 glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32UI, m_buffer[0]);
1637                 glBindTexture(GL_TEXTURE_BUFFER, m_texture_buffer[1]);
1638                 glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32UI, m_buffer[1]);
1639                 glBindTexture(GL_TEXTURE_BUFFER, 0);
1640
1641                 const GLuint index_compute0 = glGetSubroutineIndex(m_program, GL_COMPUTE_SHADER, "Compute0");
1642                 const GLuint index_compute1 = glGetSubroutineIndex(m_program, GL_COMPUTE_SHADER, "Compute1");
1643                 const GLuint index_compute2 = glGetSubroutineIndex(m_program, GL_COMPUTE_SHADER, "Compute2");
1644                 const GLuint index_compute3 = glGetSubroutineIndex(m_program, GL_COMPUTE_SHADER, "Compute3");
1645                 const GLint  loc_compute0   = glGetSubroutineUniformLocation(m_program, GL_COMPUTE_SHADER, "Compute[0]");
1646                 const GLint  loc_compute1   = glGetSubroutineUniformLocation(m_program, GL_COMPUTE_SHADER, "Compute[1]");
1647                 const GLint  loc_compute2   = glGetSubroutineUniformLocation(m_program, GL_COMPUTE_SHADER, "Compute[2]");
1648                 const GLint  loc_compute3   = glGetSubroutineUniformLocation(m_program, GL_COMPUTE_SHADER, "Compute[3]");
1649
1650                 // bind resources
1651                 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_storage_buffer[0]);
1652                 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, m_storage_buffer[1]);
1653                 glBindBufferBase(GL_ATOMIC_COUNTER_BUFFER, 0, m_atomic_counter_buffer);
1654                 glBindImageTexture(0, m_texture_buffer[0], 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA32UI);
1655                 glActiveTexture(GL_TEXTURE0);
1656                 glBindTexture(GL_TEXTURE_BUFFER, m_texture_buffer[1]);
1657
1658                 glUseProgram(m_program);
1659
1660                 // setup subroutines
1661                 GLuint indices[4];
1662                 indices[loc_compute0] = index_compute0;
1663                 indices[loc_compute1] = index_compute1;
1664                 indices[loc_compute2] = index_compute2;
1665                 indices[loc_compute3] = index_compute3;
1666                 glUniformSubroutinesuiv(GL_COMPUTE_SHADER, 4, indices);
1667
1668                 glDispatchCompute(4, 1, 1);
1669
1670                 std::vector<uvec4> data(64);
1671                 glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_storage_buffer[0]);
1672                 glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
1673                 glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(uvec4) * 64, &data[0]);
1674
1675                 for (GLuint i = 0; i < 64; ++i)
1676                 {
1677                         if (!IsEqual(data[i], uvec4(i)))
1678                         {
1679                                 m_context.getTestContext().getLog()
1680                                         << tcu::TestLog::Message << "Invalid value at index " << i << "." << tcu::TestLog::EndMessage;
1681                                 return ERROR;
1682                         }
1683                 }
1684
1685                 GLuint value;
1686                 glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, m_atomic_counter_buffer);
1687                 glGetBufferSubData(GL_ATOMIC_COUNTER_BUFFER, 0, sizeof(GLuint), &value);
1688                 if (value != 16)
1689                 {
1690                         m_context.getTestContext().getLog() << tcu::TestLog::Message << "Final atomic counter value is " << value
1691                                                                                                 << " should be 16." << tcu::TestLog::EndMessage;
1692                         return ERROR;
1693                 }
1694
1695                 return NO_ERROR;
1696         }
1697
1698         virtual long Cleanup()
1699         {
1700                 glUseProgram(0);
1701                 glDeleteProgram(m_program);
1702                 glDeleteBuffers(1, &m_atomic_counter_buffer);
1703                 glDeleteBuffers(2, m_storage_buffer);
1704                 glDeleteBuffers(2, m_buffer);
1705                 glDeleteTextures(2, m_texture_buffer);
1706                 return NO_ERROR;
1707         }
1708 };
1709
1710 class BasicResourceUniform : public ComputeShaderBase
1711 {
1712
1713         virtual std::string Title()
1714         {
1715                 return "Compute Shader resources - Uniforms";
1716         }
1717
1718         virtual std::string Purpose()
1719         {
1720                 return NL "1. Verify that all types of uniform variables work as expected in CS." NL
1721                                   "2. Verify that uniform variables can be updated with Uniform* and ProgramUniform* commands." NL
1722                                   "3. Verify that re-linking CS program works as expected.";
1723         }
1724
1725         virtual std::string Method()
1726         {
1727                 return NL "1. Create CS which uses all (single precision and integer) types of uniform variables." NL
1728                                   "2. Update uniform variables with ProgramUniform* commands." NL
1729                                   "3. Verify that uniform variables were updated correctly." NL "4. Re-link CS program." NL
1730                                   "5. Update uniform variables with Uniform* commands." NL
1731                                   "6. Verify that uniform variables were updated correctly.";
1732         }
1733
1734         virtual std::string PassCriteria()
1735         {
1736                 return "Everything works as expected.";
1737         }
1738
1739         GLuint m_program;
1740         GLuint m_storage_buffer;
1741
1742         virtual long Setup()
1743         {
1744                 m_program                = 0;
1745                 m_storage_buffer = 0;
1746                 return NO_ERROR;
1747         }
1748
1749         virtual long Run()
1750         {
1751                 const char* const glsl_cs = NL
1752                         "layout(local_size_x = 1) in;" NL "buffer Result {" NL "  int g_result;" NL "};" NL "uniform float g_0;" NL
1753                         "uniform vec2 g_1;" NL "uniform vec3 g_2;" NL "uniform vec4 g_3;" NL "uniform mat2 g_4;" NL
1754                         "uniform mat2x3 g_5;" NL "uniform mat2x4 g_6;" NL "uniform mat3x2 g_7;" NL "uniform mat3 g_8;" NL
1755                         "uniform mat3x4 g_9;" NL "uniform mat4x2 g_10;" NL "uniform mat4x3 g_11;" NL "uniform mat4 g_12;" NL
1756                         "uniform int g_13;" NL "uniform ivec2 g_14;" NL "uniform ivec3 g_15;" NL "uniform ivec4 g_16;" NL
1757                         "uniform uint g_17;" NL "uniform uvec2 g_18;" NL "uniform uvec3 g_19;" NL "uniform uvec4 g_20;" NL NL
1758                         "void main() {" NL "  g_result = 1;" NL NL "  if (g_0 != 1.0) g_result = 0;" NL
1759                         "  if (g_1 != vec2(2.0, 3.0)) g_result = 0;" NL "  if (g_2 != vec3(4.0, 5.0, 6.0)) g_result = 0;" NL
1760                         "  if (g_3 != vec4(7.0, 8.0, 9.0, 10.0)) g_result = 0;" NL NL
1761                         "  if (g_4 != mat2(11.0, 12.0, 13.0, 14.0)) g_result = 0;" NL
1762                         "  if (g_5 != mat2x3(15.0, 16.0, 17.0, 18.0, 19.0, 20.0)) g_result = 0;" NL
1763                         "  if (g_6 != mat2x4(21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0)) g_result = 0;" NL NL
1764                         "  if (g_7 != mat3x2(29.0, 30.0, 31.0, 32.0, 33.0, 34.0)) g_result = 0;" NL
1765                         "  if (g_8 != mat3(35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0)) g_result = 0;" NL
1766                         "  if (g_9 != mat3x4(44.0, 45.0, 46.0, 47.0, 48.0, 49.0, 50.0, 51.0, 52.0, 53.0, 54.0, 55.0)) g_result = "
1767                         "0;" NL NL "  if (g_10 != mat4x2(56.0, 57.0, 58.0, 59.0, 60.0, 61.0, 62.0, 63.0)) g_result = 0;" NL
1768                         "  if (g_11 != mat4x3(63.0, 64.0, 65.0, 66.0, 67.0, 68.0, 69.0, 70.0, 71.0, 27.0, 73, 74.0)) g_result = "
1769                         "0;" NL "  if (g_12 != mat4(75.0, 76.0, 77.0, 78.0, 79.0, 80.0, 81.0, 82.0, 83.0, 84.0, 85.0, 86.0, 87.0, "
1770                         "88.0, 89.0, 90.0)) g_result = 0;" NL NL "  if (g_13 != 91) g_result = 0;" NL
1771                         "  if (g_14 != ivec2(92, 93)) g_result = 0;" NL "  if (g_15 != ivec3(94, 95, 96)) g_result = 0;" NL
1772                         "  if (g_16 != ivec4(97, 98, 99, 100)) g_result = 0;" NL NL "  if (g_17 != 101u) g_result = 0;" NL
1773                         "  if (g_18 != uvec2(102u, 103u)) g_result = 0;" NL
1774                         "  if (g_19 != uvec3(104u, 105u, 106u)) g_result = 0;" NL
1775                         "  if (g_20 != uvec4(107u, 108u, 109u, 110u)) g_result = 0;" NL "}";
1776                 m_program = CreateComputeProgram(glsl_cs);
1777                 glLinkProgram(m_program);
1778                 if (!CheckProgram(m_program))
1779                         return ERROR;
1780
1781                 glGenBuffers(1, &m_storage_buffer);
1782                 /* create buffer */
1783                 {
1784                         const int data = 123;
1785                         glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_storage_buffer);
1786                         glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(data), &data, GL_STATIC_DRAW);
1787                 }
1788
1789                 glProgramUniform1f(m_program, glGetUniformLocation(m_program, "g_0"), 1.0f);
1790                 glProgramUniform2f(m_program, glGetUniformLocation(m_program, "g_1"), 2.0f, 3.0f);
1791                 glProgramUniform3f(m_program, glGetUniformLocation(m_program, "g_2"), 4.0f, 5.0f, 6.0f);
1792                 glProgramUniform4f(m_program, glGetUniformLocation(m_program, "g_3"), 7.0f, 8.0f, 9.0f, 10.0f);
1793
1794                 /* mat2 */
1795                 {
1796                         const GLfloat value[4] = { 11.0f, 12.0f, 13.0f, 14.0f };
1797                         glProgramUniformMatrix2fv(m_program, glGetUniformLocation(m_program, "g_4"), 1, GL_FALSE, value);
1798                 }
1799                 /* mat2x3 */
1800                 {
1801                         const GLfloat value[6] = { 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f };
1802                         glProgramUniformMatrix2x3fv(m_program, glGetUniformLocation(m_program, "g_5"), 1, GL_FALSE, value);
1803                 }
1804                 /* mat2x4 */
1805                 {
1806                         const GLfloat value[8] = { 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f };
1807                         glProgramUniformMatrix2x4fv(m_program, glGetUniformLocation(m_program, "g_6"), 1, GL_FALSE, value);
1808                 }
1809
1810                 /* mat3x2 */
1811                 {
1812                         const GLfloat value[6] = { 29.0f, 30.0f, 31.0f, 32.0f, 33.0f, 34.0f };
1813                         glProgramUniformMatrix3x2fv(m_program, glGetUniformLocation(m_program, "g_7"), 1, GL_FALSE, value);
1814                 }
1815                 /* mat3 */
1816                 {
1817                         const GLfloat value[9] = { 35.0f, 36.0f, 37.0f, 38.0f, 39.0f, 40.0f, 41.0f, 42.0f, 43.0f };
1818                         glProgramUniformMatrix3fv(m_program, glGetUniformLocation(m_program, "g_8"), 1, GL_FALSE, value);
1819                 }
1820                 /* mat3x4 */
1821                 {
1822                         const GLfloat value[12] = { 44.0f, 45.0f, 46.0f, 47.0f, 48.0f, 49.0f,
1823                                                                                 50.0f, 51.0f, 52.0f, 53.0f, 54.0f, 55.0f };
1824                         glProgramUniformMatrix3x4fv(m_program, glGetUniformLocation(m_program, "g_9"), 1, GL_FALSE, value);
1825                 }
1826
1827                 /* mat4x2 */
1828                 {
1829                         const GLfloat value[8] = { 56.0f, 57.0f, 58.0f, 59.0f, 60.0f, 61.0f, 62.0f, 63.0f };
1830                         glProgramUniformMatrix4x2fv(m_program, glGetUniformLocation(m_program, "g_10"), 1, GL_FALSE, value);
1831                 }
1832                 /* mat4x3 */
1833                 {
1834                         const GLfloat value[12] = {
1835                                 63.0f, 64.0f, 65.0f, 66.0f, 67.0f, 68.0f, 69.0f, 70.0f, 71.0f, 27.0f, 73, 74.0f
1836                         };
1837                         glProgramUniformMatrix4x3fv(m_program, glGetUniformLocation(m_program, "g_11"), 1, GL_FALSE, value);
1838                 }
1839                 /* mat4 */
1840                 {
1841                         const GLfloat value[16] = { 75.0f, 76.0f, 77.0f, 78.0f, 79.0f, 80.0f, 81.0f, 82.0f,
1842                                                                                 83.0f, 84.0f, 85.0f, 86.0f, 87.0f, 88.0f, 89.0f, 90.0f };
1843                         glProgramUniformMatrix4fv(m_program, glGetUniformLocation(m_program, "g_12"), 1, GL_FALSE, value);
1844                 }
1845
1846                 glProgramUniform1i(m_program, glGetUniformLocation(m_program, "g_13"), 91);
1847                 glProgramUniform2i(m_program, glGetUniformLocation(m_program, "g_14"), 92, 93);
1848                 glProgramUniform3i(m_program, glGetUniformLocation(m_program, "g_15"), 94, 95, 96);
1849                 glProgramUniform4i(m_program, glGetUniformLocation(m_program, "g_16"), 97, 98, 99, 100);
1850
1851                 glProgramUniform1ui(m_program, glGetUniformLocation(m_program, "g_17"), 101);
1852                 glProgramUniform2ui(m_program, glGetUniformLocation(m_program, "g_18"), 102, 103);
1853                 glProgramUniform3ui(m_program, glGetUniformLocation(m_program, "g_19"), 104, 105, 106);
1854                 glProgramUniform4ui(m_program, glGetUniformLocation(m_program, "g_20"), 107, 108, 109, 110);
1855
1856                 glUseProgram(m_program);
1857                 glDispatchCompute(1, 1, 1);
1858                 glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
1859
1860                 {
1861                         int data;
1862                         glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(data), &data);
1863                         if (data != 1)
1864                         {
1865                                 m_context.getTestContext().getLog()
1866                                         << tcu::TestLog::Message << "Data is " << data << " should be 1." << tcu::TestLog::EndMessage;
1867                                 return ERROR;
1868                         }
1869                 }
1870
1871                 // re-link program (all uniforms will be set to zero)
1872                 glLinkProgram(m_program);
1873
1874                 {
1875                         const int data = 123;
1876                         glBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(data), &data);
1877                 }
1878
1879                 glUniform1f(glGetUniformLocation(m_program, "g_0"), 1.0f);
1880                 glUniform2f(glGetUniformLocation(m_program, "g_1"), 2.0f, 3.0f);
1881                 glUniform3f(glGetUniformLocation(m_program, "g_2"), 4.0f, 5.0f, 6.0f);
1882                 glUniform4f(glGetUniformLocation(m_program, "g_3"), 7.0f, 8.0f, 9.0f, 10.0f);
1883
1884                 /* mat2 */
1885                 {
1886                         const GLfloat value[4] = { 11.0f, 12.0f, 13.0f, 14.0f };
1887                         glUniformMatrix2fv(glGetUniformLocation(m_program, "g_4"), 1, GL_FALSE, value);
1888                 }
1889                 /* mat2x3 */
1890                 {
1891                         const GLfloat value[6] = { 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f };
1892                         glUniformMatrix2x3fv(glGetUniformLocation(m_program, "g_5"), 1, GL_FALSE, value);
1893                 }
1894                 /* mat2x4 */
1895                 {
1896                         const GLfloat value[8] = { 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f };
1897                         glUniformMatrix2x4fv(glGetUniformLocation(m_program, "g_6"), 1, GL_FALSE, value);
1898                 }
1899
1900                 /* mat3x2 */
1901                 {
1902                         const GLfloat value[6] = { 29.0f, 30.0f, 31.0f, 32.0f, 33.0f, 34.0f };
1903                         glUniformMatrix3x2fv(glGetUniformLocation(m_program, "g_7"), 1, GL_FALSE, value);
1904                 }
1905                 /* mat3 */
1906                 {
1907                         const GLfloat value[9] = { 35.0f, 36.0f, 37.0f, 38.0f, 39.0f, 40.0f, 41.0f, 42.0f, 43.0f };
1908                         glUniformMatrix3fv(glGetUniformLocation(m_program, "g_8"), 1, GL_FALSE, value);
1909                 }
1910                 /* mat3x4 */
1911                 {
1912                         const GLfloat value[12] = { 44.0f, 45.0f, 46.0f, 47.0f, 48.0f, 49.0f,
1913                                                                                 50.0f, 51.0f, 52.0f, 53.0f, 54.0f, 55.0f };
1914                         glUniformMatrix3x4fv(glGetUniformLocation(m_program, "g_9"), 1, GL_FALSE, value);
1915                 }
1916
1917                 /* mat4x2 */
1918                 {
1919                         const GLfloat value[8] = { 56.0f, 57.0f, 58.0f, 59.0f, 60.0f, 61.0f, 62.0f, 63.0f };
1920                         glUniformMatrix4x2fv(glGetUniformLocation(m_program, "g_10"), 1, GL_FALSE, value);
1921                 }
1922                 /* mat4x3 */
1923                 {
1924                         const GLfloat value[12] = {
1925                                 63.0f, 64.0f, 65.0f, 66.0f, 67.0f, 68.0f, 69.0f, 70.0f, 71.0f, 27.0f, 73, 74.0f
1926                         };
1927                         glUniformMatrix4x3fv(glGetUniformLocation(m_program, "g_11"), 1, GL_FALSE, value);
1928                 }
1929                 /* mat4 */
1930                 {
1931                         const GLfloat value[16] = { 75.0f, 76.0f, 77.0f, 78.0f, 79.0f, 80.0f, 81.0f, 82.0f,
1932                                                                                 83.0f, 84.0f, 85.0f, 86.0f, 87.0f, 88.0f, 89.0f, 90.0f };
1933                         glUniformMatrix4fv(glGetUniformLocation(m_program, "g_12"), 1, GL_FALSE, value);
1934                 }
1935
1936                 glUniform1i(glGetUniformLocation(m_program, "g_13"), 91);
1937                 glUniform2i(glGetUniformLocation(m_program, "g_14"), 92, 93);
1938                 glUniform3i(glGetUniformLocation(m_program, "g_15"), 94, 95, 96);
1939                 glUniform4i(glGetUniformLocation(m_program, "g_16"), 97, 98, 99, 100);
1940
1941                 glUniform1ui(glGetUniformLocation(m_program, "g_17"), 101);
1942                 glUniform2ui(glGetUniformLocation(m_program, "g_18"), 102, 103);
1943                 glUniform3ui(glGetUniformLocation(m_program, "g_19"), 104, 105, 106);
1944                 glUniform4ui(glGetUniformLocation(m_program, "g_20"), 107, 108, 109, 110);
1945
1946                 glDispatchCompute(1, 1, 1);
1947                 glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
1948
1949                 /* validate */
1950                 {
1951                         int data;
1952                         glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(data), &data);
1953                         if (data != 1)
1954                         {
1955                                 m_context.getTestContext().getLog()
1956                                         << tcu::TestLog::Message << "Data is " << data << " should be 1." << tcu::TestLog::EndMessage;
1957                                 return ERROR;
1958                         }
1959                 }
1960
1961                 return NO_ERROR;
1962         }
1963
1964         virtual long Cleanup()
1965         {
1966                 glUseProgram(0);
1967                 glDeleteProgram(m_program);
1968                 glDeleteBuffers(1, &m_storage_buffer);
1969                 return NO_ERROR;
1970         }
1971 };
1972
1973 class BasicBuiltinVariables : public ComputeShaderBase
1974 {
1975
1976         virtual std::string Title()
1977         {
1978                 return "CS built-in variables";
1979         }
1980
1981         virtual std::string Purpose()
1982         {
1983                 return NL "Verify that all (gl_WorkGroupSize, gl_WorkGroupID, gl_LocalInvocationID," NL
1984                                   "gl_GlobalInvocationID, gl_NumWorkGroups, gl_WorkGroupSize)" NL
1985                                   "CS built-in variables has correct values.";
1986         }
1987
1988         virtual std::string Method()
1989         {
1990                 return NL "1. Create CS which writes all built-in variables to SSBO." NL
1991                                   "2. Dispatch CS with DispatchCompute and DispatchComputeIndirect commands." NL
1992                                   "3. Verify SSBO content." NL "4. Repeat for several different local and global work sizes.";
1993         }
1994
1995         virtual std::string PassCriteria()
1996         {
1997                 return "Everything works as expected.";
1998         }
1999
2000         GLuint m_program;
2001         GLuint m_storage_buffer;
2002         GLuint m_dispatch_buffer;
2003
2004         std::string GenSource(const uvec3& local_size, const uvec3& num_groups)
2005         {
2006                 const uvec3               global_size = local_size * num_groups;
2007                 std::stringstream ss;
2008                 ss << NL "layout(local_size_x = " << local_size.x() << ", local_size_y = " << local_size.y()
2009                    << ", local_size_z = " << local_size.z() << ") in;" NL "const uvec3 kGlobalSize = uvec3(" << global_size.x()
2010                    << ", " << global_size.y() << ", " << global_size.z()
2011                    << ");" NL "layout(std430) buffer OutputBuffer {" NL "  uvec4 num_work_groups["
2012                    << global_size.x() * global_size.y() * global_size.z() << "];" NL "  uvec4 work_group_size["
2013                    << global_size.x() * global_size.y() * global_size.z() << "];" NL "  uvec4 work_group_id["
2014                    << global_size.x() * global_size.y() * global_size.z() << "];" NL "  uvec4 local_invocation_id["
2015                    << global_size.x() * global_size.y() * global_size.z() << "];" NL "  uvec4 global_invocation_id["
2016                    << global_size.x() * global_size.y() * global_size.z() << "];" NL "  uvec4 local_invocation_index["
2017                    << global_size.x() * global_size.y() * global_size.z()
2018                    << "];" NL "} g_out_buffer;" NL "void main() {" NL
2019                           "  if ((gl_WorkGroupSize * gl_WorkGroupID + gl_LocalInvocationID) != gl_GlobalInvocationID) return;" NL
2020                           "  const uint global_index = gl_GlobalInvocationID.x +" NL
2021                           "                            gl_GlobalInvocationID.y * kGlobalSize.x +" NL
2022                           "                            gl_GlobalInvocationID.z * kGlobalSize.x * kGlobalSize.y;" NL
2023                           "  g_out_buffer.num_work_groups[global_index] = uvec4(gl_NumWorkGroups, 0);" NL
2024                           "  g_out_buffer.work_group_size[global_index] = uvec4(gl_WorkGroupSize, 0);" NL
2025                           "  g_out_buffer.work_group_id[global_index] = uvec4(gl_WorkGroupID, 0);" NL
2026                           "  g_out_buffer.local_invocation_id[global_index] = uvec4(gl_LocalInvocationID, 0);" NL
2027                           "  g_out_buffer.global_invocation_id[global_index] = uvec4(gl_GlobalInvocationID, 0);" NL
2028                           "  g_out_buffer.local_invocation_index[global_index] = uvec4(gl_LocalInvocationIndex);" NL "}";
2029                 return ss.str();
2030         }
2031
2032         bool RunIteration(const uvec3& local_size, const uvec3& num_groups, bool dispatch_indirect)
2033         {
2034                 if (m_program != 0)
2035                         glDeleteProgram(m_program);
2036                 m_program = CreateComputeProgram(GenSource(local_size, num_groups));
2037                 glLinkProgram(m_program);
2038                 if (!CheckProgram(m_program))
2039                         return false;
2040
2041                 const GLuint kBufferSize =
2042                         local_size.x() * num_groups.x() * local_size.y() * num_groups.y() * local_size.z() * num_groups.z();
2043
2044                 std::vector<uvec4> data(kBufferSize * 6);
2045                 if (m_storage_buffer == 0)
2046                         glGenBuffers(1, &m_storage_buffer);
2047                 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_storage_buffer);
2048                 glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(uvec4) * kBufferSize * 6, &data[0], GL_DYNAMIC_DRAW);
2049                 glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
2050
2051                 glUseProgram(m_program);
2052                 if (dispatch_indirect)
2053                 {
2054                         if (m_dispatch_buffer == 0)
2055                                 glGenBuffers(1, &m_dispatch_buffer);
2056                         glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, m_dispatch_buffer);
2057                         glBufferData(GL_DISPATCH_INDIRECT_BUFFER, sizeof(num_groups), &num_groups[0], GL_STATIC_DRAW);
2058                         glDispatchComputeIndirect(0);
2059                 }
2060                 else
2061                 {
2062                         glDispatchCompute(num_groups.x(), num_groups.y(), num_groups.z());
2063                 }
2064
2065                 glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_storage_buffer);
2066                 glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
2067                 glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(uvec4) * kBufferSize * 6, &data[0]);
2068
2069                 // gl_NumWorkGroups
2070                 for (GLuint index = 0; index < kBufferSize; ++index)
2071                 {
2072                         if (!IsEqual(data[index], uvec4(num_groups.x(), num_groups.y(), num_groups.z(), 0)))
2073                         {
2074                                 m_context.getTestContext().getLog()
2075                                         << tcu::TestLog::Message << "gl_NumWorkGroups: Invalid data at index " << index << "."
2076                                         << tcu::TestLog::EndMessage;
2077                                 return false;
2078                         }
2079                 }
2080                 // gl_WorkGroupSize
2081                 for (GLuint index = kBufferSize; index < 2 * kBufferSize; ++index)
2082                 {
2083                         if (!IsEqual(data[index], uvec4(local_size.x(), local_size.y(), local_size.z(), 0)))
2084                         {
2085                                 m_context.getTestContext().getLog()
2086                                         << tcu::TestLog::Message << "gl_WorkGroupSize: Invalid data at index " << index << "."
2087                                         << tcu::TestLog::EndMessage;
2088                                 return false;
2089                         }
2090                 }
2091                 // gl_WorkGroupID
2092                 for (GLuint index = 2 * kBufferSize; index < 3 * kBufferSize; ++index)
2093                 {
2094                         uvec3 expected = IndexTo3DCoord(index - 2 * kBufferSize, local_size.x() * num_groups.x(),
2095                                                                                         local_size.y() * num_groups.y());
2096                         expected.x() /= local_size.x();
2097                         expected.y() /= local_size.y();
2098                         expected.z() /= local_size.z();
2099                         if (!IsEqual(data[index], uvec4(expected.x(), expected.y(), expected.z(), 0)))
2100                         {
2101                                 m_context.getTestContext().getLog() << tcu::TestLog::Message << "gl_WorkGroupID: Invalid data at index "
2102                                                                                                         << index << "." << tcu::TestLog::EndMessage;
2103                                 return false;
2104                         }
2105                 }
2106                 // gl_LocalInvocationID
2107                 for (GLuint index = 3 * kBufferSize; index < 4 * kBufferSize; ++index)
2108                 {
2109                         uvec3 expected = IndexTo3DCoord(index - 3 * kBufferSize, local_size.x() * num_groups.x(),
2110                                                                                         local_size.y() * num_groups.y());
2111                         expected.x() %= local_size.x();
2112                         expected.y() %= local_size.y();
2113                         expected.z() %= local_size.z();
2114                         if (!IsEqual(data[index], uvec4(expected.x(), expected.y(), expected.z(), 0)))
2115                         {
2116                                 m_context.getTestContext().getLog()
2117                                         << tcu::TestLog::Message << "gl_LocalInvocationID: Invalid data at index " << index << "."
2118                                         << tcu::TestLog::EndMessage;
2119                                 return false;
2120                         }
2121                 }
2122                 // gl_GlobalInvocationID
2123                 for (GLuint index = 4 * kBufferSize; index < 5 * kBufferSize; ++index)
2124                 {
2125                         uvec3 expected = IndexTo3DCoord(index - 4 * kBufferSize, local_size.x() * num_groups.x(),
2126                                                                                         local_size.y() * num_groups.y());
2127                         if (!IsEqual(data[index], uvec4(expected.x(), expected.y(), expected.z(), 0)))
2128                         {
2129                                 m_context.getTestContext().getLog()
2130                                         << tcu::TestLog::Message << "gl_GlobalInvocationID: Invalid data at index " << index << "."
2131                                         << tcu::TestLog::EndMessage;
2132                                 return false;
2133                         }
2134                 }
2135                 // gl_LocalInvocationIndex
2136                 for (GLuint index = 5 * kBufferSize; index < 6 * kBufferSize; ++index)
2137                 {
2138                         uvec3 coord = IndexTo3DCoord(index - 5 * kBufferSize, local_size.x() * num_groups.x(),
2139                                                                                  local_size.y() * num_groups.y());
2140                         const GLuint expected = (coord.x() % local_size.x()) + (coord.y() % local_size.y()) * local_size.x() +
2141                                                                         (coord.z() % local_size.z()) * local_size.x() * local_size.y();
2142                         if (!IsEqual(data[index], uvec4(expected)))
2143                         {
2144                                 m_context.getTestContext().getLog()
2145                                         << tcu::TestLog::Message << "gl_LocalInvocationIndex: Invalid data at index " << index << "."
2146                                         << tcu::TestLog::EndMessage;
2147                                 return false;
2148                         }
2149                 }
2150                 return true;
2151         }
2152
2153         virtual long Setup()
2154         {
2155                 m_program                 = 0;
2156                 m_storage_buffer  = 0;
2157                 m_dispatch_buffer = 0;
2158                 return NO_ERROR;
2159         }
2160
2161         virtual long Run()
2162         {
2163                 if (!RunIteration(uvec3(64, 1, 1), uvec3(8, 1, 1), false))
2164                         return ERROR;
2165                 if (!RunIteration(uvec3(1, 1, 64), uvec3(1, 5, 2), true))
2166                         return ERROR;
2167                 if (!RunIteration(uvec3(1, 1, 4), uvec3(2, 2, 2), false))
2168                         return ERROR;
2169                 if (!RunIteration(uvec3(3, 2, 1), uvec3(1, 2, 3), true))
2170                         return ERROR;
2171                 if (!RunIteration(uvec3(2, 4, 2), uvec3(2, 4, 1), false))
2172                         return ERROR;
2173                 if (!RunIteration(uvec3(2, 4, 7), uvec3(2, 1, 4), true))
2174                         return ERROR;
2175                 return NO_ERROR;
2176         }
2177
2178         virtual long Cleanup()
2179         {
2180                 glUseProgram(0);
2181                 glDeleteProgram(m_program);
2182                 glDeleteBuffers(1, &m_storage_buffer);
2183                 glDeleteBuffers(1, &m_dispatch_buffer);
2184                 return NO_ERROR;
2185         }
2186 };
2187
2188 class BasicMax : public ComputeShaderBase
2189 {
2190
2191         virtual std::string Title()
2192         {
2193                 return NL "CS max values";
2194         }
2195
2196         virtual std::string Purpose()
2197         {
2198                 return NL "Verify (on the API and GLSL side) that all GL_MAX_COMPUTE_* values are not less than" NL
2199                                   "required by the OpenGL specification.";
2200         }
2201
2202         virtual std::string Method()
2203         {
2204                 return NL "1. Use all API commands to query all GL_MAX_COMPUTE_* values. Verify that they are correct." NL
2205                                   "2. Verify all gl_MaxCompute* constants in the GLSL.";
2206         }
2207
2208         virtual std::string PassCriteria()
2209         {
2210                 return NL "Everything works as expected.";
2211         }
2212
2213         GLuint m_program;
2214         GLuint m_buffer;
2215
2216         bool CheckIndexed(GLenum target, const GLint* min_values)
2217         {
2218                 GLint    i;
2219                 GLint64   i64;
2220                 GLfloat   f;
2221                 GLdouble  d;
2222                 GLboolean b;
2223
2224                 for (GLuint c = 0; c < 3; c++)
2225                 {
2226                         glGetIntegeri_v(target, c, &i);
2227                         if (i < min_values[c])
2228                         {
2229                                 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Is " << i << " should be at least "
2230                                                                                                         << min_values[c] << "." << tcu::TestLog::EndMessage;
2231                                 return false;
2232                         }
2233                 }
2234                 for (GLuint c = 0; c < 3; c++)
2235                 {
2236                         glGetInteger64i_v(target, c, &i64);
2237                         if (i64 < static_cast<GLint64>(min_values[c]))
2238                         {
2239                                 m_context.getTestContext().getLog()
2240                                         << tcu::TestLog::Message << "Is " << static_cast<GLint>(i64) << " should be at least "
2241                                         << min_values[c] << "." << tcu::TestLog::EndMessage;
2242                                 return false;
2243                         }
2244                 }
2245                 for (GLuint c = 0; c < 3; c++)
2246                 {
2247                         glGetFloati_v(target, c, &f);
2248                         if (f < static_cast<GLfloat>(min_values[c]))
2249                         {
2250                                 m_context.getTestContext().getLog()
2251                                         << tcu::TestLog::Message << "Is " << static_cast<GLint>(f) << " should be at least "
2252                                         << min_values[c] << "." << tcu::TestLog::EndMessage;
2253                                 return false;
2254                         }
2255                 }
2256                 for (GLuint c = 0; c < 3; c++)
2257                 {
2258                         glGetDoublei_v(target, c, &d);
2259                         if (d < static_cast<GLdouble>(min_values[c]))
2260                         {
2261                                 m_context.getTestContext().getLog()
2262                                         << tcu::TestLog::Message << "Is " << static_cast<GLint>(d) << " should be at least "
2263                                         << min_values[c] << "." << tcu::TestLog::EndMessage;
2264                                 return false;
2265                         }
2266                 }
2267                 for (GLuint c = 0; c < 3; c++)
2268                 {
2269                         glGetBooleani_v(target, c, &b);
2270                         if (b == GL_FALSE)
2271                         {
2272                                 m_context.getTestContext().getLog()
2273                                         << tcu::TestLog::Message << "Is GL_FALSE should be at least GL_TRUE." << tcu::TestLog::EndMessage;
2274                                 return false;
2275                         }
2276                 }
2277
2278                 return true;
2279         }
2280
2281         bool Check(GLenum target, const GLint min_value)
2282         {
2283                 GLint    i;
2284                 GLint64   i64;
2285                 GLfloat   f;
2286                 GLdouble  d;
2287                 GLboolean b;
2288
2289                 glGetIntegerv(target, &i);
2290                 if (i < min_value)
2291                 {
2292                         m_context.getTestContext().getLog() << tcu::TestLog::Message << "Is " << i << " should be at least "
2293                                                                                                 << min_value << "." << tcu::TestLog::EndMessage;
2294                         return false;
2295                 }
2296                 glGetInteger64v(target, &i64);
2297                 if (static_cast<GLint>(i64) < min_value)
2298                 {
2299                         m_context.getTestContext().getLog()
2300                                 << tcu::TestLog::Message << "Is " << static_cast<GLint>(i64) << " should be at least " << min_value
2301                                 << "." << tcu::TestLog::EndMessage;
2302                         return false;
2303                 }
2304                 glGetFloatv(target, &f);
2305                 if (f < static_cast<GLfloat>(min_value))
2306                 {
2307                         m_context.getTestContext().getLog()
2308                                 << tcu::TestLog::Message << "Is " << static_cast<GLint>(f) << " should be at least " << min_value << "."
2309                                 << tcu::TestLog::EndMessage;
2310                         return false;
2311                 }
2312                 glGetDoublev(target, &d);
2313                 if (d < static_cast<GLdouble>(min_value))
2314                 {
2315                         m_context.getTestContext().getLog()
2316                                 << tcu::TestLog::Message << "Is " << static_cast<GLint>(d) << " should be at least " << min_value << "."
2317                                 << tcu::TestLog::EndMessage;
2318                         return false;
2319                 }
2320                 glGetBooleanv(target, &b);
2321                 if (b != (min_value ? GL_TRUE : GL_FALSE))
2322                 {
2323                         m_context.getTestContext().getLog() << tcu::TestLog::Message << "Is " << b << " should be "
2324                                                                                                 << (min_value ? GL_TRUE : GL_FALSE) << "." << tcu::TestLog::EndMessage;
2325                         return false;
2326                 }
2327
2328                 return true;
2329         }
2330
2331         virtual long Setup()
2332         {
2333                 m_program = 0;
2334                 m_buffer  = 0;
2335                 return NO_ERROR;
2336         }
2337
2338         virtual long Run()
2339         {
2340                 const GLint work_group_count[3] = { 65535, 65535, 65535 };
2341                 if (!CheckIndexed(GL_MAX_COMPUTE_WORK_GROUP_COUNT, work_group_count))
2342                         return ERROR;
2343
2344                 const GLint work_group_size[3] = { 1024, 1024, 64 };
2345                 if (!CheckIndexed(GL_MAX_COMPUTE_WORK_GROUP_SIZE, work_group_size))
2346                         return ERROR;
2347
2348                 if (!Check(GL_MAX_COMPUTE_UNIFORM_BLOCKS, 12))
2349                         return ERROR;
2350                 if (!Check(GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS, 16))
2351                         return ERROR;
2352                 if (!Check(GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS, 8))
2353                         return ERROR;
2354                 if (!Check(GL_MAX_COMPUTE_ATOMIC_COUNTERS, 8))
2355                         return ERROR;
2356                 if (!Check(GL_MAX_COMPUTE_SHARED_MEMORY_SIZE, 32768))
2357                         return ERROR;
2358
2359                 if (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5)))
2360                 {
2361                         if (!Check(GL_MAX_COMPUTE_UNIFORM_COMPONENTS, 1024))
2362                                 return ERROR;
2363                 }
2364                 else
2365                 {
2366                         if (!Check(GL_MAX_COMPUTE_UNIFORM_COMPONENTS, 512))
2367                                 return ERROR;
2368                 }
2369
2370                 if (!Check(GL_MAX_COMPUTE_IMAGE_UNIFORMS, 8))
2371                         return ERROR;
2372                 if (!Check(GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS, 512))
2373                         return ERROR;
2374
2375                 const char* const glsl_cs =
2376                         NL "layout(local_size_x = 1) in;" NL "layout(std430) buffer Output {" NL "  int g_output;" NL "};" NL
2377                            "uniform ivec3 MaxComputeWorkGroupCount;" NL "uniform ivec3 MaxComputeWorkGroupSize;" NL
2378                            "uniform int MaxComputeUniformComponents;" NL "uniform int MaxComputeTextureImageUnits;" NL
2379                            "uniform int MaxComputeImageUniforms;" NL "uniform int MaxComputeAtomicCounters;" NL
2380                            "uniform int MaxComputeAtomicCounterBuffers;" NL "void main() {" NL "  g_output = 1;" NL
2381                            "  if (MaxComputeWorkGroupCount != gl_MaxComputeWorkGroupCount) g_output = 0;" NL
2382                            "  if (MaxComputeWorkGroupSize != gl_MaxComputeWorkGroupSize) g_output = 0;" NL
2383                            "  if (MaxComputeUniformComponents != gl_MaxComputeUniformComponents) g_output = 0;" NL
2384                            "  if (MaxComputeTextureImageUnits != gl_MaxComputeTextureImageUnits) g_output = 0;" NL
2385                            "  if (MaxComputeImageUniforms != gl_MaxComputeImageUniforms) g_output = 0;" NL
2386                            "  if (MaxComputeAtomicCounters != gl_MaxComputeAtomicCounters) g_output = 0;" NL
2387                            "  if (MaxComputeAtomicCounterBuffers != gl_MaxComputeAtomicCounterBuffers) g_output = 0;" NL "}";
2388                 m_program = CreateComputeProgram(glsl_cs);
2389                 glLinkProgram(m_program);
2390                 if (!CheckProgram(m_program))
2391                         return ERROR;
2392                 glUseProgram(m_program);
2393
2394                 GLint p[3];
2395                 glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_COUNT, 0, &p[0]);
2396                 glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_COUNT, 1, &p[1]);
2397                 glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_COUNT, 2, &p[2]);
2398                 glUniform3i(glGetUniformLocation(m_program, "MaxComputeWorkGroupCount"), p[0], p[1], p[2]);
2399
2400                 glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_SIZE, 0, &p[0]);
2401                 glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_SIZE, 1, &p[1]);
2402                 glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_SIZE, 2, &p[2]);
2403                 glUniform3iv(glGetUniformLocation(m_program, "MaxComputeWorkGroupSize"), 1, p);
2404
2405                 glGetIntegerv(GL_MAX_COMPUTE_UNIFORM_COMPONENTS, p);
2406                 glUniform1i(glGetUniformLocation(m_program, "MaxComputeUniformComponents"), p[0]);
2407
2408                 glGetIntegerv(GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS, p);
2409                 glUniform1iv(glGetUniformLocation(m_program, "MaxComputeTextureImageUnits"), 1, p);
2410
2411                 glGetIntegerv(GL_MAX_COMPUTE_IMAGE_UNIFORMS, p);
2412                 glUniform1i(glGetUniformLocation(m_program, "MaxComputeImageUniforms"), p[0]);
2413
2414                 glGetIntegerv(GL_MAX_COMPUTE_ATOMIC_COUNTERS, p);
2415                 glUniform1i(glGetUniformLocation(m_program, "MaxComputeAtomicCounters"), p[0]);
2416
2417                 glGetIntegerv(GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS, p);
2418                 glUniform1i(glGetUniformLocation(m_program, "MaxComputeAtomicCounterBuffers"), p[0]);
2419
2420                 GLint data = 0xffff;
2421                 glGenBuffers(1, &m_buffer);
2422                 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_buffer);
2423                 glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(GLint), &data, GL_DYNAMIC_DRAW);
2424
2425                 glDispatchCompute(1, 1, 1);
2426
2427                 glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
2428                 glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(GLint), &data);
2429
2430                 return data == 1 ? NO_ERROR : ERROR;
2431         }
2432         virtual long Cleanup()
2433         {
2434                 glUseProgram(0);
2435                 glDeleteProgram(m_program);
2436                 glDeleteBuffers(1, &m_buffer);
2437                 return NO_ERROR;
2438         }
2439 };
2440
2441 class BasicBuildMonolithic : public ComputeShaderBase
2442 {
2443
2444         virtual std::string Title()
2445         {
2446                 return "Building CS monolithic program";
2447         }
2448
2449         virtual std::string Purpose()
2450         {
2451                 return NL "1. Verify that building monolithic CS program works as expected." NL
2452                                   "2. Verify that program consisting from 3 compilation units links as expected." NL
2453                                   "3. Verify that CS consisting from 2 strings compiles as expected.";
2454         }
2455
2456         virtual std::string Method()
2457         {
2458                 return NL "1. Create, compile and link CS using CreateShader, CompileShader and LinkProgram commands." NL
2459                                   "2. Dispatch and verify CS program.";
2460         }
2461
2462         virtual std::string PassCriteria()
2463         {
2464                 return "Everything works as expected.";
2465         }
2466
2467         virtual long Run()
2468         {
2469                 const char* const cs1[2] = { "#version 430 core",
2470
2471                                                                          NL "layout(local_size_x = 1) in;" NL "void Run();" NL "void main() {" NL
2472                                                                                 "  Run();" NL "}" };
2473
2474                 const char* const cs2 =
2475                         "#version 430 core" NL "layout(binding = 0, std430) buffer Output {" NL "  vec4 g_output;" NL "};" NL
2476                         "vec4 CalculateOutput();" NL "void Run() {" NL "  g_output = CalculateOutput();" NL "}";
2477
2478                 const char* const cs3 =
2479                         "#version 430 core" NL "layout(local_size_x = 1) in;" NL "layout(binding = 0, std430) buffer Output {" NL
2480                         "  vec4 g_output;" NL "};" NL "vec4 CalculateOutput() {" NL "  g_output = vec4(0);" NL
2481                         "  return vec4(1, 2, 3, 4);" NL "}";
2482
2483                 const GLuint sh1 = glCreateShader(GL_COMPUTE_SHADER);
2484
2485                 GLint type;
2486                 glGetShaderiv(sh1, GL_SHADER_TYPE, &type);
2487                 if (static_cast<GLenum>(type) != GL_COMPUTE_SHADER)
2488                 {
2489                         m_context.getTestContext().getLog()
2490                                 << tcu::TestLog::Message << "SHADER_TYPE should be COMPUTE_SHADER." << tcu::TestLog::EndMessage;
2491                         glDeleteShader(sh1);
2492                         return false;
2493                 }
2494
2495                 glShaderSource(sh1, 2, cs1, NULL);
2496                 glCompileShader(sh1);
2497
2498                 const GLuint sh2 = glCreateShader(GL_COMPUTE_SHADER);
2499                 glShaderSource(sh2, 1, &cs2, NULL);
2500                 glCompileShader(sh2);
2501
2502                 const GLuint sh3 = glCreateShader(GL_COMPUTE_SHADER);
2503                 glShaderSource(sh3, 1, &cs3, NULL);
2504                 glCompileShader(sh3);
2505
2506                 const GLuint p = glCreateProgram();
2507                 glAttachShader(p, sh1);
2508                 glAttachShader(p, sh2);
2509                 glAttachShader(p, sh3);
2510                 glLinkProgram(p);
2511
2512                 glDeleteShader(sh1);
2513                 glDeleteShader(sh2);
2514                 glDeleteShader(sh3);
2515
2516                 bool res = CheckProgram(p);
2517
2518                 GLuint buffer;
2519                 glGenBuffers(1, &buffer);
2520                 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, buffer);
2521                 glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(vec4), &vec4(0.0f)[0], GL_DYNAMIC_DRAW);
2522                 glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
2523
2524                 glUseProgram(p);
2525                 glDispatchCompute(1, 1, 1);
2526
2527                 vec4 data;
2528                 glBindBuffer(GL_SHADER_STORAGE_BUFFER, buffer);
2529                 glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
2530                 glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(vec4), &data[0]);
2531                 if (!IsEqual(data, vec4(1.0f, 2.0f, 3.0f, 4.0f)))
2532                 {
2533                         m_context.getTestContext().getLog()
2534                                 << tcu::TestLog::Message << "Invalid value!" << tcu::TestLog::EndMessage;
2535                         res = false;
2536                 }
2537
2538                 glDeleteBuffers(1, &buffer);
2539                 glUseProgram(0);
2540                 glDeleteProgram(p);
2541
2542                 return res == true ? NO_ERROR : ERROR;
2543         }
2544 };
2545
2546 class BasicBuildSeparable : public ComputeShaderBase
2547 {
2548
2549         virtual std::string Title()
2550         {
2551                 return "Building CS separable program";
2552         }
2553
2554         virtual std::string Purpose()
2555         {
2556                 return NL "1. Verify that building separable CS program works as expected." NL
2557                                   "2. Verify that program consisting from 4 strings works as expected.";
2558         }
2559
2560         virtual std::string Method()
2561         {
2562                 return NL "1. Create, compile and link CS using CreateShaderProgramv command." NL
2563                                   "2. Dispatch and verify CS program.";
2564         }
2565
2566         virtual std::string PassCriteria()
2567         {
2568                 return "Everything works as expected.";
2569         }
2570
2571         virtual long Run()
2572         {
2573                 const char* const cs[4] = {
2574                         "#version 430 core",
2575
2576                         NL "layout(local_size_x = 1) in;" NL "void Run();" NL "void main() {" NL "  Run();" NL "}",
2577                         NL "layout(binding = 0, std430) buffer Output {" NL "  vec4 g_output;" NL "};" NL
2578                            "vec4 CalculateOutput();" NL "void Run() {" NL "  g_output = CalculateOutput();" NL "}",
2579                         NL "vec4 CalculateOutput() {" NL "  g_output = vec4(0);" NL "  return vec4(1, 2, 3, 4);" NL "}"
2580                 };
2581
2582                 const GLuint p   = glCreateShaderProgramv(GL_COMPUTE_SHADER, 4, cs);
2583                 bool             res = CheckProgram(p);
2584
2585                 GLuint buffer;
2586                 glGenBuffers(1, &buffer);
2587                 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, buffer);
2588                 glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(vec4), &vec4(0.0f)[0], GL_DYNAMIC_DRAW);
2589                 glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
2590
2591                 glUseProgram(p);
2592                 glDispatchCompute(1, 1, 1);
2593
2594                 vec4 data;
2595                 glBindBuffer(GL_SHADER_STORAGE_BUFFER, buffer);
2596                 glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
2597                 glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(vec4), &data[0]);
2598                 if (!IsEqual(data, vec4(1.0f, 2.0f, 3.0f, 4.0f)))
2599                 {
2600                         m_context.getTestContext().getLog()
2601                                 << tcu::TestLog::Message << "Invalid value!" << tcu::TestLog::EndMessage;
2602                         res = false;
2603                 }
2604
2605                 glBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(vec4), &vec4(0.0f)[0]);
2606
2607                 GLuint pipeline;
2608                 glGenProgramPipelines(1, &pipeline);
2609                 glUseProgramStages(pipeline, GL_COMPUTE_SHADER_BIT, p);
2610
2611                 glUseProgram(0);
2612                 glBindProgramPipeline(pipeline);
2613                 glDispatchCompute(1, 1, 1);
2614
2615                 glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
2616                 glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(vec4), &data[0]);
2617                 if (!IsEqual(data, vec4(1.0f, 2.0f, 3.0f, 4.0f)))
2618                 {
2619                         m_context.getTestContext().getLog()
2620                                 << tcu::TestLog::Message << "Invalid value!" << tcu::TestLog::EndMessage;
2621                         res = false;
2622                 }
2623
2624                 glDeleteProgramPipelines(1, &pipeline);
2625                 glDeleteBuffers(1, &buffer);
2626                 glDeleteProgram(p);
2627
2628                 return res == true ? NO_ERROR : ERROR;
2629         }
2630 };
2631
2632 class BasicSharedSimple : public ComputeShaderBase
2633 {
2634         virtual std::string Title()
2635         {
2636                 return "Shared Memory - simple usage";
2637         }
2638
2639         virtual std::string Purpose()
2640         {
2641                 return NL "1. Verify that shared array of uints works as expected." NL
2642                                   "2. Verify that shared memory written by one invocation is observable by other invocations" NL
2643                                   "    when groupMemoryBarrier() and barrier() built-in functions are used.";
2644         }
2645
2646         virtual std::string Method()
2647         {
2648                 return NL "1. Create and dispatch CS with DispatchCompute and DispatchComputeIndirect commands." NL
2649                                   "2. Verify results written by CS to SSBO." NL
2650                                   "3. Repeat for several different number of work groups.";
2651         }
2652
2653         virtual std::string PassCriteria()
2654         {
2655                 return "Everything works as expected.";
2656         }
2657
2658         GLuint m_program;
2659         GLuint m_storage_buffer;
2660         GLuint m_dispatch_buffer;
2661
2662         bool RunIteration(const GLuint num_groups, bool dispatch_indirect)
2663         {
2664                 const GLuint kBufferSize = 256 * num_groups;
2665
2666                 std::vector<GLuint> data(kBufferSize, 0xffff);
2667                 if (m_storage_buffer == 0)
2668                         glGenBuffers(1, &m_storage_buffer);
2669                 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_storage_buffer);
2670                 glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(GLuint) * kBufferSize, &data[0], GL_DYNAMIC_DRAW);
2671                 glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
2672
2673                 glUseProgram(m_program);
2674                 if (dispatch_indirect)
2675                 {
2676                         const GLuint groups[3] = { num_groups, 1, 1 };
2677                         if (m_dispatch_buffer == 0)
2678                                 glGenBuffers(1, &m_dispatch_buffer);
2679                         glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, m_dispatch_buffer);
2680                         glBufferData(GL_DISPATCH_INDIRECT_BUFFER, sizeof(groups), groups, GL_STATIC_DRAW);
2681                         glDispatchComputeIndirect(0);
2682                 }
2683                 else
2684                 {
2685                         glDispatchCompute(num_groups, 1, 1);
2686                 }
2687
2688                 glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_storage_buffer);
2689                 glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
2690                 glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(GLuint) * kBufferSize, &data[0]);
2691                 for (GLuint i = 0; i < kBufferSize; ++i)
2692                 {
2693                         if (data[i] != 1)
2694                         {
2695                                 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Data at index " << i << " is "
2696                                                                                                         << data[i] << " should be 1." << tcu::TestLog::EndMessage;
2697                                 return false;
2698                         }
2699                 }
2700                 return true;
2701         }
2702
2703         virtual long Setup()
2704         {
2705                 m_program                 = 0;
2706                 m_storage_buffer  = 0;
2707                 m_dispatch_buffer = 0;
2708                 return NO_ERROR;
2709         }
2710
2711         virtual long Run()
2712         {
2713                 const char* const glsl_cs =
2714                         NL "layout(local_size_x = 256) in;" NL "layout(std430) buffer Output {" NL "  uint g_output[];" NL "};" NL
2715                            "shared uint g_shared_data[256];" NL "void main() {" NL
2716                            "  g_shared_data[gl_LocalInvocationID.x] = gl_LocalInvocationIndex;" NL
2717                            "  groupMemoryBarrier();" // flush memory stores
2718                         NL "  barrier();"                        // wait for all stores to finish
2719                         NL "  g_output[gl_GlobalInvocationID.x] = 1;" NL "  if (gl_LocalInvocationIndex < 255) {" NL
2720                            "    const uint res = g_shared_data[gl_LocalInvocationID.x + "
2721                            "1];" // load data from shared memory filled by other thread
2722                         NL "    if (res != (gl_LocalInvocationIndex + 1)) {" NL "      g_output[gl_GlobalInvocationID.x] = 0;" NL
2723                            "    }" NL "  }" NL "}";
2724                 m_program = CreateComputeProgram(glsl_cs);
2725                 glLinkProgram(m_program);
2726                 if (!CheckProgram(m_program))
2727                         return ERROR;
2728
2729                 if (!RunIteration(1, false))
2730                         return ERROR;
2731                 if (!RunIteration(8, true))
2732                         return ERROR;
2733                 if (!RunIteration(13, false))
2734                         return ERROR;
2735                 if (!RunIteration(7, true))
2736                         return ERROR;
2737                 return NO_ERROR;
2738         }
2739         virtual long Cleanup()
2740         {
2741                 glUseProgram(0);
2742                 glDeleteProgram(m_program);
2743                 glDeleteBuffers(1, &m_storage_buffer);
2744                 glDeleteBuffers(1, &m_dispatch_buffer);
2745                 return NO_ERROR;
2746         }
2747 };
2748
2749 class BasicSharedStruct : public ComputeShaderBase
2750 {
2751         virtual std::string Title()
2752         {
2753                 return "Shared Memory - arrays and structers";
2754         }
2755
2756         virtual std::string Purpose()
2757         {
2758                 return NL "1. Verify that vectors, matrices, structers and arrays of those can be used" NL
2759                                   "    as a shared memory." NL
2760                                   "2. Verify that shared memory can be indexed with constant values, built-in" NL
2761                                   "    variables and dynamic expressions." NL
2762                                   "3. Verify that memoryBarrierAtomicCounter(), memoryBarrierImage(), memoryBarrier()," NL
2763                                   "     memoryBarrierBuffer() and memoryBarrierShared() built-in functions are accepted" NL
2764                                   "     by the GLSL compiler.";
2765         }
2766
2767         virtual std::string Method()
2768         {
2769                 return NL "1. Create and dispatch CS with DispatchCompute and DispatchComputeIndirect commands." NL
2770                                   "2. Verify results written by CS to SSBO.";
2771         }
2772
2773         virtual std::string PassCriteria()
2774         {
2775                 return "Everything works as expected.";
2776         }
2777
2778         GLuint m_program;
2779         GLuint m_storage_buffer;
2780         GLuint m_dispatch_buffer;
2781
2782         bool RunIteration(bool dispatch_indirect)
2783         {
2784                 const GLuint kBufferSize = 256;
2785
2786                 std::vector<vec4> data(kBufferSize);
2787                 if (m_storage_buffer == 0)
2788                         glGenBuffers(1, &m_storage_buffer);
2789                 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_storage_buffer);
2790                 glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(vec4) * kBufferSize, &data[0], GL_DYNAMIC_DRAW);
2791                 glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
2792
2793                 glUseProgram(m_program);
2794                 if (dispatch_indirect)
2795                 {
2796                         const GLuint groups[3] = { 1, 1, 1 };
2797                         if (m_dispatch_buffer == 0)
2798                                 glGenBuffers(1, &m_dispatch_buffer);
2799                         glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, m_dispatch_buffer);
2800                         glBufferData(GL_DISPATCH_INDIRECT_BUFFER, sizeof(groups), groups, GL_STATIC_DRAW);
2801                         glDispatchComputeIndirect(0);
2802                 }
2803                 else
2804                 {
2805                         glDispatchCompute(1, 1, 1);
2806                 }
2807
2808                 glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_storage_buffer);
2809                 glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
2810                 glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(vec4) * kBufferSize, &data[0]);
2811                 for (GLuint i = 0; i < kBufferSize; ++i)
2812                 {
2813                         if (!IsEqual(data[i], vec4(static_cast<float>(i))))
2814                         {
2815                                 m_context.getTestContext().getLog()
2816                                         << tcu::TestLog::Message << "Invalid data at index " << i << "." << tcu::TestLog::EndMessage;
2817                                 return false;
2818                         }
2819                 }
2820                 return true;
2821         }
2822
2823         virtual long Setup()
2824         {
2825                 m_program                 = 0;
2826                 m_storage_buffer  = 0;
2827                 m_dispatch_buffer = 0;
2828                 return NO_ERROR;
2829         }
2830
2831         virtual long Run()
2832         {
2833                 const char* const glsl_cs = NL
2834                         "layout(local_size_x = 128) in;" NL "layout(std430) buffer Output {" NL "  vec4 g_output[256];" NL "};" NL
2835                         "struct SubData {" NL "  mat2x4 data;" NL "};" NL "struct Data {" NL "  uint index;" NL "  vec3 data0;" NL
2836                         "  SubData data1;" NL "};" NL "shared Data g_shared_data[256];" NL "shared int g_shared_buf[2];" NL
2837                         "void main() {" NL "  if (gl_LocalInvocationID.x == 0) {" NL "    g_shared_buf[1] = 1;" NL
2838                         "    g_shared_buf[1 + gl_LocalInvocationID.x] = 0;" NL "    g_shared_buf[0] = 128;" NL
2839                         "    g_output[0] = vec4(g_shared_buf[1]);" NL "    g_output[128] = vec4(g_shared_buf[0]);" NL
2840                         "    memoryBarrierBuffer();" // note: this call is not needed here, just check if compiler accepts it
2841                         NL "  } else {" NL "    const uint index = gl_LocalInvocationIndex;" NL
2842                         "    g_shared_data[index].index = index;" NL "    g_shared_data[index + 128].index = index + 128;" NL
2843                         "    g_shared_data[index].data1.data = mat2x4(0.0);" NL
2844                         "    g_shared_data[index + 128].data1.data = mat2x4(0.0);" NL
2845                         "    g_output[index] = vec4(g_shared_data[index].index);" // load data from shared memory
2846                         NL "    g_output[index + 128] = vec4(g_shared_data[index + 128].index);" NL
2847                         "    memoryBarrierShared();" // note: this call is not needed here, just check if compiler accepts it
2848                         NL "  }" NL "  memoryBarrierAtomicCounter();" NL "  memoryBarrierImage();" NL
2849                         "  memoryBarrier();" // note: these calls are not needed here, just check if compiler accepts them
2850                         NL "}";
2851                 m_program = CreateComputeProgram(glsl_cs);
2852                 glLinkProgram(m_program);
2853                 if (!CheckProgram(m_program))
2854                         return ERROR;
2855
2856                 if (!RunIteration(false))
2857                         return ERROR;
2858                 if (!RunIteration(true))
2859                         return ERROR;
2860                 return NO_ERROR;
2861         }
2862
2863         virtual long Cleanup()
2864         {
2865                 glUseProgram(0);
2866                 glDeleteProgram(m_program);
2867                 glDeleteBuffers(1, &m_storage_buffer);
2868                 glDeleteBuffers(1, &m_dispatch_buffer);
2869                 return NO_ERROR;
2870         }
2871 };
2872
2873 class BasicDispatchIndirect : public ComputeShaderBase
2874 {
2875         virtual std::string Title()
2876         {
2877                 return NL "DispatchComputeIndirect command";
2878         }
2879
2880         virtual std::string Purpose()
2881         {
2882                 return NL
2883                         "1. Verify that DispatchComputeIndirect command works as described in the OpenGL specification." NL
2884                         "2. Verify that <offset> parameter is correctly applied." NL
2885                         "3. Verify that updating dispatch buffer with different methods (BufferData, BufferSubData, MapBuffer)" NL
2886                         "    just before DispatchComputeIndirect call works as expected." NL
2887                         "4. Verify that GL_DISPATCH_INDIRECT_BUFFER_BINDING binding point is set correctly.";
2888         }
2889
2890         virtual std::string Method()
2891         {
2892                 return NL
2893                         "1. Create CS and dispatch indirect buffer." NL "2. Dispatch CS with DispatchComputeIndirect command." NL
2894                         "3. Update dispatch indirect buffer." NL
2895                         "4. Repeat several times updating dispatch buffer with different methods and changing <offset> parameter.";
2896         }
2897
2898         virtual std::string PassCriteria()
2899         {
2900                 return NL "Everything works as expected.";
2901         }
2902
2903         GLuint m_program;
2904         GLuint m_storage_buffer;
2905         GLuint m_dispatch_buffer[2];
2906
2907         bool RunIteration(GLintptr offset, GLuint buffer_size)
2908         {
2909                 std::vector<GLuint> data(buffer_size);
2910                 if (m_storage_buffer == 0)
2911                         glGenBuffers(1, &m_storage_buffer);
2912                 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_storage_buffer);
2913                 glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(GLuint) * buffer_size, &data[0], GL_DYNAMIC_DRAW);
2914
2915                 glDispatchComputeIndirect(offset);
2916
2917                 glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
2918                 glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(GLuint) * buffer_size, &data[0]);
2919                 for (GLuint i = 0; i < buffer_size; ++i)
2920                 {
2921                         if (data[i] != i)
2922                         {
2923                                 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Data at index " << i << " is "
2924                                                                                                         << data[i] << " should be " << i << "." << tcu::TestLog::EndMessage;
2925                                 return false;
2926                         }
2927                 }
2928                 return true;
2929         }
2930
2931         bool CheckBinding(GLuint expected)
2932         {
2933                 GLint    i;
2934                 GLint64   i64;
2935                 GLfloat   f;
2936                 GLdouble  d;
2937                 GLboolean b;
2938
2939                 glGetIntegerv(GL_DISPATCH_INDIRECT_BUFFER_BINDING, &i);
2940                 if (static_cast<GLuint>(i) != expected)
2941                 {
2942                         return false;
2943                 }
2944                 glGetInteger64v(GL_DISPATCH_INDIRECT_BUFFER_BINDING, &i64);
2945                 if (static_cast<GLuint>(i64) != expected)
2946                 {
2947                         return false;
2948                 }
2949                 glGetFloatv(GL_DISPATCH_INDIRECT_BUFFER_BINDING, &f);
2950                 if (static_cast<GLuint>(f) != expected)
2951                 {
2952                         return false;
2953                 }
2954                 glGetDoublev(GL_DISPATCH_INDIRECT_BUFFER_BINDING, &d);
2955                 if (static_cast<GLuint>(d) != expected)
2956                 {
2957                         return false;
2958                 }
2959                 glGetBooleanv(GL_DISPATCH_INDIRECT_BUFFER_BINDING, &b);
2960                 if (b != (expected != 0 ? GL_TRUE : GL_FALSE))
2961                 {
2962                         return false;
2963                 }
2964
2965                 return true;
2966         }
2967
2968         virtual long Setup()
2969         {
2970                 m_program                = 0;
2971                 m_storage_buffer = 0;
2972                 memset(m_dispatch_buffer, 0, sizeof(m_dispatch_buffer));
2973                 return NO_ERROR;
2974         }
2975
2976         virtual long Run()
2977         {
2978                 const char* const glsl_cs =
2979                         NL "layout(local_size_x = 1) in;" NL "layout(std430) buffer Output {" NL "  uint g_output[];" NL "};" NL
2980                            "uniform uvec3 g_global_size;" NL "void main() {" NL
2981                            "  const uint global_index = gl_GlobalInvocationID.x +" NL
2982                            "                            gl_GlobalInvocationID.y * g_global_size.x +" NL
2983                            "                            gl_GlobalInvocationID.z * g_global_size.x * g_global_size.y;" NL
2984                            "  if (gl_NumWorkGroups != g_global_size) {" NL "    g_output[global_index] = 0xffff;" NL
2985                            "    return;" NL "  }" NL "  g_output[global_index] = global_index;" NL "}";
2986                 m_program = CreateComputeProgram(glsl_cs);
2987                 glLinkProgram(m_program);
2988                 if (!CheckProgram(m_program))
2989                         return ERROR;
2990
2991                 if (!CheckBinding(0))
2992                         return ERROR;
2993
2994                 glGenBuffers(2, m_dispatch_buffer);
2995
2996                 const GLuint data[]  = { 1, 2, 3, 4, 5, 6, 7, 8 };
2997                 const GLuint data2[] = { 3, 1, 4, 4 };
2998
2999                 glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, m_dispatch_buffer[0]);
3000                 glBufferData(GL_DISPATCH_INDIRECT_BUFFER, sizeof(data), data, GL_STREAM_DRAW);
3001                 if (!CheckBinding(m_dispatch_buffer[0]))
3002                         return ERROR;
3003
3004                 glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, m_dispatch_buffer[1]);
3005                 glBufferData(GL_DISPATCH_INDIRECT_BUFFER, sizeof(data2), data2, GL_STREAM_READ);
3006                 if (!CheckBinding(m_dispatch_buffer[1]))
3007                         return ERROR;
3008
3009                 glUseProgram(m_program);
3010                 glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, m_dispatch_buffer[0]);
3011
3012                 glUniform3ui(glGetUniformLocation(m_program, "g_global_size"), 1, 2, 3);
3013                 if (!RunIteration(0, 6))
3014                         return ERROR;
3015
3016                 glUniform3ui(glGetUniformLocation(m_program, "g_global_size"), 2, 3, 4);
3017                 if (!RunIteration(4, 24))
3018                         return ERROR;
3019
3020                 glUniform3ui(glGetUniformLocation(m_program, "g_global_size"), 4, 5, 6);
3021                 if (!RunIteration(12, 120))
3022                         return ERROR;
3023
3024                 glBufferSubData(GL_DISPATCH_INDIRECT_BUFFER, 20, 12, data);
3025                 glUniform3ui(glGetUniformLocation(m_program, "g_global_size"), 1, 2, 3);
3026                 if (!RunIteration(20, 6))
3027                         return ERROR;
3028
3029                 GLuint* ptr = static_cast<GLuint*>(glMapBuffer(GL_DISPATCH_INDIRECT_BUFFER, GL_WRITE_ONLY));
3030                 *ptr++          = 4;
3031                 *ptr++          = 4;
3032                 *ptr++          = 4;
3033                 glUnmapBuffer(GL_DISPATCH_INDIRECT_BUFFER);
3034
3035                 glUniform3ui(glGetUniformLocation(m_program, "g_global_size"), 4, 4, 4);
3036                 if (!RunIteration(0, 64))
3037                         return ERROR;
3038
3039                 glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, m_dispatch_buffer[1]);
3040
3041                 glUniform3ui(glGetUniformLocation(m_program, "g_global_size"), 1, 4, 4);
3042                 if (!RunIteration(4, 16))
3043                         return ERROR;
3044
3045                 glDeleteBuffers(2, m_dispatch_buffer);
3046                 memset(m_dispatch_buffer, 0, sizeof(m_dispatch_buffer));
3047
3048                 if (!CheckBinding(0))
3049                         return ERROR;
3050
3051                 return NO_ERROR;
3052         }
3053         virtual long Cleanup()
3054         {
3055                 glUseProgram(0);
3056                 glDeleteProgram(m_program);
3057                 glDeleteBuffers(1, &m_storage_buffer);
3058                 glDeleteBuffers(2, m_dispatch_buffer);
3059                 return NO_ERROR;
3060         }
3061 };
3062
3063 class BasicSSOComputePipeline : public ComputeShaderBase
3064 {
3065         virtual std::string Title()
3066         {
3067                 return NL "Separable CS Programs - Compute and non-compute stages (1)";
3068         }
3069         virtual std::string Purpose()
3070         {
3071                 return NL "1. Verify that compute and non-compute stages can be attached to one pipeline object." NL
3072                                   "2. Verify that DrawArrays and ComputeDispatch commands works as expected in this case.";
3073         }
3074         virtual std::string Method()
3075         {
3076                 return NL "1. Create VS, FS and CS. Attach all created stages to one pipeline object." NL
3077                                   "2. Bind pipeline object." NL "3. Invoke compute stage with DispatchCompute commmand." NL
3078                                   "4. Issue MemoryBarrier command." NL
3079                                   "5. Issue DrawArrays command which uses data written by the compute stage." NL "6. Verify result.";
3080         }
3081         virtual std::string PassCriteria()
3082         {
3083                 return NL "Everything works as expected.";
3084         }
3085
3086         GLuint m_vsp, m_fsp, m_csp;
3087         GLuint m_storage_buffer;
3088         GLuint m_vertex_array;
3089         GLuint m_pipeline;
3090
3091         virtual long Setup()
3092         {
3093                 m_vsp = m_fsp = m_csp = 0;
3094                 m_storage_buffer          = 0;
3095                 m_vertex_array            = 0;
3096                 m_pipeline                        = 0;
3097                 return NO_ERROR;
3098         }
3099         virtual long Run()
3100         {
3101                 const char* const glsl_cs =
3102                         NL "layout(local_size_x = 4) in;" NL "layout(std430) buffer Output {" NL "  vec4 g_output[4];" NL "};" NL
3103                            "void main() {" NL "  const vec2 quad[4] = { vec2(-1, -1), vec2(1, -1), vec2(-1, 1), vec2(1, 1) };" NL
3104                            "  g_output[gl_GlobalInvocationID.x] = vec4(quad[gl_GlobalInvocationID.x], 0, 1);" NL "}";
3105
3106                 m_csp = CreateComputeProgram(glsl_cs);
3107                 glProgramParameteri(m_csp, GL_PROGRAM_SEPARABLE, GL_TRUE);
3108                 glLinkProgram(m_csp);
3109                 if (!CheckProgram(m_csp))
3110                         return ERROR;
3111
3112                 const char* const glsl_vs =
3113                         NL "layout(location = 0) in vec4 i_position;" NL "out gl_PerVertex {" NL "  vec4 gl_Position;" NL "};" NL
3114                            "void main() {" NL "  gl_Position = i_position;" NL "}";
3115                 m_vsp = BuildShaderProgram(GL_VERTEX_SHADER, glsl_vs);
3116                 if (!CheckProgram(m_vsp))
3117                         return ERROR;
3118
3119                 const char* const glsl_fs =
3120                         NL "layout(location = 0) out vec4 o_color;" NL "void main() {" NL "  o_color = vec4(0, 1, 0, 1);" NL "}";
3121                 m_fsp = BuildShaderProgram(GL_FRAGMENT_SHADER, glsl_fs);
3122                 if (!CheckProgram(m_fsp))
3123                         return ERROR;
3124
3125                 glGenProgramPipelines(1, &m_pipeline);
3126                 glUseProgramStages(m_pipeline, GL_VERTEX_SHADER_BIT, m_vsp);
3127                 glUseProgramStages(m_pipeline, GL_FRAGMENT_SHADER_BIT, m_fsp);
3128                 glUseProgramStages(m_pipeline, GL_COMPUTE_SHADER_BIT, m_csp);
3129
3130                 glGenBuffers(1, &m_storage_buffer);
3131                 glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_storage_buffer);
3132                 glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(vec4) * 4, NULL, GL_DYNAMIC_DRAW);
3133                 glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
3134
3135                 glGenVertexArrays(1, &m_vertex_array);
3136                 glBindVertexArray(m_vertex_array);
3137                 glBindBuffer(GL_ARRAY_BUFFER, m_storage_buffer);
3138                 glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, 0);
3139                 glBindBuffer(GL_ARRAY_BUFFER, 0);
3140                 glEnableVertexAttribArray(0);
3141                 glBindVertexArray(0);
3142
3143                 glBindProgramPipeline(m_pipeline);
3144                 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_storage_buffer);
3145                 glDispatchCompute(1, 1, 1);
3146
3147                 glClear(GL_COLOR_BUFFER_BIT);
3148                 glBindVertexArray(m_vertex_array);
3149                 glMemoryBarrier(GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT);
3150                 glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
3151
3152                 if (!ValidateReadBuffer(0, 0, getWindowWidth(), getWindowHeight(), vec4(0, 1, 0, 1)))
3153                         return ERROR;
3154                 return NO_ERROR;
3155         }
3156
3157         virtual long Cleanup()
3158         {
3159                 glDeleteProgram(m_vsp);
3160                 glDeleteProgram(m_fsp);
3161                 glDeleteProgram(m_csp);
3162                 glDeleteBuffers(1, &m_storage_buffer);
3163                 glDeleteVertexArrays(1, &m_vertex_array);
3164                 glDeleteProgramPipelines(1, &m_pipeline);
3165                 return NO_ERROR;
3166         }
3167 };
3168
3169 class BasicSSOCase2 : public ComputeShaderBase
3170 {
3171         virtual std::string Title()
3172         {
3173                 return NL "Separable CS Programs - Compute and non-compute stages (2)";
3174         }
3175         virtual std::string Purpose()
3176         {
3177                 return NL "1. Verify that data computed by the compute stage is visible to non-compute stage after "
3178                                   "MemoryBarrier command." NL "2. Verify that ProgramParameteri(program, GL_PROGRAM_SEPARABLE, "
3179                                   "GL_TRUE) command works correctly for CS." NL
3180                                   "3. Verify that gl_WorkGroupSize built-in variable is a contant and can be used as an array size.";
3181         }
3182         virtual std::string Method()
3183         {
3184                 return NL "1. Create VS, FS and CS. Attach all created stages to one pipeline object." NL
3185                                   "2. Bind pipeline object." NL "3. Invoke compute stage with DispatchCompute commmand." NL
3186                                   "4. Issue MemoryBarrier command." NL
3187                                   "5. Issue DrawArrays command which uses data written to the buffer object by the compute stage." NL
3188                                   "6. Verify result.";
3189         }
3190         virtual std::string PassCriteria()
3191         {
3192                 return NL "Everything works as expected.";
3193         }
3194
3195         GLuint m_program_ab;
3196         GLuint m_program_c;
3197         GLuint m_pipeline;
3198         GLuint m_storage_buffer;
3199         GLuint m_vao;
3200
3201         virtual long Setup()
3202         {
3203                 m_program_ab     = 0;
3204                 m_program_c              = 0;
3205                 m_pipeline               = 0;
3206                 m_storage_buffer = 0;
3207                 m_vao                    = 0;
3208                 return NO_ERROR;
3209         }
3210         virtual long Run()
3211         {
3212                 GLint res;
3213                 glGetIntegerv(GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS, &res);
3214                 if (res <= 0)
3215                 {
3216                         OutputNotSupported("GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS <= 0");
3217                         return NO_ERROR;
3218                 }
3219
3220                 const char* const glsl_a =
3221                         "#version 430 core" NL "layout(binding = 1, std430) buffer Input {" NL "  vec2 g_input[4];" NL "};" NL
3222                         "out StageData {" NL "  vec3 color;" NL "} g_vs_out;" NL "out gl_PerVertex {" NL "  vec4 gl_Position;" NL
3223                         "};" NL "void main() {" NL "  gl_Position = vec4(g_input[gl_VertexID], 0, 1);" NL
3224                         "  g_vs_out.color = vec3(0, 1, 0);" NL "}";
3225
3226                 const char* const glsl_b =
3227                         "#version 430 core" NL "in StageData {" NL "  vec3 color;" NL "} g_fs_in;" NL
3228                         "layout(location = 0) out vec4 g_color;" NL "void main() {" NL "  g_color = vec4(g_fs_in.color, 1);" NL "}";
3229
3230                 const char* const glsl_c =
3231                         "#version 430 core" NL "layout(local_size_x = 4) in;" NL "layout(binding = 1, std430) buffer Output {" NL
3232                         "  vec2 g_output[gl_WorkGroupSize.x];" NL "};" NL "void main() {" NL
3233                         "  if (gl_GlobalInvocationID.x == 0) {" NL "    g_output[0] = vec2(-0.8, -0.8);" NL
3234                         "  } else if (gl_GlobalInvocationID.x == 1) {" NL "    g_output[1] = vec2(0.8, -0.8);" NL
3235                         "  } else if (gl_GlobalInvocationID.x == 2) {" NL "    g_output[2] = vec2(-0.8, 0.8);" NL
3236                         "  } else if (gl_GlobalInvocationID.x == 3) {" NL "    g_output[3] = vec2(0.8, 0.8);" NL "  }" NL "}";
3237
3238                 m_program_ab = glCreateProgram();
3239                 GLuint sh       = glCreateShader(GL_VERTEX_SHADER);
3240                 glAttachShader(m_program_ab, sh);
3241                 glDeleteShader(sh);
3242                 glShaderSource(sh, 1, &glsl_a, NULL);
3243                 glCompileShader(sh);
3244
3245                 sh = glCreateShader(GL_FRAGMENT_SHADER);
3246                 glAttachShader(m_program_ab, sh);
3247                 glDeleteShader(sh);
3248                 glShaderSource(sh, 1, &glsl_b, NULL);
3249                 glCompileShader(sh);
3250
3251                 glProgramParameteri(m_program_ab, GL_PROGRAM_SEPARABLE, GL_TRUE);
3252                 glLinkProgram(m_program_ab);
3253
3254                 m_program_c = glCreateShaderProgramv(GL_COMPUTE_SHADER, 1, &glsl_c);
3255                 glGenVertexArrays(1, &m_vao);
3256                 glGenProgramPipelines(1, &m_pipeline);
3257                 glUseProgramStages(m_pipeline, GL_ALL_SHADER_BITS, m_program_ab);
3258                 glUseProgramStages(m_pipeline, GL_COMPUTE_SHADER_BIT, m_program_c);
3259
3260                 glGenBuffers(1, &m_storage_buffer);
3261                 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, m_storage_buffer);
3262                 glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(vec2) * 4, NULL, GL_STREAM_DRAW);
3263
3264                 glClear(GL_COLOR_BUFFER_BIT);
3265                 glBindProgramPipeline(m_pipeline);
3266                 glDispatchCompute(1, 1, 1);
3267                 glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
3268                 glBindVertexArray(m_vao);
3269                 glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
3270
3271                 if (getWindowWidth() < 500 &&
3272                         !ValidateReadBufferCenteredQuad(getWindowWidth(), getWindowHeight(), vec3(0, 1, 0)))
3273                 {
3274                         return ERROR;
3275                 }
3276                 return NO_ERROR;
3277         }
3278         virtual long Cleanup()
3279         {
3280                 glDeleteProgram(m_program_ab);
3281                 glDeleteProgram(m_program_c);
3282                 glDeleteProgramPipelines(1, &m_pipeline);
3283                 glDeleteBuffers(1, &m_storage_buffer);
3284                 glDeleteVertexArrays(1, &m_vao);
3285                 return NO_ERROR;
3286         }
3287 };
3288
3289 class BasicSSOCase3 : public ComputeShaderBase
3290 {
3291         virtual std::string Title()
3292         {
3293                 return NL "Separable CS Programs - Compute stage";
3294         }
3295         virtual std::string Purpose()
3296         {
3297                 return NL "Verify that compute shader stage selected with UseProgram command has precedence" NL
3298                                   "over compute shader stage selected with BindProgramPipeline command.";
3299         }
3300         virtual std::string Method()
3301         {
3302                 return NL "1. Create CS0 with CreateProgram command. Create CS1 with CreateShaderProgramv command." NL
3303                                   "2. Verify that CS program selected with UseProgram is dispatched even if there is active" NL
3304                                   "    compute stage bound by BindProgramPipeline.";
3305         }
3306         virtual std::string PassCriteria()
3307         {
3308                 return NL "Everything works as expected.";
3309         }
3310
3311         GLuint m_program_a;
3312         GLuint m_program_b;
3313         GLuint m_pipeline;
3314         GLuint m_storage_buffer;
3315
3316         virtual long Setup()
3317         {
3318                 m_program_a              = 0;
3319                 m_program_b              = 0;
3320                 m_pipeline               = 0;
3321                 m_storage_buffer = 0;
3322                 return NO_ERROR;
3323         }
3324         virtual long Run()
3325         {
3326                 const char* const glsl_a =
3327                         "#version 430 core" NL "layout(local_size_x = 1) in;" NL "layout(binding = 3, std430) buffer Output {" NL
3328                         "  int g_output;" NL "};" NL "void main() {" NL "  g_output = 1;" NL "}";
3329
3330                 const char* const glsl_b =
3331                         "#version 430 core" NL "layout(local_size_x = 1) in;" NL "layout(binding = 3, std430) buffer Output {" NL
3332                         "  int g_output;" NL "};" NL "void main() {" NL "  g_output = 2;" NL "}";
3333
3334                 /* create program A */
3335                 {
3336                         m_program_a = glCreateProgram();
3337                         GLuint sh   = glCreateShader(GL_COMPUTE_SHADER);
3338                         glAttachShader(m_program_a, sh);
3339                         glDeleteShader(sh);
3340                         glShaderSource(sh, 1, &glsl_a, NULL);
3341                         glCompileShader(sh);
3342                         glProgramParameteri(m_program_a, GL_PROGRAM_SEPARABLE, GL_TRUE);
3343                         glLinkProgram(m_program_a);
3344                 }
3345                 m_program_b = glCreateShaderProgramv(GL_COMPUTE_SHADER, 1, &glsl_b);
3346
3347                 /* create storage buffer */
3348                 {
3349                         int data = 0;
3350                         glGenBuffers(1, &m_storage_buffer);
3351                         glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, m_storage_buffer);
3352                         glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(int), &data, GL_STREAM_READ);
3353                 }
3354
3355                 glGenProgramPipelines(1, &m_pipeline);
3356                 glUseProgramStages(m_pipeline, GL_ALL_SHADER_BITS, m_program_b);
3357
3358                 glUseProgram(m_program_a);
3359                 glBindProgramPipeline(m_pipeline);
3360                 glDispatchCompute(1, 1, 1);
3361                 glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
3362
3363                 /* validate */
3364                 {
3365                         int data;
3366                         glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(int), &data);
3367                         if (data != 1)
3368                         {
3369                                 m_context.getTestContext().getLog()
3370                                         << tcu::TestLog::Message << "Data is " << data << " should be 1." << tcu::TestLog::EndMessage;
3371                                 return ERROR;
3372                         }
3373                 }
3374
3375                 glUseProgram(0);
3376                 glDispatchCompute(1, 1, 1);
3377                 glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
3378
3379                 /* validate */
3380                 {
3381                         int data;
3382                         glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(int), &data);
3383                         if (data != 2)
3384                         {
3385                                 m_context.getTestContext().getLog()
3386                                         << tcu::TestLog::Message << "Data is " << data << " should be 2." << tcu::TestLog::EndMessage;
3387                                 return ERROR;
3388                         }
3389                 }
3390
3391                 glUseProgram(m_program_b);
3392                 glDispatchCompute(1, 1, 1);
3393                 glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
3394
3395                 /* validate */
3396                 {
3397                         int data;
3398                         glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(int), &data);
3399                         if (data != 2)
3400                         {
3401                                 m_context.getTestContext().getLog()
3402                                         << tcu::TestLog::Message << "Data is " << data << " should be 2." << tcu::TestLog::EndMessage;
3403                                 return ERROR;
3404                         }
3405                 }
3406
3407                 glUseProgram(0);
3408                 glUseProgramStages(m_pipeline, GL_COMPUTE_SHADER_BIT, m_program_a);
3409                 glDispatchCompute(1, 1, 1);
3410                 glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
3411
3412                 /* validate */
3413                 {
3414                         int data;
3415                         glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(int), &data);
3416                         if (data != 1)
3417                         {
3418                                 m_context.getTestContext().getLog()
3419                                         << tcu::TestLog::Message << "Data is " << data << " should be 1." << tcu::TestLog::EndMessage;
3420                                 return ERROR;
3421                         }
3422                 }
3423
3424                 return NO_ERROR;
3425         }
3426         virtual long Cleanup()
3427         {
3428                 glDeleteProgram(m_program_a);
3429                 glDeleteProgram(m_program_b);
3430                 glDeleteProgramPipelines(1, &m_pipeline);
3431                 glDeleteBuffers(1, &m_storage_buffer);
3432                 return NO_ERROR;
3433         }
3434 };
3435
3436 class BasicAtomicCase1 : public ComputeShaderBase
3437 {
3438         virtual std::string Title()
3439         {
3440                 return NL "Atomic functions";
3441         }
3442         virtual std::string Purpose()
3443         {
3444                 return NL "1. Verify that atomicAdd function works as expected with int and uint parameters." NL
3445                                   "2. Verify that shared memory can be used with atomic functions." NL
3446                                   "3. Verify that groupMemoryBarrier() and barrier() built-in functions work as expected.";
3447         }
3448         virtual std::string Method()
3449         {
3450                 return NL "1. Use shared memory as a 'counter' with-in one CS work group." NL
3451                                   "2. Each shader invocation increments/decrements 'counter' value using atomicAdd function." NL
3452                                   "3. Values returned by atomicAdd function are written to SSBO." NL
3453                                   "4. Verify SSBO content (values from 0 to 7 should be written).";
3454         }
3455         virtual std::string PassCriteria()
3456         {
3457                 return NL "Everything works as expected.";
3458         }
3459
3460         GLuint m_program;
3461         GLuint m_storage_buffer;
3462
3463         virtual long Setup()
3464         {
3465                 m_program                = 0;
3466                 m_storage_buffer = 0;
3467                 return NO_ERROR;
3468         }
3469         virtual long Run()
3470         {
3471                 const char* const glsl_cs =
3472                         NL "layout(local_size_x = 8) in;" NL "layout(std430, binding = 0) buffer Output {" NL
3473                            "  uint g_add_output[8];" NL "  int g_sub_output[8];" NL "};" NL "shared uint g_add_value;" NL
3474                            "shared int g_sub_value;" NL "void main() {" NL "  if (gl_LocalInvocationIndex == 0) {" NL
3475                            "    g_add_value = 0u;" NL "    g_sub_value = 7;" NL "  }" NL
3476                            "  g_add_output[gl_LocalInvocationIndex] = 0u;" NL "  g_sub_output[gl_LocalInvocationIndex] = 0;" NL
3477                            "  groupMemoryBarrier();" NL "  barrier();" NL
3478                            "  g_add_output[gl_LocalInvocationIndex] = atomicAdd(g_add_value, 1u);" NL
3479                            "  g_sub_output[gl_LocalInvocationIndex] = atomicAdd(g_sub_value, -1);" NL "}";
3480                 m_program = CreateComputeProgram(glsl_cs);
3481                 glLinkProgram(m_program);
3482                 if (!CheckProgram(m_program))
3483                         return ERROR;
3484
3485                 glGenBuffers(1, &m_storage_buffer);
3486                 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_storage_buffer);
3487                 glBufferData(GL_SHADER_STORAGE_BUFFER, 16 * sizeof(int), NULL, GL_STATIC_DRAW);
3488
3489                 glUseProgram(m_program);
3490                 glDispatchCompute(1, 1, 1);
3491                 glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
3492
3493                 std::vector<int> data(8);
3494                 glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(int) * 8, &data[0]);
3495                 std::sort(data.begin(), data.end());
3496                 for (int i = 0; i < 8; ++i)
3497                 {
3498                         if (data[i] != i)
3499                         {
3500                                 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Data at index " << i << " is "
3501                                                                                                         << data[i] << " should be " << i << "." << tcu::TestLog::EndMessage;
3502                                 return ERROR;
3503                         }
3504                 }
3505
3506                 glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, sizeof(int) * 8, sizeof(int) * 8, &data[0]);
3507                 std::sort(data.begin(), data.end());
3508                 for (int i = 0; i < 8; ++i)
3509                 {
3510                         if (data[i] != i)
3511                         {
3512                                 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Data at index " << i << " is "
3513                                                                                                         << data[i] << " should be " << i << "." << tcu::TestLog::EndMessage;
3514                                 return ERROR;
3515                         }
3516                 }
3517
3518                 return NO_ERROR;
3519         }
3520         virtual long Cleanup()
3521         {
3522                 glUseProgram(0);
3523                 glDeleteProgram(m_program);
3524                 glDeleteBuffers(1, &m_storage_buffer);
3525                 return NO_ERROR;
3526         }
3527 };
3528
3529 class BasicAtomicCase2 : public ComputeShaderBase
3530 {
3531         virtual std::string Title()
3532         {
3533                 return NL "Atomic functions - buffer variables";
3534         }
3535         virtual std::string Purpose()
3536         {
3537                 return NL "1. Verify that all atomic functions (atomicExchange, atomicMin, atomicMax," NL
3538                                   "    atomicAnd, atomicOr, atomicXor and atomicCompSwap) works as expected with buffer variables." NL
3539                                   "2. Verify that atomic functions work with parameters being constants and" NL
3540                                   "    with parameters being uniforms." NL
3541                                   "3. Verify that barrier() built-in function can be used in a control flow.";
3542         }
3543         virtual std::string Method()
3544         {
3545                 return NL "1. Create CS that uses all atomic functions. Values returned by the atomic functions are written to "
3546                                   "SSBO." NL "2. Dispatch CS with DispatchCompute and DispatchComputeIndirect commands." NL
3547                                   "3. Verify SSBO content." NL
3548                                   "4. Repeat for different number of work groups and different work group sizes.";
3549         }
3550         virtual std::string PassCriteria()
3551         {
3552                 return NL "Everything works as expected.";
3553         }
3554
3555         GLuint m_program;
3556         GLuint m_storage_buffer[2];
3557         GLuint m_dispatch_buffer;
3558
3559         std::string GenSource(const uvec3& local_size, const uvec3& num_groups)
3560         {
3561                 const uvec3               global_size = local_size * num_groups;
3562                 std::stringstream ss;
3563                 ss << NL "layout(local_size_x = " << local_size.x() << ", local_size_y = " << local_size.y()
3564                    << ", local_size_z = " << local_size.z() << ") in;" NL "const uvec3 kGlobalSize = uvec3(" << global_size.x()
3565                    << ", " << global_size.y() << ", " << global_size.z()
3566                    << ");" NL "layout(std430, binding = 0) buffer OutputU {" NL "  uint g_uint_out["
3567                    << global_size.x() * global_size.y() * global_size.z()
3568                    << "];" NL "};" NL "layout(std430, binding = 1) buffer OutputI {" NL "  int data["
3569                    << global_size.x() * global_size.y() * global_size.z()
3570                    << "];" NL "} g_int_out;" NL
3571                           "uniform uint g_uint_value[8] = uint[8](3u, 1u, 2u, 0x1u, 0x3u, 0x1u, 0x2u, 0x7u);" NL "void main() {" NL
3572                           "  const uint global_index = gl_GlobalInvocationID.x +" NL
3573                           "                            gl_GlobalInvocationID.y * kGlobalSize.x +" NL
3574                           "                            gl_GlobalInvocationID.z * kGlobalSize.x * kGlobalSize.y;" NL
3575                           "  atomicExchange(g_uint_out[global_index], g_uint_value[0]);" NL
3576                           "  atomicMin(g_uint_out[global_index], g_uint_value[1]);" NL
3577                           "  atomicMax(g_uint_out[global_index], g_uint_value[2]);" NL
3578                           "  atomicAnd(g_uint_out[global_index], g_uint_value[3]);" NL
3579                           "  atomicOr(g_uint_out[global_index], g_uint_value[4]);" NL "  if (g_uint_value[0] > 0u) {" NL
3580                           "    barrier();" // not needed here, just check if compiler accepts it in a control flow
3581                         NL "    atomicXor(g_uint_out[global_index], g_uint_value[5]);" NL "  }" NL
3582                           "  atomicCompSwap(g_uint_out[global_index], g_uint_value[6], g_uint_value[7]);" NL NL
3583                           "  atomicExchange(g_int_out.data[global_index], 3);" NL "  atomicMin(g_int_out.data[global_index], 1);" NL
3584                           "  atomicMax(g_int_out.data[global_index], 2);" NL "  atomicAnd(g_int_out.data[global_index], 0x1);" NL
3585                           "  atomicOr(g_int_out.data[global_index], 0x3);" NL "  atomicXor(g_int_out.data[global_index], 0x1);" NL
3586                           "  atomicCompSwap(g_int_out.data[global_index], 0x2, 0x7);" NL "}";
3587                 return ss.str();
3588         }
3589         bool RunIteration(const uvec3& local_size, const uvec3& num_groups, bool dispatch_indirect)
3590         {
3591                 if (m_program != 0)
3592                         glDeleteProgram(m_program);
3593                 m_program = CreateComputeProgram(GenSource(local_size, num_groups));
3594                 glLinkProgram(m_program);
3595                 if (!CheckProgram(m_program))
3596                         return false;
3597
3598                 const GLuint kBufferSize =
3599                         local_size.x() * num_groups.x() * local_size.y() * num_groups.y() * local_size.z() * num_groups.z();
3600
3601                 if (m_storage_buffer[0] == 0)
3602                         glGenBuffers(2, m_storage_buffer);
3603                 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_storage_buffer[0]);
3604                 glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(GLuint) * kBufferSize, NULL, GL_DYNAMIC_DRAW);
3605                 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, m_storage_buffer[1]);
3606                 glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(GLint) * kBufferSize, NULL, GL_DYNAMIC_DRAW);
3607
3608                 glUseProgram(m_program);
3609                 if (dispatch_indirect)
3610                 {
3611                         if (m_dispatch_buffer == 0)
3612                                 glGenBuffers(1, &m_dispatch_buffer);
3613                         glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, m_dispatch_buffer);
3614                         glBufferData(GL_DISPATCH_INDIRECT_BUFFER, sizeof(num_groups), &num_groups[0], GL_STATIC_DRAW);
3615                         glDispatchComputeIndirect(0);
3616                 }
3617                 else
3618                 {
3619                         glDispatchCompute(num_groups.x(), num_groups.y(), num_groups.z());
3620                 }
3621                 glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
3622
3623                 std::vector<GLuint> udata(kBufferSize);
3624                 glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_storage_buffer[0]);
3625                 glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(GLuint) * kBufferSize, &udata[0]);
3626                 for (GLuint i = 0; i < kBufferSize; ++i)
3627                 {
3628                         if (udata[i] != 7)
3629                         {
3630                                 m_context.getTestContext().getLog() << tcu::TestLog::Message << "uData at index " << i << " is "
3631                                                                                                         << udata[i] << " should be 7." << tcu::TestLog::EndMessage;
3632                                 return false;
3633                         }
3634                 }
3635
3636                 std::vector<GLint> idata(kBufferSize);
3637                 glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_storage_buffer[1]);
3638                 glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(GLint) * kBufferSize, &idata[0]);
3639                 for (GLint i = 0; i < static_cast<GLint>(kBufferSize); ++i)
3640                 {
3641                         if (idata[i] != 7)
3642                         {
3643                                 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Data at index " << i << " is "
3644                                                                                                         << idata[i] << " should be 7." << tcu::TestLog::EndMessage;
3645                                 return false;
3646                         }
3647                 }
3648
3649                 return true;
3650         }
3651         virtual long Setup()
3652         {
3653                 m_program                       = 0;
3654                 m_storage_buffer[0] = m_storage_buffer[1] = 0;
3655                 m_dispatch_buffer                                                 = 0;
3656                 return NO_ERROR;
3657         }
3658         virtual long Run()
3659         {
3660                 if (!RunIteration(uvec3(64, 1, 1), uvec3(8, 1, 1), false))
3661                         return ERROR;
3662                 if (!RunIteration(uvec3(1, 1, 64), uvec3(1, 5, 2), true))
3663                         return ERROR;
3664                 if (!RunIteration(uvec3(1, 1, 4), uvec3(2, 2, 2), false))
3665                         return ERROR;
3666                 if (!RunIteration(uvec3(3, 2, 1), uvec3(1, 2, 3), true))
3667                         return ERROR;
3668                 if (!RunIteration(uvec3(2, 4, 2), uvec3(2, 4, 1), false))
3669                         return ERROR;
3670                 if (!RunIteration(uvec3(2, 4, 7), uvec3(2, 1, 4), true))
3671                         return ERROR;
3672                 return NO_ERROR;
3673         }
3674         virtual long Cleanup()
3675         {
3676                 glUseProgram(0);
3677                 glDeleteProgram(m_program);
3678                 glDeleteBuffers(2, m_storage_buffer);
3679                 glDeleteBuffers(1, &m_dispatch_buffer);
3680                 return NO_ERROR;
3681         }
3682 };
3683
3684 class BasicAtomicCase3 : public ComputeShaderBase
3685 {
3686         virtual std::string Title()
3687         {
3688                 return NL "Atomic functions - shared variables";
3689         }
3690         virtual std::string Purpose()
3691         {
3692                 return NL "1. Verify that all atomic functions (atomicExchange, atomicMin, atomicMax," NL
3693                                   "    atomicAnd, atomicOr, atomicXor and atomicCompSwap) works as expected with shared variables." NL
3694                                   "2. Verify that atomic functions work with parameters being constants and" NL
3695                                   "    with parameters being uniforms." NL
3696                                   "3. Verify that atomic functions can be used in a control flow.";
3697         }
3698         virtual std::string Method()
3699         {
3700                 return NL "1. Create CS that uses all atomic functions. Values returned by the atomic functions are written to "
3701                                   "SSBO." NL "2. Dispatch CS with DispatchCompute and DispatchComputeIndirect commands." NL
3702                                   "3. Verify SSBO content." NL
3703                                   "4. Repeat for different number of work groups and different work group sizes.";
3704         }
3705         virtual std::string PassCriteria()
3706         {
3707                 return NL "Everything works as expected.";
3708         }
3709
3710         GLuint m_program;
3711         GLuint m_storage_buffer;
3712         GLuint m_dispatch_buffer;
3713
3714         std::string GenSource(const uvec3& local_size)
3715         {
3716                 std::stringstream ss;
3717                 ss << NL "layout(local_size_x = " << local_size.x() << ", local_size_y = " << local_size.y()
3718                    << ", local_size_z = " << local_size.z()
3719                    << ") in;" NL "layout(std430, binding = 0) buffer Output {" NL "  uint g_uint_out["
3720                    << local_size.x() * local_size.y() * local_size.z() << "];" NL "  int g_int_out["
3721                    << local_size.x() * local_size.y() * local_size.z() << "];" NL "};" NL "shared uint g_shared_uint["
3722                    << local_size.x() * local_size.y() * local_size.z() << "];" NL "shared int g_shared_int["
3723                    << local_size.x() * local_size.y() * local_size.z()
3724                    << "];" NL "uniform uint g_uint_value[8] = uint[8](3u, 1u, 2u, 0x1u, 0x3u, 0x1u, 0x2u, 0x7u);" NL
3725                           "void main() {" NL "  atomicExchange(g_shared_uint[gl_LocalInvocationIndex], g_uint_value[0]);" NL
3726                           "  atomicMin(g_shared_uint[gl_LocalInvocationIndex], g_uint_value[1]);" NL
3727                           "  atomicMax(g_shared_uint[gl_LocalInvocationIndex], g_uint_value[2]);" NL
3728                           "  atomicAnd(g_shared_uint[gl_LocalInvocationIndex], g_uint_value[3]);" NL
3729                           "  atomicOr(g_shared_uint[gl_LocalInvocationIndex], g_uint_value[4]);" NL
3730                           "  atomicXor(g_shared_uint[gl_LocalInvocationIndex], g_uint_value[5]);" NL
3731                           "  atomicCompSwap(g_shared_uint[gl_LocalInvocationIndex], g_uint_value[6], g_uint_value[7]);" NL NL
3732                           "  atomicExchange(g_shared_int[gl_LocalInvocationIndex], 3);" NL
3733                           "  atomicMin(g_shared_int[gl_LocalInvocationIndex], 1);" NL
3734                           "  atomicMax(g_shared_int[gl_LocalInvocationIndex], 2);" NL
3735                           "  atomicAnd(g_shared_int[gl_LocalInvocationIndex], 0x1);" NL "  if (g_uint_value[1] > 0u) {" NL
3736                           "    atomicOr(g_shared_int[gl_LocalInvocationIndex], 0x3);" NL
3737                           "    atomicXor(g_shared_int[gl_LocalInvocationIndex], 0x1);" NL
3738                           "    atomicCompSwap(g_shared_int[gl_LocalInvocationIndex], 0x2, 0x7);" NL "  }" NL NL
3739                           "  g_uint_out[gl_LocalInvocationIndex] = g_shared_uint[gl_LocalInvocationIndex];" NL
3740                           "  g_int_out[gl_LocalInvocationIndex] = g_shared_int[gl_LocalInvocationIndex];" NL "}";
3741                 return ss.str();
3742         }
3743         bool RunIteration(const uvec3& local_size, bool dispatch_indirect)
3744         {
3745                 if (m_program != 0)
3746                         glDeleteProgram(m_program);
3747                 m_program = CreateComputeProgram(GenSource(local_size));
3748                 glLinkProgram(m_program);
3749                 if (!CheckProgram(m_program))
3750                         return false;
3751
3752                 const GLuint kBufferSize = local_size.x() * local_size.y() * local_size.z();
3753
3754                 if (m_storage_buffer == 0)
3755                         glGenBuffers(1, &m_storage_buffer);
3756                 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_storage_buffer);
3757                 glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(GLuint) * kBufferSize * 2, NULL, GL_DYNAMIC_DRAW);
3758
3759                 glUseProgram(m_program);
3760                 if (dispatch_indirect)
3761                 {
3762                         const GLuint num_groups[3] = { 1, 1, 1 };
3763                         if (m_dispatch_buffer == 0)
3764                                 glGenBuffers(1, &m_dispatch_buffer);
3765                         glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, m_dispatch_buffer);
3766                         glBufferData(GL_DISPATCH_INDIRECT_BUFFER, sizeof(num_groups), &num_groups[0], GL_STATIC_DRAW);
3767                         glDispatchComputeIndirect(0);
3768                 }
3769                 else
3770                 {
3771                         glDispatchCompute(1, 1, 1);
3772                 }
3773                 glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
3774
3775                 std::vector<GLuint> udata(kBufferSize);
3776                 glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(GLuint) * kBufferSize, &udata[0]);
3777                 for (GLuint i = 0; i < kBufferSize; ++i)
3778                 {
3779                         if (udata[i] != 7)
3780                         {
3781                                 m_context.getTestContext().getLog() << tcu::TestLog::Message << "uData at index " << i << " is "
3782                                                                                                         << udata[i] << " should be 7." << tcu::TestLog::EndMessage;
3783                                 return false;
3784                         }
3785                 }
3786
3787                 std::vector<GLint> idata(kBufferSize);
3788                 glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, sizeof(GLuint) * kBufferSize, sizeof(GLint) * kBufferSize,
3789                                                    &idata[0]);
3790                 for (GLint i = 0; i < static_cast<GLint>(kBufferSize); ++i)
3791                 {
3792                         if (idata[i] != 7)
3793                         {
3794                                 m_context.getTestContext().getLog() << tcu::TestLog::Message << "iData at index " << i << " is "
3795                                                                                                         << idata[i] << " should be 7." << tcu::TestLog::EndMessage;
3796                                 return false;
3797                         }
3798                 }
3799
3800                 return true;
3801         }
3802         virtual long Setup()
3803         {
3804                 m_program                 = 0;
3805                 m_storage_buffer  = 0;
3806                 m_dispatch_buffer = 0;
3807                 return NO_ERROR;
3808         }
3809         virtual long Run()
3810         {
3811                 if (!RunIteration(uvec3(64, 1, 1), false))
3812                         return ERROR;
3813                 if (!RunIteration(uvec3(1, 1, 64), true))
3814                         return ERROR;
3815                 if (!RunIteration(uvec3(1, 1, 4), false))
3816                         return ERROR;
3817                 if (!RunIteration(uvec3(3, 2, 1), true))
3818                         return ERROR;
3819                 if (!RunIteration(uvec3(2, 4, 2), false))
3820                         return ERROR;
3821                 if (!RunIteration(uvec3(2, 4, 7), true))
3822                         return ERROR;
3823                 return NO_ERROR;
3824         }
3825         virtual long Cleanup()
3826         {
3827                 glUseProgram(0);
3828                 glDeleteProgram(m_program);
3829                 glDeleteBuffers(1, &m_storage_buffer);
3830                 glDeleteBuffers(1, &m_dispatch_buffer);
3831                 return NO_ERROR;
3832         }
3833 };
3834
3835 class AdvancedCopyImage : public ComputeShaderBase
3836 {
3837         virtual std::string Title()
3838         {
3839                 return NL "Copy Image";
3840         }
3841         virtual std::string Purpose()
3842         {
3843                 return NL "Verify that copying two textures using CS works as expected.";
3844         }
3845         virtual std::string Method()
3846         {
3847                 return NL "Use shader image load and store operations to copy two textures in the CS.";
3848         }
3849         virtual std::string PassCriteria()
3850         {
3851                 return NL "Everything works as expected.";
3852         }
3853
3854         GLuint m_program;
3855         GLuint m_texture[2];
3856
3857         virtual long Setup()
3858         {
3859                 m_program = 0;
3860                 memset(m_texture, 0, sizeof(m_texture));
3861                 return NO_ERROR;
3862         }
3863
3864         virtual long Run()
3865         {
3866                 const char* const glsl_cs = NL "#define TILE_WIDTH 16" NL "#define TILE_HEIGHT 16" NL
3867                                                                            "const ivec2 kTileSize = ivec2(TILE_WIDTH, TILE_HEIGHT);" NL NL
3868                                                                            "layout(binding = 0, rgba8) uniform image2D g_input_image;" NL
3869                                                                            "layout(binding = 1, rgba8) uniform image2D g_output_image;" NL      NL
3870                                                                            "layout(local_size_x=TILE_WIDTH, local_size_y=TILE_HEIGHT) in;" NL NL
3871                                                                            "void main() {" NL "  const ivec2 tile_xy = ivec2(gl_WorkGroupID);" NL
3872                                                                            "  const ivec2 thread_xy = ivec2(gl_LocalInvocationID);" NL
3873                                                                            "  const ivec2 pixel_xy = tile_xy * kTileSize + thread_xy;" NL NL
3874                                                                            "  vec4 pixel = imageLoad(g_input_image, pixel_xy);" NL
3875                                                                            "  imageStore(g_output_image, pixel_xy, pixel);" NL "}";
3876                 m_program = CreateComputeProgram(glsl_cs);
3877                 glLinkProgram(m_program);
3878                 if (!CheckProgram(m_program))
3879                         return ERROR;
3880
3881                 std::vector<GLubyte> in_image(64 * 64 * 4, 0x0f);
3882                 std::vector<GLubyte> out_image(64 * 64 * 4, 0x00);
3883
3884                 glGenTextures(2, m_texture);
3885                 glBindTexture(GL_TEXTURE_2D, m_texture[0]);
3886                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
3887                 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 64, 64, 0, GL_RGBA, GL_UNSIGNED_BYTE, &in_image[0]);
3888
3889                 glBindTexture(GL_TEXTURE_2D, m_texture[1]);
3890                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
3891                 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 64, 64, 0, GL_RGBA, GL_UNSIGNED_BYTE, &out_image[0]);
3892
3893                 glUseProgram(m_program);
3894                 glBindImageTexture(0, m_texture[0], 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8);
3895                 glBindImageTexture(1, m_texture[1], 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA8);
3896                 glDispatchCompute(5, 4,
3897                                                   1); // 5 is on purpose, to ensure that out of bounds image load and stores have no effect
3898                 glMemoryBarrier(GL_TEXTURE_UPDATE_BARRIER_BIT);
3899
3900                 std::vector<GLubyte> data(64 * 64 * 4);
3901                 glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, &data[0]);
3902                 for (std::size_t i = 0; i < data.size(); ++i)
3903                 {
3904                         if (getWindowWidth() > 100 && data[i] != 0x0f)
3905                         {
3906                                 m_context.getTestContext().getLog()
3907                                         << tcu::TestLog::Message << "Data at index " << i << " is " << data[i] << " should be " << 0x0f
3908                                         << "." << tcu::TestLog::EndMessage;
3909                                 return ERROR;
3910                         }
3911                 }
3912
3913                 return NO_ERROR;
3914         }
3915         virtual long Cleanup()
3916         {
3917                 glUseProgram(0);
3918                 glDeleteProgram(m_program);
3919                 glDeleteTextures(2, m_texture);
3920                 return NO_ERROR;
3921         }
3922 };
3923
3924 class AdvancedPipelinePreVS : public ComputeShaderBase
3925 {
3926         virtual std::string Title()
3927         {
3928                 return NL "CS as an additional pipeline stage - Before VS (1)";
3929         }
3930         virtual std::string Purpose()
3931         {
3932                 return NL "Verify that CS which runs just before VS and modifies VBO content works as expected.";
3933         }
3934         virtual std::string Method()
3935         {
3936                 return NL "1. Prepare VBO and VAO for a drawing operation." NL "2. Run CS to modify existing VBO content." NL
3937                                   "3. Issue MemoryBarrier(GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT) command." NL
3938                                   "4. Issue draw call command." NL "5. Verify that the framebuffer content is as expected.";
3939         }
3940         virtual std::string PassCriteria()
3941         {
3942                 return NL "Everything works as expected.";
3943         }
3944
3945         GLuint m_program[2];
3946         GLuint m_vertex_buffer;
3947         GLuint m_vertex_array;
3948
3949         virtual long Setup()
3950         {
3951                 memset(m_program, 0, sizeof(m_program));
3952                 m_vertex_buffer = 0;
3953                 m_vertex_array  = 0;
3954                 return NO_ERROR;
3955         }
3956         virtual long Run()
3957         {
3958                 const char* const glsl_cs =
3959                         NL "layout(local_size_x = 4) in;" NL "struct Vertex {" NL "  vec4 position;" NL "  vec4 color;" NL "};" NL
3960                            "layout(binding = 0, std430) buffer VertexBuffer {" NL "  Vertex g_vertex[];" NL "};" NL
3961                            "uniform float g_scale = 0.8;" NL "void main() {" NL
3962                            "  g_vertex[gl_GlobalInvocationID.x].position.xyz *= g_scale;" NL
3963                            "  g_vertex[gl_GlobalInvocationID.x].color *= vec4(0, 1, 0, 1);" NL "}";
3964                 m_program[0] = CreateComputeProgram(glsl_cs);
3965                 glLinkProgram(m_program[0]);
3966                 if (!CheckProgram(m_program[0]))
3967                         return ERROR;
3968
3969                 const char* const glsl_vs =
3970                         NL "layout(location = 0) in vec4 g_position;" NL "layout(location = 1) in vec4 g_color;" NL
3971                            "out StageData {" NL "  vec4 color;" NL "} g_vs_out;" NL "void main() {" NL
3972                            "  gl_Position = g_position;" NL "  g_vs_out.color = g_color;" NL "}";
3973
3974                 const char* const glsl_fs =
3975                         NL "in StageData {" NL "  vec4 color;" NL "} g_fs_in;" NL "layout(location = 0) out vec4 g_color;" NL
3976                            "void main() {" NL "  g_color = g_fs_in.color;" NL "}";
3977                 m_program[1] = CreateProgram(glsl_vs, glsl_fs);
3978                 glLinkProgram(m_program[1]);
3979                 if (!CheckProgram(m_program[1]))
3980                         return ERROR;
3981
3982                 /* vertex buffer */
3983                 {
3984                         const float data[] = { -1, -1, 0, 1, 1, 1, 1, 1, 1, -1, 0, 1, 1, 1, 1, 1,
3985                                                                    -1, 1,  0, 1, 1, 1, 1, 1, 1, 1,  0, 1, 1, 1, 1, 1 };
3986                         glGenBuffers(1, &m_vertex_buffer);
3987                         glBindBuffer(GL_ARRAY_BUFFER, m_vertex_buffer);
3988                         glBufferData(GL_ARRAY_BUFFER, sizeof(data), data, GL_STATIC_DRAW);
3989                         glBindBuffer(GL_ARRAY_BUFFER, 0);
3990                 }
3991
3992                 glGenVertexArrays(1, &m_vertex_array);
3993                 glBindVertexArray(m_vertex_array);
3994                 glBindBuffer(GL_ARRAY_BUFFER, m_vertex_buffer);
3995                 glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 2 * sizeof(vec4), 0);
3996                 glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 2 * sizeof(vec4), reinterpret_cast<void*>(sizeof(vec4)));
3997                 glBindBuffer(GL_ARRAY_BUFFER, 0);
3998                 glEnableVertexAttribArray(0);
3999                 glEnableVertexAttribArray(1);
4000                 glBindVertexArray(0);
4001
4002                 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_vertex_buffer);
4003                 glUseProgram(m_program[0]);
4004                 glDispatchCompute(1, 1, 1);
4005
4006                 glClear(GL_COLOR_BUFFER_BIT);
4007                 glUseProgram(m_program[1]);
4008                 glBindVertexArray(m_vertex_array);
4009                 glMemoryBarrier(GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT);
4010                 glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4, 1);
4011
4012                 if (getWindowWidth() < 500 &&
4013                         !ValidateReadBufferCenteredQuad(getWindowWidth(), getWindowHeight(), vec3(0, 1, 0)))
4014                 {
4015                         return ERROR;
4016                 }
4017                 return NO_ERROR;
4018         }
4019         virtual long Cleanup()
4020         {
4021                 glUseProgram(0);
4022                 for (int i = 0; i < 2; ++i)
4023                         glDeleteProgram(m_program[i]);
4024                 glDeleteBuffers(1, &m_vertex_buffer);
4025                 glDeleteVertexArrays(1, &m_vertex_array);
4026                 return NO_ERROR;
4027         }
4028 };
4029
4030 class AdvancedPipelineGenDrawCommands : public ComputeShaderBase
4031 {
4032         virtual std::string Title()
4033         {
4034                 return NL "CS as an additional pipeline stage - Before VS (2)";
4035         }
4036         virtual std::string Purpose()
4037         {
4038                 return NL "Verify that a complex scenario where CS is used to generate drawing commands" NL
4039                                   "and write them to a draw indirect buffer works as expected. This is a practial usage of CS." NL
4040                                   "CS is used for culling objects which are outside of the viewing frustum.";
4041         }
4042         virtual std::string Method()
4043         {
4044                 return NL "1. Run CS which will generate four sets of draw call parameters and write them to the draw indirect "
4045                                   "buffer." NL "2. One set of draw call parameters will be: 0, 0, 0, 0" NL
4046                                   "    (which means that an object is outside of the viewing frustum and should not be drawn)." NL
4047                                   "3. Issue MemoryBarrier(GL_COMMAND_BARRIER_BIT) command." NL
4048                                   "4. Issue four draw indirect commands." NL "5. Verify that the framebuffer content is as expected.";
4049         }
4050         virtual std::string PassCriteria()
4051         {
4052                 return NL "Everything works as expected.";
4053         }
4054
4055         GLuint m_program[2];
4056         GLuint m_vertex_buffer;
4057         GLuint m_index_buffer;
4058         GLuint m_vertex_array;
4059         GLuint m_draw_buffer;
4060         GLuint m_object_buffer;
4061
4062         virtual long Setup()
4063         {
4064                 memset(m_program, 0, sizeof(m_program));
4065                 m_vertex_buffer = 0;
4066                 m_index_buffer  = 0;
4067                 m_vertex_array  = 0;
4068                 m_draw_buffer   = 0;
4069                 m_object_buffer = 0;
4070                 return NO_ERROR;
4071         }
4072         virtual long Run()
4073         {
4074                 GLint res;
4075                 glGetIntegerv(GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS, &res);
4076                 if (res <= 0)
4077                 {
4078                         OutputNotSupported("GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS <= 0");
4079                         return NO_ERROR;
4080                 }
4081
4082                 const char* const glsl_cs =
4083                         NL "layout(local_size_x = 4) in;" NL "struct DrawCommand {" NL "  uint count;" NL
4084                            "  uint instance_count;" NL "  uint first_index;" NL "  int base_vertex;" NL "  uint base_instance;" NL
4085                            "};" NL "layout(std430) buffer;" NL "layout(binding = 0) readonly buffer ObjectBuffer {" NL
4086                            "  mat4 transform[4];" NL "  uint count[4];" NL "  uint first_index[4];" NL "} g_objects;" NL
4087                            "layout(binding = 1) writeonly buffer DrawCommandBuffer {" NL "  DrawCommand g_command[4];" NL "};" NL
4088                            "bool IsObjectVisible(uint id) {" NL
4089                            "  if (g_objects.transform[id][3].x < -1.0 || g_objects.transform[id][3].x > 1.0) return false;" NL
4090                            "  if (g_objects.transform[id][3][1] < -1.0 || g_objects.transform[id][3][1] > 1.0) return false;" NL
4091                            "  if (g_objects.transform[id][3][2] < -1.0 || g_objects.transform[id][3].z > 1.0) return false;" NL
4092                            "  return true;" NL "}" NL "void main() {" NL "  uint id = gl_GlobalInvocationID.x;" NL
4093                            "  g_command[id].count = 0;" NL "  g_command[id].instance_count = 0;" NL
4094                            "  g_command[id].first_index = 0;" NL "  g_command[id].base_vertex = 0;" NL
4095                            "  g_command[id].base_instance = 0;" NL "  if (IsObjectVisible(id)) {" NL
4096                            "    g_command[id].count = g_objects.count[id];" NL "    g_command[id].instance_count = 1;" NL
4097                            "    g_command[id].first_index = g_objects.first_index[id];" NL "  }" NL "}";
4098                 m_program[0] = CreateComputeProgram(glsl_cs);
4099                 glLinkProgram(m_program[0]);
4100                 if (!CheckProgram(m_program[0]))
4101                         return ERROR;
4102
4103                 const char* const glsl_vs =
4104                         NL "layout(location = 0) in vec4 g_position;" NL "layout(location = 1) in vec3 g_color;" NL
4105                            "out StageData {" NL "  vec3 color;" NL "} g_vs_out;" NL
4106                            "layout(binding = 0, std430) buffer ObjectBuffer {" NL "  mat4 transform[4];" NL "  uint count[4];" NL
4107                            "  uint first_index[4];" NL "} g_objects;" NL "uniform int g_object_id;" NL "void main() {" NL
4108                            "  gl_Position = g_objects.transform[g_object_id] * g_position;" NL "  g_vs_out.color = g_color;" NL "}";
4109
4110                 const char* const glsl_fs =
4111                         NL "in StageData {" NL "  vec3 color;" NL "} g_fs_in;" NL "layout(location = 0) out vec4 g_color;" NL
4112                            "void main() {" NL "  g_color = vec4(g_fs_in.color, 1);" NL "}";
4113                 m_program[1] = CreateProgram(glsl_vs, glsl_fs);
4114                 glLinkProgram(m_program[1]);
4115                 if (!CheckProgram(m_program[1]))
4116                         return ERROR;
4117                 glViewport(0, 0, 100, 100);
4118
4119                 /* object buffer */
4120                 {
4121                         struct
4122                         {
4123                                 mat4   transform[4];
4124                                 GLuint count[4];
4125                                 GLuint first_index[4];
4126                         } data = {
4127                                 { tcu::translationMatrix(vec3(-1.5f, -0.5f, 0.0f)), tcu::translationMatrix(vec3(0.5f, -0.5f, 0.0f)),
4128                                   tcu::translationMatrix(vec3(-0.5f, 0.5f, 0.0f)), tcu::translationMatrix(vec3(0.5f, 0.5f, 0.0f)) },
4129                                 { 4, 4, 4, 4 },
4130                                 { 0, 4, 8, 12 }
4131                         };
4132                         glGenBuffers(1, &m_object_buffer);
4133                         glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_object_buffer);
4134                         glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(data), &data, GL_STATIC_DRAW);
4135                 }
4136                 /* vertex buffer */
4137                 {
4138                         const vec3 data[] = { vec3(-0.4f, -0.4f, 0.0f), vec3(1, 0, 0), vec3(0.4f, -0.4f, 0.0f), vec3(1, 0, 0),
4139                                                                   vec3(-0.4f, 0.4f, 0.0f),  vec3(1, 0, 0), vec3(0.4f, 0.4f, 0.0f),  vec3(1, 0, 0),
4140                                                                   vec3(-0.4f, -0.4f, 0.0f), vec3(0, 1, 0), vec3(0.4f, -0.4f, 0.0f), vec3(0, 1, 0),
4141                                                                   vec3(-0.4f, 0.4f, 0.0f),  vec3(0, 1, 0), vec3(0.4f, 0.4f, 0.0f),  vec3(0, 1, 0),
4142                                                                   vec3(-0.4f, -0.4f, 0.0f), vec3(0, 0, 1), vec3(0.4f, -0.4f, 0.0f), vec3(0, 0, 1),
4143                                                                   vec3(-0.4f, 0.4f, 0.0f),  vec3(0, 0, 1), vec3(0.4f, 0.4f, 0.0f),  vec3(0, 0, 1),
4144                                                                   vec3(-0.4f, -0.4f, 0.0f), vec3(1, 1, 0), vec3(0.4f, -0.4f, 0.0f), vec3(1, 1, 0),
4145                                                                   vec3(-0.4f, 0.4f, 0.0f),  vec3(1, 1, 0), vec3(0.4f, 0.4f, 0.0f),  vec3(1, 1, 0) };
4146                         glGenBuffers(1, &m_vertex_buffer);
4147                         glBindBuffer(GL_ARRAY_BUFFER, m_vertex_buffer);
4148                         glBufferData(GL_ARRAY_BUFFER, sizeof(data), data, GL_STATIC_DRAW);
4149                         glBindBuffer(GL_ARRAY_BUFFER, 0);
4150                 }
4151                 /* index buffer */
4152                 {
4153                         const GLushort data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
4154                         glGenBuffers(1, &m_index_buffer);
4155                         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_index_buffer);
4156                         glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(data), data, GL_DYNAMIC_DRAW);
4157                         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
4158                 }
4159                 glGenBuffers(1, &m_draw_buffer);
4160                 glBindBuffer(GL_DRAW_INDIRECT_BUFFER, m_draw_buffer);
4161                 glBufferData(GL_DRAW_INDIRECT_BUFFER, 4 * sizeof(GLuint) * 5, NULL, GL_DYNAMIC_DRAW);
4162                 glBindBuffer(GL_DRAW_INDIRECT_BUFFER, 0);
4163
4164                 glGenVertexArrays(1, &m_vertex_array);
4165                 glBindVertexArray(m_vertex_array);
4166                 glBindBuffer(GL_ARRAY_BUFFER, m_vertex_buffer);
4167                 glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 2 * sizeof(vec3), 0);
4168                 glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 2 * sizeof(vec3), reinterpret_cast<void*>(sizeof(vec3)));
4169                 glBindBuffer(GL_ARRAY_BUFFER, 0);
4170                 glEnableVertexAttribArray(0);
4171                 glEnableVertexAttribArray(1);
4172                 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_index_buffer);
4173                 glBindVertexArray(0);
4174
4175                 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, m_draw_buffer);
4176                 glUseProgram(m_program[0]);
4177                 glDispatchCompute(1, 1, 1);
4178
4179                 glClear(GL_COLOR_BUFFER_BIT);
4180                 glUseProgram(m_program[1]);
4181                 glBindVertexArray(m_vertex_array);
4182                 glBindBuffer(GL_DRAW_INDIRECT_BUFFER, m_draw_buffer);
4183                 glMemoryBarrier(GL_COMMAND_BARRIER_BIT);
4184                 /* draw (CPU draw calls dispatch, could be done by the GPU with ARB_multi_draw_indirect) */
4185                 {
4186                         GLsizeiptr offset = 0;
4187                         for (int i = 0; i < 4; ++i)
4188                         {
4189                                 glUniform1i(glGetUniformLocation(m_program[1], "g_object_id"), i);
4190                                 glDrawElementsIndirect(GL_TRIANGLE_STRIP, GL_UNSIGNED_SHORT, reinterpret_cast<void*>(offset));
4191                                 offset += 5 * sizeof(GLuint);
4192                         }
4193                 }
4194                 if (getWindowWidth() >= 100 && getWindowHeight() >= 100 &&
4195                         !ValidateWindow4Quads(vec3(0), vec3(0, 1, 0), vec3(1, 1, 0), vec3(0, 0, 1)))
4196                 {
4197                         return ERROR;
4198                 }
4199                 return NO_ERROR;
4200         }
4201         virtual long Cleanup()
4202         {
4203                 glUseProgram(0);
4204                 for (int i = 0; i < 2; ++i)
4205                         glDeleteProgram(m_program[i]);
4206                 glDeleteBuffers(1, &m_vertex_buffer);
4207                 glDeleteBuffers(1, &m_index_buffer);
4208                 glDeleteVertexArrays(1, &m_vertex_array);
4209                 glDeleteBuffers(1, &m_draw_buffer);
4210                 glDeleteBuffers(1, &m_object_buffer);
4211                 glViewport(0, 0, getWindowWidth(), getWindowHeight());
4212                 return NO_ERROR;
4213         }
4214 };
4215
4216 class AdvancedPipelineComputeChain : public ComputeShaderBase
4217 {
4218         virtual std::string Title()
4219         {
4220                 return NL "Compute Chain";
4221         }
4222         virtual std::string Purpose()
4223         {
4224                 return NL "1. Verify that dispatching several compute kernels that work in a sequence" NL
4225                                   "    with a common set of resources works as expected." NL
4226                                   "2. Verify that indexing nested structures with built-in variables work as expected." NL
4227                                   "3. Verify that two kernels can write to the same resource without MemoryBarrier" NL
4228                                   "    command if target regions of memory do not overlap.";
4229         }
4230         virtual std::string Method()
4231         {
4232                 return NL "1. Create a set of GPU resources (buffers, images, atomic counters)." NL
4233                                   "2. Dispatch Kernel0 that write to these resources." NL "3. Issue MemoryBarrier command." NL
4234                                   "4. Dispatch Kernel1 that read/write from/to these resources." NL "5. Issue MemoryBarrier command." NL
4235                                   "6. Dispatch Kernel2 that read/write from/to these resources." NL
4236                                   "7. Verify that content of all resources is as expected.";
4237         }
4238         virtual std::string PassCriteria()
4239         {
4240                 return NL "Everything works as expected.";
4241         }
4242
4243         GLuint m_program[3];
4244         GLuint m_storage_buffer[4];
4245         GLuint m_counter_buffer;
4246         GLuint m_texture;
4247         GLuint m_fbo;
4248
4249         std::string Common()
4250         {
4251                 return NL "struct S0 {" NL "  int m0[8];" NL "};" NL "struct S1 {" NL "  S0 m0[8];" NL "};" NL
4252                                   "layout(binding = 0, std430) buffer Buffer0 {" NL "  int m0[5];" NL "  S1 m1[8];" NL "} g_buffer0;" NL
4253                                   "layout(binding = 1, std430) buffer Buffer1 {" NL "  uint data[8];" NL "} g_buffer1;" NL
4254                                   "layout(binding = 2, std430) buffer Buffer2 {" NL "  int data[256];" NL "} g_buffer2;" NL
4255                                   "layout(binding = 3, std430) buffer Buffer3 {" NL "  int data[256];" NL "} g_buffer3;" NL
4256                                   "layout(binding = 4, std430) buffer Buffer4 {" NL "  mat4 data0;" NL "  mat4 data1;" NL
4257                                   "} g_buffer4;" NL "layout(binding = 0, rgba32f) uniform image2D g_image0;" NL
4258                                   "layout(binding = 1, offset = 8) uniform atomic_uint g_counter[2];";
4259         }
4260         std::string GenGLSL(int p)
4261         {
4262                 std::stringstream ss;
4263                 ss << Common();
4264                 if (p == 0)
4265                 {
4266                         ss << NL "layout(local_size_x = 4, local_size_y = 4, local_size_z = 4) in;" NL
4267                                          "void UpdateBuffer0(uvec3 id, int add_val) {" NL "  if (id.x < 8 && id.y < 8 && id.z < 8) {" NL
4268                                          "    g_buffer0.m1[id.z].m0[id.y].m0[id.x] += add_val;" NL "  }" NL "}" NL
4269                                          "uniform int g_add_value = 1;" NL "uniform uint g_counter_y = 1;" NL
4270                                          "uniform vec4 g_image_value = vec4(0.125, 0.25, 0.375, 0.5);" NL "void main() {" NL
4271                                          "  uvec3 id = gl_GlobalInvocationID;" NL "  UpdateBuffer0(id, 1);" NL
4272                                          "  UpdateBuffer0(id, g_add_value);" NL "  if (id == uvec3(1, g_counter_y, 1)) {" NL
4273                                          "    uint idx = atomicCounterIncrement(g_counter[1]);" NL "    g_buffer1.data[idx] = idx;" NL
4274                                          "    idx = atomicCounterIncrement(g_counter[1]);" NL "    g_buffer1.data[idx] = idx;" NL "  }" NL
4275                                          "  if (id.x < 4 && id.y < 4 && id.z == 0) {" NL
4276                                          "    vec4 v = imageLoad(g_image0, ivec2(id.xy));" NL
4277                                          "    imageStore(g_image0, ivec2(id.xy), v + g_image_value);" NL "  }" NL
4278                                          "  if (id.x < 2 && id.y == 0 && id.z == 0) {" NL "    g_buffer2.data[id.x] -= int(g_counter_y);" NL
4279                                          "  }" NL "}";
4280                 }
4281                 else if (p == 1)
4282                 {
4283                         ss << NL "layout(local_size_x = 4, local_size_y = 4, local_size_z = 1) in;"
4284                                 // translation matrix
4285                                 NL "uniform mat4 g_mvp = mat4(1.0, 0.0, 0.0, 0.0,  0.0, 1.0, 0.0, 0.0,  0.0, 0.0, 1.0, 0.0,  10.0, "
4286                                          "20.0, 30.0, 1.0);" NL "void main() {" NL "  if (gl_GlobalInvocationID == uvec3(0)) {" NL
4287                                          "    g_buffer4.data0 *= g_mvp;" NL "  }" NL "  if (gl_WorkGroupID == uvec3(0)) {" NL
4288                                          "    g_buffer4.data1[gl_LocalInvocationID.y][gl_LocalInvocationID.x] = "
4289                                          "g_mvp[gl_LocalInvocationID.x][gl_LocalInvocationID.y];" NL "  }" NL "}";
4290                 }
4291                 else if (p == 2)
4292                 {
4293                         ss << NL "layout(local_size_x = 4, local_size_y = 4, local_size_z = 4) in;" NL "void main() {" NL "}";
4294                 }
4295                 return ss.str();
4296         }
4297         virtual long Setup()
4298         {
4299                 memset(m_program, 0, sizeof(m_program));
4300                 memset(m_storage_buffer, 0, sizeof(m_storage_buffer));
4301                 m_counter_buffer = 0;
4302                 m_texture                = 0;
4303                 return NO_ERROR;
4304         }
4305         virtual long Run()
4306         {
4307                 using namespace tcu;
4308
4309                 for (int i = 0; i < 3; ++i)
4310                 {
4311                         m_program[i] = CreateComputeProgram(GenGLSL(i));
4312                         glLinkProgram(m_program[i]);
4313                         if (!CheckProgram(m_program[i]))
4314                                 return ERROR;
4315                 }
4316
4317                 glGenBuffers(4, m_storage_buffer);
4318                 /* storage buffer 0 */
4319                 {
4320                         std::vector<int> data(5 + 8 * 8 * 8);
4321                         glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_storage_buffer[0]);
4322                         glBufferData(GL_SHADER_STORAGE_BUFFER, (GLsizeiptr)(data.size() * sizeof(int)), &data[0], GL_STATIC_COPY);
4323                 }
4324                 /* storage buffer 1 */
4325                 {
4326                         const GLuint data[8] = { 0 };
4327                         glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, m_storage_buffer[1]);
4328                         glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(data), data, GL_STATIC_COPY);
4329                 }
4330                 /* storage buffer 2 & 3 */
4331                 {
4332                         std::vector<GLint> data(512, 7);
4333                         glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_storage_buffer[2]);
4334                         glBufferData(GL_SHADER_STORAGE_BUFFER, (GLsizeiptr)(data.size() * sizeof(GLint)), &data[0], GL_STATIC_COPY);
4335
4336                         glBindBufferRange(GL_SHADER_STORAGE_BUFFER, 2, m_storage_buffer[2], 0,
4337                                                           (GLsizeiptr)(sizeof(GLint) * data.size() / 2));
4338                         glBindBufferRange(GL_SHADER_STORAGE_BUFFER, 3, m_storage_buffer[2],
4339                                                           (GLintptr)(sizeof(GLint) * data.size() / 2),
4340                                                           (GLsizeiptr)(sizeof(GLint) * data.size() / 2));
4341                 }
4342                 /* storage buffer 4 */
4343                 {
4344                         std::vector<mat4> data(2);
4345                         data[0] = mat4(1);
4346                         glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, m_storage_buffer[3]);
4347                         glBufferData(GL_SHADER_STORAGE_BUFFER, (GLsizeiptr)(data.size() * sizeof(mat4)), &data[0], GL_STATIC_COPY);
4348                 }
4349                 /* counter buffer */
4350                 {
4351                         GLuint data[4] = { 0 };
4352                         glGenBuffers(1, &m_counter_buffer);
4353                         glBindBufferBase(GL_ATOMIC_COUNTER_BUFFER, 1, m_counter_buffer);
4354                         glBufferData(GL_ATOMIC_COUNTER_BUFFER, sizeof(data), data, GL_STATIC_COPY);
4355                 }
4356                 /* texture */
4357                 {
4358                         std::vector<vec4> data(4 * 4, vec4(0.0f));
4359                         glGenTextures(1, &m_texture);
4360                         glBindTexture(GL_TEXTURE_2D, m_texture);
4361                         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
4362                         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
4363                         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, 4, 4, 0, GL_RGBA, GL_FLOAT, &data[0]);
4364                         glBindTexture(GL_TEXTURE_2D, 0);
4365                 }
4366
4367                 glUseProgram(m_program[0]);
4368                 glBindImageTexture(0, m_texture, 0, GL_FALSE, 0, GL_READ_WRITE, GL_RGBA32F);
4369                 glDispatchCompute(2, 2, 2);
4370                 glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT | GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
4371                 glDispatchCompute(3, 2, 2);
4372
4373                 glUseProgram(m_program[1]);
4374                 glDispatchCompute(4, 3, 7);
4375
4376                 glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT | GL_TEXTURE_UPDATE_BARRIER_BIT |
4377                                                 GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
4378
4379                 /* validate texture */
4380                 {
4381                         std::vector<vec4> data(4 * 4);
4382                         glBindTexture(GL_TEXTURE_2D, m_texture);
4383                         glGenFramebuffers(1, &m_fbo);
4384                         glBindFramebuffer(GL_FRAMEBUFFER, m_fbo);
4385                         glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_texture, 0);
4386                         std::vector<GLubyte> colorData(4 * 4 * 4);
4387                         glReadPixels(0, 0, 4, 4, GL_RGBA, GL_UNSIGNED_BYTE, &colorData[0]);
4388                         for (int i = 0; i < 4 * 4 * 4; i += 4)
4389                         {
4390                                 data[i / 4] =
4391                                         vec4(static_cast<GLfloat>(colorData[i] / 255.), static_cast<GLfloat>(colorData[i + 1] / 255.),
4392                                                  static_cast<GLfloat>(colorData[i + 2] / 255.), static_cast<GLfloat>(colorData[i + 3] / 255.));
4393                         }
4394                         for (std::size_t i = 0; i < data.size(); ++i)
4395                         {
4396                                 if (!ColorEqual(data[i], vec4(0.25f, 0.5f, 0.75f, 1.0f), g_color_eps))
4397                                 {
4398                                         m_context.getTestContext().getLog()
4399                                                 << tcu::TestLog::Message << "Invalid data at texture." << tcu::TestLog::EndMessage;
4400                                         return ERROR;
4401                                 }
4402                         }
4403                 }
4404                 /* validate storage buffer 0 */
4405                 {
4406                         std::vector<int> data(5 + 8 * 8 * 8);
4407                         glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_storage_buffer[0]);
4408                         glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, (GLsizeiptr)(data.size() * sizeof(int)), &data[0]);
4409                         for (std::size_t i = 5; i < data.size(); ++i)
4410                         {
4411                                 if (data[i] != 4)
4412                                 {
4413                                         m_context.getTestContext().getLog() << tcu::TestLog::Message << "Data is " << data[i]
4414                                                                                                                 << " should be 2." << tcu::TestLog::EndMessage;
4415                                         return ERROR;
4416                                 }
4417                         }
4418                 }
4419                 /* validate storage buffer 1 */
4420                 {
4421                         GLuint data[8];
4422                         glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_storage_buffer[1]);
4423                         glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(data), data);
4424                         for (GLuint i = 0; i < 4; ++i)
4425                         {
4426                                 if (data[i] != i)
4427                                 {
4428                                         m_context.getTestContext().getLog() << tcu::TestLog::Message << "Data is " << data[i]
4429                                                                                                                 << " should be " << i << "." << tcu::TestLog::EndMessage;
4430                                         return ERROR;
4431                                 }
4432                         }
4433                 }
4434                 /* validate storage buffer 2 & 3 */
4435                 {
4436                         std::vector<GLint> data(512);
4437                         glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_storage_buffer[2]);
4438                         glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, (GLsizeiptr)(sizeof(GLint) * data.size()), &data[0]);
4439                         for (int i = 0; i < 2; ++i)
4440                         {
4441                                 if (data[i] != 5)
4442                                 {
4443                                         m_context.getTestContext().getLog() << tcu::TestLog::Message << "Data is: " << data[i]
4444                                                                                                                 << " should be: 5." << tcu::TestLog::EndMessage;
4445                                         return ERROR;
4446                                 }
4447                                 if (data[i + 256] != 7)
4448                                 {
4449                                         m_context.getTestContext().getLog() << tcu::TestLog::Message << "Data is: " << data[i + 256]
4450                                                                                                                 << " should be: 7." << tcu::TestLog::EndMessage;
4451                                         return ERROR;
4452                                 }
4453                         }
4454                 }
4455                 /* validate storage buffer 4 */
4456                 {
4457                         mat4 data[2];
4458                         glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_storage_buffer[3]);
4459                         glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(data), &data[0](0, 0));
4460                         if (data[0] != translationMatrix(vec3(10.0f, 20.0f, 30.0f)))
4461                         {
4462                                 m_context.getTestContext().getLog()
4463                                         << tcu::TestLog::Message << "Data is incorrect." << tcu::TestLog::EndMessage;
4464                                 return ERROR;
4465                         }
4466                         if (data[1] != transpose(translationMatrix(vec3(10.0f, 20.0f, 30.0f))))
4467                         {
4468                                 m_context.getTestContext().getLog()
4469                                         << tcu::TestLog::Message << "Data is incorrect." << tcu::TestLog::EndMessage;
4470                                 return ERROR;
4471                         }
4472                 }
4473                 /* validate counter buffer */
4474                 {
4475                         GLuint data[4] = { 0 };
4476                         glGetBufferSubData(GL_ATOMIC_COUNTER_BUFFER, 0, sizeof(data), data);
4477                         if (data[3] != 4)
4478                         {
4479                                 m_context.getTestContext().getLog()
4480                                         << tcu::TestLog::Message << "Data is: " << data[3] << " should be: 4." << tcu::TestLog::EndMessage;
4481                                 return ERROR;
4482                         }
4483                 }
4484
4485                 return NO_ERROR;
4486         }
4487         virtual long Cleanup()
4488         {
4489                 glUseProgram(0);
4490                 for (int i = 0; i < 3; ++i)
4491                         glDeleteProgram(m_program[i]);
4492                 glDeleteBuffers(4, m_storage_buffer);
4493                 glDeleteBuffers(1, &m_counter_buffer);
4494                 glDeleteTextures(1, &m_texture);
4495                 glDeleteFramebuffers(1, &m_fbo);
4496                 return NO_ERROR;
4497         }
4498 };
4499
4500 class AdvancedPipelinePostFS : public ComputeShaderBase
4501 {
4502         virtual std::string Title()
4503         {
4504                 return NL "CS as an additional pipeline stage - After FS";
4505         }
4506         virtual std::string Purpose()
4507         {
4508                 return NL "1. Verify that CS which runs just after FS to do a post-processing on a rendered image works as "
4509                                   "expected." NL "2. Verify that CS used as a post-processing filter works as expected." NL
4510                                   "3. Verify that several CS kernels which run in a sequence to do a post-processing on a rendered "
4511                                   "image works as expected.";
4512         }
4513         virtual std::string Method()
4514         {
4515                 return NL
4516                         "1. Render image to Texture0 using VS and FS." NL
4517                         "2. Use Texture0 as an input to Kernel0 which performs post-processing and writes result to Texture1." NL
4518                         "3. Issue MemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT) command." NL
4519                         "4. Use Texture1 as an input to Kernel1 which performs post-processing and writes result to Texture0." NL
4520                         "5. Issue MemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT) command." NL
4521                         "6. Verify content of the final post-processed image (Texture0).";
4522         }
4523         virtual std::string PassCriteria()
4524         {
4525                 return NL "Everything works as expected.";
4526         }
4527
4528         GLuint m_program[3];
4529         GLuint m_render_target[2];
4530         GLuint m_framebuffer;
4531         GLuint m_vertex_array;
4532
4533         virtual long Setup()
4534         {
4535                 memset(m_program, 0, sizeof(m_program));
4536                 memset(m_render_target, 0, sizeof(m_render_target));
4537                 m_framebuffer  = 0;
4538                 m_vertex_array = 0;
4539                 return NO_ERROR;
4540         }
4541
4542         virtual long Run()
4543         {
4544                 const char* const glsl_vs =
4545                         NL "const vec2 g_vertex[4] = vec2[4](vec2(0), vec2(-1, -1), vec2(3, -1), vec2(-1, 3));" NL
4546                            "void main() {" NL "  gl_Position = vec4(g_vertex[gl_VertexID], 0, 1);" NL "}";
4547
4548                 const char* const glsl_fs =
4549                         NL "layout(location = 0) out vec4 g_color;" NL "void main() {" NL "  g_color = vec4(1, 0, 0, 1);" NL "}";
4550
4551                 m_program[0] = CreateProgram(glsl_vs, glsl_fs);
4552                 glLinkProgram(m_program[0]);
4553                 if (!CheckProgram(m_program[0]))
4554                         return ERROR;
4555
4556                 const char* const glsl_cs =
4557                         NL "#define TILE_WIDTH 16" NL "#define TILE_HEIGHT 16" NL
4558                            "const ivec2 kTileSize = ivec2(TILE_WIDTH, TILE_HEIGHT);" NL NL
4559                            "layout(binding = 0, rgba32f) uniform image2D g_input_image;" NL
4560                            "layout(binding = 1, rgba32f) uniform image2D g_output_image;" NL    NL
4561                            "layout(local_size_x = TILE_WIDTH, local_size_y=TILE_HEIGHT) in;" NL NL "void main() {" NL
4562                            "  const ivec2 tile_xy = ivec2(gl_WorkGroupID);" NL
4563                            "  const ivec2 thread_xy = ivec2(gl_LocalInvocationID);" NL NL "  if (thread_xy == ivec2(0)) {" NL
4564                            "    const ivec2 pixel_xy = tile_xy * kTileSize;" NL "    for (int y = 0; y < TILE_HEIGHT; ++y) {" NL
4565                            "      for (int x = 0; x < TILE_WIDTH; ++x) {" NL
4566                            "        imageStore(g_output_image, pixel_xy + ivec2(x, y), vec4(0, 1, 0, 1));" NL "      }" NL
4567                            "    }" NL "  }" NL "}";
4568
4569                 m_program[1] = CreateComputeProgram(glsl_cs);
4570                 glLinkProgram(m_program[1]);
4571                 if (!CheckProgram(m_program[1]))
4572                         return ERROR;
4573
4574                 const char* const glsl_cs2 = NL "#define TILE_WIDTH 32" NL "#define TILE_HEIGHT 32" NL
4575                                                                                 "const ivec2 kTileSize = ivec2(TILE_WIDTH, TILE_HEIGHT);" NL NL
4576                                                                                 "layout(binding = 0, rgba32f) uniform image2D g_input_image;" NL
4577                                                                                 "layout(binding = 1, rgba32f) uniform image2D g_output_image;" NL       NL
4578                                                                                 "layout(local_size_x = TILE_WIDTH, local_size_y=TILE_HEIGHT) in;" NL NL
4579                                                                                 "vec4 Process(vec4 ic) {" NL "  return ic + vec4(1, 0, 0, 0);" NL "}" NL
4580                                                                                 "void main() {" NL "  const ivec2 tile_xy = ivec2(gl_WorkGroupID);" NL
4581                                                                                 "  const ivec2 thread_xy = ivec2(gl_LocalInvocationID);" NL
4582                                                                                 "  const ivec2 pixel_xy = tile_xy * kTileSize + thread_xy;" NL
4583                                                                                 "  vec4 ic = imageLoad(g_input_image, pixel_xy);" NL
4584                                                                                 "  imageStore(g_output_image, pixel_xy, Process(ic));" NL "}";
4585                 m_program[2] = CreateComputeProgram(glsl_cs2);
4586                 glLinkProgram(m_program[2]);
4587                 if (!CheckProgram(m_program[2]))
4588                         return ERROR;
4589
4590                 glGenVertexArrays(1, &m_vertex_array);
4591
4592                 /* init render targets */
4593                 {
4594                         std::vector<vec4> data(128 * 128);
4595                         glGenTextures(2, m_render_target);
4596                         for (int i = 0; i < 2; ++i)
4597                         {
4598                                 glBindTexture(GL_TEXTURE_2D, m_render_target[i]);
4599                                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
4600                                 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, 128, 128, 0, GL_RGBA, GL_FLOAT, &data[0][0]);
4601                         }
4602                         glBindTexture(GL_TEXTURE_2D, 0);
4603                 }
4604
4605                 glGenFramebuffers(1, &m_framebuffer);
4606                 glBindFramebuffer(GL_FRAMEBUFFER, m_framebuffer);
4607                 glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_render_target[0], 0);
4608                 glBindFramebuffer(GL_FRAMEBUFFER, 0);
4609
4610                 glBindFramebuffer(GL_FRAMEBUFFER, m_framebuffer);
4611                 glUseProgram(m_program[0]);
4612                 glBindVertexArray(m_vertex_array);
4613                 glClear(GL_COLOR_BUFFER_BIT);
4614                 glViewport(0, 0, 128, 128);
4615                 // draw full-viewport triangle
4616                 glDrawArrays(GL_TRIANGLES, 1,
4617                                          3); // note: <first> is 1 this means that gl_VertexID in the VS will be: 1, 2 and 3
4618                 glBindFramebuffer(GL_FRAMEBUFFER, 0);
4619
4620                 glBindImageTexture(0, m_render_target[0], 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA32F);  // input
4621                 glBindImageTexture(1, m_render_target[1], 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA32F); // output
4622                 glUseProgram(m_program[1]);
4623                 glDispatchCompute(128 / 16, 128 / 16, 1);
4624
4625                 glBindImageTexture(0, m_render_target[1], 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA32F);  // input
4626                 glBindImageTexture(1, m_render_target[0], 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA32F); // output
4627                 glUseProgram(m_program[2]);
4628                 glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
4629                 glDispatchCompute(128 / 32, 128 / 32, 1);
4630
4631                 /* validate render target */
4632                 {
4633                         std::vector<vec4> data(128 * 128);
4634                         glBindTexture(GL_TEXTURE_2D, m_render_target[0]);
4635                         glMemoryBarrier(GL_TEXTURE_UPDATE_BARRIER_BIT);
4636                         glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_FLOAT, &data[0][0]);
4637                         for (std::size_t i = 0; i < data.size(); ++i)
4638                         {
4639                                 if (!IsEqual(data[i], vec4(1, 1, 0, 1)))
4640                                 {
4641                                         m_context.getTestContext().getLog()
4642                                                 << tcu::TestLog::Message << "Invalid data at index " << i << "." << tcu::TestLog::EndMessage;
4643                                         return ERROR;
4644                                 }
4645                         }
4646                 }
4647                 return NO_ERROR;
4648         }
4649
4650         virtual long Cleanup()
4651         {
4652                 glViewport(0, 0, getWindowWidth(), getWindowHeight());
4653                 glUseProgram(0);
4654                 for (int i = 0; i < 3; ++i)
4655                         glDeleteProgram(m_program[i]);
4656                 glDeleteTextures(2, m_render_target);
4657                 glDeleteVertexArrays(1, &m_vertex_array);
4658                 glDeleteFramebuffers(1, &m_framebuffer);
4659                 return NO_ERROR;
4660         }
4661 };
4662
4663 class AdvancedPipelinePostXFB : public ComputeShaderBase
4664 {
4665         virtual std::string Title()
4666         {
4667                 return NL "CS as an additional pipeline stage - After XFB";
4668         }
4669         virtual std::string Purpose()
4670         {
4671                 return NL "1. Verify that CS which process data fedback by VS works as expected." NL
4672                                   "2. Verify that XFB and SSBO works correctly together in one shader." NL
4673                                   "3. Verify that 'switch' statment which selects different execution path for each CS thread works as "
4674                                   "expected.";
4675         }
4676         virtual std::string Method()
4677         {
4678                 return NL "1. Draw triangle with XFB enabled. Some data is written to the XFB buffer." NL
4679                                   "2. Use XFB buffer as 'input SSBO' in CS. Process data and write it to 'output SSBO'." NL
4680                                   "3. Verify 'output SSBO' content.";
4681         }
4682         virtual std::string PassCriteria()
4683         {
4684                 return NL "Everything works as expected.";
4685         }
4686
4687         GLuint m_program[2];
4688         GLuint m_storage_buffer;
4689         GLuint m_xfb_buffer;
4690         GLuint m_vertex_buffer;
4691         GLuint m_vertex_array;
4692
4693         virtual long Setup()
4694         {
4695                 memset(m_program, 0, sizeof(m_program));
4696                 m_storage_buffer = 0;
4697                 m_xfb_buffer     = 0;
4698                 m_vertex_buffer  = 0;
4699                 m_vertex_array   = 0;
4700                 return NO_ERROR;
4701         }
4702         virtual long Run()
4703         {
4704                 GLint res;
4705                 glGetIntegerv(GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS, &res);
4706                 if (res <= 0)
4707                 {
4708                         OutputNotSupported("GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS <= 0");
4709                         return NO_ERROR;
4710                 }
4711
4712                 const char* const glsl_vs =
4713                         NL "layout(location = 0) in vec4 g_position;" NL "layout(location = 1) in vec4 g_color;" NL
4714                            "struct Vertex {" NL "  vec4 position;" NL "  vec4 color;" NL "};" NL "out StageData {" NL
4715                            "  vec4 color;" NL "} g_vs_out;" NL "layout(binding = 0, std430) buffer StageData {" NL
4716                            "  Vertex vertex[];" NL "} g_vs_buffer;" NL "void main() {" NL "  gl_Position = g_position;" NL
4717                            "  g_vs_out.color = g_color;" NL "  g_vs_buffer.vertex[gl_VertexID].position = g_position;" NL
4718                            "  g_vs_buffer.vertex[gl_VertexID].color = g_color;" NL "}";
4719
4720                 const char* const glsl_fs =
4721                         NL "in StageData {" NL "  vec4 color;" NL "} g_fs_in;" NL "layout(location = 0) out vec4 g_color;" NL
4722                            "void main() {" NL "  g_color = g_fs_in.color;" NL "}";
4723
4724                 m_program[0] = CreateProgram(glsl_vs, glsl_fs);
4725                 /* setup xfb varyings */
4726                 {
4727                         const char* const var[2] = { "gl_Position", "StageData.color" };
4728                         glTransformFeedbackVaryings(m_program[0], 2, var, GL_INTERLEAVED_ATTRIBS);
4729                 }
4730                 glLinkProgram(m_program[0]);
4731                 if (!CheckProgram(m_program[0]))
4732                         return ERROR;
4733
4734                 const char* const glsl_cs =
4735                         NL "layout(local_size_x = 3) in;" NL "struct Vertex {" NL "  vec4 position;" NL "  vec4 color;" NL "};" NL
4736                            "layout(binding = 3, std430) buffer Buffer {" NL "  Vertex g_vertex[3];" NL "};" NL
4737                            "uniform vec4 g_color1 = vec4(0, 0, 1, 0);" NL "uniform int g_two = 2;" NL
4738                            "void UpdateVertex2(int i) {" NL "  g_vertex[i].color -= vec4(-1, 1, 0, 0);" NL "}" NL "void main() {" NL
4739                            "  switch (gl_GlobalInvocationID.x) {" NL
4740                            "    case 0: g_vertex[gl_GlobalInvocationID.x].color += vec4(1, 0, 0, 0); break;" NL
4741                            "    case 1: g_vertex[1].color += g_color1; break;" NL "    case 2: UpdateVertex2(g_two); break;" NL
4742                            "    default: return;" NL "  }" NL "}";
4743                 m_program[1] = CreateComputeProgram(glsl_cs);
4744                 glLinkProgram(m_program[1]);
4745                 if (!CheckProgram(m_program[1]))
4746                         return ERROR;
4747
4748                 glGenBuffers(1, &m_storage_buffer);
4749                 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_storage_buffer);
4750                 glBufferData(GL_SHADER_STORAGE_BUFFER, 3 * sizeof(vec4) * 2, NULL, GL_STATIC_COPY);
4751
4752                 glGenBuffers(1, &m_xfb_buffer);
4753                 glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_xfb_buffer);
4754                 glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 3 * sizeof(vec4) * 2, NULL, GL_STREAM_COPY);
4755
4756                 const float in_data[3 * 8] = { -1, -1, 0, 1, 0, 1, 0, 1, 3, -1, 0, 1, 0, 1, 0, 1, -1, 3, 0, 1, 0, 1, 0, 1 };
4757                 glGenBuffers(1, &m_vertex_buffer);
4758                 glBindBuffer(GL_ARRAY_BUFFER, m_vertex_buffer);
4759                 glBufferData(GL_ARRAY_BUFFER, sizeof(in_data), in_data, GL_STATIC_DRAW);
4760                 glBindBuffer(GL_ARRAY_BUFFER, 0);
4761
4762                 glGenVertexArrays(1, &m_vertex_array);
4763                 glBindVertexArray(m_vertex_array);
4764                 glBindBuffer(GL_ARRAY_BUFFER, m_vertex_buffer);
4765                 glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 2 * sizeof(vec4), 0);
4766                 glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 2 * sizeof(vec4), reinterpret_cast<void*>(sizeof(vec4)));
4767                 glBindBuffer(GL_ARRAY_BUFFER, 0);
4768                 glEnableVertexAttribArray(0);
4769                 glEnableVertexAttribArray(1);
4770                 glBindVertexArray(0);
4771
4772                 glClear(GL_COLOR_BUFFER_BIT);
4773                 glUseProgram(m_program[0]);
4774                 glBindVertexArray(m_vertex_array);
4775                 glBeginTransformFeedback(GL_TRIANGLES);
4776                 glDrawArrays(GL_TRIANGLES, 0, 3);
4777                 glEndTransformFeedback();
4778
4779                 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, m_xfb_buffer);
4780                 glUseProgram(m_program[1]);
4781                 glDispatchCompute(1, 1, 1);
4782
4783                 glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
4784
4785                 /* validate storage buffer */
4786                 {
4787                         float data[3 * 8];
4788                         glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_storage_buffer);
4789                         glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(data), data);
4790                         if (memcmp(data, in_data, sizeof(data)) != 0)
4791                         {
4792                                 m_context.getTestContext().getLog()
4793                                         << tcu::TestLog::Message << "Data in shader storage buffer is incorrect."
4794                                         << tcu::TestLog::EndMessage;
4795                                 return ERROR;
4796                         }
4797                 }
4798                 /* validate xfb buffer */
4799                 {
4800                         const float ref_data[3 * 8] = {
4801                                 -1, -1, 0, 1, 1, 1, 0, 1, 3, -1, 0, 1, 0, 1, 1, 1, -1, 3, 0, 1, 1, 0, 0, 1
4802                         };
4803
4804                         float data[3 * 8];
4805                         glGetBufferSubData(GL_TRANSFORM_FEEDBACK_BUFFER, 0, sizeof(data), data);
4806                         if (memcmp(data, ref_data, sizeof(data)) != 0)
4807                         {
4808                                 m_context.getTestContext().getLog()
4809                                         << tcu::TestLog::Message << "Data in xfb buffer is incorrect." << tcu::TestLog::EndMessage;
4810                                 return ERROR;
4811                         }
4812                 }
4813                 if (!ValidateReadBuffer(0, 0, getWindowWidth(), getWindowHeight(), vec4(0, 1, 0, 1)))
4814                 {
4815                         return ERROR;
4816                 }
4817                 return NO_ERROR;
4818         }
4819
4820         virtual long Cleanup()
4821         {
4822                 glUseProgram(0);
4823                 for (int i = 0; i < 2; ++i)
4824                         glDeleteProgram(m_program[i]);
4825                 glDeleteBuffers(1, &m_vertex_buffer);
4826                 glDeleteBuffers(1, &m_storage_buffer);
4827                 glDeleteBuffers(1, &m_xfb_buffer);
4828                 glDeleteVertexArrays(1, &m_vertex_array);
4829                 return NO_ERROR;
4830         }
4831 };
4832
4833 class AdvancedSharedIndexing : public ComputeShaderBase
4834 {
4835         virtual std::string Title()
4836         {
4837                 return NL "Shared Memory - Indexing";
4838         }
4839         virtual std::string Purpose()
4840         {
4841                 return NL "1. Verify that indexing various types of shared memory works as expected." NL
4842                                   "2. Verify that indexing shared memory with different types of expressions work as expected." NL
4843                                   "3. Verify that all declaration types of shared structures are supported by the GLSL compiler.";
4844         }
4845         virtual std::string Method()
4846         {
4847                 return NL "1. Create CS which uses shared memory in many different ways." NL
4848                                   "2. Write to shared memory using different expressions." NL "3. Validate shared memory content." NL
4849                                   "4. Use synchronization primitives (barrier, groupMemoryBarrier) where applicable.";
4850         }
4851         virtual std::string PassCriteria()
4852         {
4853                 return NL "Everyting works as expected.";
4854         }
4855
4856         GLuint m_program;
4857         GLuint m_texture;
4858
4859         virtual long Setup()
4860         {
4861                 m_program = 0;
4862                 m_texture = 0;
4863                 return NO_ERROR;
4864         }
4865         virtual long Run()
4866         {
4867                 const char* const glsl_cs = NL
4868                         "layout(binding = 3, rgba32f) uniform image2D g_result_image;" NL
4869                         "layout (local_size_x = 4,local_size_y=4 ) in;" NL "shared vec4 g_shared1[4];" NL
4870                         "shared mat4 g_shared2;" NL "shared struct {" NL "  float data[4];" NL "} g_shared3[4];" NL
4871                         "shared struct Type { float data[4]; } g_shared4[4];" NL "shared Type g_shared5[4];" NL
4872                         "uniform bool g_true = true;" NL
4873                         "uniform float g_values[16] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };" NL NL
4874                         "void Sync() {" NL "  groupMemoryBarrier();" NL "  barrier();" NL "}" NL
4875                         "void SetMemory(ivec2 xy, float value) {" NL "  g_shared1[xy.y][gl_LocalInvocationID.x] = value;" NL
4876                         "  g_shared2[xy.y][xy.x] = value;" NL "  g_shared3[xy[1]].data[xy[0]] = value;" NL
4877                         "  g_shared4[xy.y].data[xy[0]] = value;" NL
4878                         "  g_shared5[gl_LocalInvocationID.y].data[gl_LocalInvocationID.x] = value;" NL "}" NL
4879                         "bool CheckMemory(ivec2 xy, float expected) {" NL
4880                         "  if (g_shared1[xy.y][xy[0]] != expected) return false;" NL
4881                         "  if (g_shared2[xy[1]][xy[0]] != expected) return false;" NL
4882                         "  if (g_shared3[gl_LocalInvocationID.y].data[gl_LocalInvocationID.x] != expected) return false;" NL
4883                         "  if (g_shared4[gl_LocalInvocationID.y].data[xy.x] != expected) return false;" NL
4884                         "  if (g_shared5[xy.y].data[xy.x] != expected) return false;" NL "  return true;" NL "}" NL
4885                         "void main() {" NL "  const ivec2 thread_xy = ivec2(gl_LocalInvocationID);" NL
4886                         "  vec4 result = vec4(0, 1, 0, 1);" NL NL
4887                         "  SetMemory(thread_xy, g_values[gl_LocalInvocationIndex] * 1.0);" NL "  Sync();" NL
4888                         "  if (!CheckMemory(thread_xy, g_values[gl_LocalInvocationIndex] * 1.0)) result = vec4(1, 0, 0, 1);" NL NL
4889                         "  SetMemory(thread_xy, g_values[gl_LocalInvocationIndex] * -1.0);" NL "  Sync();" NL
4890                         "  if (!CheckMemory(thread_xy, g_values[gl_LocalInvocationIndex] * -1.0)) result = vec4(1, 0, 0, 1);" NL NL
4891                         "  if (g_true && gl_LocalInvocationID.x < 10) {" NL
4892                         "    SetMemory(thread_xy, g_values[gl_LocalInvocationIndex] * 7.0);" NL "    Sync();" NL
4893                         "    if (!CheckMemory(thread_xy, g_values[gl_LocalInvocationIndex] * 7.0)) result = vec4(1, 0, 0, 1);" NL
4894                         "  }" NL NL "  imageStore(g_result_image, thread_xy, result);" NL "}";
4895                 m_program = CreateComputeProgram(glsl_cs);
4896                 glLinkProgram(m_program);
4897                 if (!CheckProgram(m_program))
4898                         return ERROR;
4899
4900                 /* init texture */
4901                 {
4902                         std::vector<vec4> data(4 * 4);
4903                         glGenTextures(1, &m_texture);
4904                         glBindTexture(GL_TEXTURE_2D, m_texture);
4905                         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
4906                         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, 4, 4, 0, GL_RGBA, GL_FLOAT, &data[0][0]);
4907                         glBindTexture(GL_TEXTURE_2D, 0);
4908                 }
4909
4910                 glBindImageTexture(3, m_texture, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA32F);
4911                 glUseProgram(m_program);
4912                 glDispatchCompute(1, 1, 1);
4913
4914                 /* validate render target */
4915                 {
4916                         std::vector<vec4> data(4 * 4);
4917                         glBindTexture(GL_TEXTURE_2D, m_texture);
4918                         glMemoryBarrier(GL_TEXTURE_UPDATE_BARRIER_BIT);
4919                         glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_FLOAT, &data[0][0]);
4920                         for (std::size_t i = 0; i < data.size(); ++i)
4921                         {
4922                                 if (!IsEqual(data[i], vec4(0, 1, 0, 1)))
4923                                 {
4924                                         m_context.getTestContext().getLog()
4925                                                 << tcu::TestLog::Message << "Invalid data at index " << i << "." << tcu::TestLog::EndMessage;
4926                                         return ERROR;
4927                                 }
4928                         }
4929                 }
4930                 return NO_ERROR;
4931         }
4932         virtual long Cleanup()
4933         {
4934                 glUseProgram(0);
4935                 glDeleteProgram(m_program);
4936                 glDeleteTextures(1, &m_texture);
4937                 return NO_ERROR;
4938         }
4939 };
4940
4941 class AdvancedSharedMax : public ComputeShaderBase
4942 {
4943         virtual std::string Title()
4944         {
4945                 return NL "Shared Memory - 32K";
4946         }
4947         virtual std::string Purpose()
4948         {
4949                 return NL "Support for 32K of shared memory is required by the OpenGL specifaction. Verify if an "
4950                                   "implementation supports it.";
4951         }
4952         virtual std::string Method()
4953         {
4954                 return NL "Create and dispatch CS which uses 32K of shared memory.";
4955         }
4956         virtual std::string PassCriteria()
4957         {
4958                 return NL "Everything works as expected.";
4959         }
4960
4961         GLuint m_program;
4962         GLuint m_buffer;
4963
4964         virtual long Setup()
4965         {
4966                 m_program = 0;
4967                 m_buffer  = 0;
4968                 return NO_ERROR;
4969         }
4970         virtual long Run()
4971         {
4972                 const char* const glsl_cs =
4973                         NL "layout(local_size_x = 1024) in;" NL
4974                            "shared struct Type { vec4 v[2]; } g_shared[1024];" // 32768 bytes of shared memory
4975                         NL "layout(std430) buffer Output {" NL "  Type g_output[1024];" NL "};" NL NL "void main() {" NL
4976                            "  const int id = int(gl_GlobalInvocationID.x);" NL
4977                            "  g_shared[id].v = vec4[2](vec4(1.0), vec4(1.0));" NL "  memoryBarrierShared();" NL "  barrier();" NL NL
4978                            "  vec4 sum = vec4(0.0);" NL "  int sum_count = 0;" NL "  for (int i = id - 3; i < id + 4; ++i) {" NL
4979                            "    if (id >= 0 && id < g_shared.length()) {" NL "      sum += g_shared[id].v[0];" NL
4980                            "      sum += g_shared[id].v[1];" NL "      sum_count += 2;" NL "    }" NL "  }" NL
4981                            "  if (any(greaterThan(abs((sum / sum_count) - vec4(1.0)), vec4(0.0000001f)))) return;" NL NL
4982                            "  g_output[id] = g_shared[id];" NL "}";
4983                 m_program = CreateComputeProgram(glsl_cs);
4984                 glLinkProgram(m_program);
4985                 if (!CheckProgram(m_program))
4986                         return ERROR;
4987
4988                 /* init buffer */
4989                 {
4990                         std::vector<vec4> data(1024 * 2);
4991                         glGenBuffers(1, &m_buffer);
4992                         glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_buffer);
4993                         glBufferData(GL_SHADER_STORAGE_BUFFER, (GLsizeiptr)(sizeof(vec4) * data.size()), &data[0][0],
4994                                                  GL_DYNAMIC_COPY);
4995                 }
4996
4997                 glUseProgram(m_program);
4998                 glDispatchCompute(1, 1, 1);
4999                 glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
5000
5001                 /* validate buffer */
5002                 {
5003                         std::vector<vec4> data(1024 * 2);
5004                         glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, (GLsizeiptr)(sizeof(vec4) * data.size()), &data[0][0]);
5005                         for (std::size_t i = 0; i < data.size(); ++i)
5006                         {
5007                                 if (!IsEqual(data[i], vec4(1.0f)))
5008                                 {
5009                                         m_context.getTestContext().getLog()
5010                                                 << tcu::TestLog::Message << "Invalid data at index " << i << "." << tcu::TestLog::EndMessage;
5011                                         return ERROR;
5012                                 }
5013                         }
5014                 }
5015                 return NO_ERROR;
5016         }
5017         virtual long Cleanup()
5018         {
5019                 glUseProgram(0);
5020                 glDeleteProgram(m_program);
5021                 glDeleteBuffers(1, &m_buffer);
5022                 return NO_ERROR;
5023         }
5024 };
5025
5026 class AdvancedDynamicPaths : public ComputeShaderBase
5027 {
5028         virtual std::string Title()
5029         {
5030                 return NL "Dynamic execution paths";
5031         }
5032         virtual std::string Purpose()
5033         {
5034                 return NL "1. Verify case where each of the four threads takes different execution path in the CS." NL
5035                                   "2. Execution path for each thread is not known at the compilation time." NL
5036                                   "    Selection is made based on the result of the texture sampling." NL
5037                                   "3. Verify that memory synchronization primitives (memoryBarrier* functions) are accepted" NL
5038                                   "    in the control flow.";
5039         }
5040         virtual std::string Method()
5041         {
5042                 return NL "1. Create and dispatch CS that takes different execution paths based on the result of the texture "
5043                                   "sampling." NL "2. In each execution path use different resources (buffers, samplers, uniform "
5044                                   "arrays) to compute output value.";
5045         }
5046         virtual std::string PassCriteria()
5047         {
5048                 return NL "Everything works as expected.";
5049         }
5050
5051         GLuint m_program;
5052         GLuint m_buffer[4];
5053         GLuint m_texture[2];
5054
5055         virtual long Setup()
5056         {
5057                 m_program = 0;
5058                 memset(m_buffer, 0, sizeof(m_buffer));
5059                 memset(m_texture, 0, sizeof(m_texture));
5060                 return NO_ERROR;
5061         }
5062         virtual long Run()
5063         {
5064                 const char* const glsl_cs =
5065                         NL "layout(local_size_x = 4) in;" NL "layout(std140, binding = 0) buffer Output {" NL
5066                            "  vec4 g_output[4];" NL "};" NL "uniform isamplerBuffer g_path_buffer;" NL
5067                            "uniform vec4[4] g_input0 = vec4[4](vec4(100), vec4(200), vec4(300), vec4(400));" NL
5068                            "uniform samplerBuffer g_input1;" NL "layout(binding = 1, std430) buffer Input2 {" NL
5069                            "  vec4[4] g_input2;" NL "};" NL NL "void Path2(int id) {" NL
5070                            "  g_output[id] = texelFetch(g_input1, int(gl_LocalInvocationIndex));" NL "}" NL "void main() {" NL
5071                            "  const int id = int(gl_GlobalInvocationID.x);" NL
5072                            "  const int path = texelFetch(g_path_buffer, id).x;" NL NL "  if (path == 0) {" NL
5073                            "    g_output[id] = g_input0[gl_LocalInvocationID.x];" NL "    memoryBarrier();" NL
5074                            "  } else if (path == 1) {" NL "    return;" NL "  } else if (path == 2) {" NL "    Path2(id);" NL
5075                            "    return;" NL "  } else if (path == 3) {" NL "    g_output[id] = g_input2[path - 1];" NL
5076                            "    memoryBarrierBuffer();" NL "  }" NL "}";
5077                 m_program = CreateComputeProgram(glsl_cs);
5078                 glLinkProgram(m_program);
5079                 if (!CheckProgram(m_program))
5080                         return ERROR;
5081
5082                 glGenBuffers(4, m_buffer);
5083                 glGenTextures(2, m_texture);
5084
5085                 /* init 'output' buffer */
5086                 {
5087                         std::vector<vec4> data(4, vec4(-100.0f));
5088                         glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_buffer[0]);
5089                         glBufferData(GL_SHADER_STORAGE_BUFFER, (GLsizeiptr)(sizeof(vec4) * data.size()), &data[0][0],
5090                                                  GL_DYNAMIC_COPY);
5091                 }
5092                 /* init 'input2' buffer */
5093                 {
5094                         const vec4 data[4] = { vec4(1.0f), vec4(2.0f), vec4(3.0f), vec4(4.0f) };
5095                         glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, m_buffer[1]);
5096                         glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(data), &data[0][0], GL_DYNAMIC_COPY);
5097                 }
5098                 /* init 'path' buffer */
5099                 {
5100                         const int data[4] = { 3, 2, 1, 0 };
5101                         glBindBuffer(GL_TEXTURE_BUFFER, m_buffer[2]);
5102                         glBufferData(GL_TEXTURE_BUFFER, sizeof(data), &data[0], GL_STATIC_DRAW);
5103                         glBindBuffer(GL_TEXTURE_BUFFER, 0);
5104                         glBindTexture(GL_TEXTURE_BUFFER, m_texture[0]);
5105                         glTexBuffer(GL_TEXTURE_BUFFER, GL_R32I, m_buffer[2]);
5106                         glBindTexture(GL_TEXTURE_BUFFER, 0);
5107                 }
5108                 /* init 'input1' buffer */
5109                 {
5110                         const vec4 data[4] = { vec4(10.0f), vec4(20.0f), vec4(30.0f), vec4(40.0f) };
5111                         glBindBuffer(GL_TEXTURE_BUFFER, m_buffer[3]);
5112                         glBufferData(GL_TEXTURE_BUFFER, sizeof(data), &data[0], GL_STATIC_DRAW);
5113                         glBindBuffer(GL_TEXTURE_BUFFER, 0);
5114                         glBindTexture(GL_TEXTURE_BUFFER, m_texture[1]);
5115                         glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32F, m_buffer[3]);
5116                         glBindTexture(GL_TEXTURE_BUFFER, 0);
5117                 }
5118
5119                 glUseProgram(m_program);
5120                 glUniform1i(glGetUniformLocation(m_program, "g_path_buffer"), 0);
5121                 glUniform1i(glGetUniformLocation(m_program, "g_input1"), 1);
5122                 glActiveTexture(GL_TEXTURE0);
5123                 glBindTexture(GL_TEXTURE_BUFFER, m_texture[0]);
5124                 glActiveTexture(GL_TEXTURE1);
5125                 glBindTexture(GL_TEXTURE_BUFFER, m_texture[1]);
5126                 glDispatchCompute(1, 1, 1);
5127                 glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
5128
5129                 /* validate 'output' buffer */
5130                 {
5131                         vec4 data[4];
5132                         glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_buffer[0]);
5133                         glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(data), &data[0][0]);
5134
5135                         const vec4 expected[4] = { vec4(3.0f), vec4(20.0f), vec4(-100.0f), vec4(400.0f) };
5136                         for (int i = 0; i < 4; ++i)
5137                         {
5138                                 if (!IsEqual(data[i], expected[i]))
5139                                 {
5140                                         m_context.getTestContext().getLog()
5141                                                 << tcu::TestLog::Message << "Invalid data at index " << i << "." << tcu::TestLog::EndMessage;
5142                                         return ERROR;
5143                                 }
5144                         }
5145                 }
5146                 return NO_ERROR;
5147         }
5148         virtual long Cleanup()
5149         {
5150                 glUseProgram(0);
5151                 glDeleteProgram(m_program);
5152                 glDeleteBuffers(4, m_buffer);
5153                 glDeleteTextures(2, m_texture);
5154                 return NO_ERROR;
5155         }
5156 };
5157
5158 class AdvancedResourcesMax : public ComputeShaderBase
5159 {
5160         virtual std::string Title()
5161         {
5162                 return NL "Maximum number of resources in one shader";
5163         }
5164         virtual std::string Purpose()
5165         {
5166                 return NL "1. Verify that using 8 SSBOs, 12 UBOs, 8 atomic counters, 16 samplers" NL
5167                                   "    and 8 images in one CS works as expected.";
5168         }
5169         virtual std::string Method()
5170         {
5171                 return NL "Create and dispatch CS. Verify result.";
5172         }
5173         virtual std::string PassCriteria()
5174         {
5175                 return NL "Everything works as expected.";
5176         }
5177
5178         GLuint m_program;
5179         GLuint m_storage_buffer[8];
5180         GLuint m_uniform_buffer[12];
5181         GLuint m_atomic_buffer[8];
5182         GLuint m_texture_buffer[16];
5183         GLuint m_texture[16];
5184         GLuint m_image_buffer[8];
5185         GLuint m_image[8];
5186
5187         bool RunIteration(GLuint index)
5188         {
5189                 for (GLuint i = 0; i < 8; ++i)
5190                 {
5191                         const GLuint data = i + 1;
5192                         glBindBufferBase(GL_SHADER_STORAGE_BUFFER, i, m_storage_buffer[i]);
5193                         glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(data), &data, GL_STATIC_DRAW);
5194                 }
5195                 for (GLuint i = 0; i < 12; ++i)
5196                 {
5197                         const GLuint data = i + 1;
5198                         glBindBufferBase(GL_UNIFORM_BUFFER, i, m_uniform_buffer[i]);
5199                         glBufferData(GL_UNIFORM_BUFFER, sizeof(data), &data, GL_STATIC_DRAW);
5200                 }
5201                 for (GLuint i = 0; i < 8; ++i)
5202                 {
5203                         const GLuint data = i + 1;
5204                         glBindBufferBase(GL_ATOMIC_COUNTER_BUFFER, i, m_atomic_buffer[i]);
5205                         glBufferData(GL_ATOMIC_COUNTER_BUFFER, sizeof(data), &data, GL_STATIC_DRAW);
5206                 }
5207                 for (GLuint i = 0; i < 16; ++i)
5208                 {
5209                         const GLuint data = i + 1;
5210                         glBindBuffer(GL_TEXTURE_BUFFER, m_texture_buffer[i]);
5211                         glBufferData(GL_TEXTURE_BUFFER, sizeof(data), &data, GL_DYNAMIC_READ);
5212                         glBindBuffer(GL_TEXTURE_BUFFER, 0);
5213
5214                         glActiveTexture(GL_TEXTURE0 + i);
5215                         glBindTexture(GL_TEXTURE_BUFFER, m_texture[i]);
5216                         glTexBuffer(GL_TEXTURE_BUFFER, GL_R32UI, m_texture_buffer[i]);
5217                 }
5218                 for (GLuint i = 0; i < 8; ++i)
5219                 {
5220                         const GLuint data = i + 1;
5221                         glBindBuffer(GL_TEXTURE_BUFFER, m_image_buffer[i]);
5222                         glBufferData(GL_TEXTURE_BUFFER, sizeof(data), &data, GL_DYNAMIC_COPY);
5223                         glBindBuffer(GL_TEXTURE_BUFFER, 0);
5224
5225                         glBindTexture(GL_TEXTURE_BUFFER, m_image[i]);
5226                         glTexBuffer(GL_TEXTURE_BUFFER, GL_R32UI, m_image_buffer[i]);
5227                         glBindTexture(GL_TEXTURE_BUFFER, 0);
5228
5229                         glBindImageTexture(i, m_image[i], 0, GL_FALSE, 0, GL_READ_ONLY, GL_R32UI);
5230                 }
5231
5232                 glUseProgram(m_program);
5233                 glUniform1ui(glGetUniformLocation(m_program, "g_index"), index);
5234                 /* uniform array */
5235                 {
5236                         std::vector<GLuint> data(480);
5237                         for (GLuint i = 0; i < static_cast<GLuint>(data.size()); ++i)
5238                                 data[i]   = i + 1;
5239                         glUniform1uiv(glGetUniformLocation(m_program, "g_uniform_def"), static_cast<GLsizei>(data.size()),
5240                                                   &data[0]);
5241                 }
5242                 glDispatchCompute(1, 1, 1);
5243                 glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
5244
5245                 bool result = true;
5246                 /* validate buffer */
5247                 {
5248                         GLuint data;
5249                         glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_storage_buffer[index]);
5250                         glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(data), &data);
5251
5252                         if (data != (index + 1) * 6)
5253                         {
5254                                 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Data is " << data << " should be "
5255                                                                                                         << (index + 1) * 6 << "." << tcu::TestLog::EndMessage;
5256                                 result = false;
5257                         }
5258                         glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
5259                 }
5260                 return result;
5261         }
5262         virtual long Setup()
5263         {
5264                 m_program = 0;
5265                 memset(m_storage_buffer, 0, sizeof(m_storage_buffer));
5266                 memset(m_uniform_buffer, 0, sizeof(m_uniform_buffer));
5267                 memset(m_atomic_buffer, 0, sizeof(m_atomic_buffer));
5268                 memset(m_texture_buffer, 0, sizeof(m_texture_buffer));
5269                 memset(m_texture, 0, sizeof(m_texture));
5270                 memset(m_image_buffer, 0, sizeof(m_image_buffer));
5271                 memset(m_image, 0, sizeof(m_image));
5272                 return NO_ERROR;
5273         }
5274         virtual long Run()
5275         {
5276                 const char* const glsl_cs =
5277                         NL "layout(local_size_x = 1) in;" NL "layout(std140, binding = 0) buffer ShaderStorageBlock {" NL
5278                            "  uint data;" NL "} g_shader_storage[8];" NL "layout(std140, binding = 0) uniform UniformBlock {" NL
5279                            "  uint data;" NL "} g_uniform[12];" NL "layout(binding = 0) uniform usamplerBuffer g_sampler[16];" NL
5280                            "layout(binding = 0, r32ui) uniform uimageBuffer g_image[8];" NL
5281                            "layout(binding = 0, offset = 0) uniform atomic_uint g_atomic_counter0;" NL
5282                            "layout(binding = 1, offset = 0) uniform atomic_uint g_atomic_counter1;" NL
5283                            "layout(binding = 2, offset = 0) uniform atomic_uint g_atomic_counter2;" NL
5284                            "layout(binding = 3, offset = 0) uniform atomic_uint g_atomic_counter3;" NL
5285                            "layout(binding = 4, offset = 0) uniform atomic_uint g_atomic_counter4;" NL
5286                            "layout(binding = 5, offset = 0) uniform atomic_uint g_atomic_counter5;" NL
5287                            "layout(binding = 6, offset = 0) uniform atomic_uint g_atomic_counter6;" NL
5288                            "layout(binding = 7, offset = 0) uniform atomic_uint g_atomic_counter7;" NL
5289                            "uniform uint g_uniform_def[480];" NL "uniform uint g_index = 0u;" NL NL "uint Add() {" NL
5290                            "  switch (g_index) {" NL "    case 0: return atomicCounter(g_atomic_counter0);" NL
5291                            "    case 1: return atomicCounter(g_atomic_counter1);" NL
5292                            "    case 2: return atomicCounter(g_atomic_counter2);" NL
5293                            "    case 3: return atomicCounter(g_atomic_counter3);" NL
5294                            "    case 4: return atomicCounter(g_atomic_counter4);" NL
5295                            "    case 5: return atomicCounter(g_atomic_counter5);" NL
5296                            "    case 6: return atomicCounter(g_atomic_counter6);" NL
5297                            "    case 7: return atomicCounter(g_atomic_counter7);" NL "  }" NL "}" NL "void main() {" NL
5298                            "  g_shader_storage[g_index].data += g_uniform[g_index].data;" NL
5299                            "  g_shader_storage[g_index].data += texelFetch(g_sampler[g_index], 0).x;" NL
5300                            "  g_shader_storage[g_index].data += imageLoad(g_image[g_index], 0).x;" NL
5301                            "  g_shader_storage[g_index].data += Add();" NL
5302                            "  g_shader_storage[g_index].data += g_uniform_def[g_index];" NL "}";
5303                 m_program = CreateComputeProgram(glsl_cs);
5304                 glLinkProgram(m_program);
5305                 if (!CheckProgram(m_program))
5306                         return ERROR;
5307
5308                 glGenBuffers(16, m_storage_buffer);
5309                 glGenBuffers(12, m_uniform_buffer);
5310                 glGenBuffers(8, m_atomic_buffer);
5311                 glGenBuffers(16, m_texture_buffer);
5312                 glGenTextures(16, m_texture);
5313                 glGenBuffers(8, m_image_buffer);
5314                 glGenTextures(8, m_image);
5315
5316                 if (!RunIteration(0))
5317                         return ERROR;
5318                 if (!RunIteration(1))
5319                         return ERROR;
5320                 if (!RunIteration(5))
5321                         return ERROR;
5322
5323                 return NO_ERROR;
5324         }
5325         virtual long Cleanup()
5326         {
5327                 glUseProgram(0);
5328                 glDeleteProgram(m_program);
5329                 glDeleteBuffers(16, m_storage_buffer);
5330                 glDeleteBuffers(12, m_uniform_buffer);
5331                 glDeleteBuffers(8, m_atomic_buffer);
5332                 glDeleteBuffers(16, m_texture_buffer);
5333                 glDeleteTextures(16, m_texture);
5334                 glDeleteBuffers(8, m_image_buffer);
5335                 glDeleteTextures(8, m_image);
5336                 return NO_ERROR;
5337         }
5338 };
5339
5340 class AdvancedFP64Case1 : public ComputeShaderBase
5341 {
5342         virtual std::string Title()
5343         {
5344                 return NL "FP64 support - built-in math functions";
5345         }
5346         virtual std::string Purpose()
5347         {
5348                 return NL "Verify that selected double precision math functions works as expected in the CS.";
5349         }
5350         virtual std::string Method()
5351         {
5352                 return NL "Create and dispatch CS which uses double precision math functions. Verify results.";
5353         }
5354         virtual std::string PassCriteria()
5355         {
5356                 return NL "Everything works as expected.";
5357         }
5358
5359         GLuint m_program;
5360         GLuint m_storage_buffer[4];
5361         GLuint m_uniform_buffer[2];
5362
5363         virtual long Setup()
5364         {
5365                 m_program = 0;
5366                 memset(m_storage_buffer, 0, sizeof(m_storage_buffer));
5367                 memset(m_uniform_buffer, 0, sizeof(m_uniform_buffer));
5368                 return NO_ERROR;
5369         }
5370         virtual long Run()
5371         {
5372                 const char* const glsl_cs =
5373                         NL "layout(local_size_x = 4) in;" NL "layout(std140, binding = 0) buffer ShaderStorageBlock {" NL
5374                            "  double data;" NL "} g_shader_storage[4];" NL "layout(std140, binding = 0) uniform UniformBlock {" NL
5375                            "  double data;" NL "} g_uniform[2];" NL "uniform dvec2 g_uniform_def;" NL NL "void main() {" NL
5376                            "  if (gl_GlobalInvocationID.x == 0) {" NL
5377                            "    g_shader_storage[0].data = floor(g_uniform[0].data + 0.1LF);" // floor(1.1LF) == 1.0LF
5378                         NL "  } else if (gl_GlobalInvocationID.x == 1) {" NL
5379                            "    g_shader_storage[1].data = ceil(g_uniform[1].data + 0.2LF);" // ceil(2.2LF) == 3.0LF
5380                         NL "  } else if (gl_GlobalInvocationID.x == 2) {" NL
5381                            "    g_shader_storage[2].data = min(g_uniform_def[0] + 0.1LF, 1.0LF);" // min(1.1LF, 1.0LF) == 1.0LF
5382                         NL "  } else if (gl_GlobalInvocationID.x == 3) {" NL
5383                            "    g_shader_storage[3].data = max(g_uniform_def[0], g_uniform_def.y);" // max(1.0LF, 2.0LF) == 2.0LF
5384                         NL "  }" NL "}";
5385                 m_program = CreateComputeProgram(glsl_cs);
5386                 glLinkProgram(m_program);
5387                 if (!CheckProgram(m_program))
5388                         return ERROR;
5389
5390                 glGenBuffers(4, m_storage_buffer);
5391                 for (GLuint i = 0; i < 4; ++i)
5392                 {
5393                         const GLdouble data = static_cast<GLdouble>(i + 1);
5394                         glBindBufferBase(GL_SHADER_STORAGE_BUFFER, i, m_storage_buffer[i]);
5395                         glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(data), &data, GL_STATIC_DRAW);
5396                 }
5397
5398                 glGenBuffers(2, m_uniform_buffer);
5399                 for (GLuint i = 0; i < 2; ++i)
5400                 {
5401                         const GLdouble data = static_cast<GLdouble>(i + 1);
5402                         glBindBufferBase(GL_UNIFORM_BUFFER, i, m_uniform_buffer[i]);
5403                         glBufferData(GL_UNIFORM_BUFFER, sizeof(data), &data, GL_STATIC_DRAW);
5404                 }
5405
5406                 glUseProgram(m_program);
5407                 glUniform2d(glGetUniformLocation(m_program, "g_uniform_def"), 1.0, 2.0);
5408                 glDispatchCompute(1, 1, 1);
5409                 glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
5410
5411                 /* validate */
5412                 {
5413                         const GLdouble expected[4] = { 1.0, 3.0, 1.0, 2.0 };
5414                         for (int i = 0; i < 4; ++i)
5415                         {
5416                                 GLdouble data;
5417                                 glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_storage_buffer[i]);
5418                                 glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(data), &data);
5419                                 if (data != expected[i])
5420                                 {
5421                                         m_context.getTestContext().getLog()
5422                                                 << tcu::TestLog::Message << "Data at index " << i << " is " << data << " should be "
5423                                                 << expected[i] << "." << tcu::TestLog::EndMessage;
5424                                         return ERROR;
5425                                 }
5426                         }
5427                 }
5428                 return NO_ERROR;
5429         }
5430         virtual long Cleanup()
5431         {
5432                 glUseProgram(0);
5433                 glDeleteProgram(m_program);
5434                 glDeleteBuffers(4, m_storage_buffer);
5435                 glDeleteBuffers(2, m_uniform_buffer);
5436                 return NO_ERROR;
5437         }
5438 };
5439
5440 class AdvancedFP64Case2 : public ComputeShaderBase
5441 {
5442         virtual std::string Title()
5443         {
5444                 return NL "FP64 support - uniform variables";
5445         }
5446         virtual std::string Purpose()
5447         {
5448                 return NL "1. Verify that all types of double precision uniform variables work as expected in CS." NL
5449                                   "2. Verify that all double precision uniform variables can be updated with Uniform* and "
5450                                   "ProgramUniform* commands." NL "3. Verify that re-linking CS program works as expected.";
5451         }
5452         virtual std::string Method()
5453         {
5454                 return NL "1. Create CS which uses all (double precision) types of uniform variables." NL
5455                                   "2. Update uniform variables with ProgramUniform* commands." NL
5456                                   "3. Verify that uniform variables were updated correctly." NL "4. Re-link CS program." NL
5457                                   "5. Update uniform variables with Uniform* commands." NL
5458                                   "6. Verify that uniform variables were updated correctly.";
5459         }
5460         virtual std::string PassCriteria()
5461         {
5462                 return NL "Everything works as expected.";
5463         }
5464
5465         GLuint m_program;
5466         GLuint m_storage_buffer;
5467
5468         virtual long Setup()
5469         {
5470                 m_program                = 0;
5471                 m_storage_buffer = 0;
5472                 return NO_ERROR;
5473         }
5474         virtual long Run()
5475         {
5476                 const char* const glsl_cs = NL
5477                         "layout(local_size_x = 1) in;" NL "buffer Result {" NL "  int g_result;" NL "};" NL "uniform double g_0;" NL
5478                         "uniform dvec2 g_1;" NL "uniform dvec3 g_2;" NL "uniform dvec4 g_3;" NL "uniform dmat2 g_4;" NL
5479                         "uniform dmat2x3 g_5;" NL "uniform dmat2x4 g_6;" NL "uniform dmat3x2 g_7;" NL "uniform dmat3 g_8;" NL
5480                         "uniform dmat3x4 g_9;" NL "uniform dmat4x2 g_10;" NL "uniform dmat4x3 g_11;" NL "uniform dmat4 g_12;" NL NL
5481                         "void main() {" NL "  g_result = 1;" NL NL "  if (g_0 != 1.0LF) g_result = 0;" NL
5482                         "  if (g_1 != dvec2(2.0LF, 3.0LF)) g_result = 0;" NL
5483                         "  if (g_2 != dvec3(4.0LF, 5.0LF, 6.0LF)) g_result = 0;" NL
5484                         "  if (g_3 != dvec4(7.0LF, 8.0LF, 9.0LF, 10.0LF)) g_result = 0;" NL NL
5485                         "  if (g_4 != dmat2(11.0LF, 12.0LF, 13.0LF, 14.0LF)) g_result = 0;" NL
5486                         "  if (g_5 != dmat2x3(15.0LF, 16.0LF, 17.0LF, 18.0LF, 19.0LF, 20.0LF)) g_result = 0;" NL
5487                         "  if (g_6 != dmat2x4(21.0LF, 22.0LF, 23.0LF, 24.0LF, 25.0LF, 26.0LF, 27.0LF, 28.0LF)) g_result = 0;" NL NL
5488                         "  if (g_7 != dmat3x2(29.0LF, 30.0LF, 31.0LF, 32.0LF, 33.0LF, 34.0LF)) g_result = 0;" NL
5489                         "  if (g_8 != dmat3(35.0LF, 36.0LF, 37.0LF, 38.0LF, 39.0LF, 40.0LF, 41.0LF, 42.0LF, 43.0LF)) g_result = "
5490                         "0;" NL "  if (g_9 != dmat3x4(44.0LF, 45.0LF, 46.0LF, 47.0LF, 48.0LF, 49.0LF, 50.0LF, 51.0LF, 52.0LF, "
5491                         "53.0LF, 54.0LF, 55.0LF)) g_result = 0;" NL NL
5492                         "  if (g_10 != dmat4x2(56.0, 57.0, 58.0, 59.0, 60.0, 61.0, 62.0, 63.0)) g_result = 0;" NL
5493                         "  if (g_11 != dmat4x3(63.0, 64.0, 65.0, 66.0, 67.0, 68.0, 69.0, 70.0, 71.0, 27.0, 73, 74.0)) g_result = "
5494                         "0;" NL "  if (g_12 != dmat4(75.0, 76.0, 77.0, 78.0, 79.0, 80.0, 81.0, 82.0, 83.0, 84.0, 85.0, 86.0, 87.0, "
5495                         "88.0, 89.0, 90.0)) g_result = 0;" NL "}";
5496                 m_program = CreateComputeProgram(glsl_cs);
5497                 glLinkProgram(m_program);
5498                 if (!CheckProgram(m_program))
5499                         return ERROR;
5500
5501                 glGenBuffers(1, &m_storage_buffer);
5502                 /* create buffer */
5503                 {
5504                         const int data = 123;
5505                         glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_storage_buffer);
5506                         glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(data), &data, GL_STATIC_DRAW);
5507                 }
5508
5509                 glProgramUniform1d(m_program, glGetUniformLocation(m_program, "g_0"), 1.0);
5510                 glProgramUniform2d(m_program, glGetUniformLocation(m_program, "g_1"), 2.0, 3.0);
5511                 glProgramUniform3d(m_program, glGetUniformLocation(m_program, "g_2"), 4.0, 5.0, 6.0);
5512                 glProgramUniform4d(m_program, glGetUniformLocation(m_program, "g_3"), 7.0, 8.0, 9.0, 10.0);
5513
5514                 /* mat2 */
5515                 {
5516                         const GLdouble value[4] = { 11.0, 12.0, 13.0, 14.0 };
5517                         glProgramUniformMatrix2dv(m_program, glGetUniformLocation(m_program, "g_4"), 1, GL_FALSE, value);
5518                 }
5519                 /* mat2x3 */
5520                 {
5521                         const GLdouble value[6] = { 15.0, 16.0, 17.0, 18.0, 19.0, 20.0 };
5522                         glProgramUniformMatrix2x3dv(m_program, glGetUniformLocation(m_program, "g_5"), 1, GL_FALSE, value);
5523                 }
5524                 /* mat2x4 */
5525                 {
5526                         const GLdouble value[8] = { 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0 };
5527                         glProgramUniformMatrix2x4dv(m_program, glGetUniformLocation(m_program, "g_6"), 1, GL_FALSE, value);
5528                 }
5529
5530                 /* mat3x2 */
5531                 {
5532                         const GLdouble value[6] = { 29.0, 30.0, 31.0, 32.0, 33.0, 34.0 };
5533                         glProgramUniformMatrix3x2dv(m_program, glGetUniformLocation(m_program, "g_7"), 1, GL_FALSE, value);
5534                 }
5535                 /* mat3 */
5536                 {
5537                         const GLdouble value[9] = { 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0 };
5538                         glProgramUniformMatrix3dv(m_program, glGetUniformLocation(m_program, "g_8"), 1, GL_FALSE, value);
5539                 }
5540                 /* mat3x4 */
5541                 {
5542                         const GLdouble value[12] = { 44.0, 45.0, 46.0, 47.0, 48.0, 49.0, 50.0, 51.0, 52.0, 53.0, 54.0, 55.0 };
5543                         glProgramUniformMatrix3x4dv(m_program, glGetUniformLocation(m_program, "g_9"), 1, GL_FALSE, value);
5544                 }
5545
5546                 /* mat4x2 */
5547                 {
5548                         const GLdouble value[8] = { 56.0, 57.0, 58.0, 59.0, 60.0, 61.0, 62.0, 63.0 };
5549                         glProgramUniformMatrix4x2dv(m_program, glGetUniformLocation(m_program, "g_10"), 1, GL_FALSE, value);
5550                 }
5551                 /* mat4x3 */
5552                 {
5553                         const GLdouble value[12] = { 63.0, 64.0, 65.0, 66.0, 67.0, 68.0, 69.0, 70.0, 71.0, 27.0, 73, 74.0 };
5554                         glProgramUniformMatrix4x3dv(m_program, glGetUniformLocation(m_program, "g_11"), 1, GL_FALSE, value);
5555                 }
5556                 /* mat4 */
5557                 {
5558                         const GLdouble value[16] = { 75.0, 76.0, 77.0, 78.0, 79.0, 80.0, 81.0, 82.0,
5559                                                                                  83.0, 84.0, 85.0, 86.0, 87.0, 88.0, 89.0, 90.0 };
5560                         glProgramUniformMatrix4dv(m_program, glGetUniformLocation(m_program, "g_12"), 1, GL_FALSE, value);
5561                 }
5562
5563                 glUseProgram(m_program);
5564                 glDispatchCompute(1, 1, 1);
5565                 glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
5566
5567                 /* validate */
5568                 {
5569                         int data;
5570                         glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(data), &data);
5571                         if (data != 1)
5572                         {
5573                                 m_context.getTestContext().getLog()
5574                                         << tcu::TestLog::Message << "Data is " << data << " should be 1." << tcu::TestLog::EndMessage;
5575                                 return ERROR;
5576                         }
5577                 }
5578
5579                 // re-link program (all uniforms will be set to zero)
5580                 glLinkProgram(m_program);
5581
5582                 /* clear buffer */
5583                 {
5584                         const int data = 123;
5585                         glBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(data), &data);
5586                 }
5587
5588                 glUniform1d(glGetUniformLocation(m_program, "g_0"), 1.0);
5589                 glUniform2d(glGetUniformLocation(m_program, "g_1"), 2.0, 3.0);
5590                 glUniform3d(glGetUniformLocation(m_program, "g_2"), 4.0, 5.0, 6.0);
5591                 glUniform4d(glGetUniformLocation(m_program, "g_3"), 7.0, 8.0, 9.0, 10.0);
5592
5593                 /* mat2 */
5594                 {
5595                         const GLdouble value[4] = { 11.0, 12.0, 13.0, 14.0 };
5596                         glUniformMatrix2dv(glGetUniformLocation(m_program, "g_4"), 1, GL_FALSE, value);
5597                 }
5598                 /* mat2x3 */
5599                 {
5600                         const GLdouble value[6] = { 15.0, 16.0, 17.0, 18.0, 19.0, 20.0 };
5601                         glUniformMatrix2x3dv(glGetUniformLocation(m_program, "g_5"), 1, GL_FALSE, value);
5602                 }
5603                 /* mat2x4 */
5604                 {
5605                         const GLdouble value[8] = { 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0 };
5606                         glUniformMatrix2x4dv(glGetUniformLocation(m_program, "g_6"), 1, GL_FALSE, value);
5607                 }
5608
5609                 /* mat3x2 */
5610                 {
5611                         const GLdouble value[6] = { 29.0, 30.0, 31.0, 32.0, 33.0, 34.0 };
5612                         glUniformMatrix3x2dv(glGetUniformLocation(m_program, "g_7"), 1, GL_FALSE, value);
5613                 }
5614                 /* mat3 */
5615                 {
5616                         const GLdouble value[9] = { 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0 };
5617                         glUniformMatrix3dv(glGetUniformLocation(m_program, "g_8"), 1, GL_FALSE, value);
5618                 }
5619                 /* mat3x4 */
5620                 {
5621                         const GLdouble value[12] = { 44.0, 45.0, 46.0, 47.0, 48.0, 49.0, 50.0, 51.0, 52.0, 53.0, 54.0, 55.0 };
5622                         glUniformMatrix3x4dv(glGetUniformLocation(m_program, "g_9"), 1, GL_FALSE, value);
5623                 }
5624
5625                 /* mat4x2 */
5626                 {
5627                         const GLdouble value[8] = { 56.0, 57.0, 58.0, 59.0, 60.0, 61.0, 62.0, 63.0 };
5628                         glUniformMatrix4x2dv(glGetUniformLocation(m_program, "g_10"), 1, GL_FALSE, value);
5629                 }
5630                 /* mat4x3 */
5631                 {
5632                         const GLdouble value[12] = { 63.0, 64.0, 65.0, 66.0, 67.0, 68.0, 69.0, 70.0, 71.0, 27.0, 73, 74.0 };
5633                         glUniformMatrix4x3dv(glGetUniformLocation(m_program, "g_11"), 1, GL_FALSE, value);
5634                 }
5635                 /* mat4 */
5636                 {
5637                         const GLdouble value[16] = { 75.0, 76.0, 77.0, 78.0, 79.0, 80.0, 81.0, 82.0,
5638                                                                                  83.0, 84.0, 85.0, 86.0, 87.0, 88.0, 89.0, 90.0 };
5639                         glUniformMatrix4dv(glGetUniformLocation(m_program, "g_12"), 1, GL_FALSE, value);
5640                 }
5641
5642                 glDispatchCompute(1, 1, 1);
5643                 glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
5644
5645                 /* validate */
5646                 {
5647                         int data;
5648                         glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(data), &data);
5649                         if (data != 1)
5650                         {
5651                                 m_context.getTestContext().getLog()
5652                                         << tcu::TestLog::Message << "Data is " << data << " should be 1." << tcu::TestLog::EndMessage;
5653                                 return ERROR;
5654                         }
5655                 }
5656
5657                 return NO_ERROR;
5658         }
5659         virtual long Cleanup()
5660         {
5661                 glUseProgram(0);
5662                 glDeleteProgram(m_program);
5663                 glDeleteBuffers(1, &m_storage_buffer);
5664                 return NO_ERROR;
5665         }
5666 };
5667
5668 class AdvancedFP64Case3 : public ComputeShaderBase
5669 {
5670         virtual std::string Title()
5671         {
5672                 return NL "FP64 support - subroutines";
5673         }
5674         virtual std::string Purpose()
5675         {
5676                 return NL "Verify that subroutines that performs double precision computation works as expected in the CS.";
5677         }
5678         virtual std::string Method()
5679         {
5680                 return NL
5681                         "Create and dispatch CS that uses double precision math functions in subroutines to compute output values.";
5682         }
5683         virtual std::string PassCriteria()
5684         {
5685                 return NL "Everything works as expected.";
5686         }
5687
5688         GLuint m_program;
5689         GLuint m_storage_buffer;
5690
5691         virtual long Setup()
5692         {
5693                 m_program                = 0;
5694                 m_storage_buffer = 0;
5695                 return NO_ERROR;
5696         }
5697         virtual long Run()
5698         {
5699                 const char* const glsl_cs =
5700                         NL "layout(local_size_x = 1) in;" NL "uniform double[4] g_input;" NL "uniform int index;" NL
5701                            "layout(std430, binding = 0) buffer Output {" NL "  double g_output[4];" NL "};" NL
5702                            "subroutine double MathFunc(double x);" NL "subroutine uniform MathFunc g_func[4];" NL
5703                            "subroutine(MathFunc)" NL "double Func0(double x) {" NL "  return abs(x);" // abs(-1.0LF) == 1.0LF
5704                         NL "}" NL "subroutine(MathFunc)" NL "double Func1(double x) {" NL
5705                            "  return round(x);" // round(2.2LF) == 2.0LF
5706                         NL "}" NL "subroutine(MathFunc)" NL "double Func2(double x) {" NL
5707                            "  return sign(x);" // sign(3.0LF) == 1.0LF
5708                         NL "}" NL "subroutine(MathFunc)" NL "double Func3(double x) {" NL
5709                            "  return fract(x);" // fract(4.1LF) == 0.1LF
5710                         NL "}" NL "void main() {" NL "  int i = index;" NL "  g_output[i] = g_func[i](g_input[i]);" NL "}";
5711                 m_program = CreateComputeProgram(glsl_cs);
5712                 glLinkProgram(m_program);
5713                 if (!CheckProgram(m_program))
5714                         return ERROR;
5715
5716                 glGenBuffers(1, &m_storage_buffer);
5717                 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_storage_buffer);
5718                 glBufferData(GL_SHADER_STORAGE_BUFFER, 4 * sizeof(double), NULL, GL_STATIC_DRAW);
5719
5720                 const GLuint index_compute0 = glGetSubroutineIndex(m_program, GL_COMPUTE_SHADER, "Func0");
5721                 const GLuint index_compute1 = glGetSubroutineIndex(m_program, GL_COMPUTE_SHADER, "Func1");
5722                 const GLuint index_compute2 = glGetSubroutineIndex(m_program, GL_COMPUTE_SHADER, "Func2");
5723                 const GLuint index_compute3 = glGetSubroutineIndex(m_program, GL_COMPUTE_SHADER, "Func3");
5724                 const GLint  loc_compute0   = glGetSubroutineUniformLocation(m_program, GL_COMPUTE_SHADER, "g_func[0]");
5725                 const GLint  loc_compute1   = glGetSubroutineUniformLocation(m_program, GL_COMPUTE_SHADER, "g_func[1]");
5726                 const GLint  loc_compute2   = glGetSubroutineUniformLocation(m_program, GL_COMPUTE_SHADER, "g_func[2]");
5727                 const GLint  loc_compute3   = glGetSubroutineUniformLocation(m_program, GL_COMPUTE_SHADER, "g_func[3]");
5728
5729                 glUseProgram(m_program);
5730
5731                 // setup subroutines
5732                 GLuint indices[4];
5733                 indices[loc_compute0] = index_compute0;
5734                 indices[loc_compute1] = index_compute1;
5735                 indices[loc_compute2] = index_compute2;
5736                 indices[loc_compute3] = index_compute3;
5737                 glUniformSubroutinesuiv(GL_COMPUTE_SHADER, 4, indices);
5738
5739                 /* set uniforms */
5740                 {
5741                         const GLdouble data[4] = { -1.0, 2.2, 3.0, 4.1 };
5742                         glUniform1dv(glGetUniformLocation(m_program, "g_input"), 4, data);
5743                 }
5744                 glUniform1i(glGetUniformLocation(m_program, "index"), 0);
5745                 glDispatchCompute(1, 1, 1);
5746                 glUniform1i(glGetUniformLocation(m_program, "index"), 1);
5747                 glDispatchCompute(1, 1, 1);
5748                 glUniform1i(glGetUniformLocation(m_program, "index"), 2);
5749                 glDispatchCompute(1, 1, 1);
5750                 glUniform1i(glGetUniformLocation(m_program, "index"), 3);
5751                 glDispatchCompute(1, 1, 1);
5752                 glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
5753
5754                 /* validate */
5755                 {
5756                         const GLdouble expected[4] = { 1.0, 2.0, 1.0, 0.1 };
5757                         GLdouble           data[4];
5758                         glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_storage_buffer);
5759                         glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(data), &data);
5760                         for (int i = 0; i < 4; ++i)
5761                         {
5762                                 if (fabs(data[i] - expected[i]) > g_color_eps.x())
5763                                 {
5764                                         m_context.getTestContext().getLog()
5765                                                 << tcu::TestLog::Message << "Data at index " << i << " is " << data[i] << " should be "
5766                                                 << expected[i] << "." << tcu::TestLog::EndMessage;
5767                                         return ERROR;
5768                                 }
5769                         }
5770                 }
5771                 return NO_ERROR;
5772         }
5773         virtual long Cleanup()
5774         {
5775                 glUseProgram(0);
5776                 glDeleteProgram(m_program);
5777                 glDeleteBuffers(1, &m_storage_buffer);
5778                 return NO_ERROR;
5779         }
5780 };
5781
5782 class AdvancedConditionalDispatching : public ComputeShaderBase
5783 {
5784         virtual std::string Title()
5785         {
5786                 return NL "Conditional Dispatching";
5787         }
5788         virtual std::string Purpose()
5789         {
5790                 return NL "Verify that DispatchCompute and DispatchComputeIndirect commands work as expected inside "
5791                                   "conditional blocks.";
5792         }
5793         virtual std::string Method()
5794         {
5795                 return NL "1. Render two quads. One will pass depth-test and the second one will not." NL
5796                                   "2. Use GL_ANY_SAMPLES_PASSED query objects to 'remember' these results." NL
5797                                   "3. Use DispatchCompute and DispatchComputeIndirect commands inside conditional blocks using both "
5798                                   "query objects." NL
5799                                   "4. Verify that DispatchCompute and DispatchComputeIndirect commands are only executed in" NL
5800                                   "    the conditional block that uses query object that has passed depth-test.";
5801         }
5802         virtual std::string PassCriteria()
5803         {
5804                 return NL "Everything works as expected.";
5805         }
5806
5807         GLuint m_program_vsfs;
5808         GLuint m_program_cs;
5809         GLuint m_vertex_array;
5810         GLuint m_query[2];
5811         GLuint m_storage_buffer;
5812         GLuint m_dispatch_buffer;
5813
5814         virtual long Setup()
5815         {
5816                 m_program_vsfs = 0;
5817                 m_program_cs   = 0;
5818                 m_vertex_array = 0;
5819                 memset(m_query, 0, sizeof(m_query));
5820                 m_storage_buffer  = 0;
5821                 m_dispatch_buffer = 0;
5822                 return NO_ERROR;
5823         }
5824         virtual long Run()
5825         {
5826                 const char* const glsl_vs = NL
5827                         "uniform float g_depth;" NL "uniform vec2[3] g_vertex = vec2[3](vec2(-1, -1), vec2(3, -1), vec2(-1, 3));" NL
5828                         "void main() {" NL "  gl_Position = vec4(g_vertex[gl_VertexID], g_depth, 1);" NL "}";
5829
5830                 const char* const glsl_fs =
5831                         NL "layout(location = 0) out vec4 g_color;" NL "void main() {" NL "  g_color = vec4(0, 1, 0, 1);" NL "}";
5832
5833                 m_program_vsfs = CreateProgram(glsl_vs, glsl_fs);
5834                 glLinkProgram(m_program_vsfs);
5835                 if (!CheckProgram(m_program_vsfs))
5836                         return ERROR;
5837
5838                 const char* const glsl_cs =
5839                         NL "layout(local_size_x = 1) in;" NL "layout(std430) buffer Output {" NL "  int g_output;" NL "};" NL
5840                            "void main() {" NL "  atomicAdd(g_output, 1);" NL "}";
5841                 m_program_cs = CreateComputeProgram(glsl_cs);
5842                 glLinkProgram(m_program_cs);
5843                 if (!CheckProgram(m_program_cs))
5844                         return ERROR;
5845
5846                 /* create storage buffer */
5847                 {
5848                         const int data = 0;
5849                         glGenBuffers(1, &m_storage_buffer);
5850                         glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_storage_buffer);
5851                         glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(data), &data, GL_DYNAMIC_COPY);
5852                 }
5853                 /* create dispatch buffer */
5854                 {
5855                         const GLuint data[3] = { 2, 2, 2 };
5856                         glGenBuffers(1, &m_dispatch_buffer);
5857                         glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, m_dispatch_buffer);
5858                         glBufferData(GL_DISPATCH_INDIRECT_BUFFER, sizeof(data), data, GL_STATIC_DRAW);
5859                 }
5860
5861                 glGenVertexArrays(1, &m_vertex_array);
5862                 glGenQueries(2, m_query);
5863
5864                 glEnable(GL_DEPTH_TEST);
5865                 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
5866
5867                 glUseProgram(m_program_vsfs);
5868                 glBindVertexArray(m_vertex_array);
5869
5870                 // this draw call will pass depth test
5871                 glBeginQuery(GL_ANY_SAMPLES_PASSED, m_query[0]);
5872                 glUniform1f(glGetUniformLocation(m_program_vsfs, "g_depth"), 0.0f);
5873                 glDrawArrays(GL_TRIANGLES, 0, 3);
5874                 glEndQuery(GL_ANY_SAMPLES_PASSED);
5875
5876                 // this draw call will NOT pass depth test
5877                 glBeginQuery(GL_ANY_SAMPLES_PASSED, m_query[1]);
5878                 glUniform1f(glGetUniformLocation(m_program_vsfs, "g_depth"), 0.5f);
5879                 glDrawArrays(GL_TRIANGLES, 0, 3);
5880                 glEndQuery(GL_ANY_SAMPLES_PASSED);
5881
5882                 glDisable(GL_DEPTH_TEST);
5883
5884                 glUseProgram(m_program_cs);
5885
5886                 // these commands should be executed normally
5887                 glBeginConditionalRender(m_query[0], GL_QUERY_WAIT);
5888                 glDispatchCompute(2, 2, 2);
5889                 glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
5890                 glDispatchComputeIndirect(0);
5891                 glEndConditionalRender();
5892
5893                 /* validate */
5894                 {
5895                         int data;
5896                         glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
5897                         glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(data), &data);
5898                         if (data != 16)
5899                         {
5900                                 m_context.getTestContext().getLog()
5901                                         << tcu::TestLog::Message << "Data is " << data << " should be 16." << tcu::TestLog::EndMessage;
5902                                 return ERROR;
5903                         }
5904                 }
5905
5906                 // these commands should be discarded
5907                 glBeginConditionalRender(m_query[1], GL_QUERY_WAIT);
5908                 glDispatchCompute(2, 2, 2);
5909                 glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
5910                 glDispatchComputeIndirect(0);
5911                 glEndConditionalRender();
5912
5913                 /* validate */
5914                 {
5915                         int data;
5916                         glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
5917                         glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(data), &data);
5918                         if (data != 16 && m_context.getRenderContext().getRenderTarget().getDepthBits() != 0)
5919                         {
5920                                 m_context.getTestContext().getLog()
5921                                         << tcu::TestLog::Message << "Data is " << data << " should be 16." << tcu::TestLog::EndMessage;
5922                                 return ERROR;
5923                         }
5924                         else if (data != 32 && m_context.getRenderContext().getRenderTarget().getDepthBits() == 0)
5925                         {
5926                                 m_context.getTestContext().getLog()
5927                                         << tcu::TestLog::Message << "Data is " << data << " should be 32." << tcu::TestLog::EndMessage;
5928                                 return ERROR;
5929                         }
5930                 }
5931
5932                 if (!ValidateReadBuffer(0, 0, getWindowWidth(), getWindowHeight(), vec4(0, 1, 0, 1)))
5933                 {
5934                         return ERROR;
5935                 }
5936
5937                 return NO_ERROR;
5938         }
5939         virtual long Cleanup()
5940         {
5941                 glUseProgram(0);
5942                 glDeleteProgram(m_program_vsfs);
5943                 glDeleteProgram(m_program_cs);
5944                 glDeleteVertexArrays(1, &m_vertex_array);
5945                 glDeleteQueries(2, m_query);
5946                 glDeleteBuffers(1, &m_storage_buffer);
5947                 glDeleteBuffers(1, &m_dispatch_buffer);
5948                 return NO_ERROR;
5949         }
5950 };
5951
5952 class NegativeAPINoActiveProgram : public ComputeShaderBase
5953 {
5954         virtual std::string Title()
5955         {
5956                 return NL "API errors - no active program";
5957         }
5958         virtual std::string Purpose()
5959         {
5960                 return NL "Verify that appropriate errors are generated by the OpenGL API.";
5961         }
5962         virtual std::string Method()
5963         {
5964                 return NL "";
5965         }
5966         virtual std::string PassCriteria()
5967         {
5968                 return NL "";
5969         }
5970
5971         GLuint m_program;
5972
5973         virtual long Setup()
5974         {
5975                 m_program = 0;
5976                 return NO_ERROR;
5977         }
5978         virtual long Run()
5979         {
5980                 glDispatchCompute(1, 2, 3);
5981                 if (glGetError() != GL_INVALID_OPERATION)
5982                 {
5983                         m_context.getTestContext().getLog()
5984                                 << tcu::TestLog::Message << "INVALID_OPERATION is generated by DispatchCompute or\n"
5985                                 << "DispatchComputeIndirect if there is no active program for the compute\n"
5986                                 << "shader stage." << tcu::TestLog::EndMessage;
5987                         return ERROR;
5988                 }
5989
5990                 /* indirect dispatch */
5991                 {
5992                         GLuint           buffer;
5993                         const GLuint num_group[3] = { 3, 2, 1 };
5994                         glGenBuffers(1, &buffer);
5995                         glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, buffer);
5996                         glBufferData(GL_DISPATCH_INDIRECT_BUFFER, sizeof(num_group), num_group, GL_STATIC_DRAW);
5997                         glDispatchComputeIndirect(0);
5998                         glDeleteBuffers(1, &buffer);
5999                         if (glGetError() != GL_INVALID_OPERATION)
6000                         {
6001                                 m_context.getTestContext().getLog()
6002                                         << tcu::TestLog::Message << "INVALID_OPERATION is generated by DispatchCompute or\n"
6003                                         << "DispatchComputeIndirect if there is no active program for the compute\n"
6004                                         << "shader stage." << tcu::TestLog::EndMessage;
6005                                 return ERROR;
6006                         }
6007                 }
6008
6009                 const char* const glsl_vs =
6010                         NL "layout(location = 0) in vec4 g_position;" NL "void main() {" NL "  gl_Position = g_position;" NL "}";
6011
6012                 const char* const glsl_fs =
6013                         NL "layout(location = 0) out vec4 g_color;" NL "void main() {" NL "  g_color = vec4(1);" NL "}";
6014
6015                 m_program = CreateProgram(glsl_vs, glsl_fs);
6016                 glLinkProgram(m_program);
6017                 if (!CheckProgram(m_program))
6018                         return ERROR;
6019
6020                 glUseProgram(m_program);
6021
6022                 glDispatchCompute(1, 2, 3);
6023                 if (glGetError() != GL_INVALID_OPERATION)
6024                 {
6025                         m_context.getTestContext().getLog()
6026                                 << tcu::TestLog::Message << "INVALID_OPERATION is generated by DispatchCompute or\n"
6027                                 << "DispatchComputeIndirect if there is no active program for the compute\n"
6028                                 << "shader stage." << tcu::TestLog::EndMessage;
6029                         return ERROR;
6030                 }
6031
6032                 /* indirect dispatch */
6033                 {
6034                         GLuint           buffer;
6035                         const GLuint num_group[3] = { 3, 2, 1 };
6036                         glGenBuffers(1, &buffer);
6037                         glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, buffer);
6038                         glBufferData(GL_DISPATCH_INDIRECT_BUFFER, sizeof(num_group), num_group, GL_STATIC_DRAW);
6039                         glDispatchComputeIndirect(0);
6040                         glDeleteBuffers(1, &buffer);
6041                         if (glGetError() != GL_INVALID_OPERATION)
6042                         {
6043                                 m_context.getTestContext().getLog()
6044                                         << tcu::TestLog::Message << "INVALID_OPERATION is generated by DispatchCompute or\n"
6045                                         << "DispatchComputeIndirect if there is no active program for the compute\n"
6046                                         << "shader stage." << tcu::TestLog::EndMessage;
6047                                 return ERROR;
6048                         }
6049                 }
6050
6051                 return NO_ERROR;
6052         }
6053         virtual long Cleanup()
6054         {
6055                 glUseProgram(0);
6056                 glDeleteProgram(m_program);
6057                 return NO_ERROR;
6058         }
6059 };
6060
6061 class NegativeAPIWorkGroupCount : public ComputeShaderBase
6062 {
6063         virtual std::string Title()
6064         {
6065                 return NL "API errors - invalid work group count";
6066         }
6067         virtual std::string Purpose()
6068         {
6069                 return NL "Verify that appropriate errors are generated by the OpenGL API.";
6070         }
6071         virtual std::string Method()
6072         {
6073                 return NL "";
6074         }
6075         virtual std::string PassCriteria()
6076         {
6077                 return NL "";
6078         }
6079
6080         GLuint m_program;
6081         GLuint m_storage_buffer;
6082
6083         virtual long Setup()
6084         {
6085                 m_program                = 0;
6086                 m_storage_buffer = 0;
6087                 return NO_ERROR;
6088         }
6089         virtual long Run()
6090         {
6091                 const char* const glsl_cs =
6092                         NL "layout(local_size_x = 1) in;" NL "layout(std430) buffer Output {" NL "  uint g_output[];" NL "};" NL
6093                            "void main() {" NL
6094                            "  g_output[gl_GlobalInvocationID.x * gl_GlobalInvocationID.y * gl_GlobalInvocationID.z] = 0;" NL "}";
6095                 m_program = CreateComputeProgram(glsl_cs);
6096                 glLinkProgram(m_program);
6097                 if (!CheckProgram(m_program))
6098                         return ERROR;
6099
6100                 glGenBuffers(1, &m_storage_buffer);
6101                 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_storage_buffer);
6102                 glBufferData(GL_SHADER_STORAGE_BUFFER, 100000, NULL, GL_DYNAMIC_DRAW);
6103
6104                 GLint x, y, z;
6105                 glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_COUNT, 0, &x);
6106                 glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_COUNT, 1, &y);
6107                 glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_COUNT, 2, &z);
6108
6109                 glUseProgram(m_program);
6110
6111                 glDispatchCompute(x + 1, 1, 1);
6112                 if (glGetError() != GL_INVALID_VALUE)
6113                 {
6114                         m_context.getTestContext().getLog()
6115                                 << tcu::TestLog::Message << "INVALID_VALUE is generated by DispatchCompute if any of <num_groups_x>,\n"
6116                                 << "<num_groups_y> or <num_groups_z> is greater than the value of\n"
6117                                 << "MAX_COMPUTE_WORK_GROUP_COUNT for the corresponding dimension." << tcu::TestLog::EndMessage;
6118                         return ERROR;
6119                 }
6120
6121                 glDispatchCompute(1, y + 1, 1);
6122                 if (glGetError() != GL_INVALID_VALUE)
6123                 {
6124                         m_context.getTestContext().getLog()
6125                                 << tcu::TestLog::Message << "INVALID_VALUE is generated by DispatchCompute if any of <num_groups_x>,\n"
6126                                 << "<num_groups_y> or <num_groups_z> is greater than the value of\n"
6127                                 << "MAX_COMPUTE_WORK_GROUP_COUNT for the corresponding dimension." << tcu::TestLog::EndMessage;
6128                         return ERROR;
6129                 }
6130
6131                 glDispatchCompute(1, 1, z + 1);
6132                 if (glGetError() != GL_INVALID_VALUE)
6133                 {
6134                         m_context.getTestContext().getLog()
6135                                 << tcu::TestLog::Message << "INVALID_VALUE is generated by DispatchCompute if any of <num_groups_x>,\n"
6136                                 << "<num_groups_y> or <num_groups_z> is greater than the value of\n"
6137                                 << "MAX_COMPUTE_WORK_GROUP_COUNT for the corresponding dimension." << tcu::TestLog::EndMessage;
6138                         return ERROR;
6139                 }
6140
6141                 return NO_ERROR;
6142         }
6143         virtual long Cleanup()
6144         {
6145                 glUseProgram(0);
6146                 glDeleteProgram(m_program);
6147                 glDeleteBuffers(1, &m_storage_buffer);
6148                 return NO_ERROR;
6149         }
6150 };
6151
6152 class NegativeAPIIndirect : public ComputeShaderBase
6153 {
6154         virtual std::string Title()
6155         {
6156                 return NL "API errors - incorrect DispatchComputeIndirect usage";
6157         }
6158         virtual std::string Purpose()
6159         {
6160                 return NL "Verify that appropriate errors are generated by the OpenGL API.";
6161         }
6162         virtual std::string Method()
6163         {
6164                 return NL "";
6165         }
6166         virtual std::string PassCriteria()
6167         {
6168                 return NL "";
6169         }
6170
6171         GLuint m_program;
6172         GLuint m_storage_buffer;
6173         GLuint m_dispatch_buffer;
6174
6175         virtual long Setup()
6176         {
6177                 m_program                 = 0;
6178                 m_storage_buffer  = 0;
6179                 m_dispatch_buffer = 0;
6180                 return NO_ERROR;
6181         }
6182
6183         virtual long Run()
6184         {
6185                 const char* const glsl_cs =
6186                         NL "layout(local_size_x = 1) in;" NL "layout(std430) buffer Output {" NL "  uint g_output[];" NL "};" NL
6187                            "void main() {" NL "  g_output[gl_GlobalInvocationID.x] = 0;" NL "}";
6188                 m_program = CreateComputeProgram(glsl_cs);
6189                 glLinkProgram(m_program);
6190                 if (!CheckProgram(m_program))
6191                         return ERROR;
6192
6193                 glGenBuffers(1, &m_storage_buffer);
6194                 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_storage_buffer);
6195                 glBufferData(GL_SHADER_STORAGE_BUFFER, 100000, NULL, GL_DYNAMIC_DRAW);
6196
6197                 const GLuint num_groups[6] = { 1, 1, 1, 1, 1, 1 };
6198                 glGenBuffers(1, &m_dispatch_buffer);
6199                 glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, m_dispatch_buffer);
6200                 glBufferData(GL_DISPATCH_INDIRECT_BUFFER, sizeof(num_groups), num_groups, GL_STATIC_COPY);
6201
6202                 glUseProgram(m_program);
6203
6204                 glDispatchComputeIndirect(-2);
6205                 if (glGetError() != GL_INVALID_VALUE)
6206                 {
6207                         m_context.getTestContext().getLog()
6208                                 << tcu::TestLog::Message << "INVALID_VALUE is generated by DispatchComputeIndirect if <indirect> is\n"
6209                                 << "less than zero or not a multiple of four." << tcu::TestLog::EndMessage;
6210                         return ERROR;
6211                 }
6212
6213                 glDispatchComputeIndirect(3);
6214                 if (glGetError() != GL_INVALID_VALUE)
6215                 {
6216                         m_context.getTestContext().getLog()
6217                                 << tcu::TestLog::Message << "INVALID_VALUE is generated by DispatchComputeIndirect if <indirect> is\n"
6218                                 << "less than zero or not a multiple of four." << tcu::TestLog::EndMessage;
6219                         return ERROR;
6220                 }
6221
6222                 glDispatchComputeIndirect(16);
6223                 if (glGetError() != GL_INVALID_OPERATION)
6224                 {
6225                         m_context.getTestContext().getLog()
6226                                 << tcu::TestLog::Message
6227                                 << "INVALID_OPERATION is generated by DispatchComputeIndirect if no buffer is\n"
6228                                 << "bound to DISPATCH_INDIRECT_BUFFER or if the command would source data\n"
6229                                 << "beyond the end of the bound buffer object." << tcu::TestLog::EndMessage;
6230                         return ERROR;
6231                 }
6232
6233                 glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, 0);
6234                 glDispatchComputeIndirect(0);
6235                 if (glGetError() != GL_INVALID_OPERATION)
6236                 {
6237                         m_context.getTestContext().getLog()
6238                                 << tcu::TestLog::Message
6239                                 << "INVALID_OPERATION is generated by DispatchComputeIndirect if no buffer is\n"
6240                                 << "bound to DISPATCH_INDIRECT_BUFFER or if the command would source data\n"
6241                                 << "beyond the end of the bound buffer object." << tcu::TestLog::EndMessage;
6242                         return ERROR;
6243                 }
6244
6245                 return NO_ERROR;
6246         }
6247         virtual long Cleanup()
6248         {
6249                 glUseProgram(0);
6250                 glDeleteProgram(m_program);
6251                 glDeleteBuffers(1, &m_storage_buffer);
6252                 glDeleteBuffers(1, &m_dispatch_buffer);
6253                 return NO_ERROR;
6254         }
6255 };
6256
6257 class NegativeAPIProgram : public ComputeShaderBase
6258 {
6259         virtual std::string Title()
6260         {
6261                 return NL "API errors - program state";
6262         }
6263         virtual std::string Purpose()
6264         {
6265                 return NL "Verify that appropriate errors are generated by the OpenGL API.";
6266         }
6267         virtual std::string Method()
6268         {
6269                 return NL "";
6270         }
6271         virtual std::string PassCriteria()
6272         {
6273                 return NL "";
6274         }
6275
6276         GLuint m_program;
6277         GLuint m_storage_buffer;
6278
6279         virtual long Setup()
6280         {
6281                 m_program                = 0;
6282                 m_storage_buffer = 0;
6283                 return NO_ERROR;
6284         }
6285         virtual long Run()
6286         {
6287                 const char* const glsl_vs =
6288                         NL "layout(location = 0) in vec4 g_position;" NL "void main() {" NL "  gl_Position = g_position;" NL "}";
6289
6290                 const char* const glsl_fs =
6291                         NL "layout(location = 0) out vec4 g_color;" NL "void main() {" NL "  g_color = vec4(1);" NL "}";
6292                 m_program = CreateProgram(glsl_vs, glsl_fs);
6293
6294                 GLint v[3];
6295                 glGetProgramiv(m_program, GL_COMPUTE_WORK_GROUP_SIZE, v);
6296                 if (glGetError() != GL_INVALID_OPERATION)
6297                 {
6298                         m_context.getTestContext().getLog()
6299                                 << tcu::TestLog::Message << "INVALID_OPERATION is generated by GetProgramiv if <pname> is\n"
6300                                 << "COMPUTE_LOCAL_WORK_SIZE and either the program has not been linked\n"
6301                                 << "successfully, or has been linked but contains no compute shaders." << tcu::TestLog::EndMessage;
6302                         return ERROR;
6303                 }
6304
6305                 glLinkProgram(m_program);
6306                 if (!CheckProgram(m_program))
6307                         return ERROR;
6308
6309                 glGetProgramiv(m_program, GL_COMPUTE_WORK_GROUP_SIZE, v);
6310                 if (glGetError() != GL_INVALID_OPERATION)
6311                 {
6312                         m_context.getTestContext().getLog()
6313                                 << tcu::TestLog::Message << "INVALID_OPERATION is generated by GetProgramiv if <pname> is\n"
6314                                 << "COMPUTE_LOCAL_WORK_SIZE and either the program has not been linked\n"
6315                                 << "successfully, or has been linked but contains no compute shaders." << tcu::TestLog::EndMessage;
6316                         return ERROR;
6317                 }
6318                 glDeleteProgram(m_program);
6319
6320                 const char* const glsl_cs =
6321                         "#version 430 core" NL "layout(local_size_x = 1) in;" NL "layout(std430) buffer Output {" NL
6322                         "  uint g_output[];" NL "};" NL "void main() {" NL "  g_output[gl_GlobalInvocationID.x] = 0;" NL "}";
6323                 m_program = glCreateProgram();
6324
6325                 GLuint sh = glCreateShader(GL_COMPUTE_SHADER);
6326                 glAttachShader(m_program, sh);
6327                 glDeleteShader(sh);
6328                 glShaderSource(sh, 1, &glsl_cs, NULL);
6329                 glCompileShader(sh);
6330
6331                 sh = glCreateShader(GL_VERTEX_SHADER);
6332                 glAttachShader(m_program, sh);
6333                 glDeleteShader(sh);
6334                 glShaderSource(sh, 1, &glsl_vs, NULL);
6335                 glCompileShader(sh);
6336
6337                 sh = glCreateShader(GL_FRAGMENT_SHADER);
6338                 glAttachShader(m_program, sh);
6339                 glDeleteShader(sh);
6340                 glShaderSource(sh, 1, &glsl_fs, NULL);
6341                 glCompileShader(sh);
6342
6343                 glLinkProgram(m_program);
6344                 GLint status;
6345                 glGetProgramiv(m_program, GL_LINK_STATUS, &status);
6346                 if (status == GL_TRUE)
6347                 {
6348                         m_context.getTestContext().getLog()
6349                                 << tcu::TestLog::Message << "LinkProgram will fail if <program> contains a combination"
6350                                 << " of compute and\n non-compute shaders.\n"
6351                                 << tcu::TestLog::EndMessage;
6352                         return ERROR;
6353                 }
6354
6355                 return NO_ERROR;
6356         }
6357         virtual long Cleanup()
6358         {
6359                 glUseProgram(0);
6360                 glDeleteProgram(m_program);
6361                 glDeleteBuffers(1, &m_storage_buffer);
6362                 return NO_ERROR;
6363         }
6364 };
6365
6366 class NegativeGLSLCompileTimeErrors : public ComputeShaderBase
6367 {
6368         virtual std::string Title()
6369         {
6370                 return NL "Compile-time errors";
6371         }
6372         virtual std::string Purpose()
6373         {
6374                 return NL "Verify that appropriate errors are generated by the GLSL compiler.";
6375         }
6376         virtual std::string Method()
6377         {
6378                 return NL "";
6379         }
6380         virtual std::string PassCriteria()
6381         {
6382                 return NL "";
6383         }
6384
6385         static std::string Shader1(int x, int y, int z)
6386         {
6387                 std::stringstream ss;
6388                 ss << "#version 430 core" NL "layout(local_size_x = " << x << ", local_size_y = " << y
6389                    << ", local_size_z = " << z << ") in;" NL "layout(std430) buffer Output {" NL "  uint g_output[];" NL "};" NL
6390                                                                                   "void main() {" NL "  g_output[gl_GlobalInvocationID.x] = 0;" NL "}";
6391                 return ss.str();
6392         }
6393         virtual long Run()
6394         {
6395                 // gl_GlobalInvocationID requires "#version 430" or later or GL_ARB_compute_shader
6396                 // extension enabled
6397                 if (!Compile("#version 420 core" NL "layout(local_size_x = 1) in;" NL "layout(std430) buffer Output {" NL
6398                                          "  uint g_output[];" NL "};" NL "void main() {" NL "  g_output[gl_GlobalInvocationID.x] = 0;" NL
6399                                          "}"))
6400                         return ERROR;
6401
6402                 if (!Compile("#version 430 core" NL "layout(local_size_x = 1) in;" NL "layout(local_size_x = 2) in;" NL
6403                                          "layout(std430) buffer Output {" NL "  uint g_output[];" NL "};" NL "void main() {" NL
6404                                          "  g_output[gl_GlobalInvocationID.x] = 0;" NL "}"))
6405                         return ERROR;
6406
6407                 if (!Compile("#version 430 core" NL "layout(local_size_x = 1) in;" NL "in uint x;" NL
6408                                          "layout(std430) buffer Output {" NL "  uint g_output[];" NL "};" NL "void main() {" NL
6409                                          "  g_output[gl_GlobalInvocationID.x] = x;" NL "}"))
6410                         return ERROR;
6411
6412                 if (!Compile("#version 430 core" NL "layout(local_size_x = 1) in;" NL "out uint x;" NL
6413                                          "layout(std430) buffer Output {" NL "  uint g_output[];" NL "};" NL "void main() {" NL
6414                                          "  g_output[gl_GlobalInvocationID.x] = 0;" NL "  x = 0;" NL "}"))
6415                         return ERROR;
6416
6417                 {
6418                         GLint x, y, z;
6419                         glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_SIZE, 0, &x);
6420                         glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_SIZE, 0, &y);
6421                         glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_SIZE, 0, &z);
6422
6423                         if (!Compile(Shader1(x + 1, 1, 1)))
6424                                 return ERROR;
6425                         if (!Compile(Shader1(1, y + 1, 1)))
6426                                 return ERROR;
6427                         if (!Compile(Shader1(1, 1, z + 1)))
6428                                 return ERROR;
6429                 }
6430
6431                 return NO_ERROR;
6432         }
6433
6434         bool Compile(const std::string& source)
6435         {
6436                 const GLuint sh = glCreateShader(GL_COMPUTE_SHADER);
6437
6438                 const char* const src = source.c_str();
6439                 glShaderSource(sh, 1, &src, NULL);
6440                 glCompileShader(sh);
6441
6442                 GLchar log[1024];
6443                 glGetShaderInfoLog(sh, sizeof(log), NULL, log);
6444                 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Shader Info Log:\n"
6445                                                                                         << log << tcu::TestLog::EndMessage;
6446
6447                 GLint status;
6448                 glGetShaderiv(sh, GL_COMPILE_STATUS, &status);
6449                 glDeleteShader(sh);
6450
6451                 if (status == GL_TRUE)
6452                 {
6453                         m_context.getTestContext().getLog()
6454                                 << tcu::TestLog::Message << "Compilation should fail." << tcu::TestLog::EndMessage;
6455                         return false;
6456                 }
6457
6458                 return true;
6459         }
6460 };
6461
6462 class NegativeGLSLLinkTimeErrors : public ComputeShaderBase
6463 {
6464         virtual std::string Title()
6465         {
6466                 return NL "Link-time errors";
6467         }
6468         virtual std::string Purpose()
6469         {
6470                 return NL "Verify that appropriate errors are generated by the GLSL linker.";
6471         }
6472         virtual std::string Method()
6473         {
6474                 return NL "";
6475         }
6476         virtual std::string PassCriteria()
6477         {
6478                 return NL "";
6479         }
6480
6481         virtual long Run()
6482         {
6483                 // no layout
6484                 if (!Link("#version 430 core" NL "void Run();" NL "void main() {" NL "  Run();" NL "}",
6485                                   "#version 430 core" NL "layout(std430) buffer Output {" NL "  uint g_output[];" NL "};" NL
6486                                   "void Run() {" NL "  g_output[gl_GlobalInvocationID.x] = 0;" NL "}"))
6487                         return ERROR;
6488
6489                 if (!Link("#version 430 core" NL "layout(local_size_x = 2) in;" NL "void Run();" NL "void main() {" NL
6490                                   "  Run();" NL "}",
6491                                   "#version 430 core" NL "layout(local_size_x = 1) in;" NL "layout(std430) buffer Output {" NL
6492                                   "  uint g_output[];" NL "};" NL "void Run() {" NL "  g_output[gl_GlobalInvocationID.x] = 0;" NL "}"))
6493                         return ERROR;
6494
6495                 return NO_ERROR;
6496         }
6497
6498         bool Link(const std::string& cs0, const std::string& cs1)
6499         {
6500                 const GLuint p = glCreateProgram();
6501
6502                 /* shader 0 */
6503                 {
6504                         GLuint sh = glCreateShader(GL_COMPUTE_SHADER);
6505                         glAttachShader(p, sh);
6506                         glDeleteShader(sh);
6507                         const char* const src = cs0.c_str();
6508                         glShaderSource(sh, 1, &src, NULL);
6509                         glCompileShader(sh);
6510
6511                         GLint status;
6512                         glGetShaderiv(sh, GL_COMPILE_STATUS, &status);
6513                         if (status == GL_FALSE)
6514                         {
6515                                 glDeleteProgram(p);
6516                                 m_context.getTestContext().getLog()
6517                                         << tcu::TestLog::Message << "CS0 compilation should be ok." << tcu::TestLog::EndMessage;
6518                                 return false;
6519                         }
6520                 }
6521                 /* shader 1 */
6522                 {
6523                         GLuint sh = glCreateShader(GL_COMPUTE_SHADER);
6524                         glAttachShader(p, sh);
6525                         glDeleteShader(sh);
6526                         const char* const src = cs1.c_str();
6527                         glShaderSource(sh, 1, &src, NULL);
6528                         glCompileShader(sh);
6529
6530                         GLint status;
6531                         glGetShaderiv(sh, GL_COMPILE_STATUS, &status);
6532                         if (status == GL_FALSE)
6533                         {
6534                                 glDeleteProgram(p);
6535                                 m_context.getTestContext().getLog()
6536                                         << tcu::TestLog::Message << "CS1 compilation should be ok." << tcu::TestLog::EndMessage;
6537                                 return false;
6538                         }
6539                 }
6540
6541                 glLinkProgram(p);
6542
6543                 GLchar log[1024];
6544                 glGetProgramInfoLog(p, sizeof(log), NULL, log);
6545                 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Program Info Log:\n"
6546                                                                                         << log << tcu::TestLog::EndMessage;
6547
6548                 GLint status;
6549                 glGetProgramiv(p, GL_LINK_STATUS, &status);
6550                 glDeleteProgram(p);
6551
6552                 if (status == GL_TRUE)
6553                 {
6554                         m_context.getTestContext().getLog()
6555                                 << tcu::TestLog::Message << "Link operation should fail." << tcu::TestLog::EndMessage;
6556                         return false;
6557                 }
6558
6559                 return true;
6560         }
6561 };
6562
6563 class BasicWorkGroupSizeIsConst : public ComputeShaderBase
6564 {
6565         virtual std::string Title()
6566         {
6567                 return NL "gl_WorkGroupSize is an constant";
6568         }
6569         virtual std::string Purpose()
6570         {
6571                 return NL "Verify that gl_WorkGroupSize can be used as an constant expression.";
6572         }
6573         virtual std::string Method()
6574         {
6575                 return NL "";
6576         }
6577         virtual std::string PassCriteria()
6578         {
6579                 return NL "";
6580         }
6581
6582         GLuint m_program;
6583         GLuint m_storage_buffer;
6584
6585         virtual long Setup()
6586         {
6587                 m_program                = 0;
6588                 m_storage_buffer = 0;
6589                 return NO_ERROR;
6590         }
6591
6592         virtual long Run()
6593         {
6594                 const char* const glsl_cs =
6595                         NL "layout(local_size_x = 2, local_size_y = 3, local_size_z = 4) in;" NL
6596                            "layout(std430, binding = 0) buffer Output {" NL "  uint g_buffer[22 + gl_WorkGroupSize.x];" NL "};" NL
6597                            "shared uint g_shared[gl_WorkGroupSize.x * gl_WorkGroupSize.y * gl_WorkGroupSize.z];" NL
6598                            "uniform uint g_uniform[gl_WorkGroupSize.z + 20] = { "
6599                            "1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24 };" NL "void main() {" NL
6600                            "  g_shared[gl_LocalInvocationIndex] = 1U;" NL "  groupMemoryBarrier();" NL "  barrier();" NL
6601                            "  uint sum = 0;" NL
6602                            "  for (uint i = 0; i < gl_WorkGroupSize.x * gl_WorkGroupSize.y * gl_WorkGroupSize.z; ++i) {" NL
6603                            "    sum += g_shared[i];" NL "  }" NL "  sum += g_uniform[gl_LocalInvocationIndex];" NL
6604                            "  g_buffer[gl_LocalInvocationIndex] = sum;" NL "}";
6605                 m_program = CreateComputeProgram(glsl_cs);
6606                 glLinkProgram(m_program);
6607                 if (!CheckProgram(m_program))
6608                         return ERROR;
6609
6610                 glGenBuffers(1, &m_storage_buffer);
6611                 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_storage_buffer);
6612                 glBufferData(GL_SHADER_STORAGE_BUFFER, 24 * sizeof(GLuint), NULL, GL_STATIC_DRAW);
6613
6614                 glUseProgram(m_program);
6615                 glDispatchCompute(1, 1, 1);
6616                 glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
6617
6618                 long    error = NO_ERROR;
6619                 GLuint* data;
6620                 glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_storage_buffer);
6621                 data =
6622                         static_cast<GLuint*>(glMapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, sizeof(GLuint) * 24, GL_MAP_READ_BIT));
6623                 for (GLuint i = 0; i < 24; ++i)
6624                 {
6625                         if (data[i] != (i + 25))
6626                         {
6627                                 m_context.getTestContext().getLog()
6628                                         << tcu::TestLog::Message << "Data at index " << i << " is " << data[i] << " should be " << i + 25
6629                                         << "." << tcu::TestLog::EndMessage;
6630                                 error = ERROR;
6631                         }
6632                 }
6633                 glUnmapBuffer(GL_SHADER_STORAGE_BUFFER);
6634                 glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
6635                 return error;
6636         }
6637
6638         virtual long Cleanup()
6639         {
6640                 glUseProgram(0);
6641                 glDeleteProgram(m_program);
6642                 glDeleteBuffers(1, &m_storage_buffer);
6643                 return NO_ERROR;
6644         }
6645 };
6646
6647 } // anonymous namespace
6648
6649 ComputeShaderTests::ComputeShaderTests(deqp::Context& context) : TestCaseGroup(context, "compute_shader", "")
6650 {
6651 }
6652
6653 ComputeShaderTests::~ComputeShaderTests(void)
6654 {
6655 }
6656
6657 void ComputeShaderTests::init()
6658 {
6659         using namespace deqp;
6660         addChild(new TestSubcase(m_context, "simple-compute", TestSubcase::Create<SimpleCompute>));
6661         addChild(new TestSubcase(m_context, "one-work-group", TestSubcase::Create<BasicOneWorkGroup>));
6662         addChild(new TestSubcase(m_context, "resource-ubo", TestSubcase::Create<BasicResourceUBO>));
6663         addChild(new TestSubcase(m_context, "resource-texture", TestSubcase::Create<BasicResourceTexture>));
6664         addChild(new TestSubcase(m_context, "resource-image", TestSubcase::Create<BasicResourceImage>));
6665         addChild(new TestSubcase(m_context, "resource-atomic-counter", TestSubcase::Create<BasicResourceAtomicCounter>));
6666         addChild(new TestSubcase(m_context, "resource-subroutine", TestSubcase::Create<BasicResourceSubroutine>));
6667         addChild(new TestSubcase(m_context, "resource-uniform", TestSubcase::Create<BasicResourceUniform>));
6668         addChild(new TestSubcase(m_context, "built-in-variables", TestSubcase::Create<BasicBuiltinVariables>));
6669         addChild(new TestSubcase(m_context, "max", TestSubcase::Create<BasicMax>));
6670         addChild(new TestSubcase(m_context, "work-group-size", TestSubcase::Create<BasicWorkGroupSizeIsConst>));
6671         addChild(new TestSubcase(m_context, "build-monolithic", TestSubcase::Create<BasicBuildMonolithic>));
6672         addChild(new TestSubcase(m_context, "build-separable", TestSubcase::Create<BasicBuildSeparable>));
6673         addChild(new TestSubcase(m_context, "shared-simple", TestSubcase::Create<BasicSharedSimple>));
6674         addChild(new TestSubcase(m_context, "shared-struct", TestSubcase::Create<BasicSharedStruct>));
6675         addChild(new TestSubcase(m_context, "dispatch-indirect", TestSubcase::Create<BasicDispatchIndirect>));
6676         addChild(new TestSubcase(m_context, "sso-compute-pipeline", TestSubcase::Create<BasicSSOComputePipeline>));
6677         addChild(new TestSubcase(m_context, "sso-case2", TestSubcase::Create<BasicSSOCase2>));
6678         addChild(new TestSubcase(m_context, "sso-case3", TestSubcase::Create<BasicSSOCase3>));
6679         addChild(new TestSubcase(m_context, "atomic-case1", TestSubcase::Create<BasicAtomicCase1>));
6680         addChild(new TestSubcase(m_context, "atomic-case2", TestSubcase::Create<BasicAtomicCase2>));
6681         addChild(new TestSubcase(m_context, "atomic-case3", TestSubcase::Create<BasicAtomicCase3>));
6682         addChild(new TestSubcase(m_context, "copy-image", TestSubcase::Create<AdvancedCopyImage>));
6683         addChild(new TestSubcase(m_context, "pipeline-pre-vs", TestSubcase::Create<AdvancedPipelinePreVS>));
6684         addChild(
6685                 new TestSubcase(m_context, "pipeline-gen-draw-commands", TestSubcase::Create<AdvancedPipelineGenDrawCommands>));
6686         addChild(new TestSubcase(m_context, "pipeline-compute-chain", TestSubcase::Create<AdvancedPipelineComputeChain>));
6687         addChild(new TestSubcase(m_context, "pipeline-post-fs", TestSubcase::Create<AdvancedPipelinePostFS>));
6688         addChild(new TestSubcase(m_context, "pipeline-post-xfb", TestSubcase::Create<AdvancedPipelinePostXFB>));
6689         addChild(new TestSubcase(m_context, "shared-indexing", TestSubcase::Create<AdvancedSharedIndexing>));
6690         addChild(new TestSubcase(m_context, "shared-max", TestSubcase::Create<AdvancedSharedMax>));
6691         addChild(new TestSubcase(m_context, "dynamic-paths", TestSubcase::Create<AdvancedDynamicPaths>));
6692         addChild(new TestSubcase(m_context, "resources-max", TestSubcase::Create<AdvancedResourcesMax>));
6693         addChild(new TestSubcase(m_context, "fp64-case1", TestSubcase::Create<AdvancedFP64Case1>));
6694         addChild(new TestSubcase(m_context, "fp64-case2", TestSubcase::Create<AdvancedFP64Case2>));
6695         addChild(new TestSubcase(m_context, "fp64-case3", TestSubcase::Create<AdvancedFP64Case3>));
6696         addChild(
6697                 new TestSubcase(m_context, "conditional-dispatching", TestSubcase::Create<AdvancedConditionalDispatching>));
6698         addChild(new TestSubcase(m_context, "api-no-active-program", TestSubcase::Create<NegativeAPINoActiveProgram>));
6699         addChild(new TestSubcase(m_context, "api-work-group-count", TestSubcase::Create<NegativeAPIWorkGroupCount>));
6700         addChild(new TestSubcase(m_context, "api-indirect", TestSubcase::Create<NegativeAPIIndirect>));
6701         addChild(new TestSubcase(m_context, "api-program", TestSubcase::Create<NegativeAPIProgram>));
6702         addChild(
6703                 new TestSubcase(m_context, "glsl-compile-time-errors", TestSubcase::Create<NegativeGLSLCompileTimeErrors>));
6704         addChild(new TestSubcase(m_context, "glsl-link-time-errors", TestSubcase::Create<NegativeGLSLLinkTimeErrors>));
6705 }
6706 } // gl4cts namespace