Prepared 8/19/2011 by T. O’Neil for 3460:677, Fall 2011, The University of Akron.

Partitioning: simply divides the problem into parts Divide-and-Conquer: Characterized by dividing the problem into sub-problems of same form as larger problem. Further divisions into still smaller sub-problems, usually done by recursion. Recursive divide-and-conquer amenable to parallelization because separate processes can be used for divided parts. Also usually data is naturally localized. Partitioning and Divide-and-Conquer Strategies – Slide 2

Data partitioning/domain decomposition Independent tasks apply same operation to different elements of a data set Okay to perform operations concurrently Functional decomposition Independent tasks apply different operations to different data elements Statements on each line can be performed concurrently Partitioning and Divide-and-Conquer Strategies – Slide 3 for (i=0; i<99; i++) a[i]=b[i]+c[i]; a = 2; b = 3; m = (a+b)/2; s = (a*a+b*b)/2; v = s*m*m;

Data mining: looking for meaningful patterns in large data sets Data clustering: organizing a data set into clusters of “similar” items Data clustering can speed retrieval of related items Partitioning and Divide-and-Conquer Strategies – Slide 4

1. Compute document vectors 2. Choose initial cluster centers 3. Repeat a. Compute performance function b. Adjust centers until function value converges or the maximum number of iterations have elapsed 1. Output cluster centers Partitioning and Divide-and-Conquer Strategies – Slide 5

Operations being applied to a data set Examples Generating document vectors Finding closest center to each vector Picking initial values of cluster centers Partitioning and Divide-and-Conquer Strategies – Slide 6

Partitioning and Divide-and-Conquer Strategies – Slide 7 Build document vectors Compute function value Choose cluster centers Adjust cluster centersOutput cluster centers Do in parallel

Many possibilities: Operations on sequences of numbers such as simply adding them together. Several sorting algorithms can often be partitioned or constructed in a recursive fashion. Numerical integration N-body problem Partitioning and Divide-and-Conquer Strategies – Slide 8

Partition sequence into parts and add them. Partitioning and Divide-and-Conquer Strategies – Slide 9

Partitioning and Divide-and-Conquer Strategies – Slide 10 __global__ void add (int *numbers, int *part_sum) { int partialSum = 0, tid = threadIdx.x, s = n / blockDim.x; for (int i = tid * s; i < (tid + 1) * s; i++) partialSum += numbers[i]; part_sum[tid] = partialSum; __syncthreads(); } int main(void) { int numbers[n], part_sum[m], *dev_numbers, *dev_part_sum; cudaMalloc((void**)&dev_numbers, n * sizeof(int)); cudaMalloc((void**)&dev_part_sum, m * sizeof(int)); cudaMemcpy(dev_numbers, numbers, n * sizeof(int), cudaMemcpyHostToDevice); add >>(dev_numbers, dev_part_sum); // 1 block, m threads cudaMemcpy(part_sum, dev_part_sum, m * sizeof(int), cudaMemcpyDeviceToHost); int sum = 0; for (int i = 0; i < m; i++) sum += part_sum[i]; cudaFree(dev_numbers); cudaFree(dev_part_sum); free(part_sum); }

One “bucket” assigned to hold numbers that fall within each region. Numbers in each bucket sorted using a sequential sorting algorithm. Partitioning and Divide-and-Conquer Strategies – Slide 11

Sequential sorting time complexity: O(n log n / m ) for n numbers divided into m parts. Works well if the original numbers uniformly distributed across a known interval, say 0 to a-1. Simple approach to parallelization: assign one processor for each bucket. Partitioning and Divide-and-Conquer Strategies – Slide 12

Finding positions and movements of bodies in space subject to gravitational forces from other bodies using Newtonian laws of physics. Partitioning and Divide-and-Conquer Strategies – Slide 13

Gravitational force F between two bodies of masses m a and m b is G is the gravitational constant and r the distance between the bodies. Partitioning and Divide-and-Conquer Strategies – Slide 14

Subject to forces, body accelerates according to Newton’s second law: F = ma where m is mass of the body, F is force it experiences and a is the resultant acceleration. Let the time interval be  t. Let v t be the velocity at time t. For a body of mass m the force is Partitioning and Divide-and-Conquer Strategies – Slide 15

New velocity then is Over time interval  t position changes by where x t is its position at time t. Once bodies move to new positions, forces change and computation has to be repeated. Partitioning and Divide-and-Conquer Strategies – Slide 16

Overall gravitational N-body computation can be described as Partitioning and Divide-and-Conquer Strategies – Slide 17 for (t = 0; t < tmax; t++) {/*  time periods */ for (i = 0; i < N; i++) {/* for each body */ F = Force_routine(i);/* force on body i */ v[i] new = v[i] + F * dt / m;/* new velocity */ x[i] new = x[i] + v[i] new * dt;/* new position */ } for (i = 0; i < N; i++) {/* for each body */ x[i] = x[i] new ;/* update velocity */ v[i] = v[i] new ;/* and position */ }

The sequential algorithm is an O(N²) algorithm (for one iteration) as each of the N bodies is influenced by each of the other N – 1 bodies. Not feasible to use this direct algorithm for most interesting N-body problems where N is very large. Time complexity can be reduced using observation that a cluster of distant bodies can be approximated as a single distant body of the total mass of the cluster sited at the center of mass of the cluster. Partitioning and Divide-and-Conquer Strategies – Slide 18

Start with whole space in which one cube contains the bodies (or particles). First this cube is divided into eight subcubes. If a subcube contains no particles, the subcube is deleted from further consideration. If a subcube contains one body, subcube is retained. If a subcube contains more than one body, it is recursively divided until every subcube contains one body. Partitioning and Divide-and-Conquer Strategies – Slide 19

Creates an octtree – a tree with up to eight edges from each node. The leaves represent cells each containing one body. After the tree has been constructed, the total mass and center of mass of the subcube is stored at each node. Force on each body obtained by traversing tree starting at root, stopping at a node when the clustering approximation can be used, e.g. when r  d/  where  is a constant typically 1.0 or less. Constructing tree requires a time of O(n log n), and so does computing all the forces, so that the overall time complexity of the method is O(n log n). Partitioning and Divide-and-Conquer Strategies – Slide 20

Partitioning and Divide-and-Conquer Strategies – Slide 21

(For 2-dimensional area) First a vertical line is found that divides area into two areas each with an equal number of bodies. For each area a horizontal line is found that divides it into two areas each with an equal number of bodies. Repeated as required. Partitioning and Divide-and-Conquer Strategies – Slide 22

Assume one task per particle Task has particle’s position, velocity vector Iteration Get positions of all other particles Compute new position, velocity Partitioning and Divide-and-Conquer Strategies – Slide 23

Suppose we have a function ƒ which is continuous on [ ,b] and differentiable on ( ,b). We wish to approximate  ƒ(x)dx on [ ,b]. This is a definite integral and so is the area under the curve of the function. We simply estimate this area by simpler geometric objects. The process is called numerical integration or numerical quadrature. Partitioning and Divide-and-Conquer Strategies – Slide 24

Each region calculated using an approximation given by rectangles; aligning the rectangles: Partitioning and Divide-and-Conquer Strategies – Slide 25

The area of the rectangles is the length of the base times the height. As we can see by the figure base = , while the height is the value of the function at the midpoint of p and q, i.e. height = ƒ(½(p+q)). Since there are multiple rectangles, designate the endpoints by x 0 = , x 1 = p, x 2 = q, x 3, …, x n = b; Thus Partitioning and Divide-and-Conquer Strategies – Slide 26

Can show that Divide the interval [0,1] into the N subintervals [ i-1 / N, i / N ] for i=1,2,3,…,N. Then Partitioning and Divide-and-Conquer Strategies – Slide 27

Partitioning and Divide-and-Conquer Strategies – Slide 28 #include __global__ void term (int *part_sum) { int n = blockDim.x; double int_size = 1.0/(double)n; int tid = threadIdx.x; double x = int_size * ((double)tid – 0.5); double partialSum = 4.0 / (1.0 + x * x); double temp_pi = int_size * part_sum; part_sum[tid] = temp_pi; __syncthreads(); }

Partitioning and Divide-and-Conquer Strategies – Slide 29 int main(void) { double actual_pi = ; int n; double calc_pi = 0.0, *part_sum, *dev_part_sum; printf(“The pi calculator.\n”); printf(“No. intervals ”); scanf(“%d”, &n); if (n == 0) break; malloc((void**)&part_sum, n * sizeof(double)); cudaMalloc((void**)&dev_part_sum, n * sizeof(double)); term >>(dev_part_sum); // 1 block, n threads cudaMemcpy(part_sum, dev_part_sum, n * sizeof(double), cudaMemcpyDeviceToHost); for (int i = 0; i < n; i++) calc_pi += part_sum[i]; cudaFree(dev_part_sum); free(part_sum); printf(“pi = %f\n”, calc_pi); printf(“Error = %f\n”, fabs(calc_pi – actual_pi)); }

May not be better! Partitioning and Divide-and-Conquer Strategies – Slide 30

The area of the trapezoid is the area of the triangle on top plus the area of the rectangle below. For the rectangle, we can see by the figure that base = , while the height = ƒ(p); thus area =  ·ƒ(p). For the triangle, base =  while the height = ƒ(q) – ƒ(p), so area = ½·  (ƒ(q) – ƒ(p)). Partitioning and Divide-and-Conquer Strategies – Slide 31 ƒ(p) ƒ(q)  = q-p

Thus the total area of the trapezoid is ½·  (ƒ(p)+ƒ(q)). As before there are multiple trapezoids so designate the endpoints by x 0 = , x 1 = p, x 2 = q, x 3, …, x n = b. Thus Partitioning and Divide-and-Conquer Strategies – Slide 32

Returning to our previous example we see that Partitioning and Divide-and-Conquer Strategies – Slide 33

Comparing our methods Partitioning and Divide-and-Conquer Strategies – Slide 34 NRectangle Estimate Trapezoid Estimate ,

Solution adapts to shape of curve. Use three areas A, B and C. Computation terminated when largest of A and B sufficiently close to sum of remaining two areas. Partitioning and Divide-and-Conquer Strategies – Slide 35

Some care might be needed in choosing when to terminate. Might cause us to terminate early, as two large regions are the same (i.e. C=0). Partitioning and Divide-and-Conquer Strategies – Slide 36

For this example we consider an adaptive trapezoid method. Let T( ,b) be the trapezoid calculation on [ ,b], i.e. T( ,b) = ½(b-  )(ƒ(  )+ƒ(b)). Specify a level of tolerance  > 0. Our algorithm is then: 1. Compute T( ,b) and T( ,m)+T(m,b) where m is the midpoint of [ ,b], i.e. m = ½(  +b). 2. If | T( ,b) – [T( ,m)+T(m,b)] | <  then use T( ,m)+T(m,b) as our estimate and stop. 3. Otherwise separately approximate T( ,m) and T(m,b) inductively with a tolerance of ½ . Partitioning and Divide-and-Conquer Strategies – Slide 37

Clearly  x dx over [0,1] is 2/3. Try to approximate this with a tolerance of In this case T( ,b) = ½(b –  )(  +  b). 1. T(0,1) = 0.5, tolerance is T(0,½) + T(½,1) = = |0.5 – | = ; try again. 2. Estimate T(½,1) with tolerance T(½,¾) + T(¾,1) = = | – | = ; try again. Partitioning and Divide-and-Conquer Strategies – Slide 38

3. Estimate T(½, ¾) and T(¾,1) each with tolerance a. T(½, ¾) = T(½, ⁵⁄₈) + T(⁵⁄₈, ¾) = = | – | = ; done. b. T(¾, 1) = T(¾, ⁷⁄₈) + T(⁷⁄₈, 1) = = | – | = ; done. Our revised estimate for T(½,1) is the sum of the revised estimates for T(½, ¾) and T(¾, 1). Thus T(½,1) = = Partitioning and Divide-and-Conquer Strategies – Slide 39

Now for T(0,½). Partitioning and Divide-and-Conquer Strategies – Slide 40 ab  mT(a,b)T(a,b)T(a,m) + T(m,b) |diff| 1/41/ * 1/81/ * 1/161/ * 1/321/ * 1/641/ * Subtotal

Still more for T(0,½). Partitioning and Divide-and-Conquer Strategies – Slide 41 ab  ≈ m ≈T(a,b)T(a,b)T(a,m) + T(m,b) |diff| 1/1281/643.91E E-06* 1/2561/ E E-06* 1/5121/ E E-07* 01/ E E-06* Subtotal Total

So our final estimate for T(0,½) is Our previous final estimate for T(½,1) was Thus the final estimate for T(0,1) is the sum of those for T(0,½) and T(½,1) which is The actual answer was 2/3 for an error of , well below our tolerance of Partitioning and Divide-and-Conquer Strategies – Slide 42

Two strategies Partitioning: simply divides the problem into parts Divide-and-Conquer: divide the problem into sub- problems of same form as larger problem Examples Operations on sequences of numbers such as simply adding them together. Several sorting algorithms can often be partitioned or constructed in a recursive fashion. Numerical integration N-body problem Partitioning and Divide-and-Conquer Strategies – Slide 43

Based on original material from The University of Akron: Tim O’Neil The University of North Carolina at Charlotte Barry Wilkinson, Michael Allen Oregon State University: Michael Quinn Revision history: last updated 8/19/2011. Partitioning and Divide-and-Conquer Strategies – Slide 44