1. Gauss Students’ Views on Multicore Processors Group members: Yu Yang (presenter), Xiaofang Chen, Subodh Sharma, Sarvani Vakkalanka, Anh Vo, Michael DeLisi, Geof Sawaya, Mike Kirby, Ganesh Gopalakrishnan (Photo courtesy of Intel®)

2. Verifying Cache Coherence Protocols RAC L2 Cache+Local Dir L1 Cache Main Mem Chip 1 L1 Cache Global Dir RAC L2 Cache+Local Dir L1 Cache RAC L2 Cache+Local Dir L1 Cache Verification complexity grows exponentially Compositional approaches are needed Hardware components better be loosely-coupled Chip 2 Chip 3 -- Xiaofang

3. Programmer Challenges from Multicore Majority of existing programmers are more tuned to thinking “sequentially”. To make multicore architectures useful, we need “multicore” programmers. How can we make a programmer's life easier in the multicore era? –Smarter compilers! Future compilers can identify program blocks that can be parallelized. –More architectural support ! Transaction memory can help eliminate program deadlocks and guarantee atomicity with very little effort on the programmers’ part. -- Sarvani

4. Static Analysis and Verification To guarantee the correctness of concurrent programs –Combination of static analysis and verification is needed Success stories: –In static analysis: Prefast/SDV (Windows) –In verification: SPIN What static analysis can achieve: –Abstraction: Discard irrelevant program information –Cheaper sanity checks than formal verification –Often report races / deadlocks w/o execution Success story: SoftCheck, Inspector etc. –Detect property violations sometimes Success story: Polyspace -- Subodh

5. OpenMP & Thread Building Blocks (TBB) Threads are great, but error-prone How can we make writing threading programs easier? –OpenMP: exploit loop level parallelism Support high level concepts: critical, atomic, barriers Require much less programming effort Can parallelize a program incrementally –TBB: exploit task level parallelism A template library for writing parallel programs (in C++) Easier to think in tasks than threads (TBB takes care of scheduling tasks to threads) -- Anh Vo

6. Multicore: general issues The challenges of threading and parallelism must be taught in entry level CS courses. For adoption, programming languages must make parallelism easy. –OpenMP? MPI? Compute clusters can become faster, more powerful, and smaller in size. –Also, it allows for people to have “clusters” at home where they can run complicated tasks faster (such as Folding@Home). Could allow for faster, threaded model checking on bigger and more complicated programs. -- Michael DeLisi

7. Testing Multithreaded Programs Multicore will make multithreaded programs prevalent. –Multithreaded programs are hard to get correct! Why threading programs are hard to write? –When there is something wrong, we cannot debug it in the sequential way! How to effectively test/tune up multicore programs? New programming paradigms? -- Yu Yang

8. Summary Multicore increases the complexity of hardware verification Multicore introduces new challenges on improving software productivity –Support from compilers? –Effective testing methods? –New programming paradigms?