The document discusses the Global Interpreter Lock (GIL) in Python. It explains that the GIL serializes thread execution so that only one thread can be executing Python bytecodes at any given time. Threads release the GIL during I/O to allow other threads to run. The new GIL implementation in Python 3.2 aims to improve performance by switching threads at fixed time intervals rather than based on interpreter ticks. Various options for concurrency in Python are also presented, such as multiprocessing, asynchronous programming, and coroutines.

1. Understanding GIL
Senthil Kumaran
orsenthil@gmail.com
Scipy.in 2009

2. How I use python?
Python coredev ­ stdlib.
●
At work – Akamai.
●
Fun.
●

3. Thanks!
●
●
David Beazly – Inside the Python GIL talk.
Pictures are from his slides.

4. Outline of the talk
●
●
Python Interpreter.
●
Python Threading Support.
●
What is GIL.
●
GIL Behavior.
●
Newgil in py3.2
●
Parallelism – Other ways.
●
Threads.
etc

5. Threads
●
Parallel units of execution within a process.
●
All threads share the same memory.
●
●
Eat and think around the table, sometimes
sharing the fork and knife.
Problems with Threading involve the Shared
Resources and Thread Synchronization

6. Python Programming language
●
Different Implementations.
●
●
●
Jython
●
●
Cpython
IronPython.
We are going to discuss Cpython
implementation.
Bytecode based.

7. Python Interpretor
●
●
●
Interpreter is a single process.
Within that process, only one thread can be
interpreting python byte codes at one time.
If that thread is blocked (waiting or I/O),
another thread can be run. Some C
extensions release GIL so that threads can
run concurrently.

8. This is how

9. Python and Threading Support
●
●
●
A standard library module called threading.
But the execution of threaded programs is
very basic.
You have to define the synchronization
mechanism.

10. What is Python Thread?
●
Python threads are real system threads.
●
●
●
POSIX threads (pthreads)
Windows threads
Fully managed by the host operating system.
●
●
All the scheduling/threading switching.
Represent threaded execution of the Python
inpterpretor process (written in C).

11. Thread Creation
●
Python threads simply execute a “callable”
●
The run() method of Thread
●
●
●
Inside, the Python creates a small data
structure containing some interpreter state.
A new thread (pthread) is lauched,
The thread calls PyEval_CallObject. It is just a
C function call that runs the Python callable.

12. Thread Specific State
●
Each thread has its own interpreter specific data
structure (PyThreadState)
●
●
●
●
Details of the Thread currently under execution.
The interpreter has a global variable that simply points to
the ThreadState strcture of the currently running thread.
/* Python/pystate.c */
Operations in the Interpreter implicitly depend on this
variable to know the state.

13. What is GIL
●
●
●
GIL Serializes the access to most part of the
interpreter.
Only one thread is running at a time.
The GIL ensures that each thread gets
exclusive access to the Interpreter internals
when its running.

14. GIL Behaviour
●
●
●
Its simple. Threads hold the GIL when
running.
However, they release it when blocking for
I/O.
It is coperative multi­tasking.

15. CPU Bound process
●
To deal with CPU bound threads that never
perform any I/O, the interpreter periodically
performs a “check”.
●
By default, every 100 interpreter “ticks”
●
sys.setcheckinterval
●
The check interval is independent of thread
scheduling.

16. sys.setcheckinterval

17. The Periodic Check
●
Release and Reacquire GIL.
●
Signaling the OS to run other thread.
●
Other threads get to run.. (somewhat )
All of these is for py < 3.2

18. Interpreter ticks
●
●
Ticks are uninterruptible
●
They are not time based ( for < py3.2)
Long Operations can block everything.

19. Thread Scheduling
●
●
●
●
Interpreter does not do any thread scheduling.
There is no notion of thread priorities, preemption,
round­robin scheduling.
All thread scheduling is left to the host operating
system.
There comes the problem with signals. Only main
thread handles signals and interpretor cannot schedule
it execution, but has to wait for OS to schedule it when
the any signal arrives.

20. Interpreter does NO thread
scheduling

21. More details on GIL
●
Its not a simple mutex.
●
It is some kind of semaphore.
●
●
The acquisition and release is based on the
signals from the OS.
OS does the scheduling based on priorities
like CPU bound task has low priority and IO
bound tasks have higher priority.

22. Multicore GIL contention
●
●
CPU bound operations get scheduled
simultaneous.
And they have a GIL battle in the Interpeter.

23. GIL Contention

24. Newgil implementation
●
●
●
●
●
Antoine Pitrou – Oct 2009
Ditch the switching based on tick in the newgil
implementation. (No Py_Ticker based count)
Use fixed intervals (5 milliseconds) for the main thread to
release the GIL.
This fixed interval switching has significant benefits on
thread contentions.
Forced thread switching. Improves the thread switch
latency.

25. ccbench
●
●
●
Pure Python workload (PI Calculation).
C workload which does not release GIL
(re.search)
C workload which does release GIL.

26. Other Concurrency Options
●
Practical programming scenarios ( IO and CPU Bound)
●
Multi processing.
●
C extension that can release GIL.
●
Asynchronous event based – Great for Networking applications.
●
●
Coroutines – python 2.5 where you can pass values to
generators.
Other Python implementations. Jython, IronPython, Unladen
Swallow.

27. Thanks
●
orsenthil@gmail.com
●
http://uthcode.sarovar.org
●
●
Search or David Beazly talk on Inside the
Python GIL.
Newgil implementation is currently in py3k
branch (which will become python 3.2, est. by
Jun 2010)

28. Notes
●
●
gil_locked and gil_mutex
●
gil_drop_request
●
gil_cond variable (waiting for interval)
●
sys.{set,get}checkinterval
switch_cond check for gil_last_hold.

29.
Understanding GIL
Senthil Kumaran
orsenthil@gmail.com
Scipy.in 2009
1

30.
How I use python?
●
Python coredev ­ stdlib.
●
At work – Akamai.
●
Fun.
2

31.
Thanks!
●
●
David Beazly – Inside the Python GIL talk.
Pictures are from his slides.
3

32.
Outline of the talk
●
●
Python Interpreter.
●
Python Threading Support.
●
What is GIL.
●
GIL Behavior.
●
Newgil in py3.2
●
Parallelism – Other ways.
●
Threads.
etc
4

33.
Threads
●
Parallel units of execution within a process.
●
All threads share the same memory.
●
●
Eat and think around the table, sometimes
sharing the fork and knife.
Problems with Threading involve the Shared
Resources and Thread Synchronization
5

34.
Python Programming language
●
Different Implementations.
●
●
●
Jython
●
●
Cpython
IronPython.
We are going to discuss Cpython
implementation.
Bytecode based.
6

35.
Python Interpretor
●
●
●
Interpreter is a single process.
Within that process, only one thread can be
interpreting python byte codes at one time.
If that thread is blocked (waiting or I/O),
another thread can be run. Some C
extensions release GIL so that threads can
run concurrently.
7

36.
This is how
8

37.
Python and Threading Support
●
●
●
A standard library module called threading.
But the execution of threaded programs is
very basic.
You have to define the synchronization
mechanism.
9

38.
What is Python Thread?
●
Python threads are real system threads.
●
●
●
POSIX threads (pthreads)
Windows threads
Fully managed by the host operating system.
●
●
All the scheduling/threading switching.
Represent threaded execution of the Python
inpterpretor process (written in C).
10

39.
Thread Creation
●
Python threads simply execute a “callable”
●
The run() method of Thread
●
●
●
Inside, the Python creates a small data
structure containing some interpreter state.
A new thread (pthread) is lauched,
The thread calls PyEval_CallObject. It is just a
C function call that runs the Python callable.
11

40.
Thread Specific State
●
Each thread has its own interpreter specific data
structure (PyThreadState)
●
●
●
●
Details of the Thread currently under execution.
The interpreter has a global variable that simply points to
the ThreadState strcture of the currently running thread.
/* Python/pystate.c */
Operations in the Interpreter implicitly depend on this
variable to know the state.
12

41.
What is GIL
●
●
●
GIL Serializes the access to most part of the
interpreter.
Only one thread is running at a time.
The GIL ensures that each thread gets
exclusive access to the Interpreter internals
when its running.
13

42.
GIL Behaviour
●
●
●
Its simple. Threads hold the GIL when
running.
However, they release it when blocking for
I/O.
It is coperative multi­tasking.
14

43.
CPU Bound process
●
To deal with CPU bound threads that never
perform any I/O, the interpreter periodically
performs a “check”.
●
By default, every 100 interpreter “ticks”
●
sys.setcheckinterval
●
The check interval is independent of thread
scheduling.
15

44.
sys.setcheckinterval
16

45.
The Periodic Check
●
Release and Reacquire GIL.
●
Signaling the OS to run other thread.
●
Other threads get to run.. (somewhat )
All of these is for py < 3.2
17

46.
Interpreter ticks
●
●
Ticks are uninterruptible
●
They are not time based ( for < py3.2)
Long Operations can block everything.
18

47.
Thread Scheduling
●
●
●
●
Interpreter does not do any thread scheduling.
There is no notion of thread priorities, preemption,
round­robin scheduling.
All thread scheduling is left to the host operating
system.
There comes the problem with signals. Only main
thread handles signals and interpretor cannot schedule
it execution, but has to wait for OS to schedule it when
the any signal arrives.
19

48.
Interpreter does NO thread
scheduling
20

49.
More details on GIL
●
Its not a simple mutex.
●
It is some kind of semaphore.
●
●
The acquisition and release is based on the
signals from the OS.
OS does the scheduling based on priorities
like CPU bound task has low priority and IO
bound tasks have higher priority.
21

50.
Multicore GIL contention
●
●
CPU bound operations get scheduled
simultaneous.
And they have a GIL battle in the Interpeter.
22

51.
GIL Contention
23

52.
Newgil implementation
●
●
●
●
●
Antoine Pitrou – Oct 2009
Ditch the switching based on tick in the newgil
implementation. (No Py_Ticker based count)
Use fixed intervals (5 milliseconds) for the main thread to
release the GIL.
This fixed interval switching has significant benefits on
thread contentions.
Forced thread switching. Improves the thread switch
latency.
24

53.
ccbench
●
●
●
Pure Python workload (PI Calculation).
C workload which does not release GIL
(re.search)
C workload which does release GIL.
25

54.
Other Concurrency Options
●
Practical programming scenarios ( IO and CPU Bound)
●
Multi processing.
●
C extension that can release GIL.
●
Asynchronous event based – Great for Networking applications.
●
●
Coroutines – python 2.5 where you can pass values to
generators.
Other Python implementations. Jython, IronPython, Unladen
Swallow.
26

55.
Thanks
●
orsenthil@gmail.com
●
http://uthcode.sarovar.org
●
●
Search or David Beazly talk on Inside the
Python GIL.
Newgil implementation is currently in py3k
branch (which will become python 3.2, est. by
Jun 2010)
27

56.
Notes
●
●
gil_locked and gil_mutex
●
gil_drop_request
●
gil_cond variable (waiting for interval)
●
sys.{set,get}checkinterval
switch_cond check for gil_last_hold.
28