Disabling GIL - Unleashing the True Power of Python

Introduction

Python is finally getting rid of its major limitation, the Global Interpreter Lock (GIL), which it has had since 1991. Before explaining what the GIL is, let's understand how computers and programming languages were designed in the 1990s.

Global Interpreter Lock (GIL)

When it comes to multi-threading, Python behaves a bit weird. Let's understand this with a small example.

In the world of computers, programs are like me and my brother trying to play the game. The Global Interpreter Lock (GIL) is like the rule that only allows one, either me or my brother (or thread), to play the game (or execute Python bytecode) at a time.

GIL is a rule that allows only one thread at a time to run the Python bytecode. It protects access to Python objects, preventing multiple threads from executing Python bytecode simultaneously in a single process.

Why GIL & What is the Advantage?

1. Memory Management

CPython uses reference counting as a primary mechanism for memory management. Every Python object has a reference count, which tracks how many references point to the object. When the count drops to zero, the memory occupied by the object is freed.

2. Simplicity and Safety

The GIL makes the Python interpreter easier to implement because it removes the need for detailed locking around shared resources. This simplifies maintenance and development, especially with Python's dynamic typing and complex object model.

Let us understand with an example

import threading

counter = 0
iterations = 1000000

def increment_counter():
    global counter
    for _ in range(iterations):
        counter += 1

# Create two threads
thread1 = threading.Thread(target=increment_counter)
thread2 = threading.Thread(target=increment_counter)

# Start both threads
thread1.start()
thread2.start()

# Wait for both threads to finish
thread1.join()
thread2.join()

print(f"Final counter value: {counter}")

Why not remove GIL completely?

Removing the Global Interpreter Lock (GIL) from Python has been a topic of discussion for many years. While it seems like an obvious solution, the decision is not straightforward.

Why remove it now?

The answer is simple. The growing need for AI and machine learning computations, along with the availability of powerful hardware like CPUs and GPUs, led to the decision. This change improves multi-threading, which greatly speeds up these computations and CPU operations.

Metrics & Results

import time
import threading
from time import perf_counter

def sum_of_squares(n):
    return sum(i * i for i in range(n))

def sum_of_squares_partial(start, end, result, index):
    result[index] = sum(i * i for i in range(start, end))

def run_single_threaded(n):
    start_time = perf_counter()
    result = sum_of_squares(n)
    end_time = perf_counter()
    print(f"Time taken: {end_time - start_time:.4f} seconds")

def run_multi_threaded(n, num_threads):
    chunk_size = n // num_threads
    threads = []
    results = [0] * num_threads
    start_time = perf_counter()
    for i in range(num_threads):
        start = i * chunk_size
        end = start + chunk_size if i != num_threads - 1 else n
        thread = threading.Thread(target=sum_of_squares_partial, args=(start, end, results, i))
        threads.append(thread)
        thread.start()
    for thread in threads:
        thread.join()
    end_time = perf_counter()
    print(f"Time taken: {end_time - start_time:.4f} seconds")

Summary

Removing the GIL can greatly boost performance in multi-threading, the concept that has changed the way we compute. Just imagine if Python ran without the GIL. It could greatly speed up Machine Learning, AI models, and improve performance in the Pandas library.

While removing the GIL is not easy and requires a major redesign, I believe it is worth it because of the benefits it offers in the AI field.