Attachment 138687 Details for Bug 105934 – Small program with two compute dispatches and draw

Small program with two compute dispatches and draw

intelbug.c (text/x-csrc), 9.53 KB, created by mankeli on 2018-04-08 20:46:16 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: mankeli

Created: 2018-04-08 20:46:16 UTC

Size: 9.53 KB

patch

obsolete

>/*
>	Somewhat minimal program to cause GPU hang on Intel GPU.
>	Uses SDL2 and GLEW.
>
>	$ gcc -g intelbug.c -o intelbug $(sdl2-config --libs --cflags) -lGL -lGLEW
>
>	Bug happens when timestamp queries are issued between two compute dispatches.
>	Comment any of the following defines to prevent the hang.
>*/
>
>#define DO_TIMESTAMPS
>#define DO_SECOND_COMPUTE
>
>
>
>#include <stdio.h>
>#include <stdbool.h>
>#include <SDL2/SDL.h>
>#include <GL/glew.h>
>#include <SDL2/SDL_opengl.h>
>
>GLuint drawprogram;
>GLuint computeprogram;
>GLuint computeprogram2;
>GLuint ssbo_test;
>GLuint emptyvao;
>SDL_Window *w;
>
>void error(const char *spot)
>{
>	GLenum errorcode = glGetError();
>	if (errorcode != GL_NO_ERROR)
>	{
>		printf("error %s: 0x%X\n", spot, errorcode);
>	}
>}
>
>#define QUERYCOUNT 256
>GLuint qobjs[QUERYCOUNT];
>
>void putcounter()
>{
>	static int qidx = 0;
>	#ifdef DO_TIMESTAMPS	
>	glQueryCounter(qobjs[qidx], GL_TIMESTAMP);
>	#endif
>	qidx++;
>	qidx %= QUERYCOUNT;
>}
>
>void initgl()
>{
>	SDL_Init(SDL_INIT_VIDEO);
>
>	SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
>	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
>	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 5);
>	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
>
>	w = SDL_CreateWindow("intelbug", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
>		900, 900, SDL_WINDOW_OPENGL);
>
>	SDL_GL_CreateContext(w);
>
>	SDL_GL_SetSwapInterval(1);
>	error("swap interval");
>
>	glewExperimental = GL_TRUE;
>	glewInit();
>
>
>	error("glew init");
>}
>
>void createshaders()
>{
>	{
>		const char* vpsrc[] = {
>			R"(
>#version 450
>			out vec2 v_uv2;
>
>			void main() {
>				vec2 posi1;
>
>				switch(gl_VertexID)
>				{
>					case 0: posi1 = vec2(0.0, 0.0); break;
>					case 1: posi1 = vec2(1.0, 0.0); break;
>					case 2: posi1 = vec2(0.0, 1.0); break;
>					case 3: posi1 = vec2(1.0, 1.0); break;
>				}
>
>				vec2 posi = posi1 * 2.0 - vec2(1.0);
>				v_uv2 = posi;
>				gl_Position = vec4(posi, 0.0, 1.0);
>			}
>			)"
>		};
>
>		const char* fpsrc[] = {
>			R"(
>#version 450
>			out vec4 fragColor;
>			in vec2 v_uv2;
>			uniform float u_time;
>
>			layout(std430, binding = 1) buffer testssbo_buf
>			{
>				float testssbo[];
>			};
>
>			const vec3 worldsize = vec3(2048.0);
>			const vec3 worldcenter = worldsize*0.5;
>
>			float getsdf_int(in ivec3 coord)
>			{
>				coord = clamp(coord, ivec3(0), ivec3(255));
>
>				return testssbo[((coord.z * 256) + coord.y) * 256 + coord.x];
>			}
>
>			mat3 rotateX(float rad) {
>				float c = cos(rad);
>				float s = sin(rad);
>				return mat3(
>				1.0, 0.0, 0.0,
>				0.0, c, s,
>				0.0, -s, c
>				);
>			}
>
>			mat3 rotateY(float rad) {
>				float c = cos(rad);
>				float s = sin(rad);
>				return mat3(
>				c, 0.0, -s,
>				0.0, 1.0, 0.0,
>				s, 0.0, c
>				);
>			}
>
>			mat3 rotateZ(float rad) {
>				float c = cos(rad);
>				float s = sin(rad);
>				return mat3(
>				c, s, 0.0,
>				-s, c, 0.0,
>				0.0, 0.0, 1.0
>				);
>			}
>
>
>			void main() {
>
>				float zz = sin(u_time)*70.0;
>				vec3 c = vec3(0.0);
>
>				mat3 rot = rotateX(u_time*0.12313) * rotateY(u_time*0.52112);
>
>				vec3 ro = vec3(0.0, 0.0, 100.0);
>				vec3 rd = normalize(vec3(v_uv2.x, v_uv2.y, -1.0));
>
>				ro = rot * ro;
>				rd = rot * rd;
>
>				vec3 rov = ro;
>				rov += worldcenter;
>				rov /= worldsize;
>				rov *= 256.0;
>
>				vec3 pos = floor(rov);
>				vec3 delta = vec3(1.0) / abs(rd);
>				vec3 maxx = pos - rov;
>				vec3 stepx = sign(rd);
>				maxx += max(stepx, vec3(0.0));
>				maxx /= rd;
>
>				for (int i = 0; i < 256; i++)
>				{
>					vec3 megatrick = vec3(0.0);
>					megatrick = step(maxx.xyz, maxx.yxy) * step(maxx.xyz, maxx.zzx);
>
>					maxx += delta * megatrick;
>					pos += stepx * megatrick;
>
>					if (getsdf_int(ivec3(pos)) < 0.0)
>					{
>						c = vec3(float(i)/64.0);
>						break;
>					}
>
>				}
>				fragColor = vec4(c, 1.0);
>
>			}
>			)"
>		};
>
>
>		drawprogram = glCreateProgram();
>
>		{
>			GLuint shader1 = glCreateShader(GL_VERTEX_SHADER);
>			glShaderSource(shader1, 1, vpsrc, NULL);
>			glCompileShader(shader1);
>
>			GLint compiled;
>			char infolog[1024];
>			glGetShaderiv(shader1, GL_COMPILE_STATUS, &compiled);
>			glGetShaderInfoLog(shader1, 1024, NULL, infolog);
>			printf("vp compile (comp'd %i): %s\n", compiled, infolog);
>
>			glAttachShader(drawprogram, shader1);
>		}
>		{
>			GLuint shader1 = glCreateShader(GL_FRAGMENT_SHADER);
>			glShaderSource(shader1, 1, fpsrc, NULL);
>			glCompileShader(shader1);
>
>			GLint compiled;
>			char infolog[1024];
>			glGetShaderiv(shader1, GL_COMPILE_STATUS, &compiled);
>			glGetShaderInfoLog(shader1, 1024, NULL, infolog);
>			printf("fp compile (comp'd %i): %s\n", compiled, infolog);
>
>			glAttachShader(drawprogram, shader1);
>		}
>
>
>
>		{
>			glLinkProgram(drawprogram);
>
>			GLint compiled;
>			char infolog[1024];
>			glGetProgramInfoLog(drawprogram, 1024, NULL, infolog);
>			glGetProgramiv(drawprogram, GL_LINK_STATUS, &compiled);
>			printf("draw linking (%i): %s\n", compiled, infolog);
>		}
>
>	}
>
>	error("draw create");
>
>
>
>
>	{
>		const char* src[] = {
>			R"(
> 		#version 450
>
>			uniform float u_time;
>
>			float sphere(vec3 pos)
>			{
>				float d1 = (length(pos) - 64.0)+sin(pos.y*0.1 + u_time*5.23)*4.0+sin(pos.x*0.1 + u_time*4.983)*4.0;
>				float d2 = (length(pos) - 50.0)+sin(pos.y*0.1 + u_time*5.23)*4.0+sin(pos.x*0.1 + u_time*4.983)*4.0;
>				float d3 = length(pos.xy) - 30.0;
>				float d4 = length(pos.yz) - 30.0;
>				float d5 = length(pos.xz) - 30.0;
>
>				return max(max(max(max(d1, -d2), -d3), -d4), -d5);
>			}
>
> 		//layout(binding = 0)
>
>			layout(std430, binding = 1) buffer testssbo_buf
>			{
>				float testssbo[];
>			};
>
>			layout(local_size_x = 8, local_size_y = 8, local_size_z = 8) in;
>
>			void main()
>			{
>				ivec3 coord = ivec3(gl_GlobalInvocationID.xyz);
>			//testssbo[coord.y * 256 + coord.x] = (gl_WorkGroupID.xy + uvec2(u_time*3.0)) & uvec2(15);
>
>				vec3 worldsize = vec3(2048.0);
>				vec3 worldcenter = worldsize*0.5;
>			//worldcenter += vec3(0.0, 0.0, -500.0);
>				vec3 pos = (vec3(gl_GlobalInvocationID) / 256.0) * worldsize - worldcenter;
>
>				testssbo[((coord.z * 256) + coord.y) * 256 + coord.x] = sphere(pos) -5.0;
>			}
>			)"
>		};
>
>		computeprogram = glCreateProgram();
>
>		GLuint shader = glCreateShader(GL_COMPUTE_SHADER);
>		glShaderSource(shader, 1, src, NULL);
>		glCompileShader(shader);
>
>		GLint compiled;
>		char infolog[1024];
>		glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
>		glGetShaderInfoLog(shader, 1024, NULL, infolog);
>		printf("compute compile (comp'd %i): %s\n", compiled, infolog);
>
>		glAttachShader(computeprogram, shader);
>		glLinkProgram(computeprogram);
>
>		glGetProgramInfoLog(computeprogram, 1024, NULL, infolog);
>		glGetProgramiv(computeprogram, GL_LINK_STATUS, &compiled);
>		printf("compute linking (%i): %s\n", compiled, infolog);
>	}
>
>	error("compute create");
>
>
>
>	{
>		const char* src[] = {
>			R"(
> 		#version 450
>
>			uniform float u_time;
>
> 		//layout(binding = 0)
>
>			layout(std430, binding = 1) buffer testssbo_buf
>			{
>				float testssbo[];
>			};
>
>			layout(local_size_x = 8, local_size_y = 8, local_size_z = 8) in;
>
>
>			uint gof(ivec3 coord)
>			{
>				int goff = ((coord.z * 256) + coord.y) * 256 + coord.x;
>
>				goff = clamp(goff, 0, 255*255*255);
>				return uint(goff);
>			}
>
>			void main()
>			{
>				ivec3 coord = ivec3(gl_GlobalInvocationID.xyz);
>				testssbo[gof(coord)] = testssbo[gof(coord)] + 1.0;
>			}
>			)"
>		};
>
>		computeprogram2 = glCreateProgram();
>
>		GLuint shader = glCreateShader(GL_COMPUTE_SHADER);
>		glShaderSource(shader, 1, src, NULL);
>		glCompileShader(shader);
>
>		GLint compiled;
>		char infolog[1024];
>		glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
>		glGetShaderInfoLog(shader, 1024, NULL, infolog);
>		printf("compute2 compile (comp'd %i): %s\n", compiled, infolog);
>
>		glAttachShader(computeprogram2, shader);
>		glLinkProgram(computeprogram2);
>
>		glGetProgramInfoLog(computeprogram2, 1024, NULL, infolog);
>		glGetProgramiv(computeprogram2, GL_LINK_STATUS, &compiled);
>		printf("compute2 linking (%i): %s\n", compiled, infolog);
>	}
>
>	error("compute2 create");
>
>}
>
>void createstuff()
>{
>	glGenBuffers(1, &ssbo_test);
>	glBindBuffer(GL_SHADER_STORAGE_BUFFER, ssbo_test);
>	glBufferData(GL_SHADER_STORAGE_BUFFER, 256*256*256*4, NULL, GL_STATIC_COPY);
>	glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0); // unbind
>	error("ssbo alloc");
>
>	glGenVertexArrays(1, &emptyvao);
>	error("vao create");
>
>	glGenQueries(QUERYCOUNT, qobjs);
>	error("query create");
>}
>
>void mainloop()
>{
>	bool loop = true;
>
>	while (loop)
>	{
>		SDL_Event event;
>		while (SDL_PollEvent(&event))
>		{
>			if (event.type == SDL_QUIT)
>				loop = false;
>
>			if (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_q)
>				loop = false;
>		}
>
>		float ft = SDL_GetTicks() / 1000.f;
>
>
>#if 1
>		putcounter();
>		glUseProgram(computeprogram);
>		glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, ssbo_test);
>		glUniform1f(glGetUniformLocation(computeprogram, "u_time"), ft);
>		glDispatchCompute(256/8, 256/8, 256/8);
>		glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
>		error("cp1");
>
>#endif
>#ifdef DO_SECOND_COMPUTE
>		putcounter();
>		glUseProgram(computeprogram2);
>		glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, ssbo_test);
>		glUniform1f(glGetUniformLocation(computeprogram2, "u_time"), ft);
>		glDispatchCompute(256/8, 256/8, 256/8);
>		glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
>		error("cp2");
>#endif
>
>		putcounter();
>		error("frame");
>		//glClearColor(0.0, 0.0, sin(SDL_GetTicks()), 1.0);
>		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
>
>
>		glDisable(GL_CULL_FACE);
>		glDisable(GL_DEPTH_TEST);
>
>		glUseProgram(drawprogram);
>		glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, ssbo_test);
>		glUniform1f(glGetUniformLocation(drawprogram, "u_time"), ft);
>		glBindVertexArray(emptyvao);
>		error("ee2");
>		glDrawArrays( GL_TRIANGLE_STRIP, 0, 4);
>
>		error("ee");
>
>		SDL_GL_SwapWindow(w);
>	}
>
>
>
>	SDL_Quit();
>
>}
>
>int main(void)
>{
>	initgl();
>	createshaders();
>	createstuff();
>	mainloop();
>
>	return 0;
>}

Actions: View

Attachments on bug 105934: 138687

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.