Implementations of Parallel Processing

  • 192 views
Uploaded on

Final report made for the University of Michigan -- Flint in CSC 478 "Parallel Processing" for Dr. Michael Farmer. The report explores and briefly introduces four programming languages for parallel …

Final report made for the University of Michigan -- Flint in CSC 478 "Parallel Processing" for Dr. Michael Farmer. The report explores and briefly introduces four programming languages for parallel processing: C, Charm, Erlang, and JOCaml.

More in: Education , Technology
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
No Downloads

Views

Total Views
192
On Slideshare
0
From Embeds
0
Number of Embeds
0

Actions

Shares
Downloads
4
Comments
0
Likes
1

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. Implementations of Parallel Processing Languages and Thoughts Robert J. Knuuti University of Michigan – Flint April 19, 2010 FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 1 / 60
  • 2. Outline Topics 1 Purpose 2 Languages Studied C and C++ Charm++ Erlang JoCaml 3 Benchmark 4 Bibliography FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 2 / 60
  • 3. Purpose Philosophies There are no silver bullets There shall never be one implementation that will work in every case. [2] Use the right tool for the right job You should always let a project dictate what you should use rather than always select the most general choice. FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 3 / 60
  • 4. Purpose Philosophies TIMTOWTDI “There Is More Than One Way To Do It”. This is a very powerful statement developed by the practitioners of Larry Wall’s Perl scripting language. By having multiple ways to complete a task, new and innovative ways will be recognized leading to the evolution of parallel utilities. [9] FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 4 / 60
  • 5. Purpose Parallel Process Models There are only two accepted models for parallel processing: Shared Memory (Threaded-Centric) Each executing process has access to a pool of memory which the program has access to. Requires Locking system to ensure that data is being securely operated on Process (Message Passing) Each executing process has its own unique copy of data Nullifies data dependencies and mutexes. FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 5 / 60
  • 6. Purpose Considerations Questions Which implementation is the fastest? Which implementation is the cleanest? Which implementation is the most efficient? FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 6 / 60
  • 7. Languages Studied 1 Purpose 2 Languages Studied C and C++ Charm++ Erlang JoCaml 3 Benchmark 4 Bibliography FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 7 / 60
  • 8. Languages Studied Overview of Paradigms Procedural Stepped execution Has conditionals and branching, mutable data, and calls Typically follow Shared Memory Model Functional Lambda execution (all operations are functions) Pattern Matching and Guards Typically follow Process Model FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 8 / 60
  • 9. Languages Studied 1 Purpose 2 Languages Studied C and C++ Charm++ Erlang JoCaml 3 Benchmark 4 C and C++ Bibliography FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 9 / 60
  • 10. Languages Studied C and C++ Background Unarguably most used language Great deal of support and extension Parallelism achieved through libraries Threads shall be implemented in C++0x FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 10 / 60
  • 11. Languages Studied C and C++ Supported Paradigms Message Passing Uses MPI and AMPI libraries to perform tasks Requires a VM layer to facilitate network communication Shared Memory MFC Threads (Windows Library) PThreads (Unix Library, experimental Windows support) Boost Threads (Cross-Platform wrapper) Shared Memory is the most commonly used implementation. FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 11 / 60
  • 12. Languages Studied C and C++ Example: Hello World Listing 1: C Hello World § #i n c l u d e < s t d i o . h> i n t main ( ) { p r i n t f ( ” H e l l o World ! ” ) ; return 0; } ¥ FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 12 / 60
  • 13. Languages Studied C and C++ Example: Factorial I Listing 2: C Factorial § #i n c l u d e < s t d i o . h> #i n c l u d e < s t d l i b . h> long f a c t o r i a l ( i n t n ) { i f ( n <= 1 ) r e t u r n 1 ; else r e t u r n n∗ f a c t o r i a l ( n−1) ; } i n t main ( i n t a r g c , c h a r ∗∗ a r g v ) { long i n t f = f a c t o r i a l ( a t o i ( argv [ 1 ] ) ) ; p r i n t f ( ”%dn” , f ) ; return 0; } ¥ FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 13 / 60
  • 14. Languages Studied C and C++ PThread Library Built off of the Posix standard (1003.1-1995) Has modules for thread creation, mutexes, and condition barriers Over 60 function calls Has modifiers for manipulating each module’s actions Implemented in C FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 14 / 60
  • 15. Languages Studied C and C++ PThread Code Index Type system: pthread module t. Functions: pthread module function. Constants: PTHREAD CONST. This is covered in detail inside the book. FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 15 / 60
  • 16. Languages Studied 1 Purpose 2 Languages Studied C and C++ Charm++ Erlang JoCaml 3 Benchmark 4 Charm++ Bibliography FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 16 / 60
  • 17. Languages Studied Charm++ Background Event-driven object oriented programming language Based on C++ Provides built in primitives for parallel programming (using interface) files to identify parallel C++ code) Runs on a VM which is complied and optimized for compiled code. [6] FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 17 / 60
  • 18. Languages Studied Charm++ Supported Paradigms Message Passing Utilizes an optimized VM layer to communicate between nodes Uses built in calls to communicate between VMs Shared Memory Uses a pooled namespace classes, known as “Chares” Global variables are required to be read-only. FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 18 / 60
  • 19. Languages Studied Charm++ Novelties Mutexes are unneeded, as parallel data is essentially exclusive or marked read-only. Pseudo parallelism is generated automatically from programming code, split by objects. FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 19 / 60
  • 20. Languages Studied Charm++ Example: Hello World I Listing 3: Header File § #i f n d e f #d e f i n e HELLO H HELLO H c l a s s H e l l o : p u b l i c CBase Main { public : Main ( CkArgMsg ∗msg ) ; Main ( C k M i g r a t e M e s s a g e ∗msg ) ; }; #e n d i f // HELLO H ¥ FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 20 / 60
  • 21. Languages Studied Charm++ Example: Hello World II Listing 4: Source File § #i n c l u d e ” h e l l o . d e c l . h” #i n c l u d e ” h e l l o . h” Main : : Main ( CkArgMsg ∗msg ) { C k P r i n t f ( ” H e l l o World ! n” ) ; CkExit () ; } Main : : Main ( C k M i g r a t e M e s s a g e ∗msg ) {} #i n c l u d e ” h e l l o . d e f . h” ¥ FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 21 / 60
  • 22. Languages Studied Charm++ Example: Hello World III Listing 5: Interface File § mainmodule h e l l o { mainchare H e l l o { e n t r y H e l l o ( CkArgMsg ∗m) ; }; }; ¥ FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 22 / 60
  • 23. Languages Studied Charm++ Basics I Files Applications are composed of at least three files: Source File (.C) Header File (.h) Common Interface File (.ci) FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 23 / 60
  • 24. Languages Studied Charm++ Basics II CI file The CI file is unique to the charm system and identifies parallel execution agents, results in two generated headers for the charm system to read. It identifies: A parent namespace, called module A server class, called mainchare Identification of reentrant function using the keyterm entry Identification of read only data using the term readonly. § module h e l l o { a r r a y [ 1D] H e l l o { entry Hello () ; entry void sayHi ( i n t ) ; }; }; Knuuti (UM Flint) Implementations of Parallel Processing ¥ WI ’10 FLINT 24 / 60
  • 25. Languages Studied Charm++ Basics III § mainmodule main { r e a d o n l y CProxy Main mainProxy ; e x t e r n module h e l l o ; mainchare Main { e n t r y Main ( CkArgMsg ∗msg ) ; e n t r y v o i d done ( ) ; }; }; ¥ H file Very similar to a C++ class header, the header files have an identical syntax, with the exception of inheriting from a class called CBase Main. FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 25 / 60
  • 26. Languages Studied Charm++ Basics IV § #i f n d e f #d e f i n e HELLO H HELLO H c l a s s Hello : public CBase Hello { public : Hello () ; H e l l o ( C k M i g r a t e M e s s a g e ∗msg ) ; v o i d s a y H i ( i n t from ) ; }; #e n d i f // HELLO H ¥ FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 26 / 60
  • 27. Languages Studied Charm++ Basics V § #i f n d e f #d e f i n e MAIN H MAIN H c l a s s Main : p u b l i c CBase Main { private : i n t numElements ; i n t doneCount ; public : Main ( CkArgMsg ∗msg ) ; Main ( C k M i g r a t e M e s s a g e ∗msg ) ; v o i d done ( ) ; }; #e n d i f // MAIN H ¥ FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 27 / 60
  • 28. Languages Studied Charm++ Basics VI C file The C file (which is actually a C++ file; the compiler looks for capital c extensions) is a little abnormal, but keeps the familiar C++ syntax. A thing to note is the addition of the two headers generated by the ci file. These two includes contain the necessary bindings to use the charmrun command. § #i n c l u d e ” h e l l o . d e c l . h” #i n c l u d e ” h e l l o . c ” e x t e r n /∗ r e a d o n l y ∗/ CProxy Main mainProxy ; H e l l o : : H e l l o ( ) {} H e l l o : : H e l l o ( C k M i g r a t e M e s s a g e ∗msg ) {} v o i d H e l l o : : s a y H i ( i n t from ) { FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 28 / 60
  • 29. Languages Studied Charm++ Basics VII C k P r i n t f ( ” H e l l o from c h a r e %d on P(%d ) , t o l d by %d . n” , t h i s I n d e x , CkMyPe ( ) , from ) ; ma in Pro xy . done ( ) ; } #i n c l u d e ” h e l l o . d e f . h” ¥ § #i n c l u d e ” main . d e c l . h” #i n c l u d e ” main . h” #i n c l u d e ” h e l l o . d e c l . h” /∗ r e a d o n l y ∗/ CProxy Main mainProxy ; Main : : Main ( CkArgMsg ∗msg ) { doneCount = 0 ; numElements = 5 ; Knuuti (UM Flint) Implementations of Parallel Processing FLINT WI ’10 29 / 60
  • 30. Languages Studied Charm++ Basics VIII i f ( msg−>a r g c > 1 ) numElements = a t o i ( msg−>a r g v [ 1 ] ) ; d e l e t e msg ; C k P r i n t f ( ” Running H e l l o World u s i n g %d e l e m e n t s o v e r %d p r o c e s s o r s . n” , numElements , CkNumPes ( ) ) ; ma in Pro xy = t h i s P r o x y ; CProxy Hello = helloArray = C P r o x y H e l l o : : ckNew ( numElements ) ; h e l l o A r r a y . s a y H i ( −1) ; } Main : : Main ( C k M i g r a t e M e s s a g e ∗msg ) {} FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 30 / 60
  • 31. Languages Studied Charm++ Basics IX v o i d Main : : done ( ) { doneCount++; i f ( doneCount >= numElements ) CkExit () ; } #i n c l u d e ” main . d e f . h” ¥ FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 31 / 60
  • 32. Languages Studied Charm++ Basics X Building Building the project into an executable is a bit detailed, but nothing really different from your typical managed C/C++ applications. compile interface files using charmc compile independent classes, creating object files compile main class, also creating an object file link the two together, using charmc § CHARMDIR=/p a t h / t o / charm / r o o t CHARMC=$ (CHARMDIR) / b i n / charmc $ (OPTS) default : all all : hello FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 32 / 60
  • 33. Languages Studied Charm++ Basics XI h e l l o : main . o h e l l o . $ (CHARMC) −l a n g u a g e charm++ −o h e l l o main . o hello .o main . o : main . C main . h main . d e c l . h main . d e f . h hello . decl . h $ (CHARMC) −o main . o main . C main . d e c l . h main . d e f . h : main . c i $ (CHARMC) main . c i h e l l o . o : h e l l o .C h e l l o . h h e l l o . decl . h h e l l o . def . h main . d e c l . h $ (CHARMC) −o h e l l o . o h e l l o . C h e l l o . decl . h h e l l o . def . h : h e l l o . ci $ (CHARMC) h e l l o . c i FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 33 / 60
  • 34. Languages Studied Charm++ Basics XII clean : rm −f main . d e c l . h main . d e f . h main . o rm −f h e l l o . d e c l . h h e l l o . d e f . h h e l l o . o rm −f h e l l o charmrun ¥ Nodefile This is similar to how MPI works, where you must create a nodelist to specify which computers are identified as an element, and also the number of processing elements in each node. The list wraps, making it possible to have multiple processes over one single computer. FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 34 / 60
  • 35. Languages Studied Charm++ Basics XIII § g r o u p main ++s h e l l s s h h o s t member1 h o s t member2 h o s t member3 h o s t member4 h o s t member5 h o s t member6 h o s t member7 h o s t member8 group h a l f h o s t member2 ++s h e l l s s h h o s t member3 ++s h e l l r s h g r o u p l o c a l ++s h e l l s s h host l o c a l h o s t ¥ FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 35 / 60
  • 36. Languages Studied Charm++ Basics XIV Running To run, all you have to do is prefix the application with the charmrun executable, the program name, number of processing elements, and whatever other options you wish to have. Something like, ./charmrun ./hello +p4 ++verbose This will run the hello program over 4 elements, and display processing data verbosely to the screen. FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 36 / 60
  • 37. Languages Studied 1 Purpose 2 Languages Studied C and C++ Charm++ Erlang JoCaml 3 Benchmark 4 Erlang Bibliography FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 37 / 60
  • 38. Languages Studied Erlang Background Very stable platform Light weight process spawning Primitives built into the language for parallel programming Immutable (unchanging) variable assignments (purely functional). Conditional processing is performed by “guards”. [3] FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 38 / 60
  • 39. Languages Studied Erlang Supported Paradigms Message Passing Uses built in syntax to communicate between processes Any data can be passed between processes, including other processes. FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 39 / 60
  • 40. Languages Studied Erlang Example: Factorial I Listing 6: Erlang factorial function § −module ( f a c t o r i a l ) . −e x p o r t ( [ f a c t o r i a l /1 ] ) . f a c t o r i a l ( 0 ) −> 1; f a c t o r i a l (N) −> N∗ f a c t o r i a l (N−1) . ¥ FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 40 / 60
  • 41. Languages Studied Erlang Example: Hello World I Listing 7: Erlang Hello World § −module ( h e l l o ) . −e x p o r t ( [ s t a r t /0 ] ) . s t a r t ( ) −> spawn ( f u n ( ) −> l o o p ( ) end ) . l o o p ( ) −> receive h e l l o −> i o : f o r m a t ( ” H e l l o World ! ˜n” ) , loop () ; goodbye −> ok end . ¥ FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 41 / 60
  • 42. Languages Studied Erlang Basics I REPL Erlang is VM and language specification, thus all programs are run within the VM unit. This is accessed though erl, which starts a Read-Evaluate-Print-Loop (REPL) environment. All commands, including compilation, are done in this environment. Modules and Exports Erlang uses a modular design philosophy, which is similar to namespacing in C++. Thus, every file is a module, and every module begins the file. Exports are similar to public functions in the C++ class model. only the functions listed in export can be accessed outside of the module. FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 42 / 60
  • 43. Languages Studied Erlang Basics II Pattern Matching Erlang uses pattern matching for it’s definitions. As seen with the earlier factorial program, a function definitions can have actual values placed inside them. This allows the compiler to identify which function definition to call. Spawning Spawning is really simple in Erlang. Simply call the spawn/3 function which takes three arguments, and returns a process ID to associate the spawn with. Module name (?MODULE is the current module name) function name a list of arguments FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 43 / 60
  • 44. Languages Studied Erlang Basics III Message Passing Message passing is built into the language, using the ! operator and the receive, end block identifiers. Sending as message uses an infix operator (!) where the right hand side is the message (any data) to transfer and the left side is the process to transfer it to. Receiving a message uses a case-like structure statement, where a block is defined and a series of matching arguments are listed with associated execution functions. FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 44 / 60
  • 45. Languages Studied Erlang Basics IV compiling Start the erlang shell Call the c/1 function, passing the module name Your module has been imported into the shell for execution § −module ( b a s i c s p a w n ) . −e x p o r t ( [ s t a r t / 1 , s t a r t p r o c /2 ] ) . s t a r t (Num) −> s t a r t p r o c (Num, s e l f ( ) ) . s t a r t p r o c ( 0 , P i d ) −> P i d ! ok ; s t a r t p r o c (Num, P i d ) −> NPid = spawn ( ?MODULE, s t a r t p r o c , [Num−1, P i d ] ) , NPid ! ok , FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 45 / 60
  • 46. Languages Studied Erlang Basics V r e c e i v e ok −> ok end . ¥ FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 46 / 60
  • 47. Languages Studied 1 Purpose 2 Languages Studied C and C++ Charm++ Erlang JoCaml 3 Benchmark 4 JoCaml Bibliography FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 47 / 60
  • 48. Languages Studied JoCaml Background Extension off of OCaml Very strongly typed Uses pattern matching, and stream processing FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 48 / 60
  • 49. Languages Studied JoCaml Supported Paradigms Shared Memory Uses Join Calculus to implement threads [4] Mutex locking is unneeded for thread “channels” FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 49 / 60
  • 50. Languages Studied JoCaml Pi Calculus Pi Calculus (π-calculus) is a mathematical construct which provides the framework for basic process calculation. It defines a minimalistic language based off of BNF grammar to discuss processes based off of: Concurrency Written P | Q, where P and Q are individual processes and the pipe operator means parallel execution. Communication By way of input prefixing (function waiting for input followed by process it belongs execute) or by outfix prefixing (function sending data to process). Replication Written as !P, which essentially means copy. Creation Written (νx)P, stating the creation of x inside of P. Nil Written as 0 identifies a process’s complete halt. FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 50 / 60
  • 51. Languages Studied JoCaml Join Calculus Join Calculus is a revised form of Pi-Calculus with a focus on locality and mobility, and provide a method to model asynchronous communication. Added Pattern Matching capabilities and several utility systems that were not provided in pi calculus, most notably Tests and Equivalencies Tracing Extended the pi calculus specification from 20 pages to 80 pages Further information can be found in Fournet and Gonthier’s paper on Join Calculus. [4] FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 51 / 60
  • 52. Languages Studied JoCaml Example: Hello World I Listing 8: OCaml Hello World § let = p r i n t e n d l i n e ” H e l l o World ” ; ; ¥ FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 52 / 60
  • 53. Languages Studied JoCaml Example: Factorial I Listing 9: OCaml Factorial § l e t rec f a c t o r i a l n = i f n = 1 then 1 e l s e f a c t o r i a l ( n−1) ∗ n ; ; ¥ FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 53 / 60
  • 54. Benchmark 1 Purpose 2 Languages Studied C and C++ Charm++ Erlang JoCaml 3 Benchmark 4 Bibliography FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 54 / 60
  • 55. Benchmark What is a Benchmark? Definition A Benchmark is a standard defined by a context of “good” and “bad”. Provide a numerical or graphical representation of performance. Professional benchmarks are often packaged as a “suite” of tools. FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 55 / 60
  • 56. Benchmark Challenges of Parallel Process Benchmarking Keeping track of every node and process. An acceptable way to sum each process execution. Dealing with overhead v.s. micro benchmarking FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 56 / 60
  • 57. Benchmark The Real Challenges of Benchmarking I was unable to take benchmarks down, due to unforeseen MPI issues. FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 57 / 60
  • 58. Bibliography Sources I Charm++ programming tutorial, April 2009. http://charm.cs.uiuc.edu/tutorial. Brooks, Jr., F. P. The Mythical Man Month, 1995 ed. Addison-Wesley, Crawfordsville, Indiania, 2009. Cesarini, F., and Thompson, S. Erlang Programming, 1st ed. O’Reilly, June 2009. Fournet, C., and Gonther, G. The join calculus: a language for distributed mobile programming. Tech. rep., Microsoft Research and INRIA Rocquencourt, 2001. http://research.microsoft.com/en-us/um/people/fournet/ papers/join-tutorial.pdf. FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 58 / 60
  • 59. Bibliography Sources II Jordan, H. F., and Alaghband, G. Fundamentals of Parallel Processing, 1st ed. Prentice Hall, 2003. Kale, L., and Krishnan, S. Charm++: Parallel Programming with Message-Driven Objects. University of Illinois at Urbana-Champaign, 1996. http://charm.cs.uiuc.edu. Mandel, L., and Maranget, L. The JoCaml Language Release 3.11. Institut National de Recherche en Informatique et en Automatique, 2007. http://jocaml.inria.fr. FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 59 / 60
  • 60. Bibliography Sources III R Development Core Team. R: A Language and Environment for Statistical Computing. R Foundation for Statistical Computing, Vienna, Austria, 2008. http://www.R-project.org. Wall, L. Perl, the first postmodern computer language, March 1999. http://www.perl.com/pub/a/1999/03/pm.html. FLINT Knuuti (UM Flint) Implementations of Parallel Processing WI ’10 60 / 60