Spending Moore's dividend

@article{Larus2009SpendingMD,
  title={Spending Moore's dividend},
  author={James R. Larus},
  journal={Commun. ACM},
  year={2009},
  volume={52},
  pages={62-69}
}
  • J. Larus
  • Published 1 May 2009
  • Computer Science
  • Commun. ACM
Multicore computers shift the burden of software performance from chip designers and processor architects to software developers. 
The hardware lottery
After decades of incentivizing the isolation of hardware, software, and algorithm development, the catalysts for closer collaboration are changing the paradigm.
Adapting computing curricula to a multicore world
  • R. LeBlanc, M. Wrinn
  • Computer Science
    2010 IEEE Frontiers in Education Conference (FIE)
  • 2010
The impact of ubiquitous parallel computing hardware on computing curricula is examined in this paper, with a focus on identifying new outcomes to drive curriculum evolution.
Software-Hardware Evolution and birth of Multicore Processors
TLDR
It appears that the HW-SW industry trend can be represented by a mathematical model, for which future developments are predictable, and establishes that future of computer industry lies in more thrust in software to exploit parallelism available in software.
Multicore education: pieces of the parallel puzzle
Although Moore's Law continues to hold at present, Moore's Dividend - where software developers could rely on increasingly faster CPUs to make their software faster - has expired [5]. Instead of
n-Core Encore?
TLDR
The case is now being presented for software and newer applications to catch up with hardware, in particular to Moore's law, to enhance operating systems, compilers, software languages, and applications in that order, for maximum utilization of the underlying hardware.
Chip multiprocessors for server workloads
TLDR
Reactive NUCA (R-NUCA), a distributed cache design which reacts to the class of each access to place blocks close to the requesting cores is proposed, and it is found that heterogeneous multicores hold great promise in improving designs even further.
FPGA-Accelerated Deserialization of Object Structures
TLDR
This work presents an efficient FPGA implementation for C++ object deserialization which is compared with the traditional approach and describes how to create FPGa circuits based on the object layout and the serialization procedure.
Efficient Architectures for Multichip Communication
xi
Early and often: Bringing more parallelism into undergraduate Computer Science
1. The time is now In view of recent industry shifts towards both multi-core processors and applications of distributed computing through techniques such as map-reduce, the question naturally arises:
Techniques for Memory Mapping on Multi-Core Automotive Embedded Systems
The demand to increase performance while conserving power has led to the invention of multicore systems. The software until now had the convenience of gaining better performance over faster
...
1
2
3
4
5
...

References

SHOWING 1-10 OF 37 REFERENCES
Amdahl's Law in the Multicore Era
Augmenting Amdahl's law with a corollary for multicore hardware makes it relevant to future generations of chips with multiple processor cores. Obtaining optimal multicore performance will require
The Future of Microprocessors
TLDR
The performance of microprocessors that power modern computers has continued to increase exponentially over the years because processor designers have been able to harness the increasing numbers of transistors available on modern chips to extract more parallelism from software.
End-to-end performance of commercial applications in the face of changing hardware
TLDR
The performance data as observed from the OS and from hardware performance counters is dissected, and areas for further improvements are suggested.
Comparative characterization of SPEC CPU2000 and CPU2006 on Itanium® architecture
TLDR
IPC (instructions per cycle), L1, L2 data cache misses and branch prediction, especially in CPU2006 is analyzed; specifically, it is shown that branch prediction in SPEC CPU2006 has changed significantly since CPU2000.
Singularity: rethinking the software stack
TLDR
This paper describes the efforts of the Singularity project to re-examine these design choices in light of advances in programming languages and verification tools, and sketches the ongoing research in experimental systems that build upon it.
An in-depth look at computer performance growth
TLDR
This paper takes a fresh look at -- and tries to remove the confusion about -- performance scaling that exists in the computer architecture community.
Engineering: 5 commandments
There are sublime, silly, real and true laws, and folksy rules of thumb laws that have come up from mathematical observations, pithy pronouncements, and even a few enduring self-fulfilling prophecies
Composable memory transactions
TLDR
This paper presents a new concurrency model, based on transactional memory, that offers far richer composition, and describes new modular forms of blocking and choice that have been inaccessible in earlier work.
Deconstructing process isolation
TLDR
To compare the performance of Singularity's SIPs against traditional isolation techniques, an optional hardware isolation mechanism was implemented and found that hardware-based isolation incurs non-trivial performance costs and complicates system implementation.
Making reliable distributed systems in the presence of software errors
TLDR
It is argued how certain of the requirements necessary to build a fault-tolerant system are solved in the language, and others are solve in the standard libraries, which form a basis for building fault-Tolerant software systems.
...
1
2
3
4
...