1 / 31

Lazy Execution

Lazy Execution. Seif Haridi KTH Peter Van Roy UCL. Lazy execution. Up to now the execution order of each thread follows textual order, when a statement comes as the first in sequence it will execute, whether or not its results are needed later

Download Presentation

Lazy Execution

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Lazy Execution Seif Haridi KTH Peter Van Roy UCL S. Haridi and P. Van Roy

  2. Lazy execution • Up to now the execution order of each thread follows textual order, when a statement comes as the first in sequence it will execute, whether or not its results are needed later • The execution scheme is called eager execution, or supply-driven execution • Another execution order is that a statement is executed only if its results are needed some in the program • This scheme is called lazy evaluation, or demand-driven evaluation S. Haridi and P. Van Roy

  3. Example B = {F1 X} C = {F2 Y} A = B+C • Assume F1 and F2 are lazy functions (see Haskell) • B = {F1 X} and C = {F2 Y} are executed only if their results are needed in A = B+C S. Haridi and P. Van Roy

  4. Example • In Lazy execution, an operation suspends until its result are needed • The suspended operationis triggered when another operation needs the value for its arguments • In general multiple suspendedoperations could start concurrently B = {F1 X} C = {F2 Y} Demand A = B+C S. Haridi and P. Van Roy

  5. Example II • In data-driven execution, an operation suspend until the values of its arguments results are available • In general the suspended computation could start concurrently B = {F1 X} C = {F2 Y} Data driven A = B+C S. Haridi and P. Van Roy

  6. Lazy streams funlazy {Generate N} N|{Generate N+1} end fun {Sum Xs A Limit} if Limit>0 then case Xs of X|Xr then {Sum Xr A+X Limit-1} end else A end end local Xs S in thread Xs={Generate 0} end S={Sum Xs 0 15000000} {Show S} end S. Haridi and P. Van Roy

  7. How does it work? fun {Sum Xs A Limit} if Limit>0 then caseXs of X|Xrthen {Sum Xr A+X Limit-1} end else A end end funlazy {Generate N} N|{Generate N+1} end local Xs S in thread Xs={Generate 0}end S={Sum Xs 0 15000000} {Show S} end S. Haridi and P. Van Roy

  8. Improving throughput • Use a lazy buffer • It takes a lazy input stream In and an integer N, and returns a lazy output stream Out • When it is first called, it first fills itself with N elements by asking the producer • The buffer now has N elements filled • Whenever the consumer asks for an element, the buffer in turn asks the producer for another element S. Haridi and P. Van Roy

  9. N producer buffer consumer N producer buffer consumer The buffer example S. Haridi and P. Van Roy

  10. The buffer fun {Buffer1 In N} End={List.drop In N} funlazy {Loop In End} In.1|{Loop In.2 End.2} end in {Loop In End} end Traverse the In stream, forces the producer to emit N elements S. Haridi and P. Van Roy

  11. The buffer II fun {Buffer1 In N} thread End={List.drop In N} end funlazy {Loop In End} In.1|{Loop In.2 End.2} end in {Loop In End} end Traverse the In stream, forces the producer to emit N elements and at the same time serves the consumer S. Haridi and P. Van Roy

  12. The buffer III fun {Buffer1 In N} thread End={List.drop In N} end funlazy {Loop In End}threadE2= End.2 end In.1|{Loop In.2 E2} end in {Loop In End} end Traverse the In stream, forces the producer to emit N elements and at the same time serves the consumer, and request the next element ahead S. Haridi and P. Van Roy

  13. Larger Example:The sieve of Eratosthenes • Produces prime numbers • It takes a stream 2...N, peals off 2 from the rest of the stream • Delivers the rest to the next sieve Sieve X Xs X|Zs Filter Sieve Zs Xr Ys S. Haridi and P. Van Roy

  14. Lazy Sieve fun lazy {Sieve Xs} X|Xr = Xs in X | {Sieve {LFilter Xr fun {$ Y} Y mod X \= 0 end }} end fun {Primes} {Sieve {IntsFrom 2}} end S. Haridi and P. Van Roy

  15. Lazy Filter For the Sieve program we need a lazy filter fun lazy {LFilter Xs F} case Xs of nil then nil [] X|Xr then if {F X} then X|{LFilter Xr F} else {LFilter Xr F} end end end S. Haridi and P. Van Roy

  16. Define streams implicitly • Ones = 1 | Ones • Infinite stream of ones 1 Ones cons S. Haridi and P. Van Roy

  17. Define streams implicitly • Xs = 1 | {LMap Xsfun {$ X} X+1 end} • What is Xs ? 1 Xs? cons +1 S. Haridi and P. Van Roy

  18. *2 *3 *5 The Hamming problem • Generate the first N elements of stream of integers of the form: 2a3b5c with a,b,c  0 (in ascending order) S. Haridi and P. Van Roy

  19. *2 *3 Merge *5 The Hamming problem • Generate the first N elements of stream of integers of the form: 2a3b5c with a,b,c  0 (in ascending order) S. Haridi and P. Van Roy

  20. *2 *3 Merge *5 The Hamming problem • Generate the first N elements of stream of integers of the form: 2a3b5c with a,b,c  0 (in ascending order) 1 H cons S. Haridi and P. Van Roy

  21. Lazy File reading fun {ToList FO}fun lazy {LRead} L T inif{File.readBlock FO L T}then T = {LRead}else T = nil {File.close FO} end Lend{LRead} end • This avoids reading the whole file in memory S. Haridi and P. Van Roy

  22. List Comprehensions • Abstraction provided in lazy functional languages that allows writing highe level set-like expression • In our context we produce lazy lists instead of sets • The mathemnatical set expression • {x*y | 1x 10, 1y x} • Equivalent List comprehension expression is • [X*Y | X = 1..10 ; Y = 1..X] • Example: • [1*1 2*1 2*2 3*1 3*2 3*3 ... 10*10] S. Haridi and P. Van Roy

  23. List Comprehensions • The general form is • [ f(x,y, ...,z) | x  gen(a1,...,an) ; guard(x,...)y  gen(x, a1,...,an) ; guard(y,x,...) ....] • No linguistic support in Mozart/Oz, but can be easily expressed S. Haridi and P. Van Roy

  24. Example 1 • z = [x#x | x  from(1,10)] • Z = {LMap {LFrom 1 10} fun{$ X} X#X end} • z = [x#y | x  from(1,10), y  from(1,x)] • Z = {LFlatten{LMap {LFrom 1 10} fun{$ X} {LMap {LFrom 1 X}fun {$ Y} X#Yend }end} } S. Haridi and P. Van Roy

  25. Example 2 • z = [x#y | x from(1,10), y from(1,x), x+y10] • Z ={LFilter{LFlatten{LMap {LFrom 1 10} fun{$ X} {LMap {LFrom 1 X}fun {$ Y} X#Yend }end} }fun {$ X#Y} X+Y=<10 end} } S. Haridi and P. Van Roy

  26. Implementation of lazy execution The following defines the syntax of a statement, sdenotes a statement s::= skip empty statement | ... |threads1 end thread creation| {ByNeedfun{$} eendx} by need statement zero arityfunction variable S. Haridi and P. Van Roy

  27. Implementation f x some statement stack {ByNeedfun{$} eendX,E } A function value is created in the store (say f) the function f is associated with the variable x execution proceeds immediately to next statement f store S. Haridi and P. Van Roy

  28. Implementation f x : f some statement stack {ByNeed fun{$} e end X,E } A function value is created in the store (say f) the function f is associated with the variable x execution proceeds immediately to next statement f store (fun{$} eendX,E) S. Haridi and P. Van Roy

  29. Accessing the byNeed variable • X = {ByNeed fun{$} 111*111 end} (by thread T0) • Access by some thread T1 • if X > 1000 then {Show hello#X} end or • {Wait X} • Causes X to be bound to 12321 (i.e. 111*111) S. Haridi and P. Van Roy

  30. Implementation Thread T1 • X is needed • start a thread T2 to exeute F (the function) • only T2 is allowed to bind X Thread T2 • Evaluate Y = {F} • Bind X the value Y • Terminate T2 • Allow access on X S. Haridi and P. Van Roy

  31. Lazy functions funlazy {From N} N | {From N+1} end fun {From N} fun {F} N | {From N+1} end in {ByNeed F} end S. Haridi and P. Van Roy

More Related