We apply Amdahl’s Law to multicore chips using symmetric cores, asymmetric cores, and dynamic techniques that allow cores to work together on sequential execution. To Amdahl’s simple software model, we add a simple hardware model based on fixed chip resources. Our results encourage multicore

Abstract. Multicore architecture has become the trend of high perfor-mance processors. While it is generally accepted that we have entered the multicore era, concerns exist on scaling multicore processors. Technology is available, but major vendors are hesitant in entering the multicore mar

� Manufacturers could not make uniprocessors faster Heat dissipation a problem “Large uniprocessors are no longer scaling in performance...”

as we enter the multicore era, researchers should still seek methods of speeding sequential execution. Moreover, methods that appear locally inefficient (e.g., tripling sequential performance with a 9x resource cost) can still be globally efficient as they reduce the sequential phase when the rest

The scalability problem is in the first place of the dozen long-term information-technology research goals indicated by Jim Gray [2]. Chip multiprocessors (CMPs) or multicores are emerging as the dominant computing platform. In the

constraint for future technology nodes. Our results, based on a scaled multicore processor, indicate that worstcase on-chip IR drop at 16nm will be at least three times larger than that at 45nm. We propose a first-order optimization algorithm to derive the number and placement of C4 pads for by power

Software systems must face two challenges today: growing complexity and increasing parallelism in the underlying computational models. The problem of increased complexity is often solved by dividing systems into modules in a way that permits analysis of these modules in isolation. The problem of lack of concurrency is often tackled by dividing system execution into tasks that permits execution of these tasks in isolation. The key challenge in software design is to manage the explicit and implicit dependence between modules that decreases modularity. The key challenge for concurrency is to manage the explicit and implicit dependence between tasks that decreases parallelism. Even though these challenges appear to be strikingly similar, current software design practices and languages do not take advantage of this similarity. The net effect is that the modularity and concurrency goals are often tackled mutually

Active research by verification communities.

storage managers to use non-scalable approaches without any penalty. With the arrival of multicore chips, however, this situation is rapidly changing. More and more threads can run in parallel, stressing the internal scalability of the storage manager. Systems optimized for high performance at a limited

Everyone knows Amdahl's Law, but quickly forgets it.