Unlocking Python\u2019s true potential in terms of speed through shared-memory parallelism<\/a> has traditionally been limited and challenging to achieve. That\u2019s because the global interpreter lock (GIL)<\/a> doesn\u2019t allow for thread-based parallel processing in Python. Fortunately, there are several work-arounds for this notorious limitation, which you\u2019re about to explore now!<\/p>\n In this tutorial, you\u2019ll learn how to:<\/strong><\/p>\n To get the most out of this advanced tutorial, you should understand the difference between concurrency<\/a> and parallelism<\/a>. You\u2019ll benefit from having previous experience with multithreading<\/a> in programming languages other than Python. Finally, it\u2019s best if you\u2019re eager to explore uncharted territory, such as calling foreign Python bindings<\/a> or writing bits of C code<\/a>.<\/p>\n Don\u2019t worry if your knowledge of parallel processing is a bit rusty, as you\u2019ll have a chance to quickly refresh your memory in the upcoming sections. Also, note that you\u2019ll find all the code samples, image files, and the demo project from this tutorial in the supporting materials, which you can download below:<\/p>\n Get Your Code:<\/strong> Click here to download the free sample code<\/a> that shows you how to bypass the GIL and achieve parallel processing in Python.<\/p>\n<\/div>\n Before dipping your toes into specific ways of bypassing the GIL in Python, you might want to revisit some related topics. Over the following few sections, you\u2019ll familiarize yourself with different computer processing models, task types, abstractions over modern CPUs, and some history. If you already know this information, then feel free to jump ahead to the classic mechanism<\/a> for parallelization in Python.<\/p>\n Under Flynn\u2019s taxonomy<\/a>, the most common types of parallel processing<\/strong> allow you to run the same (SIMD<\/a>) or different code fragments (MIMD<\/a>) in separate execution streams at the same time:<\/p>\n Here, two independent tasks or jobs<\/a> execute alongside each other. To run more than one piece of code simultaneously like this, you need a computer equipped with a central processing unit (CPU)<\/a> comprising multiple physical cores<\/a>, which is the norm nowadays. While you could alternatively access a cluster<\/a> of geographically distributed machines<\/a>, you\u2019ll consider only the first option in this tutorial.<\/p>\n Parallel processing is a particular form of concurrent processing<\/strong>, which is a broader term encompassing context switching<\/a> between multiple tasks. It means that a currently running task might voluntarily suspend its execution or be forcibly suspended to give a slice of the CPU time<\/a> to another task:<\/p>\n In this case, two tasks have been sliced into smaller and intertwined chunks of work that share a single core of the same processing unit. This is analogous to playing chess against multiple opponents<\/a> at the same time, as shown in one of the scenes from the popular TV miniseries The Queen\u2019s Gambit<\/em><\/a>. After each move, the player proceeds to the next opponent in a round-robin<\/a> fashion, trying to remember the state of the corresponding game.<\/p>\n Note:<\/strong> Context switching makes multitasking<\/a> possible on single-core architectures. However, multi-core CPUs also benefit from this technique when the tasks outnumber the available processing power, which is often the case. Therefore, concurrent processing usually involves spreading the individual task slices over many CPUs, combining the power of context switching and parallel processing.<\/p>\n<\/div>\n While it takes time for people to switch their focus, computers take turns much quicker. Rapid context switching gives the illusion of parallel execution despite using only one physical CPU. As a result, multiple tasks are making progress together.<\/p>\n Because of time-sharing<\/a>, the total time required to finish your intertwined tasks running concurrently is longer when compared to a genuinely parallel version. In fact, context switching has a noticeable overhead that makes the execution time even worse than if you run your tasks one after another using sequential processing<\/strong> on a single CPU. Here\u2019s what sequential processing looks like:<\/p>\n With sequential processing, you don\u2019t start another task until the previous one finishes, so you don\u2019t have the costs of switching back and forth. This situation corresponds to playing an entire chess game with one opponent before moving on to the next one. Meanwhile, the remaining players must sit tight, patiently waiting for their turn.<\/p>\n On the other hand, playing multiple games concurrently can maximize your throughput<\/a>. When you prioritize games with players who make quick decisions over those who need more time to think, then you\u2019ll finish more games sooner. Therefore, intertwining can improve the latency<\/a>, or response times<\/strong>, of the individual tasks, even when you only have one stream of execution.<\/p>\n As you can probably tell, choosing between parallel<\/strong>, concurrent<\/strong>, and sequential<\/strong> processing models can feel like plotting out your next three moves in chess. You have to consider several factors, so there\u2019s no one-size-fits-all solution.<\/p>\n Whether context switching actually helps will depend on how you prioritize your tasks. Inefficient task scheduling can lead to starving<\/a> shorter tasks of CPU time.<\/p>\n Additionally, the types of tasks are critical. Two broad categories of concurrent tasks are CPU-bound<\/strong> and I\/O-bound<\/strong> ones. The CPU-bound tasks will only benefit from truly parallel execution to run faster, whereas I\/O-bound tasks can leverage concurrent processing to reduce latency. You\u2019ll learn more about these categories\u2019 characteristics now.<\/p>\n [ Improve Your Python With ? Python Tricks ? \u2013 Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples<\/a> ]<\/em><\/p>\n\n In this tutorial, you’ll take a deep dive into parallel processing in Python. You’ll learn about a few traditional and several novel ways of sidestepping the global interpreter lock (GIL) to achieve genuine shared-memory parallelism of your CPU-bound tasks.<\/p>\n<\/div>","protected":false},"author":2055,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"slim_seo":{"title":"Bypassing the GIL for Parallel Processing in Python - ITTeacherITFreelance.hk","description":"In this tutorial, you'll take a deep dive into parallel processing in Python. You'll learn about a few traditional and several novel ways of sidestepping the gl"},"footnotes":""},"categories":[10700],"tags":[],"_links":{"self":[{"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/posts\/329502"}],"collection":[{"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/users\/2055"}],"replies":[{"embeddable":true,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/comments?post=329502"}],"version-history":[{"count":1,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/posts\/329502\/revisions"}],"predecessor-version":[{"id":329503,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/posts\/329502\/revisions\/329503"}],"wp:attachment":[{"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/media?parent=329502"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/categories?post=329502"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/tags?post=329502"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}\n
Recall the Fundamentals of Parallel Processing<\/a><\/h2>\n
What\u2019s Parallel Processing?<\/a><\/h3>\n
![\"Parallel](\"https:\/\/files.realpython.com\/media\/parallel.bcf05cc11397.png\")
<\/a>![\"Concurrent](\"https:\/\/files.realpython.com\/media\/concurrent.f333207efd07.png\")
<\/a>![\"Sequential](\"https:\/\/files.realpython.com\/media\/sequential.f52f718348b0.png\")
<\/a>How Do CPU-Bound and I\/O-Bound Tasks Differ?<\/a><\/h3>\n<\/div>\n
Read the full article at https:\/\/realpython.com\/python-parallel-processing\/ \u00bb<\/a><\/h2>\n
\n![\\\"IT\u96fb\u8166\u88dc\u7fd2](\\\"http:\/\/itteacheritfreelance.hk\/test\/wordpress\/wp-content\/uploads\/2016\/05\/logo2-2.png\\\"){kind=logo}
\r\nwww.itsec.hk<\/a>
\r\nwww.itsec.vip<\/a>
\r\nwww.itseceu.uk<\/a>
<\/p>","protected":false},"excerpt":{"rendered":"