STREAMS VS PARALLELSTREAMS BY VAIBHAV CHOUDHARY JAVA PLATFORMS TEAM, ORACLE

Transcription

1 STREAMS VS PARALLELSTREAMS BY VAIBHAV CHOUDHARY JAVA PLATFORMS TEAM, ORACLE

2 IN SHORT, WE WILL DISCUSS Concurrency and Parallelism Stream support in Java 8 Streams to Parallel Streams Implementation of Parallel Streams Performance Considerations

3 PERFORMANCE DEFINTION CHANGE Performance definition changed over time ::- Single-Core Time frame - Non-blocking, Prioritisation Multi-Core Time Frame - Focused on better throughput Many-Core Time Frame - Focused on better latency Software should dynamically adapt the requirements.

4 TREND IN JDK RELEASES JDK 1 JDK 5 JDK 7 JDK 8 Threads, Locks, Condition queues Fork-Join Framework Concurrency Package, Blocking Queues, Latches, Thread Pools Parallel Streams

5 CONCURRENCY VS PARALLELISM Concurrency is tough Its about efficiently using the shared resources. Its about dealing with thread safety, locks, semaphores, race conditions ITS TOUGH. Parallelism is relatively less complex Its about breaking the task into sub-task and get results faster. Faster, and only faster (with more resources).

6 PARALLELISM It is all about optimisation. Faster results, that s it! Analyse -> Implement -> Test -> Repeat If no better result, move to sequential work. Why you think, it should take more time than sequential implementation?

7 PARALLELISM OVERHEAD Parallel computation always involves more task than its alternative sequential computation. Always a slow start-up. DECOMPOSE THE PROBLEM INTO TASK LAUNCH TASK, MANAGE TASK, WAIT FOR COMPLETION + SOLVE THE PROBLEM COMBINE RESULTS

8 PARALLELISM WHEN And to succeed, you need it ( ALL ) :- A problem that can be broken into parallel. A niche implementation A good runtime support Minimum data to get benefited out of it.

9 UNDERSTANDING DATA FLOW DEPENDENCY Consider a problem and look at the data dependency. f(f(0) need f(0) Iterative problem Bad idea to think of parallelism G(3) G(2) G(N) = F (G(N-1)), IF N > 0 G(1) G(0) = F(0) G(0)

10 CONSIDER SIMILAR PROBLEMS G(N) = F(N) + G(N-1), IF N>0 G(2) G(0) = F(0) G(1) F(2) G(0) F(1) G(2) F(0) F(2) F(1) F(0)

11 REACHING TO PARALLEL COMPUTATION Example: Sum number. Lets talk of the various possible approach. INT SUM (INT[] ARR) { INT SUM = 0; FOR (INT I : ARR) SUM = SUM + I; RETURN SUM; Bad! Unlearn, accumulator pattern! Bad!

12 Let s try to solve this problem with Concurrency. INT SUM (INT[] ARR) { INT SUM = 0; FOR (INT I : ARR) SUM = SUM + ARR[I]; RETURN SUM; ATOMIC{ ATOMIC{ INT SUM (INT[] ARR) { INT SUM = 0; INT MID = ARR.LENGTH/2; CONCURRENT { { FOR (INT I=0; I< MID; I++) SUM = SUM + ARR[I]; { FOR (INT I=MID;I<ARR.LENGTH; I++) SUM = SUM + ARR[I]; RETURN SUM;

13 INT SUM (INT[] ARR) { INT SUM = 0; INT MID = ARR.LENGTH/2; CONCURRENT { { FOR (INT I=0; I< MID; I++) ATOMIC { SUM = SUM + ARR[I]; { FOR (INT I=MID;I<ARR.LENGTH; I++) ATOMIC { SUM = SUM + ARR[I]; RETURN SUM; -> Performance : It will just suck! -> What s wrong: Spending too much time in safeguarding the data -> Best practices: Don t share, Don t mutate, Coordinate access. -> Let s try with Don t share

14 DON T SHARE INT SUM (INT[] ARR) { INT LEFT = 0, INT RIGHT = 0; INT MID = ARR.LENGTH/2; CONCURRENT { { FOR (INT I=0; I< MID; I++) ATOMIC { LEFT = LEFT + ARR[I]; { FOR (INT I=MID;I<ARR.LENGTH; I++) ATOMIC { RIGHT = RIGHT + ARR[I]; RETURN LEFT + RIGHT; -> Looks better. -> But not the generic solution.

15 TOWARDS PARALLELISM // PSEUDOCODE Result solve(problem problem) { if (problem.size < SEQUENTIAL_THRESHOLD) return solvesequentially(problem); else { Result left, right; INVOKE-IN-PARALLEL { left = solve(extractlefthalf(problem)); right = solve(extractrighthalf(problem)); return combine(left, right);

16 Fork-Join Framework TASK SUB-TASK SUB-TASK SUB-TASK SUB-TASK SUB-TASK SUB-TASK JOIN JOIN JOIN JOIN JOIN JOIN JOIN

17 public class MaxWithFJ extends RecursiveAction { private final int threshold; private final SelectMaxProblem problem; public int result; public MaxWithFJ(SelectMaxProblem problem, int threshold) { this.problem = problem; this.threshold = threshold; protected void compute() { if (problem.size < threshold) result = problem.solvesequentially(); else { int midpoint = problem.size / 2; MaxWithFJ left = new MaxWithFJ(problem.subproblem(0, mi MaxWithFJ right = new MaxWithFJ(problem.subproblem(mid 1, problem.size), threshold); coinvoke(left, right); result = Math.max(left.result, right.result); public static void main(string[] args) { SelectMaxProblem problem =... int threshold =... int nthreads =... MaxWithFJ mfj = new MaxWithFJ(problem, threshold); ForkJoinExecutor fjpool = new ForkJoinPool(nThreads); fjpool.invoke(mfj); int result = mfj.result;

18 RESULTS AND SELECTION THREAD/ THRESHOLD 500K 50K 5K thread thread thread thread Run for the size of 500K better but underperforming

19 PERFORMANCE CONSIDERATIONS Splitting / Decomposing the problem Sometimes splitting is more expensive Task Management Cost Need to have a close look. Result Combination Cost Locality issue - Cache misses. EACH OF IT CAN BE PERFORMANCE KILLER.

20 STREAMS IN JAVA 8 Complexity of Fork-Join - Simplified in Streams. Simple pipelines like reduce, sort, map, filter. Exploits lazy evaluation. No magical parallelism. We have to own it. We have to apply our knowledge to get the right result.

21 THE NQ MODEL Simple model for parallel performance N : No of elements Q: amount of work per item. N X Q > 10,000 -> chance for parallelism. Important for say minimum data

22 SOURCE SPLITTING Source splitting is very important. Some source split awesome, some sucks. Cost of computation for split. Evenness in split. Predicability in split. Array rocks, LinkedList sucks, Tree goes OK-OK.

23 LOCALITY PLAYS ROLE Locality is dangerous. Parallelism is good if CPU is busy in good work. Cache miss is not a good work. Stream.of(int[].sum()) vs Stream.of(Integer[].sum()) Speed Up N=1K N=10K N=1M int 1x 6.2x 7.9x Integer -4.9x 1.5x 3.5x

24 LETS REPEAT When to consider parallelism NQ is high Low Cache miss Source good for splitting. Combining cost not high. Pipeline takes order insensitive operations.

25 LETS PRACTICE

26 JUST GET A BIT OF TECHNICALITY COLLECTIONS.STREAM() // SOURCE.FILTER() //INTERMEDIATE OPS.MAP() //INTERMEDIATE OPS.COLLECT() //TERMINAL OPS COLLECTIONS.STREAM() // SOURCE.FILTER() //INTERMEDIATE OPS.PARALLEL() // PARELLEL STREAM.MAP() //INTERMEDIATE OPS.SEQUENTIAL() // SEQUENTIAL ST.COLLECT() //TERMINAL OPS ( Last wins, either parallel or sequential)

27 FIRST EXAMPLE import java.util.list; import java.util.stream.intstream; import static java.util.stream.collectors.tolist; public class ParallelExample1 { public static void main(string[] args) { List <String> output = IntStream.range(0,50).parallel(). filter(i -> i%5 == 0). maptoobj(i -> String.valueOf(i/5)). collect(tolist()); System.out.println(output); WITHOUT PARALLEL : OUTPUT: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] WITH PARALLEL : OUTPUT: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

28 TIME ORDER VS SPACIAL ORDER.parallel() So, in example 1, time order change not the spatial order

29 EXAMPLE 2 - GOOD USAGES import java.util.arraylist; import java.util.list; import java.util.random; import java.util.set; import java.util.concurrent.concurrentskiplistset; import java.util.stream.collectors; public class SortingParallelExample { public static void main(string[] args) { List<Integer> list = new ArrayList<>(); Set<String> nthread = new ConcurrentSkipListSet<>(); Random rn = new Random(); for (int i = 0; i < 10_00_00_00; i++) { list.add((int) rn.nextint() * ); for (int i = 0; i < 10; i++) { long start = System.currentTimeMillis(); List<Integer> even = list.parallelstream(). filter(n -> n % 2 == 0). peek(n -> nthread.add(thread.currentthread().getname())). sorted(). collect(collectors.tolist()); long end = System.currentTimeMillis(); System.out.println(end - start + " " + "Active threads " + Thread.activeCount()); System.out.println("Thread Names are " + nthread);