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
Subtraktion
Programmiergerät
Mereologie
Freeware
Formale Sprache
t-Test
Implementierung
Computerunterstütztes Verfahren
Kombinatorische Gruppentheorie
Systemplattform
Code
Computeranimation
Informationsmodellierung
Parallelrechner
Maschinensprache
Maskierung <Informatik>
Determiniertheit <Informatik>
Programmierparadigma
Thread
Softwareentwickler
Optimierung
Grundraum
Tonnelierter Raum
Leistung <Physik>
Programmiersprache
Soundverarbeitung
Entwurfsmuster
Systemaufruf
p-Block
Physikalisches System
Fokalpunkt
Rechenschieber
Objekt <Kategorie>
Automatische Indexierung
Geschlecht <Mathematik>
Mereologie
Parallelrechner
Projektive Ebene
Baum <Mathematik>
Subtraktion
Folge <Mathematik>
Programmiergerät
Formale Sprache
Computerunterstütztes Verfahren
Term
Code
Computeranimation
Eins
Formale Semantik
Informationsmodellierung
Variable
Modul <Datentyp>
Parallelrechner
Digitale Photographie
Maschinensprache
Arbeitsplatzcomputer
Nichtunterscheidbarkeit
Programmierparadigma
Ordnung <Mathematik>
Optimierung
Soundverarbeitung
Lineares Funktional
Datenmodell
Systemaufruf
p-Block
Variable
Systemaufruf
Arithmetisches Mittel
Parallelrechner
Speicherverwaltung
p-Block
Funktionale Programmiersprache
Baum <Mathematik>
Resultante
Programmiergerät
Folge <Mathematik>
Prozess <Physik>
Formale Sprache
Applet
Datenmanagement
Implementierung
Zahlenbereich
Hierarchische Struktur
Computer
Computer
Element <Mathematik>
Systemplattform
Code
Computeranimation
Formale Semantik
Metropolitan area network
Datenmanagement
Maschinensprache
Gravitationsgesetz
Default
Gerade
Modul
Implementierung
Soundverarbeitung
Videospiel
Lineares Funktional
Kraftfahrzeugmechatroniker
Dicke
Sichtenkonzept
Präprozessor
Rechenzeit
Schlussregel
p-Block
Modul
Objekt <Kategorie>
Rhombus <Mathematik>
Scheduling
Dienst <Informatik>
Mereologie
Information
Compiler
Ordnung <Mathematik>
Charakteristisches Polynom
Baum <Mathematik>
Informationssystem
Resultante
Prozess <Physik>
Mereologie
Gruppenkeim
Versionsverwaltung
Element <Mathematik>
Computerunterstütztes Verfahren
Computeranimation
Übergang
Metropolitan area network
Algorithmus
Mehrrechnersystem
Mustersprache
Mapping <Computergraphik>
Default
Kraftfahrzeugmechatroniker
Lineares Funktional
Softwareentwickler
Abstraktionsebene
Singularität <Mathematik>
Entwurfsmuster
Ähnlichkeitsgeometrie
Übergang
Digitalfilter
Mehrprozessorsystem
Konstante
Mustersprache
Scheduling
Datenfeld
Forcing
Automatische Indexierung
Parallelrechner
Reelle Zahl
Datenfluss
p-Block
Versionsverwaltung
Folge <Mathematik>
Subtraktion
Zahlenbereich
Implementierung
Task
Bildschirmmaske
Informationsmodellierung
Task
Parallelrechner
Äußere Algebra eines Moduls
Optimierung
Analysis
Modul
Implementierung
Logarithmus
Modul
Datenfluss
Mapping <Computergraphik>
Loop
Mereologie
Baum <Mathematik>
Abstimmung <Frequenz>
Folge <Mathematik>
Web log
Regulärer Ausdruck
Oval
Physikalische Theorie
Computeranimation
Task
Metropolitan area network
Variable
Bildschirmmaske
Arithmetischer Ausdruck
Task
Prozess <Informatik>
Parallelrechner
Gamecontroller
Maschinensprache
Optimierung
Ordnung <Mathematik>
Lineares Funktional
Schlussregel
Biprodukt
Variable
Systemaufruf
Konfiguration <Informatik>
Funktion <Mathematik>
Rechter Winkel
Parallelrechner
Boolesche Algebra
p-Block
Programmiergerät
Prozess <Physik>
Konfiguration <Informatik>
Momentenproblem
Implementierung
Zahlenbereich
Computeranimation
Task
Physikalisches System
Task
Datenmanagement
Regulärer Graph
Maschinensprache
Mustersprache
Minimum
Modul
Wald <Graphentheorie>
Division
Ausnahmebehandlung
Physikalisches System
Modul
Teilbarkeit
Konfiguration <Informatik>
Mustersprache
Parallelrechner
Mereologie
p-Block
Baum <Mathematik>
Polare
Instantiierung
Resultante
Lineares Funktional
Folge <Mathematik>
Dicke
Logarithmus
Formale Sprache
Gruppenkeim
Digitalfilter
Element <Mathematik>
Ein-Ausgabe
Computeranimation
Mapping <Computergraphik>
Metropolitan area network
Mustersprache
Loop
Parallelrechner
Mapping <Computergraphik>
p-Block
Funktion <Mathematik>
Quelle <Physik>
Resultante
Folge <Mathematik>
Prozess <Physik>
Warping
Zahlenbereich
Computeranimation
Task
Metropolitan area network
Mailing-Liste
Parallelrechner
Mustersprache
Mapping <Computergraphik>
Wurzel <Mathematik>
Optimierung
Implementierung
Funktion <Mathematik>
Videospiel
Lineares Funktional
Singularität <Mathematik>
Systemaufruf
Mailing-Liste
p-Block
Ein-Ausgabe
Mapping <Computergraphik>
Mustersprache
Quadratzahl
Loop
Decodierung
p-Block
Instantiierung
Folge <Mathematik>
Präprozessor
Singularität <Mathematik>
Ein-Ausgabe
Komplex <Algebra>
Code
Computeranimation
Mapping <Computergraphik>
Task
Objekt <Kategorie>
Mustersprache
Metropolitan area network
Mailing-Liste
Datenmanagement
Rechter Winkel
Maschinensprache
Minimum
Maskierung <Informatik>
Mapping <Computergraphik>
Translation <Mathematik>
p-Block
Optimierung
Rungescher Approximationssatz
Informationssystem
Resultante
Nebenbedingung
Folge <Mathematik>
Klasse <Mathematik>
Element <Mathematik>
Computeranimation
Übergang
Metropolitan area network
Mailing-Liste
Mittelwert
Parallelrechner
Maschinensprache
Mapping <Computergraphik>
Assoziativgesetz
Parametersystem
Lineares Funktional
Logarithmus
Inverse
Digitalfilter
Ein-Ausgabe
Rechenschieber
Mustersprache
Loop
Compiler
p-Block
Unterring
Algorithmus
Ganze Zahl
Machsches Prinzip
Klasse <Mathematik>
Zahlenbereich
Mailing-Liste
p-Block
Fokalpunkt
Computeranimation
Resultante
Lineares Funktional
Folge <Mathematik>
Wellenpaket
Web log
Logarithmus
Klasse <Mathematik>
Mailing-Liste
Digitalfilter
Element <Mathematik>
Computeranimation
Mapping <Computergraphik>
Mustersprache
Mailing-Liste
Datenfeld
Parallelrechner
Loop
Ein-Ausgabe
Mereologie
Mapping <Computergraphik>
p-Block
Schaltfunktion
Funktion <Mathematik>
Metropolitan area network
Resultante
Subtraktion
Web log
Regulärer Ausdruck
p-Block
Variable
Computeranimation
Arithmetischer Ausdruck
Variable
Datensatz
Parallelrechner
Gamecontroller
Maschinensprache
Parallelrechner
p-Block
Optimierung
Lineares Funktional
Multiplexbetrieb
Singularität <Mathematik>
Matrizenrechnung
p-Block
Schwach besetzte Matrix
Element <Mathematik>
Extrempunkt
Bitrate
Biprodukt
Binder <Informatik>
Computeranimation
Task
Mustersprache
Vektorrechner
Datensatz
Mustersprache
Inklusion <Mathematik>
Soundverarbeitung
Präprozessor
Multiplexbetrieb
Wasserdampftafel
Matrizenrechnung
Entwurfsmuster
Schlussregel
Framework <Informatik>
Variable
Computeranimation
Mustersprache
Flächeninhalt
Parallelrechner
Maschinensprache
Parallelrechner
Compiler
p-Block
Instantiierung
Resultante
Telekommunikation
Paralleler Algorithmus
Web Site
Subtraktion
Abstrakter Syntaxbaum
Prozess <Physik>
Versionsverwaltung
t-Test
Interaktives Fernsehen
Systemplattform
Framework <Informatik>
Computeranimation
Internetworking
Skalierbarkeit
Algorithmus
Parallelrechner
Serielle Schnittstelle
Lineare Regression
Notebook-Computer
t-Test
Anwendungsspezifischer Prozessor
Mustersprache
Translation <Mathematik>
Inverser Limes
Cluster <Rechnernetz>
Datenstruktur
Grundraum
Implementierung
Soundverarbeitung
Programmiersprache
Lineares Funktional
Präprozessor
Singularität <Mathematik>
Anwendungsspezifischer Prozessor
Entwurfsmuster
Kompakter Raum
Festspeicher
Mereologie
Parallelrechner
Projektive Ebene
Compiler
Versionsverwaltung
Baum <Mathematik>
Programmiergerät
Gemeinsamer Speicher
Compiler
Formale Sprache
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
Fokalpunkt
Modul
Quick-Sort
Höhere Programmiersprache
Kollaboration <Informatik>
Parallelrechner
Mereologie
Baum <Mathematik>

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...