Concurrency ECE2893. Lecture 12. ECE2893 Concurrency Spring / 16

Transcription

1 Concurrency ECE2893 Lecture 12 ECE2893 Concurrency Spring / 16

2 Single Core Architectures 1 Recall that in the very beginning of the class we discussed the basic architecture of a modern computer, consisting of: 1 Memory (usually up to 4 Giga Bytes (billion bytes)) 2 Central Processing Unit (CPU) 3 Input Output Devices (keyboard, mouse, monitor, disks, network) 2 Up till recently, computers were most often designed with with only one CPU. ECE2893 Concurrency Spring / 16

3 Computer Conceptual Model ECE2893 Concurrency Spring / 16

4 Multi Processing 1 Even with only one CPU, the computer can do many tasks simultaneously. 2 It does this by multi processing (sometimes called multi tasking). 3 The CPU periodically switches its attention between the various tasks (called processes). 4 The so called context switch time varies between operating system implementations, but is usually on the order of 10 milliseconds. 5 Switching tasks that often gives the appearance of doing many things at once! 6 In fact, at any one point in time, only one task (process) is being executed by the CPU. ECE2893 Concurrency Spring / 16

5 Sample process list from Mac OSX Processes: 77 total, 2 running, 1 stuck, 74 sleeping threads 10:11:04 Load Avg: 0.35, 0.28, 0.25 CPU usage: 9.52% user, 8.23% sys, 82.25% idle SharedLibs: num = 4, resident = 86M code, 4464K data, 5172K linkedit. MemRegions: num = 17688, resident = 442M + 32M private, 320M shared. PhysMem: 607M wired, 1245M active, 229M inactive, 2092M used, 2005M free. VM: 7797M + 374M (0) pageins, 0(0) pageouts PID COMMAND %CPU TIME #TH #PRTS #MREGS RPRVT RSHRD RSIZE VSIZE top 12.6% 0: K 200K 1192K 18M cupsd 0.0% 0: K 228K 2088K 19M mdworker 0.0% 0: K 17M 7720K 37M emacs 0.2% 0: K 28M 19M 238M nmbd 0.0% 0: K 188K 1260K 19M Mail 0.2% 2: M 52M 86M 343M mdworker 0.0% 0: K 14M 2940K 34M tcsh 0.0% 0: K 188K 1364K 18M login 0.0% 0: K 228K 1064K 19M PrinterPro 0.0% 0: K 19M 7004K 203M PrinterPro 0.0% 0: K 19M 7084K 203M QuickTime 0.0% 0: M 41M 42M 311M 8739 DiskManage 0.0% 0: K 11M 1880K 29M 8738 Software U 0.0% 0: M 28M 24M 250M 4582 quartz-wm 0.0% 0: K 5500K 2696K 166M 4579 Xquartz 0.4% 2: K 26M 13M 234M ECE2893 Concurrency Spring / 16

6 Multi Core Architectures 1 Recently, processor chip manufacturers (Intel) are using a multi core design. 2 Each CPU chip in fact has more than one central processing unit! 3 However, we still have only one memory unit, and the multiple CPUs share the Input Output Devices. 4 Current designs (Fall 2008) can have two to four CPU s per chip. 5 The multiple CPUs per chip operate completely independenly. 1 Separate Register files 2 Separate Program Counter 3 Separate Stack Pointer 4 etc. 6 Question. How can we effectively utilize this design to gain better performance? ECE2893 Concurrency Spring / 16

7 Multi Core Architectures 1 One approach is to assign the CPUs to different processes. 1 One CPU could be working on bubble sort 2 One CPU could be working on Euclid s algorithm 3 One CPU could be working on a binary tree 4 One CPU could be working on text editing with emacs. 2 Since each of the above processes are completely idependent of each other, they can all work without any knowledge of that the other is doing. 3 This works well when a given computer has many simultaneous, CPU intensive processes to work on. 4 However, this is not a good solution for situations where we want a single task (process) to execute faster. ECE2893 Concurrency Spring / 16

8 Multi Core Architectures ECE2893 Concurrency Spring / 16

9 Parallel Bubble Sort 1 Suppose we have a large array (perhaps 256,000 elements) to be sorted using bubble sort. 2 Can we modify our existing bubble sort algorithm (or the binary tree algorithm) to use multiple CPU s simulataneously and get the sorted results faster? 3 YES! But it requires us to re think the basic approach to the sorting algorithm. ECE2893 Concurrency Spring / 16

10 Parallel Bubble Sort Algorithm 1 Assume we have k CPUs available to work on the bubble sort, for an array d of size N to be sorted. 2 Divide the array begin sorted into k sub arrays. 3 Each CPU gets N/k elements to sort. 1 For example, if k = 2 and the array length is 32: 2 Assign CPU zero to the first 16 elements. 3 Assign CPU one to the last 16 elements. 4 It is not necessary that each CPU get exactly the same number of elements to sort, but they should be about the same. 5 Each CPU independently sorts it s sub array. 6 When all CPUs have finished sorting, perform the Merge steps: 1 Create a new array e of size N. 2 Create an array f of size k, all values initially zero. 3 SET i = 0 4 WHILE (i < N) 1 Find the smallest value in each of the sub arrays, assuming that each sub array starts at f [k]. Set k1 to the index of the sub array with the smallest value. 2 Copy the minimum value to e[i]. 3 SET f [k1] = f [k1] SET i = i Array e now contains the sorted values. 8 Question: If the original single CPU bubble sort ran in 60 seconds, how long would the parallel sort run if we assigned 2 CPU s to it? ECE2893 Concurrency Spring / 16

11 Parallel Bubble Sort Complexity 1 Recall that the performance of bubble sort is proportional to N 2, where N is the size of the array being sorted. 2 If we assign 2 CPU s, then each CPU sorts N 2 elements 3 Thus, the complexity of each of the two sub array sorts is ( N 2 )2 = N We do need some time to do the merge, but this is proportional to kn, not N 2, so can be ignored in this analysis. 5 This means that if the single CPU case runs in 60 seconds, we can expect the 2 CPU case to run in 15 seconds! 6 What if we only have one CPU, but divide the array to be sorted into two sub arrays and sort them sequentially? 7 In this case, we still see an improvement, running in 30 seconds. 8 Again, keep in mind that we are ignoring the time needed to do the merging of the sub arrays, but that time is proportional to kn, not N 2. ECE2893 Concurrency Spring / 16

12 Parallel Binary Tree 1 Can we use multiple CPUs to speed up the performance of the insertion sort with binary trees? 2 We can of course use the multiple sub arrays as before, assigning each CPU to sort part of the array 3 In this case however, we want to build a single binary tree with the sorted value for the entire array. 4 This means that the multiple CPUs will be accessing (and changing) the contents of the single binary tree simultaneously. 5 This introduces some difficulties, as we shall see. ECE2893 Concurrency Spring / 16

13 Insertion Sort Algorithm 1 void InsertValue(TreeNode* n, int v) // Insert value v into the (sub)-tree with root at n. // There are three possibilities. 1 If Value v is the same as the value at node n then increment the count value in node n. 2 If Value v is less than the value in node n then a) If the left side child is NULL Create a new node with value v and count 1. Make the new node the left side child if node n. otherwise: InsertValue(n->LeftChild, v); // Recursion 3 If Value v is greater than the value in node n then a) If the right side child is NULL Create a new node with value v and count 1. Make the new node the right side child of node n. otherwise: InsertValue(n->RightChild, v); // Recursion ECE2893 Concurrency Spring / 16

14 Parallel Insertion Sort, Step Step 1.1 above says (essentially) if v is the same as the value at node n, set count to count This seems simple enough, but unfortunately causes problem when implementing the concurrent version. 3 Here is a possible assembly language implementation of: count = count + 1 LDM R1,count # Load the value of count into R1 ADDI R1,R1, 1 # Increment R1 by 1 STM R1,count # Store incremented count 4 What if 2 CPU s execute the above assembly language at exactly the same time? 5 In this case, count should be incremented twice, but it only ends up being incremented by one! ECE2893 Concurrency Spring / 16

15 Parallel Insertion Sort, Step 1.2.a 1 Step 1.2.a says, (essentially) if the left side is NULL, create a new node and make the left side point to the new node. 2 This also seems simple enough, but again causes problems. LDI R0,0 # Set R0 to zero (the null pointer) LDM R1,LeftChild # Set R1 to LeftChild ptr BNE R1,R0,?? # LeftChild NOT NULL, branch # At this point, the left child is NULL. # We allocate a new node (code not shown) # and put the pointer (address) in R2 STM R2,LeftChild # Store the left child pointer 3 As in the previous case, if two CPU s do the above at exactly the same time, we end up with incorrect results. 4 Step 1.3.a has the same problem. ECE2893 Concurrency Spring / 16

16 Mutual Exclusion 1 The prior discussion is an example of a very common problem in concurrent programming called concurrent access or concurrent update. 2 Fortunately, there is a well known an well understood approach to solving such problems, called Mutual Exclusion. 3 This is one of the topics for the next handout. ECE2893 Concurrency Spring / 16