Merken

Python's Infamous GIL

Zitierlink des Filmsegments
Embed Code

Automatisierte Medienanalyse

Beta
Erkannte Entitäten
Sprachtranskript
ideal is the mike working yet again so on I'm very these things and this is Python's into the skill I'm going to talk about the Guillaume to talk about what it is and what problems trying to solve how it solves it but the ramifications of those choices are all its history is like and what its features like and I originally
proposes top and and that little more advanced level in the way that I wrote it it's really kind of friendly for beginners to so don't get scared so but what about the clock back to 1992
icons about 2 years old but it was still young and fraction evolving rapidly is mostly used around CWI word we was working but also been released on the Internet there was a new technology out there in operating systems something called multithreading this isn't something that people had dealt with very much today it was a market thing was about 1 summer west most of our
existence and support I it wasn't data for the new operating system from Microsoft called Windows NT but this multithreading what it was was kind like process except that it was all in 1 process you have multiple threads of execution happening inside the same process all the shares the same shared states but they want to try experimenting with threats in Python but but you couldn't just stop and try and expect everything work and there's
gonna be a problem the 1st problem is global so global and C is kind of like a modular Attribute Python and it's something there's only 1 of them and everybody knows where it is if multiples of these threads involve trying to talk the same global variable on Republican have problems as an example of 1 of these articles in Python and there's a pointer to the current executing frame object and that's is 1 of them and it's a global variable everybody can see it if multiple people try to play with the frame object pointed you have a problem and even worse problem those reference counting so Python uses a technical reference counting to manage the lifetimes of objects and to destroy them when nobody is interested in them anymore and into a deep dive right now about what reference coming
is how it works and how what the implications are profound counting is with a multithreading so reference counting inside of the Python interpreter at runtime every single Python
object starts with these 2 fields and the 2nd 1 is the type of the objects and the first one is what's called the reference count this is an integer and integer tells you how many people are interested in the subject right now how many people are holding reference itself the reference count is 3 that means that the 3 pointers pointing at this object and what you do with this reference count every time you take a new reference the object you increment that number and every time you are no longer in the object you decrement that number so you in graph and that graph when the object count of reference count 0 nobody is interested in the subject anymore and so you should destroy you call the vendor delegates got under Del and you release the memory of the getting back the Apennines system or are recycling and using it for another object so in se there are these
things called macros is is kind of like a subroutine call but it's actually done is more of a textual substitution so a graph and the graph of how you manage the reference count inside city but these are what they look like today today's the ones in 1982 look much the same so
let's look at what happens if we have 2 threads they're trying to do with reference kind of the same time on the show it to you in exhaustive detail and showed to you both when it works and when it fails now thread 1 thread to both have references this object in the center and they're both going to drop the references about point at let's Trinidad graph into the underlying see but even this is in deep enough to actually have to go 1 level deeper and look at the assembly language that this was compiled into by the C compiler and this is actually
just pseudo assembly language but this is very accurate to what's actually going on so that said the act as a reference can 3 thread 1 loads that reference can into something called AX AX is register on the CPU and so you think of it as a variable of each thread has its own set of registers effectively they get swapped around so from 1 loads the value 3 in the X then decremented so notes to and it stores it back into the object the reference count and the object is enough to comes along does the same thing loads and a AX decremented and stores it the reference count on that object is 1 this work we had 2 threads they both drop the references that reference count on the object graph to 1 now stood again but this time
we're going to do those objects those things in a different from 1 loads of announces at 3 to bed at the same time almost exactly the same times that 1 does that and also sees decrement so stores so just to but that to enter 1 both with the same value both threads drop the references it should have dropped from 3 1 but only dropped from 3 to 2 this is above so this is what's called a race condition both of the French were racing along in this kind of step on each other's feet now you have the inverse problem with incorrect if you have 2 threads at both the graph the object at the same time then the reference can can be 1 2 small but the problem here so that that you get different results depending on which it is if you have the reference come to large
then what happens is if everybody releases the references the object of the reference can still positive 1 or more and nobody has reference to the object so nobody's ever in cleanups analysis leak memory and if there's a finalize arena has resources as finalized our resources finalized and you're linking resources to fund the all the inverse problems much worse if the reference time too low then must say that it's too and the 3 people of references to the 1st power drops in the props to 1 the 2nd drops and adopts a 0 and it goes away have clean up the object we release the memory of that governing system for every user but there's still 1 guy who has a reference this memory he thinks it's about object what's he going to see if the main reason given that govern system the program of evident
recycled these for another object is in the current values in my crashed my computer some inaccurate results announced but this is a really nasty but is really hard but so getting a reference can numbers are on is really painful so 1 prevent this from happening if or when making pattern so the the
1st approach that 1 might think
of would be at Luxor and everything a lot is something usable their programming to prevent multiple people from using something in the same time you can the it's kind like a bouncer the bouncer standing at the Bar Ilan that's 1 person inside a times the 1st person comes along he says go on the 2nd reason comes along they have to wait until the 1st person comes back out and about as OK now you can go so we could throw a lot around every single global thing we could say in order to use the frame pointer you have to be holding this loss In order to be told or maybe we could do it for groups of things together we can group together all the stuff that's for the runtime currently executing stack we also need at least 1 may be more than 1 for reference counts the problem with using multiple lots like this is you
have a special kind race condition called the deadline so let's say that we have 2 threads here is an example of
a lot on a and B are locks and thread 1 thread to are going to try and use those what the problem is that they grab them in the opposite order so that 1 grabs a then B tried to GM B then the problem is if you execute them in this order what dreaded 1 tries again like a network tried to present block the that works fine the thread keeps going from monkeys going into is available at the node has to wait thread to try to grab what they build as to these different and that that they will never make progress and if any other threat comes along and says I want Fred area a like a like the it's can get stuck to this is a deadlock this is not a painful thing threat of programming you don't want to have this problem so we know very
carefully In 1992 very
cleverly created something called the guilt that's it that is interpret what that is global to the whole of Python running process we call the global interpret a lot or the you for sure and that's what it looked like in 1992 almost 2 years the date by the license inside the Python repository was created in on a suitable site today in Python 2 7 really hasn't changed meaning
of word this is 24 years in Python 2 7 and you will get into that now in order to interact with the Python interpreter but to do anything you have to be holding the interval in order to interact with an object in order to run Python bytecode to the interpreter you have to hold the guilt but which is both good and bad so let's talk about the this is simple simple is easy to get right but because it's part of the Python
extension modules have to hold the guilt in order to interact with the Python interpreter this made it a very simple rule and was very easy for extension offers to get right this led to Python people writing what extension modules for Python the story of the Python deal is really the story of the success of Python people at the guilt don't understand Python's history without the guilt Python would not have been as successful as it is that so also because you only have 1 deal you can have a deadline because there are 2 blocks the have now if you have O-bound threat I want to know if you have multiple threads and they're all blocking IO then this also just works magically your program runs as fast as it can if your program CPU-bound but then your firms effectively single-threaded because again only 1 thread can hold little below the time and therefore only 1 thread in the interacting with the Python interpreter so if you have 3 threads all 1 running code only 1 continued the time therefore the effect of using interest we're gonna talk about that that's why people don't like to go now about this of the reason that works magically friable and code there's only there's another 1 these macro subscribe to that actually tied again allow threads entire and allow threads so we'll all realized if you're going to go off and do some long computation see if you're going to be calculating so long Fibonacci number or you're gonna be blocking on or something you know in the interactive Python interpreter you might as well drop the guilt but somebody else for a while and then you can go and grab again you needed so that's what these macros still and these are again very easy to use an extension models they're used all over in the Python source of anytime you could something that might take a while stop the bill you think gravedigger again so what's examples of the sense if you're gonna go to sleep obviously you don't need to go if going to read or write file that you can drop the gold it write socket you've indefinite article secretary take knows how but sharing the legal CPU-bound and in now the Gill
didn't change like set for all very long time and in 2009 David Beasley gave a presentation at Chicago area Python user group in easily a computer researcher loves Python and is very interested in legal he's played with lot and he discovered some things that were kind offer so 1st of all but when you have multiple threads that are trying to use the guilt there is an internal thing in Python I should put on the screen is not there it's called the cis . cec set check interval insists that gets check interval and this is number that's set to 100 and what that says is every 100 by codes the currently running thread is supposed to say OK but something else have it that is more so and here is a diagram showing 2 threads running at the same time they're both CPU-bound they both want to use the go all the time they can and you can see that where the that 66 thousand text this is 667 times longer than was ever supposed to be this chapter were responsibility to to to to to to digitize title fight and running for a very long time so people are listening supposed but it gets worse if you have 2 threads and 1 of
them as I O-bound and the other 1 CPU bound what you want is the CPU that the thread doesn't controversy very often a dozen run for very long but the little work and then wait times so the meant that will work in which you will let that thing 1 whenever it's ready to run so he was CPU-bound thread and I wouldn't trade in the same process you want preferred the I for here the CPU-bound thread is getting all the time the island striking evidence derived this is what's called priority inversion in the world of every assistance into words and Python having a really bad when the problem is this code that's supposed to be
releasing the Gill and letting other people have a chance to run so this
is but what it does is this pi thread states what they that's this macro that we saw before this time also allow beginthread it's called and threatening inference so this is releasing the goal here then we other things can run out and then the median next thing we do is acquire lock soul was really happening is if we have 2 threads and this 1 is you have to go right now and this 1 wants that he is saying is that in order to you know the logic this guy never gets a chance to get the deal and it's worse if you CPU-bound never has a chance and if he is I about that he's never got a check so this by the way is is still what Python 2 7 is like this I find it was
fixed in Python trade in 2009 by and want to prove here what's called the new Deal with is not only a minor change the guilt on it added a new variable called still got drop request which is something called condition variable in fact this is a fly that if the 2nd guys trying to grab the girl and he's not getting it he sets the slides as look there's somebody waiting you really have to give it up and the 1st guy who releases that uses the looks licenses all I really have to back off a lot of the people so with this change in place the really bad behavior that babies saying is fixed there still funny conditions that you can arrive at where and you can still threads of 1st CPU time and I'm never going to but it's a lot less bad now and affects those really funny conditions would make we will require mechanical lot more complicated but and what we're really talking about at this point is writing schedule and i'll in a little bit about competences research but I can tell you right is that was very complicated and the more fairy wanna make it harder problem becomes and this is really kind of graphic we don't wanna go down Python source so but the plan was unified go this way and see if it worked OK and basically it's been fine and we just 1 leave alone so this is the ability to settle in 3 who and above think no meanwhile while
we have made the intentional this the world has kind of changed around so I remind you Python itself was written in 2009 19 nineties originally
created in 1990 and Moldova was that in mind to I think now you see multiple utility multiple CPU's in a computer very often that you have to actually go and get a 2nd CPU would have both of them on the motherboard I had a computer like that in 1995 and 6 I had to Pentium 133 is in 1 single computer but I was kind of weird you really see it prevalent until you have multiple cores on a single CPU and you see that until about 2005 that's servicing views and thus helps use actually see views used in game consoles to home those all multi-core 2005 natural really seeing a lot of in our multi-core use program laptops themselves with thought of multi-core in 2007 tablets and phones
and systems on there embedded in very small projects ozone the core in about 2011 eyeglasses when multi-core in 2013 watches when will be gone 2014 LaserJet
and eyeglasses and wristwatches in a multicore we live in a very hectic or world and we still
have a solution for running Python on multiple cores simultaneously now we'll just
talk about this he wrote a blog post back and doesn't seventies said but he said by the way Python 3 K. that's the old name for Python 3 on he said I'm looking at a set of patterns in the predicate only in the performance for a single threaded program and for multithreaded but I O-bound program does not decrease this is a tall order it's been almost 8 years nobody has done an we're not sure how to do people tried in the past there was a famous
patch back in the Python 1 of 4 days called the free trading patch but what it did it didn't require change in CAP just good but it took all those global variables like the pointer to the current frame and accept them all into 1 single day but are a struct excuse me structure is a roughly equal to a Python class so now you have more than 1 of them so he created a 1 per thread and evidence stamp on each other and then he added a single file locker mutual exclusion walk around in graph that so you have to call this lock in order to do in in graph adapt and so you would grab it do your customized releases this added so much or whatever performance is terrible was about to between 4 and sometimes law and this is result based on David easily revises this actually 10 years later a couple years ago at
random and on the true and conference today on he tried something using atomic tests set some modern computers actually have a machine language instructions that is a single instruction that says subtract 1 from this value over here so you remember those 3 instructions low decrement and store the commands it was single instruction which it guarantees will happen atomically you'll never have any problems of races so that's good but it doesn't require any API changes is also but it makes a 30 % loss so that it doesn't need the body leader was talking about now here's something considered there are for the Python interpreter is in the world the C Python and then there's everybody else C Python has a guild everybody else does see
python uses reference counting everybody else that's what the other people use use something called garbage collection markets recovered collection you can if you if you have a a lot of garbage collection you don't need the Gill nearly as much it's very easy to say OK we can get around on type I actually has a little bit of a guild that they just use string garbage collection cycles they say it wouldn't be that you know it the kind of a pain to get rid of that but it's not impossible is impossible don't songs were using reference so people say we should go to garbage collection with Python
the problem with that is that changes the
API we change so In order to talk to the Python interpreter you call see in order to deal with objects in the CAT you have to understand Python's memory management approach so see extra programmers have to you know in graph and that it we got rid of those and change to the garbage collection that is the API that makes every extension of that there are a lot of extensions for Python we don't want a break so I'm not sure that we can do this would be any slower would be faster on conventional wisdom or release told me by my Michael Ford by is that of garbage collection and reference counting or roughly the same but we would naturally until we get an a be a lot of work and nobody has been gutsy enough to try is something else to consider them so all the major languages that have come out since Python was invented like you know the JVM Java and CLR for C sharp all the rest and go all these things using garbage collection also all of them don't have seen the typewriter no superior you know why is that well the obvious
reason is that these languages are generally considered about as fast as C so the reason for writing this extension to speed things up and they all have the ability to call out into a C library and so on but maybe they think that well you just don't need it you know you can talk to C library and you don't need the optimization of an extension so we don't need see it but o thing to consider is that like I just said have a CPI means exposing your memory management model the world which means that now your hands are tied to the change international model you break everybody's extensions if they don't expose the memory management model for the world they are not free to changing internal type I started out with a simple mark-and-sweep I think he can correct but it start out with some mark-and-sweep and over time became generational and they came in incremental collectors and Arman told me that the changed incremental would broken antibodies code machines generational probably would if they had exposes CPI they wouldn't and free to make those changes and pipe I wouldn't have the better man memory manager that it does so if see Python switched to garbage collection again
to break every out there and if we made improvements will later we might break everybody again so in my opinion and I think that if we went the round of trying to
change to a garbage collection we should probably give up on having a CAT I began to break everybody's sentence and we don't fix them again and said we say we're a extensions in Python and UCF of which by the way is wonderful because then that want to run on type I and also Ji found in IronPython talking about and see if I support so this would mean that you're extensions were now portable across Python implementations I think it's a little for political reasons the only thing that we can really talk about atomic tests set and even with 30 % speed loss but I think that the pressure for supporting the core is going to get big enough that we really don't have to look at doing this a said such that each
coffee break this started so if you're if you Jones in for a cup of coffee or you can take off if you have questions I'm happy to answer questions for a couple minutes until they take if somebody is holding up their end up on the on the and that but 1st of all
thank you very much for this awesome talk and so you see what 1 of the main problem with the garbage collector EC extensions but what if somehow mark the cold as your Python code that doesn't interact and this extensions and there is again with those objects you can you to garbage collection and somehow mark that the cold that interacts with the C extensions and their use your Atomique increments agreements because like there is a lot of pure Python code out there the only
1 that when it is garbage collector and there python code that runs in Python doesn't care about whether as a garbage collector or whether it's a reference so I kind of didn't understand a question material after clarifying but I'll point out to you that the Python has reference counting on all the other presentations use their reflection and your code still runs either way so it doesn't matter so I'm not sure I'm answering question and imaginative at your Python program that dozens rectilinear and C extensions what prevents having a garbage collector there's nothing you can not because you can run under diphone Orion type II knows how periodic actually don't have non you what went on to implement it wouldn't surprise just when not implemented within the CASE 501 going survivor because that makes all the extensions and people use fact that all the time year and that intended to provide a data
point of this this time to reply so result systems of 1 . implemented something called ironclad which was an implementation of the Python C API for Python and I'm Python doesn't have a kill it doesn't use reference count but all of that we maintain binary compatibility with the existing 1 with existing binary with windows and people could basic basically can't compiler extensions that was all you have a those existing binaries you have see objects effectively Python objects implemented in C that expects to use reference counting and and so on we have a hybrid system we also objects that were returned from this expansion we artificially inflated the reference counting by 1 so that the the macros compiled into the binary would never be triggered by getting down to 0 and then we have a proxy object that's if garbage collection was entered for this object then we would and and then we will try to reference can account for the we would decrement the reference counts as 0 I'm technically we have only considered because if you passing references to Python objects the to this expansion C extension could keep references to those aligned amount was essentially what Larry incentives and if you move to something like mark-and-sweep to the main Python C interpreter those see objects are opaque to the garbage collector it can't know what internal references you have that's that's kind of what you're saying is is no and unless you change the the rest so high that actually supports garbage collection C
Python does support reflection but it only used a very small weights used to break up reference count cycles and most objects don't bother to implement so if you had an object created the extension might have references to other objects and you have no visibility inside of it but the the world that he lived in defined patterns different where they running time the CLR and the art of every in the C runtime environment we really know nothing about the memory that you know what I mean in practice we have no memory leaks that we could find from objects from C extensions keeping other objects alive all those objects but dying that this extension but that was only in practice it seemed like it works you kind of want your system to be theoretically type not just working by accident most of the time the
I the the ensign Microseeds nobody seems possible that threats think that the Gillies free million and then something similar happens that they're they're they're like objects are
provided by the operating system and there's very so 1 1 regrets the Pollock and the operating and a very good job of only 1 along personality that it's not fast and it depends on the system actually like Linux has what they call the future x I think of on the Python they use the taxes on Linux so that is very fast depends on the operating system somewhat actually result but we live in 2015 I think all the fastest hi uh what it thinks is the
visibility you all have in 5 from clone interpreter that breaks the CAP I and you use it when extensions have caught up so are you talking about 14
the Python interpreter and going to our for that yes certainly you would that's possible I'll point out to you that we in 2015 and C Python 3 . 0 came out in what 2008 and there are a lot of the sentences still haven't caught up here so people are very slow to adjust to changes in the API and and I'm worried that the change to garbage collection would be even worse than the change from Python 2 to Python 3 so so I'm not optimistic about making a fork of type that has your garbage collection and every single I wanna switch over to that and really taking an at some point that you make so many changes it is recognizable Python anymore which the pipeline as as it has been doing for a long time and were mostly OK I think everybody wants to coffee thank you
Verzweigungspunkt
Ideal <Mathematik>
Auswahlaxiom
Computeranimation
Bruchrechnung
Wort <Informatik>
Physikalisches System
Bildschirmsymbol
Baum <Mathematik>
Computeranimation
Internetworking
Übergang
Prozess <Physik>
Rahmenproblem
Gemeinsamer Speicher
Ausnahmebehandlung
Computeranimation
Objekt <Kategorie>
Methodenbank
Multiplikation
Erwartungswert
Existenzsatz
Netzbetriebssystem
Bildschirmfenster
Thread
Zeiger <Informatik>
Baum <Mathematik>
Attributierte Grammatik
Aggregatzustand
Objekt <Kategorie>
Interpretierer
Datenfeld
Graph
Rechter Winkel
Ganze Zahl
Festspeicher
Datentyp
Zahlenbereich
Rechenzeit
Physikalisches System
Zeiger <Informatik>
Zählen
Baum <Mathematik>
Computeranimation
Punkt
Graph
Assembler
Compiler
Systemaufruf
Zählen
Computeranimation
Eins
Übergang
Objekt <Kategorie>
Thread
Substitution
Makrobefehl
Resultante
Assembler
Graph
Zählen
Zentraleinheit
Systemaufruf
Computeranimation
Objekt <Kategorie>
Menge
Last
Konditionszahl
Thread
Speicher <Informatik>
Chi-Quadrat-Verteilung
Resultante
Zahlenbereich
Physikalisches System
Computer
Systemaufruf
Computeranimation
Objekt <Kategorie>
Leck
Festspeicher
Mustersprache
Inverses Problem
Tropfen
Baum <Mathematik>
Leistung <Physik>
Analysis
Einfügungsdämpfung
Rahmenproblem
Gruppenkeim
Rechenzeit
Zeiger <Informatik>
Optimierung
Ordnung <Mathematik>
Computeranimation
Verklemmung
Knotenmenge
Datennetz
Flächeninhalt
Konditionszahl
Thread
p-Block
Optimierung
Ordnung <Mathematik>
Computeranimation
Logik höherer Stufe
Arithmetisches Mittel
Web Site
Datentyp
Prozess <Physik>
Dokumentenserver
Statistische Analyse
Interpretierer
Bitrate
Computeranimation
Schreiben <Datenverarbeitung>
Interaktives Fernsehen
Computerunterstütztes Verfahren
Code
Computeranimation
Informationsmodellierung
Fibonacci-Folge
Endlicher Graph
Byte-Code
Thread
Maßerweiterung
Optimierung
Ganze Funktion
Soundverarbeitung
Interpretierer
Datentyp
Schlussregel
Interpretierer
Quellcode
p-Block
Elektronische Publikation
Modul
Objekt <Kategorie>
Mereologie
Wort <Informatik>
Socket
Ordnung <Mathematik>
Makrobefehl
Mathematisierung
Gruppenkeim
Zahlenbereich
Kombinatorische Gruppentheorie
Computeranimation
Metropolitan area network
Diagramm
Flächeninhalt
Informatiker
Digitalisierer
Endogene Variable
Codierung
Thread
PCMCIA
Chi-Quadrat-Verteilung
Touchscreen
Prozess <Physik>
Regulärer Ausdruck
Notepad-Computer
Wort <Informatik>
Thread
Umkehrung <Mathematik>
Interpretierer
Zentraleinheit
Ausgleichsrechnung
Code
Computeranimation
Tropfen
Bit
Punkt
Inferenz <Künstliche Intelligenz>
Mathematisierung
Automatische Handlungsplanung
Aggregatzustand
Interpretierer
Quellcode
Zentraleinheit
Medianwert
Mathematische Logik
Computeranimation
RFID
Rechenschieber
Scheduling
Variable
Konditionszahl
Statistische Analyse
Thread
Ordnung <Mathematik>
Tropfen
Makrobefehl
Server
Sichtenkonzept
Spielkonsole
Softwarewerkzeug
Computer
Hauptplatine
Zentraleinheit
Mehrkernprozessor
Computeranimation
Multiplikation
Spieltheorie
Notebook-Computer
Tablet PC
Speicherabzug
Optimierung
Server
Multiplikation
Spielkonsole
Notebook-Computer
Speicherabzug
Projektive Ebene
Physikalisches System
Computeranimation
Resultante
Web log
Freeware
Klasse <Mathematik>
Mathematisierung
Gesetz <Physik>
Computeranimation
Variable
Mustersprache
Thread
Zeiger <Informatik>
Datenstruktur
Optimierung
Inklusion <Mathematik>
Graph
Wechselseitiger Ausschluss
Einfache Genauigkeit
Elektronische Publikation
Kugelkappe
Einfache Genauigkeit
Prädikat <Logik>
Patch <Software>
Menge
Zustandsdichte
Ordnung <Mathematik>
Softwaretest
Interpretierer
Einfügungsdämpfung
Bit
Mathematisierung
Computerunterstütztes Verfahren
Maschinensprache
Computeranimation
Datentyp
Dreiecksfreier Graph
Speicher <Informatik>
Speicherbereinigung
Zeichenkette
Objekt <Kategorie>
Interpretierer
Programmiergerät
Applet
Formale Sprache
Kontrollstruktur
Speicherverwaltung
Computerunterstützte Übersetzung
Ordnung <Mathematik>
Speicherbereinigung
Zählen
Maßerweiterung
Computeranimation
Minimierung
Formale Sprache
Mathematisierung
Unrundheit
Computeranimation
Virtuelle Maschine
Informationsmodellierung
Datentyp
Programmbibliothek
Speicherverwaltung
Speicherbereinigung
Maßerweiterung
Baum <Mathematik>
Metropolitan area network
Inklusion <Mathematik>
Softwaretest
Einfügungsdämpfung
Mathematisierung
Implementierung
ROM <Informatik>
Computeranimation
Druckverlauf
Datentyp
Vorlesung/Konferenz
Speicherabzug
Speicherbereinigung
Computerunterstützte Übersetzung
Maßerweiterung
Speicherverwaltung
Objekt <Kategorie>
Interaktives Fernsehen
Kontrollstruktur
Vorlesung/Konferenz
Speicherbereinigung
Maßerweiterung
Baum <Mathematik>
Code
Proxy Server
Interpretierer
Punkt
Spiegelung <Mathematik>
Compiler
REST <Informatik>
Implementierung
Physikalisches System
Kombinatorische Gruppentheorie
Zählen
Binärcode
Code
Computeranimation
Objekt <Kategorie>
Binärdaten
Bildschirmfenster
Datentyp
Vorlesung/Konferenz
Wärmeausdehnung
Maßerweiterung
Optimierung
Speicherbereinigung
Makrobefehl
Baum <Mathematik>
Objekt <Kategorie>
Leck
Spiegelung <Mathematik>
Gewicht <Mathematik>
Festspeicher
Datentyp
Dreiecksfreier Graph
Mustersprache
Laufzeitsystem
Vorlesung/Konferenz
Physikalisches System
Maßerweiterung
Zählen
Baum <Mathematik>
Computeranimation
Interpretierer
Nichtlinearer Operator
Prozess <Informatik>
Netzbetriebssystem
Vorlesung/Konferenz
Physikalisches System
Maßerweiterung
Baum <Mathematik>
Computeranimation
Kugelkappe
Interpretierer
Punkt
Datentyp
Mathematisierung
Speicherbereinigung
Baum <Mathematik>

Metadaten

Formale Metadaten

Titel Python's Infamous GIL
Serientitel EuroPython 2015
Teil 67
Anzahl der Teile 173
Autor Hastings, Larry
Lizenz CC-Namensnennung - keine kommerzielle Nutzung - Weitergabe unter gleichen Bedingungen 3.0 Unported:
Sie dürfen das Werk bzw. den Inhalt zu jedem legalen und nicht-kommerziellen Zweck nutzen, verändern und in unveränderter oder veränderter Form vervielfältigen, verbreiten und öffentlich zugänglich machen, sofern Sie den Namen des Autors/Rechteinhabers in der von ihm festgelegten Weise nennen und das Werk bzw. diesen Inhalt auch in veränderter Form nur unter den Bedingungen dieser Lizenz weitergeben
DOI 10.5446/20150
Herausgeber EuroPython
Erscheinungsjahr 2015
Sprache Englisch
Produktionsort Bilbao, Euskadi, Spain

Technische Metadaten

Dauer 28:58

Inhaltliche Metadaten

Fachgebiet Informatik
Abstract Larry Hastings - Python's Infamous GIL You've heard about Python's GIL. But what is it really? What does it do, both good and bad? Come learn all about the Python GIL. You'll learn about its history, all the problems it solves, all the problems it causes (that we know about!), and what it would take to remove the GIL. Attendees should be familiar with the terrors inherent in multithreaded programming, and be comfortable with a little C code in the slides.
Schlagwörter EuroPython Conference
EP 2015
EuroPython 2015

Ähnliche Filme

Loading...