[Python-Dev] Why is the GIL not in PyInterpreterState?

[Tobias Oberstein]

Is there a reason why PyInterpreterState is not defined like so:

typedef struct _is {
   ..
   PyThread_type_lock interpreter_lock;
   PyThreadState *_PyThreadState_Current;
   ..
} PyInterpreterState;

which could be the basis for support of multiple, separated
interpreters within a single process.

I'm coming up with this since I need a scripting language embedded
in a multithreaded server which scales on SMP machines. I've read
through the history of the GIL-issue, and no I can't work around
it (other than using TCL, which I want to avoid at all costs).
please also see:
http://mail.python.org/pipermail/python-list/2003-February/144544.html


Would it be so hard to proceed like indicated below?
Please help a naive geek.

Tobias



PyInterpreterState* Py_Initialize_Ex()

void Py_Finalize_Ex(PyInterpreterState *interp)


PyThreadState* Py_NewInterpreter_Ex(PyInterpreterState *interp)

/* unchanged signature */
void Py_EndInterpreter_Ex(PyThreadState *tstate)


PyThreadState * PyThreadState_Get(PyInterpreterState *interp)


PyObject * PyImport_GetModuleDict(PyThreadState *tstate)


int PyRun_SimpleString_Ex(PyThreadState *tstate, char *command)




#define Py_BEGIN_ALLOW_THREADS(interp) { \
			PyThreadState *_save; \
			_save = PyEval_SaveThread_Ex(interp);
#define Py_BLOCK_THREADS(interp)	PyEval_RestoreThread_Ex(interp,_save);
#define Py_UNBLOCK_THREADS(interp)	_save = PyEval_SaveThread_Ex(interp);
#define Py_END_ALLOW_THREADS(interp)	PyEval_RestoreThread_Ex(interp,_save);
\
		 }



PyThreadState *
PyThreadState_Swap_Ex(PyInterpreterState *interp, PyThreadState *new)
{
	PyThreadState *old = interp->_PyThreadState_Current;

	_PyThreadState_Current = new;

	return old;
}


PyThreadState *
PyEval_SaveThread_Ex(PyInterpreterState *interp)
{
	PyThreadState *tstate = PyThreadState_Swap(interp, NULL);
	if (tstate == NULL)
		Py_FatalError("PyEval_SaveThread: NULL tstate");
#ifdef WITH_THREAD
	if (interp->interpreter_lock)
		PyThread_release_lock(interp->interpreter_lock);
#endif
	return tstate;
}



.. and so on ..
for backward compatibility one could do ..


/* essentially the only global to be left .. */
static PyInterpreterState* interp;


void Py_Initialize()
{
  interp = Py_Initialize_Ex();
}


void
Py_Finalize(void)
{
  Py_Finalize_Ex(interp);
}


PyThreadState *
Py_NewInterpreter(void)
{
  return Py_NewInterpreter_Ex(interp);
}


void
Py_EndInterpreter(PyThreadState *tstate)
{
  Py_EndInterpreter_Ex(PyThreadState *tstate)
}


PyThreadState *
PyThreadState_Get(void)
{
	return PyThreadState_Get(interp)
}


int
PyRun_SimpleString(char *command)
{
	return PyRun_SimpleString_Ex(PyThreadState_Get(interp), command);
}


PyObject *
PyImport_GetModuleDict(void)
{
  return PyImport_GetModuleDict(PyThreadState_Get(interp));
}