Merken

Implementing Parallel Programming Design Patterns using EFL for Python

Zitierlink des Filmsegments
Embed Code

Automatisierte Medienanalyse

Beta
Erkannte Entitäten
Sprachtranskript
a solution Ammonium it leaves them look a monarch speaker from the ground we will be talking about designing in Python akin to freeze In this he said it was in this presentation is about our research and development project that we have in in working with the the the also with the students free our laboratories and also on a 3rd partner in the are if escape the gender of the same presentation will be the motivation of all the idea of the embedded flexible language our objective the programming model of the effective execution model the implementation of all the same idea how and then the focus of this lecture is how we can implement power design patterns in the affairs conclusions are far from then the modulation you know we know that we are and we have an atherogenic the AI you which is Gennady of incompatibility of programming the barrel programming platforms they MPI open and the Python threads vitamin a multiprocessing etc. There is a need to to make it easier to program parallel systems for a common approach which will free programmers for platforms in the technical intricacies our objectives were and continue to be a major objective has been to develop a straightforward language which implements that common approach and allows implicit instead of explicit parallel programming making it easier for the programmer to program policies these should allow flexible computation that path and we will talk about it in which sequential and parallel executions produce identical deterministic results it doesn't matter if we run the same programs sequentially or in parallel it we have ensure that values the result values will be the same they're they're rhymed execution is completely deterministic to facilitate these other deterministic prior programming tool has been the developed and his name is embedded flexible language for the programming model of the if the suppose we have a program a sequential program and we decided that to to have a better the performance we we want to parallelize the call then in those parts of the program and wants to In the finalized Dr. that parts of the code we add it we embed blocks of the affair let you see here in the the in the slide on the sequential parts of the program of freedom in the host language maybe Python maybe see maybe any aid in programming language the parts of the program which are to be executed in parallel are written as the different embedded goal the difference that's the CA-style why because we wanted something universal that the same embedded language could be used for any language on the most wisely is used seems that in programming is the style that because of that we decided that the efficiency index will be sees that on the host language independent to the university the
semantics of the if there is a terministic like in functional programming the memory management we keep to the to the host language implemented by translating embedded in different blocks semantics is implemented but by translating into a minute here photographs of code into the parallel code of the host language then what is the
the principles of the programming model of the effect to ensure that the mean is the station 1st the programmer should call pure functions functions that don't don't have side effects ensuring their functional programming concept of references transparency viable used inside here for blocks maybe of the 2 kinds of only in or hours but not in our values that we can really only from them all right all for of them things to them but not balls on the mountain very important concept of one's all the assignment that is connected to the principle of that variables may be only in or out then the execution model of the effect the key aspect of the different execution model is that parallel and or sequential institution those of the program execution is that the program that is everything according to the different programming model we use the term in stick identical about and because of that the flexibility of also execution we call our execution model flexible computation
then we will now we try to to understand why they we need once all the assignments if you see here it is called example is that we in each other's needs and wife with 1 and 3 and here the block of the the effects that we have 3 lines here it's it's received the value of f of x y value of f of B and each sequence it's Peru's if of use the information and we execute these called sequentially you in the line 1 after aligned to the cost of the line length 3 that there the final in values of x and y are at the exists if rules of seen and why is forbade but In a parallel execution that every line can be can be executed in any order with the and then they or in the or the is 3 to what we have a completely different values than in the sequential institution then allowing it to be in and also our leads to undeterministic results is if we're so if we don't allow it in our out all and only in or out of the same code will be written in this way that excuse only and I would be a valuable also sent out valuable and then the sequential execution also this Parliament execution any part execution will use exactly the same value is once all the assignments prevents the undeterministic results that we have in the in the in the in you not only non here from cold then how
we implement our idea of the of the offense the precompiler of would it is let's let's see here don't use the view of the implement that he writes this syntax and semantics of the effect we use that as a tool that the score jobless CC General compiler-compiler the Java compiler-compiler according to the syntax semantics with we generate the creator a from specific different precompiler and you know I would have thought precompilers and we will talk about them in in in in and 5 in the late the late tho it later in his life and the programmers you he writes and the effect based host language services that the is code is translated by the precompiler were paralyze language called and then the host language runtime platform right Orion's that paralyzed it's called they you see that the our approach is that if we have a specific precompiler of fail we can right with your in any language but I implementations and you know 4 by then we implemented in the the precompiler for the multiprocessing module of to they whatever the characteristic here that the pull upwards of objects that collection of fix number child processes that the number of Chinese process defaults to the number of course in the computer the porn object mechanism serves of the scheduler of that it is parallel execution on inside there is this a Python module we have they clean them up from functionality that we will see in later the importance of that functionality the course module was modified by allowing unlimited hierarchy of non-diamond processes because the original title generates all the diamond process and that constrains the hierarchy or the nesting of parallelism and that the poem based scheduling management these in the the element that allows us to In manage all of their their the scheduling of the patent execution they are the implementation the
2nd implementations and MPI there's a version that is based on a module that was developed at the University of Monterrey that is called the that these are an element inside have a package of evolutionary algorithms that they didn't know that this could be beginnings a Python modular written using the MPI for Python module he said earlier on Over the MPI for BPM allows the efficient implicit parallel programming in a similar level of abstraction as that that we have that we get a very good debate multiprocessing Python even they syntax in the D N is very similar to the C. index in the multiprocessing was also indeed and we have a map function and and the number of child processes before it's here to the number of course in the computer cluster that we around the MPI scheduling mechanism also is beauty in being the BPM now we will focus on how we implement this policy design patterns in the affairs and we will talk about the implementation also they form joint by pattern and those are the constants in the affair that allows the implementation of the spot the master worker about with the default not patterns with all as we have a year 3 alternative model of my group look for the regular spot them and the field and will yours so a construct that may be very useful but it's not connected to any in specific about they if you look then the data for form a joint in a pattern In maybe the part
of you know what is that they the drawing we have here a program and the analysis of sequential contraflow here the use of force that generates child task and feel all the tasks in not finished the program where it's the different tyres professor waits until all of finished and then each joins all their results policy of results of the computation of all the child task and then it continues its sequential is equal for flow then In the
1st day of the year for constructive allow us very easily to to to implement the idea of the form a joint in other is the assignment in the assignment below we have M assignments that all the right hand side of the assignments are executed in parallel when all the there this child task finish the job there In all the the value of the variables receive the value and then the program continues after the end of the rule of the of can we have to live examples the 1st example of my value while he was 5 my value to it was if 5 8 we decided that these data in an assignment blog we have these kind of assignment of simply of value this assignment will not generate a child task it's a waste of time that these kind of assignment will be will be executed sequentially like in any other sequentially probe it and and here because we have at all to what function years these these quantities executed in about here we have an l example of according to computing-intensive functions in this case both are running parallel both generate a child task and when both in theory we that my violate it 1 and my my vote to receive their values and then the product of the another hand option to
tool this is the 4th joint is that if we if we have here at the end like in Seattle on like you in by the as if it's the all the Boolean expressions are executed in violation of of the 1st ones sequential that these 2 rules at the time of lounges where the the the body of the of the options but there may
be a problem with the beef is safe we have a case like this and a is settled these may you may provoke a divide by 0 exception the that problem of the all the danger of the belief is that if the programmer is not the 1 of the 1 of the options here that all already executed in parallel may provoke an exception must
working we implement the master work of out with the for columns and the 4 aphorical looks like a regular flaw in C. right but every instance of the of body of the for these is executed in Part I suppose we have m of processes or all of them put it in forest in the system when n greater than and this kid willing it built into the polar molecules a n is the number of all the tasks that are generated and indeed for small use of module of processing and in the task manager of the D. N. they they allow implicitly the implementation of the Master Worker pattern then in in every moment we will have M processes running on all the others are waiting to be executed if n equals m that the the bottom is actually a 4 for a joint that is implemented also by the foreign bonds laugh at
the you know well the idea of the market is that we have an input sequence may be at least maybe at the top of maybe I'm not ready in other languages of a of length n we've we have a function that is applied over all the end of the elements of the in the input sequence and then the demand generates output sequence exactly of the same length about them and its elements are the result of applying the function of the corresponding element of the input the sequence of that here we have the the scene that of the MAP MAP group receives a function and then in the input sequence they are
not construct with a completely different it kind of execution is that implements also the amount pattern is the slope of in the low block we have here a label that is like the name of a function and here there is are the recasting of a call to the label and then recursively block generates in instances of calling the CPU-intensive function it according to them to the value of life then also here we will have n processes and tasks that are you know if you run in parallel but the the launching is like recalcitrant now we we
see here how actually they they useful because you know warps if we have saying that here a program that receives a list of numbers I will return to the square root of every 1 of those numbers then the bottom-up function that receives the input sequence was generated uh an output sequence that is simply it the result of the market on 16 but think it should be 6 notes occur in here in it this said and then in MAP MAP fun and then the result of spring that on the is program ends implicitly you know you see In here we have are analyzed the the calling of the encoding of the map map from as how did he
looks after the translation with the precompiler these this example is with the multiprocessing aiming at precompiler you see here we have the bottom of here the origi nal for broke starts then are an object so far out of a pool of forward fully non-diamond molecule is is created a manager of multiprocessing escape that at q of manager is generated and then he had a from the pool of the map a synchronous method called with the amount fire on data in the input the input sequence of that and here mapped out we'll after all the it is after all they is tasks were allowed to then we thought we begin the the they get methods that waits until all the subtasks are only an hour and then map out receives a the they out sequence and then here we close the ball and we we joined all of the the subtasks that that were created and return map out you see the problem doesn't have to deal with all these complexes code of multiprocessing here
very simply like sequential programming in a program right
OK radio spots average In for reduced by
that he works that you see here in this in this slide we have an input sequence on those from that function should be on a an associate the function that like class were multiplied and then every tool elements are in to the function here and here and then there's the results we have a and temporary in sequence of the results of the 1st level and then every 1 of every every couple using these past to the function and again and be you we receive the reduced value the this is the result of all the the deals and for that we have a constraint that is called lobe lobe it receives the input sequence and inverse . associative functions that must be in needs to receive 2 parameters to be able to do what would you see here in these in the sense that picture then
it here here we have a very valuable audience some of the local loop that in the questions if you would like to be found we found that it underlies the the algorithm now here
you have they are an example of we have our our list of numbers and we the our they are the main focus of this in class of the integers of Don when close to local with then on the that are the of being and what happens in the running want to most from it for those who want to right 3 it was 4 7 etc. and then in the other around 3 and 7 standard 11 and 15 26 and then we have the receptor that way the local loop works but
we can it yours they are the possibilities that the class or the art of this training flowers and then so we we kind will review it with a every every kind of London this thing on
the part of the field of about
it is implemented using the man in it is it uses the map function that is in it essentially so users are Boolean functions not In every element that is the William factions remains the same element on others that defines the Boolean function is not true the the map function we them now and then the result of the mapped out we'll be all the places In this sequence where the William function is the city passed to the output and all the others are American and then you see after the the year for the blog we have a list comprehension that gets rid of all of the elements in a map out there are 9 and then in stick out we have only those that are true for the William the Boolean function that way we we may implement the the field there part using using a different and these
blogs is like a sequential in sequential it is that every in this case instead of being In this case every Boolean expression is evaluated sequentially and the first one that is through the body is executed but all the year for a blog is executed it in parallel with all this in the the probe then now
we will see a to different programming exam the 1st using assignment block and if and you see here that in the 1st block we have a and b that our 4 . our out body of that we'll have data the result of F on it and the the result of the but often G on then we go out from that block and then we in the next block we can use it as a and B as in value and then in in the in the in the 2nd row we it we can operate from early on from B because of the 2nd block a and B are in the variables and not out of the 2nd
example that also in it shows how we can very easily implement the nesting patterns in next thing is that we we have there are only I'm sorry
we we have In the child task and every child every child does also so we lounge policy we have here a rates of 2 would be links with a vector in in the main function we started with the fall inside a year for the block by it by the rows and every role is the sparse to more to you make also in the product between every every element of the wrong with the it with the element that I really got hoarding elements in the vector and then you we see that uh we
say that we have a nesting of instances of the master of the water bottle when In in May the 4 rules up on the roles of the matrix and in the 2nd in the nested 1 area it is in the up on the items of the of the world
conclusions do we have further precompilers would implemented safe and efficient parallelism has been made possible by the framework and parallel design patterns have been shown to be implementable using effect we need a in
the electron into Department of our college to students being these clusters of 64 prosperity by processes and we after we go back to we will try to in this yeah 1st scalability with that 64 mastery bicluster that in every 1 of them running the MPI the notion of of the effect father war we are developing a new physical requirements to the child to implement serial and parallel algorithms flexible algorithms with different also we will we will want to implementing concurrent data structures using the effect also we want to do it and so the question our purely functional functional data structures compact and also with the Internet giant brought project with Professor of newest laptop of each from Serbia we are rewriting an algorithm for if predicting structure of proteins that is called the exam using the effect and using softer transactional memory on the
invitation liking the lightning talks here we invite you to join us to collaborate with us to redesign the affair with vitamin like syntax and then they make happy or the crowd here in the in the vitamin conference that we have our our new friend regression that is completely purely by agreement also we have you what we want to implement new versions of the different precompilers for other parallel programming platforms and other host programming language and also implemented all the the the basic 80 in a chemical warfare parallel design patterns using it fairly on the but a week we also have to to answer the question are there are at the patterns that cannot be implemented within the framework maybe we have to research the then to the a I where a lower Corey is the FlexCom love you the website your inability to enter the website and download the the installation keep of the effect of the fact in the laboratory middle that the beyond here in the audience you don't over reference translation in and of the human Interactive from the electronics department that the students feel that that cluster of of this and also our students part of them already going away and if you use a lot of the material was nearly the amount of money they are developing their MPI Our finishing the result in the limit the a version of of the the combined and amino problems from the Novi Sad university so where research European research priority and here you have the picture of companies deliver academic center in that is also called Jerusalem on it but I think you
worry much huh questions that you just referred for a few questions of questions nobody wants to collaborates with us in our project but if it yes so I was wondering if I ever use see but it seems like a hardware description language might be a better syntax for the if you felt parts I'm during any use of like more a hardware description language or EGG just you see because that's more familiar to computer programmers so we have enough he offended especially our friends shares that was that was very it was not easy to to program in that explicitly that with the parliament a tools that are in Python or in other languages than if we if we design later all over there this this is part of the tool of the specific language we'll we'll is we make it it easier for the programmer to program and the and we can they ask if it the the code generated by the compiler will be ask in efficient and that that if we could write the by have that is the same question that can in the In the end of the nineteen sixties when people are there in operating systems in the Ricci on family and the in the laboratory is the level of the C language and they argue that we can implement an optical system in a high-level language and I these what we have days to that nobody writes an operating system assembly and also here we we would like to you they allow everybody to write panel called very easily and then it will penalize all the computing power that we we have now removed for and clusters of 3 of 4 computers by my the answer I answered your question OK study of question yes but I think what understood the there's already some sort of focal points among module in some in some that the origin or are you going to start from scratch implement the uniform was a constant the we we will not we we can consider that idea but our idea is in at least in my now tool to have are a language that is embedded in the host language and he'd users on the the platform the possibilities of cake maybe that in the future we will think about it a it transforming if offending item model that is what you are asking right in for will be as a module in by III and we may we may think about that but because what what I said in the beginning and our idea is to have a universal solution for parallel programming anyway in any language but we can think about the possibility that the effect will be module for 5 so we have time for 1 more question if there are no no more questions so please so that in our speaker and you want to after the lecture to to talk with me please
Resultante
Programmiergerät
Subtraktion
Mereologie
Freeware
t-Test
Implementierung
Computerunterstütztes Verfahren
Kombinatorische Gruppentheorie
Systemplattform
Code
Computeranimation
Informationsmodellierung
Parallelrechner
Code
Natürliche Sprache
Maskierung <Informatik>
Determiniertheit <Informatik>
Programmierparadigma
Thread
Softwareentwickler
Optimierung
Grundraum
Tonnelierter Raum
Leistung <Physik>
Folge <Mathematik>
Programmiersprache
Soundverarbeitung
Datenmodell
Entwurfsmuster
Systemaufruf
p-Block
Physikalisches System
Optimierung
Natürliche Sprache
Fokalpunkt
Rechenschieber
Objekt <Kategorie>
Automatische Indexierung
Geschlecht <Mathematik>
Parallelrechner
Mereologie
Projektive Ebene
Nichtunterscheidbarkeit
Unterring
Folge <Mathematik>
Subtraktion
Programmiergerät
Determiniertheit <Informatik>
Computerunterstütztes Verfahren
Term
Code
Computeranimation
Formale Semantik
Eins
Informationsmodellierung
Variable
Parallelrechner
Digitale Photographie
Code
Natürliche Sprache
Arbeitsplatzcomputer
Nichtunterscheidbarkeit
Kommutativgesetz
Programmierparadigma
Ordnung <Mathematik>
Optimierung
Folge <Mathematik>
Soundverarbeitung
Lineares Funktional
Datenmodell
Systemaufruf
Magnetooptischer Speicher
p-Block
Lineares Funktional
Optimierung
Natürliche Sprache
Variable
Arithmetisches Mittel
Funktion <Mathematik>
ATM
Parallelrechner
Programmiergerät
Nichtunterscheidbarkeit
Speicherverwaltung
p-Block
Funktionale Programmiersprache
Speicherverwaltung
Resultante
Programmiergerät
Reihenfolgeproblem
Prozess <Physik>
Applet
Datenmanagement
Computer
Element <Mathematik>
Computer
Computeranimation
Formale Semantik
Datenmanagement
Mapping <Computergraphik>
Default
Gerade
Folge <Mathematik>
Kraftfahrzeugmechatroniker
Lineares Funktional
Dicke
Präprozessor
Sichtenkonzept
Prozess <Informatik>
p-Block
Natürliche Sprache
Mechanismus-Design-Theorie
Scheduling
Rhombus <Mathematik>
Dienst <Informatik>
Hierarchische Struktur
Funktion <Mathematik>
Scheduling
Information
Charakteristisches Polynom
Ordnung <Mathematik>
Folge <Mathematik>
Hierarchische Struktur
Zahlenbereich
Implementierung
Systemplattform
Code
Parallelrechner
Modul
Implementierung
Soundverarbeitung
Videospiel
Default
Dämon <Informatik>
Datenmodell
Rechenzeit
Schlussregel
Modul
Sichtenkonzept
Objekt <Kategorie>
Mereologie
Compiler
Resultante
Prozess <Physik>
Gruppenkeim
Versionsverwaltung
Element <Mathematik>
Computerunterstütztes Verfahren
Abstraktionsebene
Computeranimation
Übergang
Mehrrechnersystem
Algorithmus
Mustersprache
Mapping <Computergraphik>
Kontrollfluss
Default
Folge <Mathematik>
Kraftfahrzeugmechatroniker
Lineares Funktional
Prozess <Informatik>
Abstraktionsebene
Entwurfsmuster
Ähnlichkeitsgeometrie
Digitalfilter
Optimierung
Mehrprozessorsystem
Mechanismus-Design-Theorie
Konstante
Mustersprache
Scheduling
Datenfeld
Forcing
Funktion <Mathematik>
Automatische Indexierung
Parallelrechner
Scheduling
p-Block
Versionsverwaltung
Folge <Mathematik>
Subtraktion
Implementierung
Zahlenbereich
Task
Informationsmodellierung
Bildschirmmaske
Task
Parallelrechner
Äußere Algebra eines Moduls
Ordnungsreduktion
Optimierung
Analysis
Modul
Implementierung
Algorithmus
Vererbungshierarchie
Default
Modul
Datenfluss
Konstruktor <Informatik>
Mapping <Computergraphik>
Loop
Mereologie
Compiler
Abstimmung <Frequenz>
Folge <Mathematik>
Web log
Regulärer Ausdruck
Physikalische Theorie
Computeranimation
Task
Variable
Bildschirmmaske
Arithmetischer Ausdruck
Task
Parallelrechner
Prozess <Informatik>
Code
Optimierung
Lineares Funktional
Schlussregel
Boolesche Algebra
Biprodukt
Variable
Konfiguration <Informatik>
Funktion <Mathematik>
Rechter Winkel
Parallelrechner
Boolesche Algebra
p-Block
Programmiergerät
Prozess <Physik>
Momentenproblem
Ausnahmebehandlung
Zahlenbereich
Implementierung
Computeranimation
Task
Physikalisches System
Task
Datenmanagement
Regulärer Graph
Code
Minimum
Mustersprache
Modul
Wald <Graphentheorie>
Ausnahmebehandlung
Physikalisches System
Modul
Teilbarkeit
Konfiguration <Informatik>
Mustersprache
Scheduling
Mereologie
Parallelrechner
Verbandstheorie
p-Block
Zentraleinheit
Polare
Instantiierung
Resultante
Lineares Funktional
Folge <Mathematik>
Dicke
Gruppenkeim
Digitalfilter
Element <Mathematik>
Ein-Ausgabe
Natürliche Sprache
Konstruktor <Informatik>
Computeranimation
Strukturierte Programmierung
Mapping <Computergraphik>
Mustersprache
Loop
Parallelrechner
Ordnungsreduktion
p-Block
Funktion <Mathematik>
Resultante
Quelle <Physik>
Folge <Mathematik>
Prozess <Physik>
Zahlenbereich
Warping
Rekursivität
Computeranimation
Task
Mailing-Liste
Iteration
Parallelrechner
Mustersprache
Mapping <Computergraphik>
Strebe
Wurzel <Mathematik>
Optimierung
Implementierung
Funktion <Mathematik>
Folge <Mathematik>
Videospiel
Lineares Funktional
Mathematisierung
Systemaufruf
Mailing-Liste
p-Block
Instantiierung
Ein-Ausgabe
Hochdruck
Mapping <Computergraphik>
Mustersprache
Quadratzahl
Loop
Zahlenbereich
Decodierung
p-Block
Innerer Punkt
Instantiierung
Folge <Mathematik>
Komplex <Algebra>
Code
Computeranimation
Task
Mailing-Liste
Datenmanagement
Maschinensprache
Maskierung <Informatik>
Minimum
Mapping <Computergraphik>
Translation <Mathematik>
Optimierung
Präprozessor
Mathematisierung
Ein-Ausgabe
Hochdruck
Mapping <Computergraphik>
Objekt <Kategorie>
Warteschlange
Mustersprache
Rechter Winkel
Zahlenbereich
Mehrprozessorsystem
Verbandstheorie
p-Block
Innerer Punkt
Resultante
Nebenbedingung
Folge <Mathematik>
Klasse <Mathematik>
Element <Mathematik>
Computeranimation
Übergang
Mailing-Liste
Mittelwert
Parallelrechner
Maschinensprache
Assoziativgesetz
Lineares Funktional
Parametersystem
Logarithmus
Inverse
Analytische Fortsetzung
Digitalfilter
Ein-Ausgabe
Hochdruck
Konstruktor <Informatik>
Rechenschieber
Mustersprache
Funktion <Mathematik>
Loop
Zahlenbereich
Präprozessor
p-Block
Innerer Punkt
Folge <Mathematik>
Rundung
Logarithmus
Klasse <Mathematik>
Zahlenbereich
Mathematisierung
Mailing-Liste
Fokalpunkt
Computeranimation
Spannweite <Stochastik>
Algorithmus
Funktion <Mathematik>
Ganze Zahl
Loop
Login
p-Block
Resultante
Lineares Funktional
Folge <Mathematik>
Wellenpaket
Web log
Logarithmus
Klasse <Mathematik>
Mailing-Liste
Digitalfilter
Element <Mathematik>
Hochdruck
Konstruktor <Informatik>
Computeranimation
Mapping <Computergraphik>
Mustersprache
Datenfeld
Parallelrechner
Loop
Ein-Ausgabe
Mereologie
Ordnungsbegriff
Strebe
Verbandstheorie
p-Block
Schaltfunktion
Metropolitan area network
Funktion <Mathematik>
Resultante
Subtraktion
Web log
Multiplikationssatz
Regulärer Ausdruck
p-Block
Boolesche Algebra
Variable
Computeranimation
Arithmetischer Ausdruck
Datensatz
Variable
Stochastische Matrix
Parallelrechner
Code
Parallelrechner
Optimierung
p-Block
Lineares Funktional
Skalierbarkeit
Matrizenrechnung
Element <Mathematik>
p-Block
Schwach besetzte Matrix
Biprodukt
Binder <Informatik>
Bitrate
Computeranimation
Task
Vektorrechner
Mustersprache
Datensatz
Loop
Mustersprache
Vektorrechner
Zentraleinheit
Soundverarbeitung
Präprozessor
Wasserdampftafel
Matrizenrechnung
Entwurfsmuster
Multiplikationssatz
Schlussregel
Framework <Informatik>
Variable
Computeranimation
Mustersprache
Framework <Informatik>
Flächeninhalt
Parallelrechner
Loop
Code
Parallelrechner
Vektorrechner
Compiler
p-Block
Instantiierung
Resultante
Paralleler Algorithmus
Prozess <Physik>
Sampler <Musikinstrument>
Skalierbarkeit
Versionsverwaltung
t-Test
Computeranimation
Internetworking
Algorithmus
Skalierbarkeit
Lineare Regression
Serielle Schnittstelle
Mustersprache
Anwendungsspezifischer Prozessor
Translation <Mathematik>
Lineares Funktional
Präprozessor
Entwurfsmuster
Prognostik
Optimierung
Gruppenkeim
Framework <Informatik>
Datenstruktur
Kompakter Raum
Festspeicher
Parallelrechner
Projektive Ebene
Versionsverwaltung
Zentraleinheit
Telekommunikation
Web Site
Subtraktion
Interaktives Fernsehen
Systemplattform
Framework <Informatik>
Parallelrechner
Notebook-Computer
Inverser Limes
Cluster <Rechnernetz>
Datenstruktur
Grundraum
Implementierung
Programmiersprache
Soundverarbeitung
Anwendungsspezifischer Prozessor
Systemplattform
Lineares Funktional
Föderiertes System
Rastertunnelmikroskop
Mereologie
Compiler
Programmiergerät
Gemeinsamer Speicher
Compiler
Familie <Mathematik>
Programm
Computerunterstütztes Verfahren
Systemplattform
Technische Optik
Code
Übergang
Mooresches Gesetz
Informationsmodellierung
Dämpfung
Netzbetriebssystem
Uniforme Struktur
Optimierung
Cluster <Rechnernetz>
Grundraum
Umwandlungsenthalpie
Soundverarbeitung
Beobachtungsstudie
Oval
Hardwarebeschreibungssprache
Physikalisches System
Modul
Natürliche Sprache
Fokalpunkt
Quick-Sort
Höhere Programmiersprache
Kollaboration <Informatik>
Parallelrechner
Mereologie

Metadaten

Formale Metadaten

Titel Implementing Parallel Programming Design Patterns using EFL for Python
Serientitel EuroPython 2016
Teil 119
Anzahl der Teile 169
Autor Goldstein, Moshe
Dayan, David
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/21197
Herausgeber EuroPython
Erscheinungsjahr 2016
Sprache Englisch

Inhaltliche Metadaten

Fachgebiet Informatik
Abstract Moshe Goldstein/david dayan - Implementing Parallel Programming Design Patterns using EFL for Python EFL (Embedded Flexible Language), a deterministic parallel programming tool, may be embedded in any host language. Two versions of the EFL pre-compiler for Python were implemented. One translates EFL blocks into Python's Multiprocessing code, and the other one into DTM/MPI4PY code. EFL implementations of Parallel Programming Design Patterns will be shown, generated parallel code compared, and differences discussed. ----- Multi-core CPUs are abundant and utilizing them effectively requires programmers to parallelize CPU-intensive code. To facilitate this, we have developed EFL (Embedded Flexible Language), a deterministic parallel programming tool. The parallel parts of a program are written as EFL-blocks, which are embedded into a sequential host language program. The sequential parts of the program are written in the host language, outside the EFL blocks. EFL may be embedded in any host language by writing an appropriate EFL pre-compiler. At the moment, we implemented two versions of the EFL pre-compiler. Both pre-compilers translate EFL blocks into parallel Python code - one of them generates parallel code based on Python's Multiprocessing module, and the other one generates parallel code based on the DTM/MPI4PY Python module. We will present the principles upon which EFL is built. We will show the implementation of Parallel Programming Design Patterns using EFL's parallel programming constructs (such as parallel assignments, parallel for-loops, etc.). Using our two EFL pre-compilers we will show their translation to Python parallel code according to the Multiprocessing module as well as the DTM/MPI4PY module. The differences between code versions produced by the EFL pre-compilers will be discussed.

Zugehöriges Material

Ähnliche Filme

Loading...