Due: Fri, Sept 15 th, 5:00 p.m. Parallel and Sequential Data Structures and Algorithms (Fall 17)

Transcription

1 Lab 2 - SkylineLab Due: Fri, Sept 15 th, 5:00 p.m. Parallel and Sequential Data Structures and Algorithms (Fall 17) 1 Introduction This assignment is designed to give you more practice with divide-and-conquer algorithms as well as provide an introduction to using the sequence function scan. You will analyze and solve the skyline problem, which is a geometric problem in 2 dimensions. This lab is conceptually difficult, so be sure to get started early! 2 Files After downloading the assignment tarball from Autolab, extract the files by running: tar -xvf skylinelab-handout.tgz from a terminal window. Some of the files worth looking at are listed below. The files denoted by * will be submitted for grading. 1. * MkSkyline.sml 2. * MkPerfSkyline.sml 3. Sandbox.sml 4. Tests.sml Additionally, you should create a file called: written.pdf which contains the answers to the written parts of the assignment. provided a L A TEX template (written.tex). For your convenience, we ve 3 Submission To submit your assignment to Autolab, generate a handin archive handin.tgz with the command make package then open the Autolab webpage and submit your handin.tgz file via the Submit File link. If your code compiles correctly, then in the Compilation column, Autolab will display a score of 0. Code which does not compile will show a negative score in this column. Please double check your submission on the Autolab webpage to make sure there were no errors. Once you ve completed all problems, you should submit your written.pdf to Gradescope. Note that your code will not be graded until after the due date. It is your responsibility to test your code thoroughly before submitting.

2 (Fall 2017) SkylineLab 4 The Skyline Problem Feast your eyes upon downtown Pittsburgh. From our perspective, most of the buildings are roughly rectangular (the exceptions being those like PPG Place), so let s assume from now on that all buildings are rectangles. We ll also assume that the ground is perfectly flat so that all the rectangles rest on the same line. The skyline of these rectangles is basically their silhouette. 4.1 Buildings Under the assumptions given, each building can be represented by a triple (`, h, r) which describes a rectangle with corners (`, 0), (`, h), (r, h), and (r, 0). We will assume ` < r so that ` and r are the left and right sides of the building, and h is the height of the building. 2

3 4.2 Definition The skyline of a set of buildings B is { (x, H(x)) : x X } x = min X H(x) H(prev(x)) where X is the set of all x-coordinates in B, H(x) is the max height at x, and prev(x) is the nearest x to the left of x, given by X = {l, r} (l,h,r) B H(x) = max { h : (l, h, r) B l x < r } prev(x) = max { x X x < x } In other words, the x-coordinates in the skyline are exactly those which appear in B, and the y-coordinate for any particular x is the height h of the tallest building (l, h, r) for which l x < r. We do not include redundant points: points whose height is unchanged from the nearest point to the left. 4.3 Example In the diagrams below, skyline points are marked with diagram with.. Redundant points are marked in the first Skyline: Buildings: l h r x y

4 4.4 Implementation We define type skyline = (int * int) Seq.t. We maintain the convention that all skylines are sorted by x-coordinate, and do not contain redundant points. Throughout, we assume that all x-coordinates are unique and non-negative, and that all heights are strictly positive. Given a sequence of buildings B in no particular order, your goal is to write a divide-and-conquer algorithm for the skyline problem of the following form: fun skyline B = case Seq.splitMid B of Seq.EMPTY Seq.empty () Seq.ONE x singleton x Seq.PAIR (L, R) combine (Primitives.par (fn () skyline L, fn () skyline R)) The runtime behavior of this code is identical to the following, which uses reduce to automate the divide-and-conquer process. fun skyline B = Seq.reduce combine (Seq.empty ()) singleton b : b B All you have to do is write the functions singleton and combine. Task 4.1 (70 pts). In MkSkyline.sml, implement the following functions. val singleton : int * int * int skyline (singleton (l, h, r)) should evaluate to the skyline of a single building (l, h, r). Your implementation must take constant time. val combine : skyline * skyline skyline (combine (S 1, S 2 )) should evaluate to the skyline of all buildings from both S 1 and S 2. Your implementation must have O( S 1 + S 2 ) work and O(log S 1 + log S 2 ) span. Some notes: As usual, assume Seq = ArraySequence for cost analysis. In combine, you will probably find the functions merge, scan (or scanincl), and filter (or filteridx) particularly useful. Note that for constant-time functions f, (scan f b S) has O( S ) work and O(log S ) span. The cost bounds of scanincl are identical to scan. Don t forget about removing redundant points! 4

5 5 Testing There are two ways to test your code. 1. In Sandbox.sml, write whatever testing code you d like. You can then access the sandbox at the REPL: - CM.make "sandbox.cm";... - open Sandbox; 2. In Tests.sml, add test cases according to the instructions given. Then run the autograder: - CM.make "autograder.cm";... - Autograder.run (); As usual, it is very important that you thoroughly test your code before you submit. deadline, we will grade your code with a private set of test cases. After the 5

6 6 Analysis 6.1 Cost Consider the functions skyline, combine, and singleton as given in section 4.4. Assume combine and singleton are implemented correctly and meet the required cost bounds. Task 6.1 (5 pts). Give an upper bound for combine (S 1, S 2 ) in terms of S 1 and S 2. Task 6.2 (5 pts). Write the work and span recurrences of (skyline B) in terms of n = B. State the tight Big-O bound for each recurrence (don t show your work of solving them; we just want the bound). Task 6.3 (15 pts). Suppose that (combine (S 1, S 2 )) now has O( S 1 log S 1 + S 2 log S 2 ) work. Write the new work recurrence of (skyline B) in terms of n = B. Solve it using the substitution method and give a tight Big-O bound (show your work this time). 6.2 Finding a Lower Bound Our skyline algorithm runs in O(n log n) time. 1 But is this algorithm the fastest possible, asymptotically? It turns out that the answer is yes! It is well known that any comparison-based sorting algorithm requires at least Ω(n log n) work in the worst case. 2 This lower bound applies to the skyline problem as well; for a proof, we just have to construct a reduction from the sorting problem. Task 6.4 (15 pts). Assume you have a black-box algorithm skyline with the same specification as the one given in section 4.4. In written.pdf, write pseudocode for a function val sort : int Seq.t int Seq.t which sorts its input. Your solution must be O(n + W skyline (n)). For the sake of simplicity, you may assume the input contains only non-negative numbers and no duplicates. Our solution is 4 lines long. Task 6.5 (5 pts). Argue in just a few short sentences why this reduction proves that skyline must run in time Ω(n log n) in the worst case. 1 Oops, this pretty much gives away the answer for part of an earlier task... oh well! 2 If you haven t seen this proof before, a quick Google search should yield a wealth of useful information. 6

7 7 Performance You will now adapt your Skyline code to be (hopefully) faster, and test it. First, you will need access to the mlton-spoonhower compiler. Begin by SSHing into linux.andrew.cmu.edu, and then add the following to your PATH. Don t forget to source the edited file so that the changes to PATH are visible. /afs/cs/academic/class/15210-s17/mlton-spoonhower/build/bin/ (If you do not know how to do this, first check which shell you are using via echo $SHELL, and then Google search! If you re still having trouble, ask another student or a TA for help.) Task 7.1 (10 pts). In MkPerfSkyline.sml, implement skyline with the goal of better performance. As a starting point, try copying in your existing implementations of singleton and combine, and write skyline by adapting the code shown in Section 4.4. We will not be grading the code in MkPerfSkyline.sml for style and readability. Note that in this file, skyline also takes an argument g, which is intended to be a granularity parameter. g will be controllable from the command line. Feel free to use it however you would like in your implementation. After completing your new implementation, compile your code via mlton-spoonhower skyline.fj.mlb and then run a self-speedup experiment with the following command. You should replace <ps> with a comma-separated list of processor counts. Replace <r> with the number of times each trial should be repeated (the results will be averaged; more runs will reduce the effect of random noise in your experiment). Replace <n> with the desired input size, which should be at least 1,000,000. Finally, replace <g> with the desired granularity, which is then passed as an argument to your implementation../plotting/plot.pl -proc <ps> -runs <r> -size <n> -granularity <g> For example:./plotting/plot.pl -proc 1,2,4,8 -runs 5 -size granularity 1000 This command produces a speedup plot in a file plots.pdf. Please include an image of this plot in your submitted written.pdf. Finally, write a paragraph or two detailing what changes you made to your implementation, and what the effects were. Note that we won t penalize you for not achieving good performance. If you find that one of your changes made things worse, then tell us about it! 7