RE: I want to release the GIL

[Delaney, Timothy (Tim)]

Piotr Sobolewski wrote:

Hello,
I have such program:

import time
import thread
def f():
* * global lock
* * while True:
* * * * lock.acquire()
* * * * print thread.get_ident()
* * * * time.sleep(1)
* * * * lock.release()
lock=thread.allocate_lock()
thread.start_new_thread(f,())
thread.start_new_thread(f,())
time.sleep(60)

1. You should use the threading module.

2. No need for the "global lock" statement here - you're not rebinding the name "lock".

3. These aren't daemon threads, so your program will never exit. You will need to set a flag or something after the time.sleep(60).

As you can see, I start two threads. Each one works in an infinite
loop.
Inside that loop it acquires lock, prints its own id, sleeps a bit and
then
releases lock.

4. Because you are holding the lock while sleeping, the other thread does not get the chance to run. Sleeping does not release any locks held.

Instead try something like:

while True:
with lock:
print thread.get_ident()
time.sleep(1)

Note that to use the "with lock:" idiom, you need to be using Python 2.6, or Python 2.5 with a "from __future__ import with_statement".

Tim Delaney

[Piotr Sobolewski]

Thanks for answers.
But what about my main question? Is it possible to release GIL without
sleeping? I know that in this example situation I can achieve my goals
without that - I can just move sleep outside of locked block. But I
just want to know it for future - can I just do something like
thread.gil_release()?

[k3xji]

See yield() statement.

[Diez B. Roggisch]

Piotr Sobolewski schrieb:

Thanks for answers.
But what about my main question? Is it possible to release GIL without
sleeping? I know that in this example situation I can achieve my goals
without that - I can just move sleep outside of locked block. But I
just want to know it for future - can I just do something like
thread.gil_release()?

No, you can't. That is the reason for the python multiprocessing module
http://docs.python.org/library/multiprocessing.html, which is part of
2.6 standard lib.

For older python versions, there is "processing" that essentially does
the same.

Diez

[Gabriel Genellina]

En Tue, 21 Oct 2008 04:58:00 -0200, Piotr Sobolewski
<pi**************@o2.plescribió:

But what about my main question? Is it possible to release GIL without
sleeping? I know that in this example situation I can achieve my goals
without that - I can just move sleep outside of locked block. But I
just want to know it for future - can I just do something like
thread.gil_release()?

No, you can't release the GIL *and* continue executing Python code.

--
Gabriel Genellina

[Carl Banks]

On Oct 21, 5:09*am, "Gabriel Genellina" <[e-mail]>
wrote:

En Tue, 21 Oct 2008 04:58:00 -0200, Piotr Sobolewski *
<[e-mail]ó:

But what about my main question? Is it possible to release GIL without
sleeping? I know that in this example situation I can achieve my goals
without that - I can just move sleep outside of locked block. But I
just want to know it for future - can I just do something like
thread.gil_release()?

No, you can't release the GIL *and* continue executing Python code.

I don't think that's what the OP was asking about; I think he merely
wanted to force a GIL release to give the other thread a chance to
run.

Reason being: in his code the lock was re-acquired right after it was
released. This meant that the same thread that released the lock
almost always acquired it right back, since there was only a tiny
window in which a thread switch could take place. Obviously the
wisdom of what he was doing was suspect, but the OP was right in that
a manual GIL release would allow a thread switch and could have helped
avoid starvation in that case.
Carl Banks

[MRAB]

On Oct 21, 10:22*am, Carl Banks <[e-mail]:

On Oct 21, 5:09*am, "Gabriel Genellina" <[e-mail]>
wrote:

En Tue, 21 Oct 2008 04:58:00 -0200, Piotr Sobolewski *
<[e-mail]ó:

But what about my main question? Is it possible to release GIL without
sleeping? I know that in this example situation I can achieve my goals
without that - I can just move sleep outside of locked block. But I
just want to know it for future - can I just do something like
thread.gil_release()?

No, you can't release the GIL *and* continue executing Python code.

I don't think that's what the OP was asking about; I think he merely
wanted to force a GIL release to give the other thread a chance to
run.

Reason being: in his code the lock was re-acquired right after it was
released. *This meant that the same thread that released the lock
almost always acquired it right back, since there was only a tiny
window in which a thread switch could take place. *Obviously the
wisdom of what he was doing was suspect, but the OP was right in that
a manual GIL release would allow a thread switch and could have helped
avoid starvation in that case.

If he released the GIL then he would still have to ensure that other
thread got a chance to claim it before the releaser tried to reclaim
it, which suggests the sleep that he was trying to avoid (unless the
release was really "yield the GIL to another thread if one is waiting
for it").