Using OpenGL with threads?

OpenGL is not thread safe. I understand that (or maybe not). I have heard that all OpenGL calls have to be made in the original thread. I don't understand why that would be. It seems to me that as long as you don't call multiple OpenGL calls simultaneously, that it would work. However, by observation, it seems that it is true. I still don't understand why, though.

Here is a simple application that seems, to me, like it should work. But it segfaults.

// Compile this program with "gcc -o tmp tmp.c `sdl-config --libs` -lGL"

#include "SDL/SDL.h"
#include "SDL/SDL_thread.h"

#include "GL/gl.h"
#include <unistd.h>

int my_thread(void * data) {
	glGetString(GL_VERSION );
}

int main(int argc, char ** argv) {
	SDL_Init(SDL_INIT_VIDEO);
	SDL_SetVideoMode(320, 240, 32, SDL_OPENGL);

	SDL_Thread * test = SDL_CreateThread(my_thread, NULL);

	SDL_WaitThread(test, NULL);

	SDL_Quit();

	return 0;
}

Can someone explain why this program segfaults? Is there a simple way to fix it? Is there any way at all that opengl calls can be made in non-primary threads?

I have heard that all OpenGL calls have to be made in the original thread. I don't understand why that would be/

This is because OpenGL is a state machine and the state will be shared with multiple threads; thus meaning there could be a data race at any time. So if this is what you need to do, then the design needs changing.

I have heard the same thing about OpenGL. The usual solution I think is to have one thread which does OpenGL calls, and farm out non-gl functions to other threads, e.g. game physics or other calculations, but only draw them in the GL thread.

Thanks, guys. Is putting all OpenGL calls in the original thread the only way to solve this? Is there any other way at all?

OpenGL is a state machine and the state will be shared with multiple threads; thus meaning there could be a data race at any time. So if this is what you need to do, then the design needs changing.

If they all share the same state, how could there be a data race? Wouldn't they all have the exact same state, and therefore be perfectly in sync? Or did I misunderstand you?

Think of the OpenGL state as a global variable and there are multiple threads which can change or access it. Is it safe to do this without some form of mutual exclusion?

The problem is you can not add a mutual exclusion to the OpenGL state.

Normally you have a renderer (which may be in its own thread), you send data batches in the form of vertex data(FFP) or something similar and the renderer makes all the API calls.