Futures. COS 326 David Walker Princeton University

Transcription

1 Futures COS 326 David Walker Princeton University

2 Futures module type FUTURE = sig type a future (* future f x forks a thread to run f(x) and stores the result in a future when complete *) val future : ( a-> b) -> a -> b future (* force f causes us to wait until the thread computing the future value is done and then returns its value. *) val force : a future -> a end 2

3 Future Implementa?on (Version 1) module Future : FUTURE = struct type a future = {tid : Thread.t ; value : a option ref } end 3

4 Future Implementa?on (Version 1) module Future : FUTURE = struct type a future = {tid : Thread.t ; value : a option ref } let future(f: a-> b)(x: a) : b future = let r = ref None in let t = Thread.create (fun () -> r := Some(f x)) () in {tid=t ; value=r} end 4

5 Future Implementa?on (Version 1) module Future : FUTURE = struct type a future = {tid : Thread.t ; value : a option ref } let future(f: a-> b)(x: a) : b future = let r = ref None in let t = Thread.create (fun () -> r := Some(f x)) () in {tid=t ; value=r} end let force (f: a future) : a = Thread.join f.tid ; match!(f.value) with Some v -> v None -> failwith impossible! 5

6 Now using Futures let x = future f () in let y = g () in let v = force x in (* compute with v and y *) 6

7 Compiling Create a _tags file in your directory: _tags: true: thread, package(threads) Invoke ocamlbuild from your shell (code in future.ml): $ ocamlbuild -use-ocamlfind future.d.byte

8 Back to the Futures module type FUTURE = sig type a future val future : ( a-> b) -> a -> b future val force : a future -> a end val f : unit -> int val g : unit -> int with futures library: let x = future f () in let y = g () in let v = force x in y + v without futures library: let r = ref None let t = Thread.create (fun _ -> r := Some(f ())) () in let y = g() in Thread.join t ; match!r with Some v -> y + v None -> failwith impossible 8

9 Back to the Futures module type FUTURE = sig type a future val future : ( a-> b) -> a -> b future val force : a future -> a end val f : unit -> int val g : unit -> int with futures library: let x = future f () in let y = g () in let v = force x in y + v what happens if we delete these lines? without futures library: let r = ref None let t = Thread.create (fun _ -> r := Some(f ())) () in let y = g() in Thread.join t ; match!r with Some v -> y + v None -> failwith impossible 9

10 Back to the Futures module type FUTURE = sig type a future val future : ( a-> b) -> a -> b future val force : a future -> a end val f : unit -> int val g : unit -> int with futures library: let x = future f () in let y = g () in let v = force x in y + x what happens if we use x and forget to force? without futures library: let r = ref None let t = Thread.create (fun _ -> r := Some(f ())) () in let y = g() in Thread.join t ; match!r with Some v -> y + v None -> failwith impossible 10

11 Back to the Futures module type FUTURE = sig type a future val future : ( a-> b) -> a -> b future val force : a future -> a end val f : unit -> int val g : unit -> int with futures library: let x = future f () in let y = g () in let v = force x in y + x Moral: Futures + typing ensure en?re categories of errors can t happen - - you protect yourself from your own stupidity without futures library: let r = ref None let t = Thread.create (fun _ -> r := Some(f ())) () in let y = g() in Thread.join t ; match!r with Some v -> y + v None -> failwith impossible 11

12 Back to the Futures module type FUTURE = sig type a future val future : ( a-> b) -> a -> b future val force : a future -> a end val f : unit -> int val g : unit -> int with futures library: let x = future f () in let v = force x in let y = g () in y + x what happens if you relocate force, join? without futures library: let r = ref None let t = Thread.create (fun _ -> r := Some(f ())) () in Thread.join t ; let y = g() in match!r with Some v -> y + v None -> failwith impossible 12

13 Back to the Futures module type FUTURE = sig type a future val future : ( a-> b) -> a -> b future val force : a future -> a end val f : unit -> int val g : unit -> int with futures library: let x = future f () in let v = force x in let y = g () in y + x Moral: Futures are not a universal savior without futures library: let r = ref None let t = Thread.create (fun _ -> r := Some(f ())) () in Thread.join t ; let y = g() in match!r with Some v -> y + v None -> failwith impossible 13

14 An Example: Mergesort on Arrays let mergesort (cmp:'a->'a->int) (arr : 'a array) : 'a array = let rec msort (start:int) (len:int) : 'a array = match len with 0 -> Array.of_list [] 1 -> Array.make 1 arr.(start) _ -> let half = len / 2 in let a1 = msort start half in let a2 = msort (start + half) merge a1 a2 (len - half) in and merge (a1:'a array) (a2:'a array) : 'a array =... 14

15 An Example: Mergesort on Arrays let mergesort (cmp:'a->'a->int) (arr : 'a array) : 'a array = let rec msort (start:int) (len:int) : 'a array = match len with 0 -> Array.of_list [] 1 -> Array.make 1 arr.(start) _ -> let half = len / 2 in let a1 = msort start half in let a2 = msort (start + half) (len - half) in merge a1 a2 and merge (a1:'a array) (a2:'a array) : 'a array = let a = Array.make (Array.length a1 + Array.length a2) a1.(0) in let rec loop i j k = match i < Array.length a1, j < Array.length a2 with true, true -> if cmp a1.(i) a2.(j) <= 0 then (a.(k) <- a1.(i) ; loop (i+1) j (k+1)) else (a.(k) <- a2.(j) ; loop i (j+1) (k+1)) true, false -> a.(k) <- a1.(i) ; loop (i+1) j (k+1) false, true -> a.(k) <- a2.(j) ; loop i (j+1) (k+1) false, false -> () in loop ; a in msort 0 (Array.length arr) 15

16 An Example: Mergesort on Arrays let mergesort (cmp:'a->'a->int) (arr : 'a array) : 'a array = let rec msort (start:int) (len:int) : 'a array Opportunity = for paralleliza?on match len with 0 -> Array.of_list [] 1 -> Array.make 1 arr.(start) _ -> let half = len / 2 in let a1 = msort start half in let a2 = msort (start + half) merge a1 a2 (len - half) in and merge (a1:'a array) (a2:'a array) : 'a array =... 16

17 Making Mergesort Parallel let mergesort (cmp:'a->'a->int) (arr : 'a array) : 'a array = let rec msort (start:int) (len:int) : 'a array = match len with 0 -> Array.of_list [] 1 -> Array.make 1 arr.(start) _ -> let half = len / 2 in let a1_f = Future.future (msort start) half in let a2 = msort (start + half) (len - half) in merge (Future.force a1_f) a2 and merge (a1:'a array) (a2:'a array) : 'a array =... 17

18 Making it Pre_er We've seen this a lot: let a1 = Future.future f x in let a2 = g y in... (Future.force a1)... a

19 Making it Pre_er We've seen this a lot: let a1 = Future.future f x in let a2 = g y in... (Future.force a1).. a2 Let's build another abstrac?on that evaluates a pair of func?ons in parallel: let both f x g y = let a1 = Future.future f x in let a2 = g y in (Future.force a1, a2) 19

20 Making it Pre_er We've seen this a lot: let a1 = Future.future f x in let a2 = g y in... (Future.force a1)... a2... let a1, a2 = both f x g y in... a1... a

21 Making Mergesort Parallel let mergesort (cmp:'a->'a->int) (arr : 'a array) : 'a array = let rec msort (start:int) (len:int) : 'a array = match len with 0 -> Array.of_list [] 1 -> Array.make 1 arr.(start) _ -> let half = len / 2 in let a1,a2 = both (msort start) half in merge a1 a2 (msort (start + half)) (len half) and merge (a1:'a array) (a2:'a array) : 'a array = 21

22 Divide- and- Conquer This is an instance of a basic divide- and- conquer padern in parallel programming take the problem to be solved and divide it in half fork a thread to solve the first half simultaneously solve the second half synchronize with the thread we forked to get its results combine the two solu?on halves into a solu?on for the whole problem. Warning: the fact that we only had to rewrite 2 lines of code for mergesort made the paralleliza?on transforma?on look decep?vely easy we also had to verify that any two threads did not touch overlapping por?ons of the array - - if they did we would have to again worry about scheduling non- determinism 22

23 Caveats There is some overhead for crea?ng a thread. On a uni- processor, parallel code will run slower than the sequen?al code. Even on a mul?- processor, we probably do not always want to fork a thread when the sub- array is small, faster to sort it than to fork a thread to sort it. similar to using inser?on sort when arrays are small vs. quicksort this is known as a granularity problem more parallelism than we can effec?vely take advantage of. 23

24 Caveats In a good implementa?on of futures, a compiler and run-?me system might look to see whether the cost of doing the fork is jus?fied by the amount of work that will be done. Today, it s up to you to figure this out L typically, use parallel divide- and- conquer un?l (a) we have generated at least as many threads as there are processors ogen more threads than processors because different jobs take different amounts of?me to complete and we would like to keep all processors busy (b) the sub- arrays have goden small enough that it s not worth forking. 24

25 Another Example type 'a tree = Leaf Node of 'a node and 'a node = {left : 'a tree ; value : 'a ; right : 'a tree } let rec fold (f:'a -> 'b -> 'b -> 'b) (u:'b) (t:'a tree) : 'b = match t with Leaf -> u Node n -> let l,r = (fold f u n.left, in f n.value l r fold f u n.right) let sum (t:int tree) = fold (+) 0 t 25

26 Another Example type 'a tree = Leaf Node of 'a node and 'a node = {left : 'a tree ; value : 'a ; right : 'a tree } let rec pfold (f:'a -> 'b -> 'b -> 'b) (u:'b) (t:'a tree) : 'b = match t with Leaf -> u Node n -> let l,r = both (pfold f u) n.left (pfold f u) n.right in f n.value l r let sum (t:int tree) = pfold (+) 0 t 26

27 Note If the tree is imbalanced, then we re not going to get the same speedup as if it s balanced. Consider the degenerate case of a list. The forked child will terminate without doing any useful work. So the parent is going to have to do all that work. Pure overhead L In general, lists are a horrible data structure for parallelism. we can t cut the list in half in constant :me for arrays and trees, we can do that (assuming the tree is balanced.) 27

28 REVISITING OUR FUTURE IMPLEMENTATION

29 Excep?ons and Futures exception Hello let main () = let x = Future.future (fun x -> raise Hello) () in try force x with Hello -> print_endline "world" let _ = main () What happens now?

30 Excep?ons and Futures exception Hello let main () = let x = Future.future (fun x -> raise Hello) () in try force x with Hello -> print_endline "world" let _ = main () $./future.d.byte Thread 1 killed on uncaught exception Future.Hello Fatal error: exception Failure("impossible!")

31 Future Implementa?on (Version 2) module Future : FUTURE = struct type 'a result = Unevaluated Evaluated of 'a Exception of exn type 'a future = { tid: Thread.t; result: 'a result ref } let future f x = let r = ref Unevaluated in... let work () = try r := Evaluated (f x) with e -> r := Exception e in let t = Thread.create work () in {tid=t ; result=r} 31

32 Future Implementa?on (Version 2) module Future : FUTURE = struct type 'a result = Unevaluated Evaluated of 'a Exception of exn type 'a future = { tid: Thread.t; result: 'a result ref }... end let force (f:'a future) : 'a = Thread.join f.tid; match!(f.result) with Evaluated v -> v Exception e -> raise e Unevaluated -> failwith "impossible!" 32

33 Future Implementa?on (Version 2) module Future : FUTURE exception Hello let main () = let x = future (fun x -> raise Hello) () in try force x with Hello -> print_endline "world" let _ = main () 33

34 Future Implementa?on (Version 2) module Future : FUTURE exception Hello let main () = let x = future (fun x -> raise Hello) () in try force x with Hello -> print_endline "world" let _ = main () $./future.d.byte world 34

35 Other Side Effects? type 'a tree = Leaf Node of 'a node and 'a node = { left : 'a tree ; value : 'a ; right : 'a tree } let rec pfold (f:'a -> 'b -> 'b -> 'b) (u:'b) (t:'a tree) : 'b = match t with Leaf -> u Node n -> let l,r = both (pfold f u) n.left (pfold f u) n.right in f n.value l r let print (t:int tree) = pfold (fun n -> Printf.print %d\n n) () 35

36 Pure Func?ons A func?on (or expression) is pure if it has no effects. (Valuable expressions are pure) Recall that a func?on has an effect if its behavior cannot be completely explained by a determinis:c, total func?on that relates its inputs and its outputs Expressions have effects when they: don't terminate raise excep?ons read from stdin/print to stdout read or write to a shared mutable data structure increasingly difficult to deal with Not an effect: reading from immutable data structures

37 Benign Effects & Futures What if your program has effects? (Most useful programs do!) Try to push the effects to the edges of your program and put parallelism in the middle. Especially limit mutable data. let main () = effect let main () = effect effect effect effect pure parallelism

38 REASONING PRINCIPLES

39 Huge Point If code is purely func:onal, then it never maaers in what order it is run. If f () and g () are pure then the following are equivalent: if f, g are total func?ons (f (), g ()) == both f () g () 39

40 Huge Point If code is purely func:onal, then it never maaers in what order it is run. If f () and g () are pure then the following are equivalent: if f, g are total func?ons (f (), g ()) == both f () g () let x = e1 in e2 == let x = future (fun _ -> e1) () in e2[force x/x] if e1 is valuable 40

41 Huge Point If code is purely func:onal, then it never maaers in what order it is run. If f () and g () are pure then the following are equivalent: if f, g are total func?ons (f (), g ()) == both f () g () let x = e1 in e2 == let x = future (fun _ -> e1) () in e2[force x/x] if e1 is valuable If your code contains no other effects, futures do not introduce non- determinism! Consequence: when it comes to reasoning about the correctness of your programs, we can reduce the problem of reasoning about pure func?onal code + parallel futures to the problem of reasoning about pure func?onal sequen?al code! 41

42 if e1 is valuable then: let x = e1 in e2 Example Transforma?on == let x = future (fun _ -> e1) () in e2[force x/x] type 'a tree = Leaf Node of 'a * 'a tree * 'a tree let rec fold (f:'a -> 'b -> 'b -> 'b) (u:'b) (t:'a tree) : 'b = match t with Leaf -> u Node (n,left,right) -> let left' = fold f u left in let right' = fold f u right in f n left' right'

43 if e1 is valuable then: let x = e1 in e2 Example Transforma?on == let x = future (fun _ -> e1) () in e2[force x/x] type 'a tree = Leaf Node of 'a * 'a tree * 'a tree let rec fold (f:'a -> 'b -> 'b -> 'b) (u:'b) (t:'a tree) : 'b = match t with Leaf -> u Node (n,left,right) -> let left' = future (fun _ -> fold f u left) () in let right' = fold f u right in f n (force left') right'

44 if e1 is valuable then: let x = e1 in e2 Example Transforma?on == let x = future (fun _ -> e1) () in e2[force x/x] type 'a tree = Leaf Node of 'a * 'a tree * 'a tree let rec fold (f:'a -> 'b -> 'b -> 'b) (u:'b) (t:'a tree) : 'b = match t with Leaf -> u Node (n,left,right) -> let left' = future (fun _ -> fold f u left) () in let right' = fold f u right in f n (force left') right' Moral: It is vastly easier to introduce parallelism in to a pure func:onal program using futures than in to an impera?ve program with effects

45 END