Survey
* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project
* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project
Part I Fundamental Concepts Spring 2006 Parallel Processing, Fundamental Concepts Slide 1 About This Presentation This presentation is intended to support the use of the textbook Introduction to Parallel Processing: Algorithms and Architectures (Plenum Press, 1999, ISBN 0-306-45970-1). It was prepared by the author in connection with teaching the graduate-level course ECE 254B: Advanced Computer Architecture: Parallel Processing, at the University of California, Santa Barbara. Instructors can use these slides in classroom teaching and for other educational purposes. Any other use is strictly prohibited. © Behrooz Parhami Edition First Spring 2006 Released Revised Spring 2005 Spring 2006 Parallel Processing, Fundamental Concepts Revised Slide 2 I Fundamental Concepts Provide motivation, paint the big picture, introduce the 3 Ts: • Taxonomy (basic terminology and models) • Tools for evaluation or comparison • Theory to delineate easy and hard problems Topics in This Part Chapter 1 Introduction to Parallelism Chapter 2 A Taste of Parallel Algorithms Chapter 3 Parallel Algorithm Complexity Chapter 4 Models of Parallel Processing Spring 2006 Parallel Processing, Fundamental Concepts Slide 3 1 Introduction to Parallelism Set the stage for presenting the course material, including: • Challenges in designing and using parallel systems • Metrics to evaluate the effectiveness of parallelism Topics in This Chapter 1.1 Why Parallel Processing? 1.2 A Motivating Example 1.3 Parallel Processing Ups and Downs 1.4 Types of Parallelism: A Taxonomy 1.5 Roadblocks to Parallel Processing 1.6 Effectiveness of Parallel Processing Spring 2006 Parallel Processing, Fundamental Concepts Slide 4 1.1 Why Parallel Processing? Processor performance TIPS 1.6 / yr GIPS Pentium II R10000 Pentium 80486 68040 80386 MIPS 68000 80286 KIPS 1980 1990 2000 2010 Calendar year Fig. 1.1 The exponential growth of microprocessor performance, known as Moore’s Law, shown over the past two decades (extrapolated). Spring 2006 Parallel Processing, Fundamental Concepts Slide 5 The Semiconductor Technology Roadmap Calendar year 2001 2004 2007 2010 2013 2016 140 90 65 45 32 22 Clock freq. (GHz) 2 4 7 12 20 30 Wiring levels 7 8 9 10 10 10 Power supply (V) 1.1 1.0 0.8 0.7 0.6 0.5 Max. power (W) 130 160 190 220 250 290 Halfpitch (nm) From the 2001 edition of the roadmap [Alla02] Factors contributing to the validity of Moore’s law Denser circuits; Architectural improvements Measures of processor performance Instructions/second (MIPS, GIPS, TIPS, PIPS) Floating-point operations per second (MFLOPS, GFLOPS, TFLOPS, PFLOPS) Running time on benchmark suites Spring 2006 Processor performance TIPS Parallel Processing, Fundamental Concepts 1.6 / yr GIPS Pentium II R10000 Pentium 80486 68040 80386 MIPS 68000 80286 KIPS 1980 1990 2000 Calendar year Slide 6 2010 Why High-Performance Computing? Higher speed (solve problems faster) Important when there are “hard” or “soft” deadlines; e.g., 24-hour weather forecast Higher throughput (solve more problems) Important when there are many similar tasks to perform; e.g., transaction processing Higher computational power (solve larger problems) e.g., weather forecast for a week rather than 24 hours, or with a finer mesh for greater accuracy Categories of supercomputers Uniprocessor; aka vector machine Multiprocessor; centralized or distributed shared memory Multicomputer; communicating via message passing Massively parallel processor (MPP; 1K or more processors) Spring 2006 Parallel Processing, Fundamental Concepts Slide 7 The Speed-of-Light Argument The speed of light is about 30 cm/ns. Signals travel at a fraction of speed of light (say, 1/3). If signals must travel 1 cm during the execution of an instruction, that instruction will take at least 0.1 ns; thus, performance will be limited to 10 GIPS. This limitation is eased by continued miniaturization, architectural methods such as cache memory, etc.; however, a fundamental limit does exist. How does parallel processing help? Wouldn’t multiple processors need to communicate via signals as well? Spring 2006 Parallel Processing, Fundamental Concepts Slide 8 Why Do We Need TIPS or TFLOPS Performance? Reasonable running time = Fraction of hour to several hours (103-104 s) In this time, a TIPS/TFLOPS machine can perform 1015-1016 operations Example 1: Southern oceans heat Modeling (10-minute iterations) 300 GFLOP per iteration 300 000 iterations per 6 yrs = 1016 FLOP Example 2: Fluid dynamics calculations (1000 1000 1000 lattice) 109 lattice points 1000 FLOP/point 10 000 time steps = 1016 FLOP Example 3: Monte Carlo simulation of nuclear reactor 1011 particles to track (for 1000 escapes) 104 FLOP/particle = 1015 FLOP Decentralized supercomputing ( from Mathworld News, 2006/4/7 ): Grid of tens of thousands networked computers discovers 230 402 457 – 1, the 43rd Mersenne prime, as the largest known prime (9 152 052 digits ) Spring 2006 Parallel Processing, Fundamental Concepts Slide 9 The ASCI Program Performance (TFLOPS) 1000 Plan Develop Use 100+ TFLOPS, 20 TB ASCI Purple 100 30+ TFLOPS, 10 TB ASCI Q 10+ TFLOPS, 5 TB ASCI White 10 ASCI 3+ TFLOPS, 1.5 TB ASCI Blue 1+ TFLOPS, 0.5 TB 1 1995 ASCI Red 2000 2005 2010 Calendar year Fig. 24.1 Milestones in the Accelerated Strategic (Advanced Simulation &) Computing Initiative (ASCI) program, sponsored by the US Department of Energy, with extrapolation up to the PFLOPS level. Spring 2006 Parallel Processing, Fundamental Concepts Slide 10 The Quest for Higher Performance Top Three Supercomputers in 2005 (IEEE Spectrum, Feb. 2005, pp. 15-16) 1. IBM Blue Gene/L 2. SGI Columbia 3. NEC Earth Sim LLNL, California NASA Ames, California Earth Sim Ctr, Yokohama Material science, nuclear stockpile sim Aerospace/space sim, climate research Atmospheric, oceanic, and earth sciences 32,768 proc’s, 8 TB, 28 TB disk storage 10,240 proc’s, 20 TB, 440 TB disk storage 5,120 proc’s, 10 TB, 700 TB disk storage Linux + custom OS Linux Unix 71 TFLOPS, $100 M 52 TFLOPS, $50 M 36 TFLOPS*, $400 M? Dual-proc Power-PC chips (10-15 W power) 20x Altix (512 Itanium2) Built of custom vector linked by Infiniband microprocessors Full system: 130k-proc, 360 TFLOPS (est) Volume = 50x IBM, Power = 14x IBM * Led the top500 list for 2.5 yrs Spring 2006 Parallel Processing, Fundamental Concepts Slide 11 Supercomputer Performance Growth PFLOPS Supercomputer performance ASCI goals $240M MPPs CM-5 TFLOPS $30M MPPs Vector supers CM-5 CM-2 Micros Y-MP GFLOPS Alpha Cray X-MP 80860 80386 MFLOPS 1980 1990 2000 2010 Calendar year Fig. 1.2 The exponential growth in supercomputer performance over the past two decades (from [Bell92], with ASCI performance goals and microprocessor peak FLOPS superimposed as dotted lines). Spring 2006 Parallel Processing, Fundamental Concepts Slide 12 Init. 1.2 A Motivating Example Fig. 1.3 The sieve of Eratosthenes yielding a list of 10 primes for n = 30. Marked elements have been distinguished by erasure from the list. Any composite number has a prime factor that is no greater than its square root. Spring 2006 2m 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 Pass 1 Pass 2 Pass 3 2 3m 2 3 2 3 5 5m 5 7 7 7 m 9 11 11 11 13 13 13 17 17 17 19 19 19 23 23 23 25 25 15 21 27 29 Parallel Processing, Fundamental Concepts 29 29 Slide 13 Single-Processor Implementation of the Sieve Current Prime P Bit-vector 1 Index 2 n Fig. 1.4 Schematic representation of single-processor solution for the sieve of Eratosthenes. Spring 2006 Parallel Processing, Fundamental Concepts Slide 14 Control-Parallel Implementation of the Sieve Index P2 P1 Shared Memory Index ... Index Pp Current Prime I/O Device 1 2 n (b) Fig. 1.5 Schematic representation of a control-parallel solution for the sieve of Eratosthenes. Spring 2006 Parallel Processing, Fundamental Concepts Slide 15 Running Time of the Sequential/Parallel Sieve Time 0 100 200 300 400 500 600 700 800 900 1000 1100 1200 1300 1400 1500 +-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+ 2 | 3 | 5 | 7 | 11 |13|17 19 29 p = 1, t = 1411 23 31 23 29 31 2 | 7 |17 3 5 | 11 |13| 19 p = 2, t = 706 2 | 3 5 | 7 p = 3, t = 11 | 13|17 | 19 29 31 23 499 Fig. 1.6 Control-parallel realization of the sieve of Eratosthenes with n = 1000 and 1 p 3. Spring 2006 Parallel Processing, Fundamental Concepts Slide 16 Data-Parallel Implementation of the Sieve P1 Current Prime 1 Assume at most n processors, so that all prime factors dealt with are in P1 (which broadcasts them) Index 2 n/p P2 Communication Pp Current Prime Current Prime n/p+1 Index 2n/p Index n <n/p n–n/p+1 Fig. 1.7 Spring 2006 n Data-parallel realization of the sieve of Eratosthenes. Parallel Processing, Fundamental Concepts Slide 17 One Reason for Sublinear Speedup: Communication Overhead Ideal speedup Solution time Actual speedup Computation Communication Number of processors Number of processors Fig. 1.8 Trade-off between communication time and computation time in the data-parallel realization of the sieve of Eratosthenes. Spring 2006 Parallel Processing, Fundamental Concepts Slide 18 Another Reason for Sublinear Speedup: Input/Output Overhead Ideal speedup Solution time Actual speedup Computation I/O time Number of processors Number of processors Fig. 1.9 Effect of a constant I/O time on the data-parallel realization of the sieve of Eratosthenes. Spring 2006 Parallel Processing, Fundamental Concepts Slide 19 1.3 Parallel Processing Ups and Downs Fig. 1.10 Richardson’s circular theater for weather forecasting calculations. Using thousands of “computers” (humans + calculators) for 24-hr weather prediction in a few hours 1960s: ILLIAC IV (U Illinois) – four 8 8 mesh quadrants, SIMD Conductor Spring 2006 1980s: Commercial interest – technology was driven by government grants & contracts. Once funding dried up, many companies went bankrupt 2000s: Internet revolution – info providers, multimedia, data mining, etc. need lots of power Parallel Processing, Fundamental Concepts Slide 20 Trends in High-Technology Development Graphics GovResGovResGovResGovResGovResGovResGovResGovResGovResGovRes IndResIndResIndResIndResIndResIndResIndResIndResIndResIndRes IndDevIndDev $1B$1B$1B$1B$1B$1B$1B$1B$1B$1B$1B$1B GovResGovResGovResGovResGovResGovResGovResGovResGovResGovRe Networking Transfer of ideas/people IndResIndResIndResIndResIndResIndResIndResIndResIndR IndDevIndDev $1B$1B$1B$1B$1B$1B$1B$1B$1B$1B$1 GovRes RISC IndResIndR IndDev Parallelism GovResGovResGovResG GovResGovResGovResGo IndResIndResIndResIndResIndResInd Evolution of parallel processing has been quite different from other high tech fields 1960 1970 $1B$1B$1B$1B$1B$1B$1B$1B$ IndDevIndDev 1980 1990 $1B$1B$1B$1B$1B$1B$1 2000 Development of some technical fields into $1B businesses and the roles played by government research and industrial R&D over time (IEEE Computer, early 90s?). Spring 2006 Parallel Processing, Fundamental Concepts Slide 21 Trends in Hi-Tech Development (2003) Spring 2006 Parallel Processing, Fundamental Concepts Slide 22 Status of Computing Power (circa 2000) GFLOPS on desktop: Apple Macintosh, with G4 processor TFLOPS in supercomputer center: 1152-processor IBM RS/6000 SP (switch-based network) Cray T3E, torus-connected PFLOPS on drawing board: 1M-processor IBM Blue Gene (2005?) 32 proc’s/chip, 64 chips/board, 8 boards/tower, 64 towers Processor: 8 threads, on-chip memory, no data cache Chip: defect-tolerant, row/column rings in a 6 6 array Board: 8 8 chip grid organized as 4 4 4 cube Tower: Boards linked to 4 neighbors in adjacent towers System: 323232 cube of chips, 1.5 MW (water-cooled) Spring 2006 Parallel Processing, Fundamental Concepts Slide 23 SISD SIMD Uniprocessors Array or vector processors MISD Rarely used MIMD Multiproc’s or multicomputers Shared variables Global memory Multiple data streams Distributed memory Single data stream Johnson’ s expansion Multiple instr streams Single instr stream 1.4 Types of Parallelism: A Taxonomy GMSV Message passing GMMP Shared-memory multiprocessors Rarely used DMSV DMMP Distributed Distrib-memory shared memory multicomputers Flynn’s categories Fig. 1.11 Spring 2006 The Flynn-Johnson classification of computer systems. Parallel Processing, Fundamental Concepts Slide 24 1.5 Roadblocks to Parallel Processing Grosch’s law: Economy of scale applies, or power = cost2 No longer valid; in fact we can get more bang per buck in micros Minsky’s conjecture: Speedup tends to be proportional to log p Has roots in analysis of memory bank conflicts; can be overcome Tyranny of IC technology: Uniprocessors suffice (x10 faster/5 yrs) Faster ICs make parallel machines faster too; what about x1000? Tyranny of vector supercomputers: Familiar programming model Not all computations involve vectors; parallel vector machines Software inertia: Billions of dollars investment in software New programs; even uniprocessors benefit from parallelism spec Amdahl’s law: Unparallelizable code severely limits the speedup Spring 2006 Parallel Processing, Fundamental Concepts Slide 25 Amdahl’s Law 50 f = fraction f = 0 Spee du p ( s ) 40 unaffected f = 0 .01 p = speedup 30 of the rest f = 0 .02 20 f = 0 .05 s= 10 f = 0 .1 min(p, 1/f) 0 0 10 20 30 40 1 f + (1 – f)/p 50 E nha nc em en t f ac tor ( p ) Fig. 1.12 Limit on speed-up according to Amdahl’s law. Spring 2006 Parallel Processing, Fundamental Concepts Slide 26 1.6 Effectiveness of Parallel Processing Fig. 1.13 Task graph exhibiting limited inherent parallelism. 1 2 3 4 p Number of processors W(p) Work performed by p processors T(p) Execution time with p processors T(1) = W(1); T(p) W(p) S(p) Speedup = T(1) / T(p) 5 8 7 10 6 E(p) Efficiency = T(1) / [p T(p)] 9 R(p) Redundancy = W(p) / W(1) 11 12 13 Spring 2006 W(1) = 13 T(1) = 13 T() = 8 U(p) Utilization = W(p) / [p T(p)] Q(p) Quality = T3(1) / [p T2(p) W(p)] Parallel Processing, Fundamental Concepts Slide 27 Reduction or Fan-in Computation Example: Adding 16 numbers, 8 processors, unit-time additions ----------- 16 numbers to be added ----------- Zero-time communication + + + + + + + + + + + + E(8) = 15 / (8 4) = 47% S(8) = 15 / 4 = 3.75 R(8) = 15 / 15 = 1 Q(8) = 1.76 Unit-time communication + + + E(8) = 15 / (8 7) = 27% S(8) = 15 / 7 = 2.14 R(8) = 22 / 15 = 1.47 Q(8) = 0.39 Sum Fig. 1.14 Spring 2006 Computation graph for finding the sum of 16 numbers . Parallel Processing, Fundamental Concepts Slide 28 ABCs of Parallel Processing in One Slide A Amdahl’s Law (Speedup Formula) Bad news – Sequential overhead will kill you, because: Speedup = T1/Tp 1/[f + (1 – f)/p] min(1/f, p) Morale: For f = 0.1, speedup is at best 10, regardless of peak OPS. B Brent’s Scheduling Theorem Good news – Optimal scheduling is very difficult, but even a naive scheduling algorithm can ensure: T1/p Tp T1/p + T = (T1/p)[1 + p/(T1/T)] Result: For a reasonably parallel task (large T1/T), or for a suitably small p (say, p T1/T), good speedup and efficiency are possible. C Cost-Effectiveness Adage Real news – The most cost-effective parallel solution may not be the one with highest peak OPS (communication?), greatest speed-up (at what cost?), or best utilization (hardware busy doing what?). Analogy: Mass transit might be more cost-effective than private cars even if it is slower and leads to many empty seats. Spring 2006 Parallel Processing, Fundamental Concepts Slide 29 2 A Taste of Parallel Algorithms Learn about the nature of parallel algorithms and complexity: • By implementing 5 building-block parallel computations • On 4 simple parallel architectures (20 combinations) Topics in This Chapter 2.1 Some Simple Computations 2.2 Some Simple Architectures 2.3 Algorithms for a Linear Array 2.4 Algorithms for a Binary Tree 2.5 Algorithms for a 2D Mesh 2.6 Algorithms with Shared Variables Spring 2006 Parallel Processing, Fundamental Concepts Slide 30 2.1 Some Simple Computations x0 identity element x1 t=0 x2 t=1 t=2 t=3 . . . xn–2 xn–1 s = x0 x1 . . . xn–1 t = n– 1 t=n s Fig. 2.1 Spring 2006 Semigroup computation on a uniprocessor. Parallel Processing, Fundamental Concepts Slide 31 Parallel Semigroup Computation x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 log2 n levels s = x0 x1 . . . xn–1 s Semigroup computation viewed as tree or fan-in computation. Spring 2006 Parallel Processing, Fundamental Concepts Slide 32 Parallel Prefix Computation x0 identity element x1 t=0 x2 t=1 t=2 s0 s1 t=3 Parallel version much trickier compared to that of semigroup computation . s2 . . Requires a minimum of log2 n levels xn–2 xn–1 s = x 0 x1 x2 ... xn–1 t = n– 1 t=n s n–2 s n–1 Prefix computation on a uniprocessor. Spring 2006 Parallel Processing, Fundamental Concepts Slide 33 The Five Building-Block Computations Semigroup computation: aka tree or fan-in computation All processors to get the computation result at the end Parallel prefix computation: The ith processor to hold the ith prefix result at the end Packet routing: Send a packet from a source to a destination processor Broadcasting: Send a packet from a source to all processors Sorting: Arrange a set of keys, stored one per processor, so that the ith processor holds the ith key in ascending order Spring 2006 Parallel Processing, Fundamental Concepts Slide 34 2.2 Some Simple Architectures P0 P1 P2 P3 P4 P5 P6 P7 P8 P0 P1 P2 P3 P4 P5 P6 P7 P8 Fig. 2.2 A linear array of nine processors and its ring variant. Max node degree Network diameter Bisection width Spring 2006 d=2 D=p–1 B=1 Parallel Processing, Fundamental Concepts ( p/2 ) (2) Slide 35 (Balanced) Binary Tree Architecture P0 Complete binary tree 2q – 1 nodes, 2q–1 leaves Balanced binary tree Leaf levels differ by 1 P1 P2 Max node degree Network diameter Bisection width P4 P5 P3 d=3 D = 2 log2 p B=1 (-1) P6 P7 P8 Fig. 2.3 A balanced (but incomplete) binary tree of nine processors. Spring 2006 Parallel Processing, Fundamental Concepts Slide 36 Two-Dimensional (2D) Mesh P P P P P P P P Nonsquare mesh P (r rows, 5 p/r col’s) also possible P P P P P P P P P 0 1 3 4 6 7 2 8 Max node degree Network diameter Bisection width Fig. 2.4 Spring 2006 0 3 6 d=4 D = 2p – 2 B p 1 4 7 2 5 8 ( p ) ( 2p ) 2D mesh of 9 processors and its torus variant. Parallel Processing, Fundamental Concepts Slide 37 Shared-Memory Architecture Max node degree Network diameter Bisection width P 0 P P 8 1 P P 7 2 P P 6 3 P 5 Fig. 2.5 Spring 2006 d=p–1 D=1 B = p/2 p/2 Costly to implement Not scalable But . . . Conceptually simple Easy to program P 4 A shared-variable architecture modeled as a complete graph. Parallel Processing, Fundamental Concepts Slide 38 Architecture/Algorithm Combinations Semigroup P0 P1 P2 P3 P4 P5 P6 P7 P8 P0 P1 P2 P3 P4 P0 P5 P6 P7 P8 P1 P2 P5 P P P P P P P P P P P P P P P P P 1 2 4 6 Sorting P8 P 3 Broadcasting P6 P7 0 Packet routing We will spend more time on linear array and binary tree P4 P3 Parallel prefix 0 5 7 3 8 6 P 0 P P 8 1 P 1 4 7 2 5 8 and less time on mesh and shared memory (studied later) P 7 2 P P 6 3 P 5 Spring 2006 P 4 Parallel Processing, Fundamental Concepts Slide 39 2.3 Algorithms for a Linear Array P0 5 5 8 8 8 8 9 P1 2 8 8 8 8 9 9 Fig. 2.6 P2 8 8 8 8 9 9 9 P3 6 8 8 9 9 9 9 P4 3 7 9 9 9 9 9 P5 7 9 9 9 9 9 9 P6 9 9 9 9 9 9 9 P7 1 9 9 9 9 9 9 P8 4 4 9 9 9 9 9 Initial values Maximum identified Maximum-finding on a linear array of nine processors. For general semigroup computation: Phase 1: Partial result is propagated from left to right Phase 2: Result obtained by processor p – 1 is broadcast leftward Spring 2006 Parallel Processing, Fundamental Concepts Slide 40 Linear Array Prefix Sum Computation P0 P1 5 5 5 5 5 5 5 5 5 2 7 7 7 7 7 7 7 7 Fig. 2.7 P2 8 8 15 15 15 15 15 15 15 P3 6 6 6 21 21 21 21 21 21 P4 3 3 3 3 24 24 24 24 24 P5 7 7 7 7 7 31 31 31 31 P6 9 9 9 9 9 9 40 40 40 P7 1 1 1 1 1 1 1 41 41 P8 4 4 4 4 4 4 4 4 45 Initial values Final results Computing prefix sums on a linear array of nine processors. Diminished parallel prefix computation: The ith processor obtains the result up to element i – 1 Spring 2006 Parallel Processing, Fundamental Concepts Slide 41 Linear-Array Prefix Sum Computation P0 5 5 P1 1 6 0 5 6 2 2 6 8 P2 8 3 8 11 P3 6 6 P4 2 8 3 3 5 8 P5 7 3 7 10 P6 9 6 9 15 P7 1 1 7 8 P8 4 4 5 Initial values 9 Local prefixes + 6 14 25 33 41 51 66 74 = 8 22 31 36 48 60 67 78 14 25 33 41 51 66 74 83 Diminished prefixes Final results Fig. 2.8 Computing prefix sums on a linear array with two items per processor. Spring 2006 Parallel Processing, Fundamental Concepts Slide 42 Linear Array Routing and Broadcasting Left-moving packets P0 P1 P2 P3 P4 P5 P6 P7 P8 Right-moving packets Routing and broadcasting on a linear array of nine processors. To route from processor i to processor j: Compute j – i to determine distance and direction To broadcast from processor i: Send a left-moving and a right-moving broadcast message Spring 2006 Parallel Processing, Fundamental Concepts Slide 43 5 2 8 6 3 7 9 1 4 5 2 8 6 3 7 9 1 4 5 2 8 6 3 7 9 1 5 2 8 6 3 7 1 Linear Array Sorting (Externally Supplied Keys) 5 2 8 6 3 1 5 2 8 6 1 5 2 8 1 5 2 1 5 1 1 Fig. 2.9 Sorting on a linear array with the keys input sequentially from the left. Spring 2006 4 9 7 3 6 8 2 5 4 4 9 4 7 3 3 3 2 4 6 8 3 5 9 7 4 4 4 3 9 7 6 8 4 9 7 6 9 7 8 9 9 1 2 1 2 3 1 2 3 4 1 2 3 4 5 1 2 3 4 5 6 1 2 3 4 5 6 7 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 5 6 4 6 5 Parallel Processing, Fundamental Concepts 7 7 6 8 7 6 9 8 7 9 8 7 9 8 9 8 9 9 Slide 44 9 Linear Array Sorting (Internally Stored Keys) P0 5 5 2 2 2 2 2 2 1 P1 2 2 5 3 3 3 3 1 2 Fig. 2.10 P2 8 8 3 5 5 5 1 3 3 P3 6 3 8 6 6 1 5 4 4 P4 3 6 6 8 1 6 4 5 5 P5 7 7 7 1 8 4 6 6 6 P6 9 9 1 7 4 8 7 7 7 P7 1 1 9 4 7 7 8 8 8 4 4 4 9 9 9 9 9 9 In odd steps, 1, 3, 5, etc., oddnumbered processors exchange values with their right neighbors Odd-even transposition sort on a linear array. T(1) = W(1) = p log2 p T(p) = p S(p) = log2 p (Minsky’s conjecture?) Spring 2006 P8 Parallel Processing, Fundamental Concepts W(p) p2/2 R(p) = p/(2 log2 p) Slide 45 2.4 Algorithms for a Binary Tree P0 P0 P1 P2 P4 P3 P1 P5 P6 P7 P2 P4 P3 P5 P8 P6 P7 Semigroup computation and broadcasting on a binary tree. Spring 2006 Parallel Processing, Fundamental Concepts Slide 46 P8 x 0 x 1 x 2 x 3 x 4 Binary Tree Parallel Prefix Computation x 0 x 1 x 2 x 3 x 4 Upward propagation Upward Propagation x0 x1 x 3 x 4 x2 x3 x4 Identity Fig. 2.11 Parallel prefix computation on a binary tree of processors. x 0 x 1 Identity Identity x0 x0 x1 x 0 x 1 x 2 x 0 x 1 x2 x 0 x 1 x 2 x3 x0 x 0 x 1 x4 x 0 x 1 x 2 Parallel Processing, Fundamental Concepts Downward propagation x 0 x 1 x 2 x 3 x 0 x 1 x 2 x 3 x 0 x 1 x 2 x 3 x 4 Spring 2006 Downward Propagation Results Slide 47 Node Function in Binary Tree Parallel Prefix Insert latches for systolic operation (no long wires or propagation path) [0, i – 1] [i, k] Two binary operations: one during the upward propagation phase, and another during downward propagation Upward propagation Downward propagation [i, j – 1] [0, j – 1] [0, i – 1] Spring 2006 Parallel Processing, Fundamental Concepts [ j, k] Slide 48 Usefulness of Parallel Prefix Computation Ranks of 1s in a list of 0s/1s: Data: Prefix sums: Ranks of 1s: 0 0 0 0 1 1 1 0 1 1 2 2 0 2 0 2 1 3 3 1 4 4 1 5 5 0 5 0 1 0 0 1 1 0 0 0 1 0 0 0 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 0 1 0 0 Priority arbitration circuit: Data: Dim’d prefix ORs: Complement: AND with data: 0 0 1 0 0 0 1 0 1 0 1 1 Carry-lookahead network: p¢x=x a¢x=a g¢x=g Spring 2006 p g a g g p p p g a cin g or a Direction of indexing Parallel Processing, Fundamental Concepts Slide 49 Binary Tree Packet Routing XXX P0 P1 RXX LXX P4 RRX LLX P2 P3 P5 P6 LRX RLX RRR RRL Preorder indexing P7 P8 Node index is a representation of the path from the tree root Packet routing on a binary tree with two indexing schemes. Spring 2006 Parallel Processing, Fundamental Concepts Slide 50 Binary Tree Sorting 5 2 5 2 3 1 (a) 3 4 5 3 1 (c) Spring 2006 2 1 5 Fig. 2.12 1 4 (b) 2 Small values “bubble up,” causing the root to “see” the values in ascending order 4 Linear-time sorting (no better than linear array) 3 (d) 4 The first few steps of the sorting algorithm on a binary tree. Parallel Processing, Fundamental Concepts Slide 51 The Bisection-Width Bottleneck in a Binary Tree Bis ection Width = 1 Linear-time sorting is the best possible due to B = 1 Fig. 2.13 Spring 2006 The bisection width of a binary tree architecture. Parallel Processing, Fundamental Concepts Slide 52 2.5 Algorithms for a 2D Mesh 5 2 8 8 8 8 9 9 9 6 3 7 7 7 7 9 9 9 9 1 4 9 9 9 9 9 9 Column maximums Row maximums Finding the max value on a 2D mesh. 5 7 15 5 7 15 0 5 7 6 9 16 6 9 16 15 21 24 9 10 14 Row prefix sums 9 10 14 31 45 40 41 Broadcast in rows and combine Diminished prefix sums in last column 15 31 Computing prefix sums on a 2D mesh Spring 2006 Parallel Processing, Fundamental Concepts Slide 53 Routing and Broadcasting on a 2D Mesh P P P P P P P P Nonsquare mesh P (r rows, 5 p/r col’s) also possible P P P P P P P P P 0 3 6 1 4 7 2 8 0 3 6 1 4 7 2 5 8 Routing: Send along the row to the correct column; route in column Broadcasting: Broadcast in row; then broadcast in all column Routing and broadcasting on a 9-processors 2D mesh or torus Spring 2006 Parallel Processing, Fundamental Concepts Slide 54 s Sorting on a 2D Mesh Using Shearsort 5 2 8 6 3 7 9 1 4 Initial values 2 5 8 7 6 3 1 4 9 2 5 8 1 4 3 1 3 4 1 Number of iterations = log2 p 7 Compare-exchange 6 3 2 5 steps 8 in each 8 iteration 5 2 = 2p 6 Total steps = (log2 p + 1) p 1 4 9 7 6 9 6 7 9 8 3 2 5 4 7 9 Snake-like Top-to-bottom Snake-like Top-to-bottom column column row sort row sort 1 4 3 1 3 4 1 3 2 1 2 3 sort sort Phase Phase 2 5 8 6 5 4 1 8 5 2 2 4 5 6 7 6 9 6 7 9 8 7 9 7 8 9 Snake-like Top-to-bottom Snake-like Top-to-bottom Left-to-right column column row sort row sort row sort sort sort Phase 1 Phase 2 Phase 3 1 2.14 The shearsort algorithm 2 on a 3 3 mesh. 3 Fig. Spring 2006 Parallel Processing, Fundamental Concepts Slide 55 2.6 Algorithms with Shared Variables Semigroup computation: Each processor can perform the computation locally P 0 P P 8 1 P P 7 2 P P 6 3 P 5 Spring 2006 P 4 Parallel prefix computation: Same as semigroup, except only data from smaller-index processors are combined Packet routing: Trivial Broadcasting: One step with all-port (p – 1 steps with single-port) communication Sorting: Each processor determines the rank of its data element; followed by routing Parallel Processing, Fundamental Concepts Slide 56 3 Parallel Algorithm Complexity Review algorithm complexity and various complexity classes: • Introduce the notions of time and time/cost optimality • Derive tools for analysis, comparison, and fine-tuning Topics in This Chapter 3.1 Asymptotic Complexity 3.2 Algorithms Optimality and Efficiency 3.3 Complexity Classes 3.4 Parallelizable Tasks and the NC Class 3.5 Parallel Programming Paradigms 3.6 Solving Recurrences Spring 2006 Parallel Processing, Fundamental Concepts Slide 57 3.1 Asymptotic Complexity c g(n) c' g(n) g(n) f(n) g(n) f(n) f(n) c g(n) c g(n) n0 n f(n) = O(g(n)) f(n) = O(g(n)) Fig. 3.1 n0 n f(n) = (g(n)) f(n) = (g(n)) n0 n f(n) = f(n) = (g(n)) (g(n)) Graphical representation of the notions of asymptotic complexity. 3n log n = O(n2) Spring 2006 ½ n log2 n = (n) Parallel Processing, Fundamental Concepts 2000 n2= (n2) Slide 58 Little Oh, Big Oh, and Their Buddies Notation Growth rate Example of use f(n) = o(g(n)) strictly less than T(n) = cn2 + o(n2) f(n) = O(g(n)) no greater than T(n, m) = O(n logn+m) f(n) = (g(n)) = the same as T(n) = (n log n) f(n) = (g(n)) no less than T(n) = (n) f(n) = w(g(n)) > strictly greater than T(n) = w(log n) Spring 2006 Parallel Processing, Fundamental Concepts Slide 59 Growth Rates for Typical Functions Table 3.1 Comparing the Growth Rates of Sublinear and Superlinear Functions (K = 1000, M = 1 000 000). (n/4)log2n n -------- -------- nlog2n 100 n1/2 -------- -------- 10 20 s 2 min 5 min 100 15 min 1 hr 15 min 1K 6 hr 1 day 1 hr 10 K 5 day 20 day 3 hr 100 K 2 mo 1 yr 9 hr 1 M 3 yr 11 yr 1 day Spring 2006 Sublinear Linear Superlinear log2n n1/2 n -------- -------- -------- 9 36 81 169 256 361 3 10 31 100 316 1K 10 90 30 100 3.6 K 1K 1K 81 K 31 K 10 K 1.7 M 1M 100 K 26 M 31 M 1 M 361 M 1000 M n3/2 -------- 30 s 15 min 9 hr 10 day 1 yr 32 yr n log2n -------- n3/2 -------- Table 3.3 Effect of Constants on the Growth Rates of Running Times Using Larger Time Units and Round Figures. Warning: Table 3.3 in text needs corrections. Parallel Processing, Fundamental Concepts Slide 60 Some Commonly Encountered Growth Rates Notation Class name Notes O(1) O(log log n) O(log n) O(logk n) O(na), a < 1 O(n / logk n) Constant Double-logarithmic Logarithmic Polylogarithmic Rarely practical Sublogarithmic k is a constant e.g., O(n1/2) or O(n1–e) Still sublinear ------------------------------------------------------------------------------------------------------------------------------------------------------------------- O(n) Linear ------------------------------------------------------------------------------------------------------------------------------------------------------------------- O(n logk n) O(nc), c > 1 O(2n) n 2 O(2 ) Spring 2006 Polynomial Exponential Double-exponential Superlinear e.g., O(n1+e) or O(n3/2) Generally intractable Hopeless! Parallel Processing, Fundamental Concepts Slide 61 3.2 Algorithm Optimality and Efficiency Lower bounds: Theoretical arguments based on bisection width, and the like Upper bounds: Deriving/analyzing algorithms and proving them correct Shifting lower bounds 1988 Zak’s thm. (log n) Improving upper bounds 1994 Ying’s thm. (log2n) log2n log n Sublinear Optimal algorithm? n / log n 1996 1991 1988 Dana’s alg. Chin’s alg. Bert’s alg. O(n) O(n log log n) O(n log n) n Linear n log log n n log n 1982 Anne’s alg. O(n 2 ) n2 Superlinear Typical complexity classes Fig. 3.2 Spring 2006 Upper and lower bounds may tighten over time. Parallel Processing, Fundamental Concepts Slide 62 Some Notions of Algorithm Optimality Time optimality (optimal algorithm, for short) T(n, p) = g(n, p), where g(n, p) is an established lower bound Problem size Number of processors Cost-time optimality (cost-optimal algorithm, for short) pT(n, p) = T(n, 1); i.e., redundancy = utilization = 1 Cost-time efficiency (efficient algorithm, for short) pT(n, p) = (T(n, 1)); i.e., redundancy = utilization = (1) Spring 2006 Parallel Processing, Fundamental Concepts Slide 63 Beware of Comparing Step Counts Solution Machine or algorithm A 4 steps 20 steps Machine or algorithm B For example, one algorithm may need 20 GFLOP, another 4 GFLOP (but float division is a factor of 10 slower than float multiplication Fig. 3.2 Five times fewer steps does not necessarily mean five times faster. Spring 2006 Parallel Processing, Fundamental Concepts Slide 64 3.3 Complexity Classes NP-hard (Intractable?) Exponential time (intractable problems ) NP-complete (e.g. the subset sum problem) NP Pspace-complete Nondetermin istic Po lyno mial Pspace NPcomplete P Po lyno mial (Tractable) NP Co-NPCo-NP complete ? P = NP P (tractable) A more complete view of complexity classes Conceptual view of the P, NP, NP-complete, and NP-hard classes. Spring 2006 Parallel Processing, Fundamental Concepts Slide 65 Some NP-Complete Problems Subset sum problem: Given a set of n integers and a target sum s, determine if a subset of the integers adds up to s. Satisfiability: Is there an assignment of values to variables in a product-of-sums Boolean expression that makes it true? (Is in NP even if each OR term is restricted to have exactly three literals) Circuit satisfiability: Is there an assignment of 0s and 1s to inputs of a logic circuit that would make the circuit output 1? Hamiltonian cycle: Does an arbitrary graph contain a cycle that goes through all of its nodes? Traveling salesman: Find a lowest-cost or shortest-distance tour of a number of cities, given travel costs or distances. Spring 2006 Parallel Processing, Fundamental Concepts Slide 66 3.4 Parallelizable Tasks and the NC Class NP-hard (Intractable?) NP-complete (e.g. the subset sum problem) NP Nondetermin istic Po lyno mial P Po lyno mial (Tractable) P-complete NC Nick's Class ? P = NP ? NC = P "efficiently" paralleliz able Fig. 3.4 NC (Nick’s class): Subset of problems in P for which there exist parallel algorithms using p = nc processors (polynomially many) that run in O(logk n) time (polylog time). P-complete problem: Given a logic circuit with known inputs, determine its output (circuit value prob.). A conceptual view of complexity classes and their relationships. Spring 2006 Parallel Processing, Fundamental Concepts Slide 67 3.5 Parallel Programming Paradigms Divide and conquer Decompose problem of size n into smaller problems; solve subproblems independently; combine subproblem results into final answer T(n) = Td(n) + Ts + Tc(n) Decompose Solve in parallel Combine Randomization When it is impossible or difficult to decompose a large problem into subproblems with equal solution times, one might use random decisions that lead to good results with very high probability. Example: sorting with random sampling Other forms: Random search, control randomization, symmetry breaking Approximation Iterative numerical methods may use approximation to arrive at solution(s). Example: Solving linear systems using Jacobi relaxation. Under proper conditions, the iterations converge to the correct solutions; more iterations greater accuracy Spring 2006 Parallel Processing, Fundamental Concepts Slide 68 3.6 Solving Recurrences f(n) = f(n – 1) + n {rewrite f(n – 1) as f((n – 1) – 1) + n – 1} = f(n – 2) + n – 1 + n = f(n – 3) + n – 2 + n – 1 + n ... = f(1) + 2 + 3 + . . . + n – 1 + n = n(n + 1)/2 – 1 = (n2) This method is known as unrolling f(n) = f(n/2) + 1 {rewrite f(n/2) as f((n/2)/2 + 1} = f(n/4) + 1 + 1 = f(n/8) + 1 + 1 + 1 ... = f(n/n) + 1 + 1 + 1 + . . . + 1 -------- log2 n times -------- = log2 n = (log n) Spring 2006 Parallel Processing, Fundamental Concepts Slide 69 More Example of Recurrence Unrolling f(n) = 2f(n/2) + 1 = 4f(n/4) + 2 + 1 = 8f(n/8) + 4 + 2 + 1 ... = n f(n/n) + n/2 + . . . + 4 + 2 + 1 = n – 1 = (n) f(n) = f(n/2) + n = f(n/4) + n/2 + n = f(n/8) + n/4 + n/2 + n ... Solution via guessing: Guess f(n) = (n) = cn + g(n) cn + g(n) = cn/2 + g(n/2) + n Thus, c = 2 and g(n) = g(n/2) = f(n/n) + 2 + 4 + . . . + n/4 + n/2 + n = 2n – 2 = (n) Spring 2006 Parallel Processing, Fundamental Concepts Slide 70 Still More Examples of Unrolling f(n) = 2f(n/2) + n = 4f(n/4) + n + n = 8f(n/8) + n + n + n ... = n f(n/n) + n + n + n + . . . + n Alternate solution method: f(n)/n = f(n/2)/(n/2) + 1 Let f(n)/n = g(n) g(n) = g(n/2) + 1 = log2 n --------- log2 n times --------- = n log2n = (n log n) f(n) = f(n/2) + log2 n = f(n/4) + log2(n/2) + log2 n = f(n/8) + log2(n/4) + log2(n/2) + log2 n ... = f(n/n) + log2 2 + log2 4 + . . . + log2(n/2) + log2 n = 1 + 2 + 3 + . . . + log2 n = log2 n (log2 n + 1)/2 = (log2 n) Spring 2006 Parallel Processing, Fundamental Concepts Slide 71 Master Theorem for Recurrences Theorem 3.1: Given f(n) = a f(n/b) + h(n); a, b constant, h arbitrary function the asymptotic solution to the recurrence is (c = logb a) f(n) = (n c) if h(n) = O(n c – e) for some e > 0 f(n) = (n c log n) if h(n) = (n c) f(n) = (h(n)) if h(n) = (n c + e) for some e > 0 Example: Spring 2006 f(n) = 2 f(n/2) + 1 a = b = 2; c = logb a = 1 h(n) = 1 = O( n 1 – e) f(n) = (n c) = (n) Parallel Processing, Fundamental Concepts Slide 72 Intuition Behind the Master Theorem Theorem 3.1: Given f(n) = a f(n/b) + h(n); a, b constant, h arbitrary function the asymptotic solution to the recurrence is (c = logb a) f(n) = (n c) if h(n) = O(n c – e) for some e > 0 f(n) = 2f(n/2) + 1 = 4f(n/4) + 2 + 1 = . . . = n f(n/n) + n/2 + . . . + 4 + 2 + 1 f(n) = (n c log n) if h(n) = (n c) f(n) = 2f(n/2) + n = 4f(n/4) + n + n = . . . = n f(n/n) + n + n + n + . . . + n f(n) = (h(n)) All terms are comparable if h(n) = (n c + e) for some e > 0 f(n) = f(n/2) + n = f(n/4) + n/2 + n = . . . = f(n/n) + 2 + 4 + . . . + n/4 + n/2 + n Spring 2006 The last term dominates Parallel Processing, Fundamental Concepts The first term dominates Slide 73 4 Models of Parallel Processing Expand on the taxonomy of parallel processing from Chap. 1: • Abstract models of shared and distributed memory • Differences between abstract models and real hardware Topics in This Chapter 4.1 Development of Early Models 4.2 SIMD versus MIMD Architectures 4.3 Global versus Distributed Memory 4.4 The PRAM Shared-Memory Model 4.5 Distributed-Memory or Graph Models 4.6 Circuit Model and Physical Realizations Spring 2006 Parallel Processing, Fundamental Concepts Slide 74 4.1 Development of Early Models Associative memory Parallel masked search of all words Bit-serial implementation with RAM 100111010110001101000 Associative processor Add more processing logic to PEs Table 4.1 Comparand Mask Memory array with comparison logic Entering the second half-century of associative processing ––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––– Decade Events and Advances Technology Performance ––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––– 1940s Formulation of need & concept Relays 1950s Emergence of cell technologies Magnetic, Cryogenic Mega-bit-OPS 1960s Introduction of basic architectures Transistors 1970s Commercialization & applications ICs Giga-bit-OPS 1980s Focus on system/software issues VLSI Tera-bit-OPS 1990s Scalable & flexible architectures ULSI, WSI Peta-bit-OPS ––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––– Spring 2006 Parallel Processing, Fundamental Concepts Slide 75 The Flynn-Johnson Classification Revisited Data stream(s) “Array processor” MISD GMSV (Rarely used) DMSV Fig. 4.2 Fig. 4.1 Spring 2006 DMMP “Distributed “Distrib-memory shared memory” multicomputer Data Out I3 MIMD GMMP Shared variables Message passing Communication/ Synchronization I4 MIMD Memory “Uniprocessor” versus Distrib Global SIMD I5 Data In SIMD SISD I2 I1 Multiple “Shared-memory multiprocessor” Multiple Control stream(s) Single Single Global versus Distributed memory The Flynn-Johnson classification of computer systems. Parallel Processing, Fundamental Concepts Slide 76 4.2 SIMD versus MIMD Architectures Most early parallel machines had SIMD designs Attractive to have skeleton processors (PEs) Eventually, many processors per chip High development cost for custom chips, high cost MSIMD and SPMD variants Most modern parallel machines have MIMD designs COTS components (CPU chips and switches) MPP: Massively or moderately parallel? Tightly coupled versus loosely coupled Explicit message passing versus shared memory Network-based NOWs and COWs Networks/Clusters of workstations Grid computing Vision: Plug into wall outlets for computing power Spring 2006 Parallel Processing, Fundamental Concepts SIMD Timeline 1960 1970 ILLIAC IV DAP 1980 1990 2000 Goodyear MPP TMC CM-2 MasPar MP-1 Clearspeed array coproc 2010 Slide 77 4.3 Global versus Distributed Memory Memory modules Processors 0 0 1 1 Processorto-processor network . . . Processorto-memory network . . . p-1 m-1 ... Parallel I/O Fig. 4.3 Spring 2006 Options: Crossbar Bus(es) MIN Bottleneck Complex Expensive A parallel processor with global memory. Parallel Processing, Fundamental Concepts Slide 78 Removing the Processor-to-Memory Bottleneck Processors Processorto-processor network Memory modules Caches 0 0 1 1 Challenge: Cache coherence . . . Processorto-memory network p-1 . . . m-1 ... Parallel I/O Fig. 4.4 Spring 2006 A parallel processor with global memory and processor caches. Parallel Processing, Fundamental Concepts Slide 79 Distributed Shared Memory Memories Processors Some Terminology: 0 NUMA Nonuniform memory access (distributed shared memory) 1 . . . Interconnection network UMA Uniform memory access (global shared memory) p-1 Parallel I/O Fig. 4.5 Spring 2006 . . . COMA Cache-only memory arch A parallel processor with distributed memory. Parallel Processing, Fundamental Concepts Slide 80 4.4 The PRAM Shared-Memory Model Fig. 4.6 Conceptual view of a parallel random-access machine (PRAM). Spring 2006 Parallel Processing, Fundamental Concepts Slide 81 PRAM Implementation and Operation Process ors 0 Memory Acces s Network & Controller PRAM Cycle: Shared Memory 0 1 Process or Control 2 1 . . . 3 . . . p–1 Fig. 4.7 Spring 2006 All processors read memory locations of their choosing All processors compute one step independently All processors m–1 store results into memory locations of their choosing PRAM with some hardware details shown. Parallel Processing, Fundamental Concepts Slide 82 4.5 Distributed-Memory or Graph Models Fig. 4.8 Spring 2006 The sea of interconnection networks. Parallel Processing, Fundamental Concepts Slide 83 Some Interconnection Networks (Table 4.2) ––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––– Network name(s) Number of nodes Network diameter Bisection Node width degree Local links? ––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––– 1D mesh (linear array) k k–1 1 2 Yes 1D torus (ring, loop) k k/2 2 2 Yes 2D Mesh k2 2k – 2 k 4 Yes 2D torus (k-ary 2-cube) k2 k 2k 4 Yes1 3D mesh k3 3k – 3 k2 6 Yes 3D torus (k-ary 3-cube) k3 3k/2 2k2 6 Yes1 Pyramid (4k2 – 1)/3 2 log2 k 2k 9 No Binary tree 2l – 1 2l – 2 1 3 No 4-ary hypertree 2l(2l+1 – 1) 2l 2l+1 6 No Butterfly 2l(l + 1) 2l 2l 4 No Hypercube 2l l 2l–1 l No Cube-connected cycles 2l l 2l 2l–1 3 No Shuffle-exchange 2l 2l – 1 2l–1/l 4 unidir. No De Bruijn 2l l 2l /l 4 unidir. No –––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––– 1 With folded layout Spring 2006 Parallel Processing, Fundamental Concepts Slide 84 4.6 Circuit Model and Physical Realizations Bus switch (Gateway) Low-level cluster Scalability dictates hierarchical connectivity Fig. 4.9 Spring 2006 Example of a hierarchical interconnection architecture. Parallel Processing, Fundamental Concepts Slide 85 Signal Delay on Wires No Longer Negligible Fig. 4.10 Spring 2006 Intrachip wire delay as a function of wire length. Parallel Processing, Fundamental Concepts Slide 86 Pitfalls of Scaling up (Fig. 4.11) If the weight of ant grows by a factor of one trillion, the thickness of its legs must grow by a factor of one million to support the new weight O(10O(104 )) 4 up ant on the rampage! Scaled upScaled ant on with thethisrampage! What is wrong picture? What is wrong with this picture? Ant scaled up in length from 5 mm to 50 m Leg thickness must grow from 0.1 mm to 100 m Scaled ant collapses under own under weight. own weight. Scaled upupant collapses Spring 2006 Parallel Processing, Fundamental Concepts Slide 87