Jan
// Get a reference to one of the main threads
hpx::threads::executors::main_pool_executor scheduler;
// run an async function on the main thread to do a render
hpx::future<void> render = hpx::async(scheduler, [&isoSurface]()
{
render_code_in_here(isoSurface,...);
});
This is how I call my VTK render function that uses OpenGL.
JB
On 21/01/16 15:58, "[email protected] on behalf of
Jan-Tobias Sohns" <[email protected] on behalf of
[email protected]> wrote:
>Hello hpx-users,
>
>I'm still working on my parallel rendering project and can't find a
>solution for an error for over a month now.
>Whenever i call my rendering routine through an action (component- or
>plain action), i get a Segfault at glLinkProgram().
>If i call it in hpx_main() as a normal method or through std::async, it
>works fine, so my method is not faulty (correct image, no glErrors).
>
>I want to call it in a component action to render 16 images on 16
>components of a 16-core node/locality simultaneously, but the simplified
>version of just calling it once on a 1-core locality in a plain action
>in the hpx_main() gives the same segmentation fault.
>
>I know this most likely is an error on the interaction of OpenGL and
>asynchronous actions in general, but maybe someone on this list has an
>idea or has used OpenGL with HPX.
>Thanks in advance for any hints.
>
>Best,
>Jan
>
>
>
>Code snippets:
>- in readable order
>- single core version with OSMesa
>- interesting lines marked with ++++++++++++++++++++++++++++++++++)
>- can provide more if necessary
>
>
>
>the call: +++++++++++++++++++++++++++++++++++++++++++++++
>hpx::async<process_context_action>(hpx::find_here(), locID, locnum,
>m_currentImage).get();
>
>
>
>
>int process_context(GLuint offset, GLuint groups, Image image)
>{
> const GLint z = 32, stencil = 0, accum = 0;
> OSMesaContext ctx;
> void *buffer;
> GLint cBits;
>
> GLenum type = GL_UNSIGNED_BYTE;
> GLint bits = 8;
>
> setenv( "MESA_GL_VERSION_OVERRIDE", "3.3", 0 );
> setenv( "MESA_GLSL_VERSION_OVERRIDE", "330", 0);
>
> ctx = OSMesaCreateContextExt(OSMESA_RGBA, z, stencil, accum, NULL
>);
> if (!ctx) {
> printf("OSMesaCreateContextExt() failed!\n");
> return 0;
> }
>
> // Allocate the image buffer
> buffer = malloc(width * height * 4);
> if (!buffer) {
> printf("Alloc image buffer failed!\n");
> return 0;
> }
>
> // Bind the buffer to the context and make it current
> if (!OSMesaMakeCurrent( ctx, buffer, type, width, height )) {
> printf("OSMesaMakeCurrent (%d bits/channel) failed!\n", bits);
> free(buffer);
> OSMesaDestroyContext(ctx);
> return 0;
> }
>
> /* sanity checks */
> glGetIntegerv(GL_RED_BITS, &cBits);
> if (cBits != bits) {
> fprintf(stderr, "Unable to create %d-bit/channel
>renderbuffer.\n", bits);
> fprintf(stderr, "May need to recompile Mesa with CHAN_BITS=16
>or 32.\n");
> return 0;
> }
>
> OSMesaColorClamp(GL_TRUE);
> // ++++++++++++++++++++ go in next method ++++++++++++++++++++++
> if (!render_image(offset,groups))
> {
> return 0;
> }
>
> OSMesaDestroyContext(ctx);
>
> free(buffer);
>
> return 1;
>}
>HPX_PLAIN_ACTION(process_context, process_context_action);
>
>
>
>int render_image(GLuint offs, GLuint grps)
>{
> // Enable depth test
> glEnable(GL_DEPTH_TEST);
> glDepthFunc(GL_LESS);
>
> // Initialize VAO
> GLuint VertexArray;
> glGenVertexArrays(1, &VertexArray);
> glBindVertexArray(VertexArray);
>
> // Load and compile shaders +++++++++++ go in next method
>++++++++++++++++
> GLuint program = LoadShaders();
>
> // Get indices of shader-uniforms
> GLint MVPShaderID = glGetUniformLocation(program, "MVP");
> if (MVPShaderID == -1){
> fprintf(stderr, "FAILED: MVP misspelled or not used in
>shader.\n");
> return 0;
> }
> GLint ModelMatrixID = glGetUniformLocation(program, "M");
> if (ModelMatrixID == -1){
> fprintf(stderr, "FAILED: M misspelled or not used in shader.\n");
> return 0;
> }
> GLint ViewMatrixID = glGetUniformLocation(program, "V");
> if (ViewMatrixID == -1){
> fprintf(stderr, "FAILED: V misspelled or not used in shader.\n");
> return 0;
> }
> GLint LightPosID = glGetUniformLocation(program,
>"LightPosition_worldspace");
> if (LightPosID == -1){
> fprintf(stderr, "FAILED: LightPosition_worldspace misspelled or
>not used in shader.\n");
> return 0;
> }
>
> // Projection matrix
> glm::mat4 P = glm::perspective(80.0f, // FoV
> (float)width / (float)height, // Aspect Ratio
> 0.1f, 4.0f*std::max(std::max(camPos.x, camPos.y),
>camPos.z)); // Display Range
> // Camera matrix
> glm::mat4 V = glm::lookAt(
> camPos, // Camera-Position
> glm::vec3(0,0,0), // Looks at Point
> glm::vec3(0,-1,0)); // Up-Vector
> // Model matrix
> glm::mat4 M =
>glm::translate(glm::mat4(1.0f),glm::vec3(0.0f,0.0f,0.0f));
> // Compute MVP-Matrix
> glm::mat4 MVP = P * V * M;
>
> // Load Data
> std::vector<glm::vec3> VertexBufferData;
> std::vector<glm::vec3> ColorBufferData;
> std::vector<glm::vec3> NormalBufferData;
> std::vector<unsigned int> IndexBufferData;
>
> loadOBJ("../src/suzanne.obj", VertexBufferData, ColorBufferData,
>NormalBufferData, IndexBufferData, offs, grps);
>
> // Create VertexBuffer
> GLuint VBO;
> glGenBuffers(1, &VBO);
> glBindBuffer(GL_ARRAY_BUFFER, VBO);
> glBufferData(GL_ARRAY_BUFFER, VertexBufferData.size() *
>sizeof(glm::vec3),
> &VertexBufferData[0], GL_STATIC_DRAW);
>
> // Create ColorBuffer
> GLuint CBO;
> glGenBuffers(1, &CBO);
> glBindBuffer(GL_ARRAY_BUFFER, CBO);
> glBufferData(GL_ARRAY_BUFFER, ColorBufferData.size() *
>sizeof(glm::vec3),
> &ColorBufferData[0], GL_STATIC_DRAW);
>
> // Create NormalBuffer
> GLuint NBO;
> glGenBuffers(1, &NBO);
> glBindBuffer(GL_ARRAY_BUFFER, NBO);
> glBufferData(GL_ARRAY_BUFFER, NormalBufferData.size() *
>sizeof(glm::vec3),
> &NormalBufferData[0], GL_STATIC_DRAW);
>
> // Create IndexBuffer
> GLuint IBO;
> glGenBuffers(1, &IBO);
> glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);
> glBufferData(GL_ELEMENT_ARRAY_BUFFER, IndexBufferData.size() *
> sizeof(unsigned int), &IndexBufferData[0], GL_STATIC_DRAW);
>
> // Set clear color
> glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
> //glClearDepth(0.5f);
>
> glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
>
> // Use shader
> glUseProgram(program);
>
> // Give shader Matrices & Light
> glUniformMatrix4fv(MVPShaderID, 1, GL_FALSE, &MVP[0][0]);
> glUniformMatrix4fv(ModelMatrixID, 1, GL_FALSE, &M[0][0]);
> glUniformMatrix4fv(ViewMatrixID, 1, GL_FALSE, &V[0][0]);
> glUniform3f(LightPosID, lightPos.x, lightPos.y, lightPos.z);
>
> // Vertices atrribute buffer
> glEnableVertexAttribArray(0);
> glBindBuffer(GL_ARRAY_BUFFER, VBO);
> glVertexAttribPointer(
> 0, // attribute
> 3, // size
> GL_FLOAT, // type
> GL_FALSE, // normalized
> 0, // stride
> (void*)0 // array buffer offset
> );
>
> // Color attribute buffer
> glEnableVertexAttribArray(1);
> glBindBuffer(GL_ARRAY_BUFFER, CBO);
> glVertexAttribPointer(
> 1, // attribute
> 3, // size
> GL_FLOAT, // type
> GL_FALSE, // normalized
> 0, // stride
> (const GLvoid*)0 // array buffer offset
> );
>
> // Normal attribute buffer
> glEnableVertexAttribArray(2);
> glBindBuffer(GL_ARRAY_BUFFER, NBO);
> glVertexAttribPointer(
> 2, // attribute
> 3, // size
> GL_FLOAT, // type
> GL_FALSE, // normalized
> 0, // stride
> (const GLvoid*)0 // array buffer offset
> );
>
> // Index Buffer
> glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);
>
> // Draw triangles (mode, size, type,
>offset)
> glDrawElements(GL_TRIANGLES, IndexBufferData.size(),
>GL_UNSIGNED_INT, 0);
>
> // Cleanup VAO-Attributes
> glDisableVertexAttribArray(0);
> glDisableVertexAttribArray(1);
> glDisableVertexAttribArray(2);
>
> /* Make sure buffered commands are finished! */
> glFinish();
>
> // Cleanup VBO and shader
> glDeleteBuffers(1, &VBO);
> glDeleteBuffers(1, &CBO);
> glDeleteBuffers(1, &NBO);
> glDeleteBuffers(1, &IBO);
> glDeleteProgram(program);
> glDeleteVertexArrays(1, &VertexArray);
>
> return 1;
>}
>
>
>
>
>
>
>GLuint LoadShaders(){
>
> // Create the shaders
> GLuint VertexShader = glCreateShader(GL_VERTEX_SHADER);
> GLuint FragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
>
> // Vertex Shader code
> const char* VertexShaderCode = "\
>#version 330 core\n\
>layout(location = 0) in vec3 vertexPosition_modelspace;\
>layout(location = 1) in vec3 color;\
>layout(location = 2) in vec3 vertexNormal_modelspace;\
>out vec3 col;\
>out vec3 vertexNormal_cameraspace;\
>out vec3 EyeDirection_cameraspace;\
>out vec3 LightDirection_cameraspace;\
>uniform mat4 MVP;\
>uniform mat4 M;\
>uniform mat4 V;\
>uniform vec3 LightPosition_worldspace;\
>void main(){\
> gl_Position = MVP * vec4(vertexPosition_modelspace,1.0);\
> vec3 vertexPosition_cameraspace = (V * M *
>vec4(vertexPosition_modelspace,1)).xyz;\
> EyeDirection_cameraspace = vec3(0,0,0) - vertexPosition_cameraspace;\
> vec3 LightPosition_cameraspace = ( V *
>vec4(LightPosition_worldspace,1)).xyz;\
> LightDirection_cameraspace = LightPosition_cameraspace +
>EyeDirection_cameraspace;\
> col = color;\
> vertexNormal_cameraspace = (V * M *
>vec4(vertexNormal_modelspace,0.0)).xyz;\
>}";
>
> // Fragment Shader code
> const char* FragmentShaderCode = "\
>#version 330 core\n\
>in vec3 col;\
>in vec3 vertexNormal_cameraspace;\
>in vec3 EyeDirection_cameraspace;\
>in vec3 LightDirection_cameraspace;\
>out vec4 FragColor;\
>void main(){\
> vec3 MaterialDiffuseColor = col;\
> vec3 MaterialAmbientColor = vec3(0.3,0.3,0.3) *
>MaterialDiffuseColor;\
> vec3 MaterialSpecularColor = vec3(0.3,0.3,0.3);\
> vec3 n = normalize(vertexNormal_cameraspace);\
> vec3 l = normalize(LightDirection_cameraspace);\
> float cosTheta = clamp(dot(n,l), 0, 1);\
> vec3 E = normalize(EyeDirection_cameraspace);\
> vec3 R = reflect(-l,n);\
> float cosAlpha = clamp(dot(E,R), 0, 1);\
> FragColor = \
> vec4(MaterialAmbientColor +\
> MaterialDiffuseColor * cosTheta +\
> MaterialSpecularColor * pow(cosAlpha,5), 1.0);\
>}";
>
> GLint Result = GL_FALSE;
> int InfoLogLength;
>
> // Compile Vertex Shader
> glShaderSource(VertexShader, 1, &VertexShaderCode, NULL);
> glCompileShader(VertexShader);
>
> // Check Vertex Shader
> glGetShaderiv(VertexShader, GL_COMPILE_STATUS, &Result);
> if (!Result) {
> printf("VertexShader compilation failed:\n");
> }
> glGetShaderiv(VertexShader, GL_INFO_LOG_LENGTH, &InfoLogLength);
> if ( InfoLogLength > 0 ){
> std::vector<char> VertexShaderErrorMessage(InfoLogLength+1);
> glGetShaderInfoLog(VertexShader, InfoLogLength, NULL,
> &VertexShaderErrorMessage[0]);
> printf("%s", &VertexShaderErrorMessage[0]);
> }
>
> // Compile Fragment Shader
> glShaderSource(FragmentShader, 1, &FragmentShaderCode, NULL);
> glCompileShader(FragmentShader);
>
> // Check Fragment Shader
> glGetShaderiv(FragmentShader, GL_COMPILE_STATUS, &Result);
> if (!Result) {
> printf("FragmentShader compilation failed:\n");
> }
> glGetShaderiv(FragmentShader, GL_INFO_LOG_LENGTH, &InfoLogLength);
> if ( InfoLogLength > 0 ){
> std::vector<char> FragmentShaderErrorMessage(InfoLogLength+1);
> glGetShaderInfoLog(FragmentShader, InfoLogLength, NULL,
> &FragmentShaderErrorMessage[0]);
> printf("%s", &FragmentShaderErrorMessage[0]);
> }
>
> // Link the program
> GLuint program = glCreateProgram();
> glAttachShader(program, VertexShader);
> glAttachShader(program, FragmentShader);
>
> GLenum glErr;
> glErr = glGetError();
> if (glErr != 0){
> std::cout << "OpenGL error: " << glErr << endl;
> }
> printf("Linking Program...\n");
> glLinkProgram(program); +++++++++++++++++ SEGFAULT HERE
>++++++++++++++
> printf("Program linked\n");
>
> // Check the program
> glGetProgramiv(program, GL_LINK_STATUS, &Result);
> glGetProgramiv(program, GL_INFO_LOG_LENGTH, &InfoLogLength);
> if ( InfoLogLength > 0 ){
> std::vector<char> ProgramErrorMessage(InfoLogLength+1);
> glGetProgramInfoLog(program, InfoLogLength, NULL,
>&ProgramErrorMessage[0]);
> printf("%s", &ProgramErrorMessage[0]);
> }
>
> // Detach & delete shaders
> glDetachShader(program, VertexShader);
> glDetachShader(program, FragmentShader);
> glDeleteShader(VertexShader);
> glDeleteShader(FragmentShader);
>
> return program;
>}
>_______________________________________________
>hpx-users mailing list
>[email protected]
>https://mail.cct.lsu.edu/mailman/listinfo/hpx-users
_______________________________________________
hpx-users mailing list
[email protected]
https://mail.cct.lsu.edu/mailman/listinfo/hpx-users
