Why is there a debate to remove GIL from CPython?

In my last linkedin post, we discussed in brief about what is GIL and why it was implemented in the first place. In this article we will be going in brief as to why GIL could be a cause of bottleneck.

What is GIL (once more)?

The GIL is a mutex that allows only one thread to execute in the interpreter at any given time. This was initially introduced to deal with CPython's memory management issues and to simplify the implementation of the interpreter. While the GIL makes single-threaded programs fast and simplifies many types of multi-threaded programming, it has its drawbacks, especially for multi-core systems.

The case for removing GIL

1. Multi-core Utilization

One of the most compelling arguments for removing the GIL is the inability of CPython to effectively utilize multiple cores in a multi-core processor. While multi-threading should theoretically allow tasks to be distributed across multiple cores, the GIL prevents this from happening in CPython. This limitation is particularly problematic for applications that require heavy computational work.

2. Complexity in Concurrent Programming

The presence of the GIL makes concurrent programming complex and error-prone. Developers often have to resort to multi-processing, which involves creating separate memory spaces and communication protocols, instead of the more straightforward multi-threading approach. And multi-processing comes with it's own relatively intense overheads.

The Case for Keeping the GIL

1. Simplicity and Backward Compatibility

One of the reasons the GIL has not been removed is that it simplifies the CPython implementation. Removing it would require a significant overhaul of the internal code, which could introduce new bugs and break backward compatibility.

2. Single-threaded Performance

The GIL actually improves the performance of single-threaded programs, as it eliminates the overhead of acquiring and releasing locks.

Conclusion

The debate around removing the GIL from CPython is a complex issue that involves trade-offs between performance, simplicity, and backward compatibility. While there is a strong case for its removal, especially as multi-core processors become increasingly common, there are also valid reasons for its existence. As of now, the Python community continues to explore alternatives and optimizations, but the GIL remains a hotly debated topic. There are python implementations present which are without GIL but from my research they sabotage the single-threaded performance as well.